mypy.typeops

Return a copy of method, with the type of its first parameter (usually self or cls) bound to original_type.

If the type of self is a generic type (T, or Type[T] for classmethods), instantiate every occurrence of type with original_type in the rest of the signature and in the return type.

original_type is the type of E in the expression E.copy(). It is None in compatibility checks. In this case we treat it as the erasure of the declared type of self.

This way we can express "the type of self". For example:

T = TypeVar('T', bound='A') class A:

def copy(self: T) -> T: ...

class B(A): pass

b = B().copy() # type: B

Undocumented

Does this type have a custom special method such as __format__() or __eq__()?

If check_all is True ensure all items of a union have a custom method, not just some.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Whether a type is a simple enough literal to allow for fast Union simplification

For now this means enum or string

Returns 'true' if this type is a "singleton type" -- if there exists exactly only one runtime value associated with this type.

That is, given two values 'a' and 'b' that have the same type 't', 'is_singleton_type(t)' returns True if and only if the expression 'a is b' is always true.

Currently, this returns True when given NoneTypes, enum LiteralTypes and enum types with a single value.

Note that other kinds of LiteralTypes cannot count as singleton types. For example, suppose we do 'a = 100000 + 1' and 'b = 100001'. It is not guaranteed that 'a is b' will always be true -- some implementations of Python will end up constructing two distinct instances of 100001.

Build union type with redundant union items removed.

If only a single item remains, this may return a non-union type.

Examples:

• [int, str] -> Union[int, str]
• [int, object] -> object
• [int, int] -> int
• [int, Any] -> Union[int, Any] (Any types are not simplified away!)
• [Any, Any] -> Any

Note: This must NOT be used during semantic analysis, since TypeInfos may not

be fully initialized.

The keep_erased flag is used for type inference against union types containing type variables. If set to True, keep all ErasedType items.

Map type variables in a type defined in a supertype context to be valid in the subtype context. Assume that the result is unique; if more than one type is possible, return one of the alternatives.

For example, assume

class D(Generic[S]): ... class C(D[E[T]], Generic[T]): ...

Now S in the context of D would be mapped to E[T] in the context of C.

Is this a supported kind of explicit self-types?

Currently, this means a X or Type[X], where X is an instance or a type variable with an instance upper bound.

Contracts any literal types back into a sum type if possible.

Will replace the first instance of the literal with the sum type and remove all others.

If we call try_contracting_union(Literal[Color.RED, Color.BLUE, Color.YELLOW]), this function will return Color.

We also treat Literal[True, False] as bool.

Attempts to recursively expand any enum Instances with the given target_fullname into a Union of all of its component LiteralTypes.

For example, if we have:

class Color(Enum):

RED = 1 BLUE = 2 YELLOW = 3

class Status(Enum):

SUCCESS = 1 FAILURE = 2 UNKNOWN = 3

...and if we call try_expanding_enum_to_union(Union[Color, Status], 'module.Color'), this function will return Literal[Color.RED, Color.BLUE, Color.YELLOW, Status].

Returns the Instance fallback for this type if one exists.

Otherwise, returns None.

If the given expression or type corresponds to an int Literal or a union of int Literals, returns a list of the underlying ints. Otherwise, returns None.

For example, if we had the type 'Literal[1, 2, 3]' as input, this function would return a list of ints [1, 2, 3].

If the given expression or type corresponds to a string literal or a union of string literals, returns a list of the underlying strings. Otherwise, returns None.

Specifically, this function is guaranteed to return a list with one or more strings if one one the following is true:

1. 'expr' is a StrExpr
2. 'typ' is a LiteralType containing a string
3. 'typ' is a UnionType containing only LiteralType of strings

If the given expression or type corresponds to a string Literal or a union of string Literals, returns a list of the underlying strings. Otherwise, returns None.

For example, if we had the type 'Literal["foo", "bar"]' as input, this function would return a list of strings ["foo", "bar"].

Undocumented