# inspect_annotations module

Annotation parsing. For links inside annotations see test_inspect.TypeLinks.

## Classes

class AContainer
  A generic class. No parent class info extracted yet.
class AContainer2
  Another class derived from a typing thing.
class Foo
  A class with properties
class FooSlots
  A class with slots

## Functions

def annotated_positional_keyword(bar = False, *, foo: str, **kwargs)
  Function with explicitly delimited keyword args and type annotations
def annotation(param: typing.List[int], another: bool, third: str = 'hello') -> float
  An annotated function
def annotation_any(a: typing.Any)
  Annotation with the Any type
def annotation_callable(a: typing.Callable[[float, int], str])
  Annotation with the Callable type
def annotation_callable_no_args(a: typing.Callable[[], typing.Dict[int, float]])
  Annotation with the Callable type w/o arguments
def annotation_ellipsis(a: typing.Callable[[...], int], b: typing.Tuple[str, ...])
  Annotation with ellipsis
def annotation_func_instead_of_type(a)
  Annotation with a function instead of a type, ignored
def annotation_func_instead_of_type_nested(a, b, c)
  Annotations with nested problems, ignoring the whole thing
def annotation_generic(a: typing.List[Tp]) -> Tp
  Annotation with a generic type
def annotation_list_noparam(a: typing.List)
  Annotation with the unparametrized List type. 3.7 and 3.8 adds an implicit TypeVar to it, 3.6, 3.9 and 3.10 not, so the output is different between the versions.
def annotation_optional(a: typing.Optional[float])
  Annotation with the Optional type
def annotation_strings(param: typing.List[int], another: bool, third: str = 'hello') -> float
  Annotated using strings, should result in exactly the same as annotation()
def annotation_tuple_instead_of_tuple(a)
  Annotation with a tuple instead of Tuple, ignored
def annotation_union(a: typing.Union[float, int])
  Annotation with the Union type
def annotation_union_of_undefined(a: typing.Union[int, something.Undefined])
  Annotation with an union that has an undefined type inside, where we can't use isinstance either
def annotation_union_second_bracketed(a: typing.Union[float, typing.List[int]])
  Annotation with the Union type and second type bracketed, where we can't use isinstance
def args_kwargs(a, b, *args, **kwargs)
  Function with args and kwargs
def no_annotation(a, b, z)
  Non-annotated function
def no_annotation_default_param(param, another, third = 'hello')
  Non-annotated function with a default parameter
def partial_annotation(foo, param: typing.Tuple[int, int], unannotated, cls: object)
  Partially annotated function
def positional_keyword(positional_kw, *, kw_only)
  Function with explicitly delimited keyword args
def returns_none(a: typing.Callable[[], None]) -> None
  In order to disambiguate between a missing return annotation and an annotated none, the None return annotation is kept, converted from NoneType to None
def returns_none_type(a: typing.Callable[[], None]) -> None
  And it should behave the same when using None or type(None)

## Data

ANNOTATED_VAR: typing.Tuple[bool, str] = (False, 'No.')
UNANNOTATED_VAR = 3.45