# inspect_type_links.first.Foo class

A class in the first module

first.Foo and inspect_type_links.first.Foo should lead to self; referencing the subclass via Foo, Foo.Foo, first.Foo.Foo or Bar. second.Foo and inspect_type_links.Bar lead to other classes.

This is consistent with how Python type annotations inside a class are interpreted -- see reference_self_data, reference_inner_data and reference_inner_other_data. Inside function definitions the rules are different as per https://docs.python.org/3/reference/executionmodel.html#resolution-of-names:

> The scope of names defined in a class block is limited to the class block; it does not extend to the code blocks of methods

This means relative annotations in reference_self(), reference_inner() and reference_inner_other() are parsed differently -- but in the documentation, these are shown with the same rules as for data themselves.

## Classes

class Bar
  Another inner class.
class Foo
  An inner class in the first module

## Methods

def reference_inner(self, a: Foo, b: Foo)
  Referencing an inner class using Foo.Foo and first.Foo.Foo. Outside of a function it would be enough to reference via Foo, thus docs display just Foo.
def reference_inner_other(self, a: Bar)
  Referencing another inner class using Foo.Bar. Bar alone doesn't work, outside of a function it would, thus docs display just Bar.
def reference_other(self, a: second.Foo, b: inspect_type_links.Bar)
  Referencing a type in another module using second.Foo or inspect_type_links.Bar.
def reference_parent(self, a: inspect_type_links.Foo)
  Referencing a class in a parent module using inspect_type_links.Foo.
def reference_self(self, a: first.Foo, b: first.Foo)
  Referencing its wrapper class using Foo and first.Foo. Outside of a function Foo would reference the inner, thus docs display first.Foo to disambiguate.

## Data

reference_inner_data: typing.Tuple[Foo, Foo, Foo] = {}
  Referencing the inner class using `Foo`, `Foo.Foo` or `first.Foo.Foo`, displayed as just `Foo`. This is different from reference_inner().
reference_inner_other_data: typing.Tuple[Bar, Bar, Bar] = {}
  Referencing another inner class using `Bar`, `Foo.Bar` or `first.Foo.Bar`, displayed as just `Bar`. This is different from reference_inner_other().
reference_self_data: typing.Tuple[first.Foo] = {}
  Referencing its wrapper class using `first.Foo`, displayed as `first.Foo` as well. `Foo` alone would reference the inner. This is different from reference_self().