libstatic._analyzer.typeinfer.Type

class documentation

class Type(_BaseType): (source)

Known subclasses: libstatic._analyzer.typeinfer.TypeVariable

Internal implementation of libstatic.Type.

Method	`__hash__`	Undocumented
Method	`__str__`	Undocumented
Method	`add_args`	Get a copy of the Type with the given args added in the list of args.
Method	`add_meta`	Get a copy of the Type with the given meta informations updated.
Method	`get_meta`	Undocumented
Method	`merge`	Get a union of the two given types.
Method	`supertype_of`	Undocumented
Class Variable	`Any`	Undocumented
Class Variable	`Callable`	Undocumented
Class Variable	`Literal`	Undocumented
Class Variable	`ModuleType`	Undocumented
Class Variable	`Optional`	Undocumented
Class Variable	`overload`	Undocumented
Class Variable	`TypeType`	Undocumented
Class Variable	`Union`	Undocumented
Instance Variable	`__dict__`	Undocumented
Instance Variable	`args`	Arguments of a generic type if any.
Instance Variable	`meta`	Stores meta information when the type annotations are not expressive enougth. Used for intermediate inference steps.
Instance Variable	`name`	The name of the type.
Instance Variable	`scope`	The scope where the type is defined. This is often a module, but it migth be a class or a function in some cases.
Property	`annotation`	Represent the type as a string suitable for type annotations.
Property	`definition`	Undocumented
Property	`is_callable`	Undocumented
Property	`is_literal`	A literal type means it's literal values can be recovered with:
Property	`is_module`	Undocumented
Property	`is_none`	Undocumented
Property	`is_optional`	Undocumented
Property	`is_overload`	No summary
Property	`is_protocol`	Undocumented
Property	`is_type`	Undocumented
Property	`is_typevar`	Undocumented
Property	`is_union`	Undocumented
Property	`location`	Undocumented
Property	`long_annotation`	Like `annotation` but returns the type with qualified names.
Property	`qualname`	The full name of the type.
Property	`supertype`	Undocumented
Property	`unknown`	Undocumented
Method	`_replace`	Undocumented

def __hash__(self) -> int: (source) ¶

Undocumented

def __str__(self) -> str: (source) ¶

Undocumented

def add_args(self, args: Iterable[Type]) -> Type: (source) ¶

Get a copy of the Type with the given args added in the list of args.

def add_meta(self, **meta: object) -> Type: (source) ¶

Get a copy of the Type with the given meta informations updated.

@overload

def get_meta(self, key: Lit[definition]) -> Def | None:

@overload

def get_meta(self, key: Lit[location]) -> NodeLocation | None:

@overload

def get_meta(self, key: Lit[members]) -> Mapping[str, Type] | None:

@overload

def get_meta(self, key: Lit[mro]) -> Sequence[Type] | None:

@overload

def get_meta(self, key: Lit[unknown]) -> bool | None:

@overload

def get_meta(self, key: Lit[is_protocol]) -> bool | None:

@overload

def get_meta(self, key: Lit[keyword]) -> str | None:

(source) ¶

Undocumented

def merge(self, other: Type) -> Type: (source) ¶

Get a union of the two given types.

If any of the types is unknown, the other is returned. When possible, the type is simplified. For instance, int | int will be simplified to just int.

def supertype_of(self, other: Type) -> bool: (source) ¶

Undocumented

Any: ClassVar[Type] = (source) ¶

Undocumented

Callable: ClassVar[Type] = (source) ¶

Undocumented

Literal: ClassVar[Type] = (source) ¶

Undocumented

ModuleType: ClassVar[Type] = (source) ¶

Undocumented

Optional: ClassVar[Type] = (source) ¶

Undocumented

overload: ClassVar[Type] = (source) ¶

Undocumented

TypeType: ClassVar[Type] = (source) ¶

Undocumented

Union: ClassVar[Type] = (source) ¶

Undocumented

__dict__: dict = (source) ¶

Undocumented

args: Sequence[Type] = (source) ¶

overrides libstatic.Type.args

Arguments of a generic type if any.

For example, (str, int) if the type is dict[str, int].

meta: Mapping[str, object] = (source) ¶

Stores meta information when the type annotations are not expressive enougth. Used for intermediate inference steps.

name: str = (source) ¶

overrides libstatic.Type.name

The name of the type.

For example, Iterable or list.

scope: str = (source) ¶

The scope where the type is defined. This is often a module, but it migth be a class or a function in some cases.

For example, typing if the type is Iterable. Empty string for built-ins or other special cases.

@property
@lru_cache(maxsize=None)
annotation: str = (source) ¶

overrides libstatic.Type.annotation

Represent the type as a string suitable for type annotations.

The string is a valid Python 3.10 expression. For example, str | dict[str, Any].

@property
definition: Def | None = (source) ¶

Undocumented

@property
is_callable: bool = (source) ¶

Undocumented

@property
is_literal: bool = (source) ¶

A literal type means it's literal values can be recovered with:

>>> type = Type.Literal.add_args(args=[Type('"val"')])
>>> ast.literal_eval(type.args[0].name)
'val'

@property
is_module: bool = (source) ¶

Undocumented

@property
is_none: bool = (source) ¶

Undocumented

@property
is_optional: bool = (source) ¶

Undocumented

@property
is_overload: bool = (source) ¶

>>> t = Type.overload.add_args(args=[Type.Callable.add_args([Type('int', 'builtins'), Type('int', 'builtins'),]),
... Type.Callable.add_args([Type('str', 'builtins'), Type('str', 'builtins'),])])
>>> print(t.annotation)
(int) -> int | (str) -> str
>>> assert t.is_overload