To annotate an object that is a class, use typing.Type. For example, this would tell the type checker that some_class is class Foo or any of its subclasses: from typing import Type class Foo: … class Bar(Foo): … class Baz: … some_class: Type[Foo] some_class = Foo # ok some_class = Bar # ok some_class = … Read more
and types.ModuleType() is a constructor. That doesn’t matter. types.ModuleType is still a reference to a type, just like str and int are. There is no need for a generic Module[typehint] annotation, so types.ModuleType is exacly what you need to use here. For example, the official Python typeshed project provides a type hint annotation for sys.modules … Read more
This is because typing.NamedTuple is not really a proper type. It is a class. But its singular purpose is to take advantage of meta-class magic to give you a convenient nice way to define named-tuple types. And named-tuples derive from tuple directly. Note, unlike most other classes, from typing import NamedTuple class Foo(NamedTuple): pass print(isinstance(Foo(), … Read more
Your problem is that you want to use type hints but you want this class itself to be able to take arguments of its own type. The type hints PEP (0484) explains that you can use the string version of the type’s name as a forward reference. The example there is of a Tree data … Read more
You are looking for TypedDict. It is currently only a mypy-only extension, but there are plans to make it an officially sanctioned type in the near-future. I am not sure if PyCharm supports this feature yet, though. So, in your case, you’d do: from mypy_extensions import TypedDict RectangleElements = TypedDict(‘RectangleElements’, { ‘front’: Line, ‘left’: Line, … Read more
If you’re willing to install a not-quite-offical extension to typing, typing-extensions, you can use a Protocol, which should be an implementation of PEP-0544: from typing_extensions import Protocol from typing import Any class GetItem(Protocol): def __getitem__(self: ‘Getitem’, key: Any) -> Any: pass class BadGetItem: def __getitem__(self, a: int, b: int) -> Any: pass def do_thing(arg: GetItem): … Read more
You can use Forward References as defined in PEP 484 A situation where this occurs commonly is the definition of a container class, where the class being defined occurs in the signature of some of the methods. For example, the following code (the start of a simple binary tree implementation) does not work: class Tree: … Read more
You’re looking for types.ModuleType.
The trick is to explicitly add an annotation to the cls parameter, in combination with TypeVar, for generics, and Type, to represent a class rather than the instance itself, like so: from typing import TypeVar, Type # Create a generic variable that can be ‘Parent’, or any subclass. T = TypeVar(‘T’, bound=’Parent’) class Parent: def … Read more
Yes, there is a difference. Although in Python 3, all objects are instances of object, including object itself, only Any documents that the return value should be disregarded by the typechecker. The Any type docstring states that object is a subclass of Any and vice-versa: >>> import typing >>> print(typing.Any.__doc__) Special type indicating an unconstrained … Read more