I would like to pass generic class to a function so I can return the same type as result. My use case is writing ORM and a read function, which will take a table ORM, and return the same type as result, something like this:
def read<T>(id, fields="*") -> T:
Currently without typing, my code look like this:
def read(table, id, fields="*"):
Is something like this possible?
TL;DR Python doesn't need generics because it is a dynamically typed langauge. This allows us to use so-called duck typing instead of explicit generics.
The first thing to note is that type annotations in python are only suggestions. They help static analysis tools such as code completion while you are writing code but are not enforced at run-time.
With that in mind, let's look at a non-annotated version of your function:
def read(table, fields="*"):
pass
Here, python doesn't care what you pass for table as long as it supports the operations that are used inside of read(). This is what we call duck-typing: if it quacks like a duck, it's a duck. You see this in functions that act on sequeneces. For example:
def print_list(my_list):
for el in my_list:
print(el)
We can call print_list() with a list or a tuple:
print_list([1, 2, 3, 4])
print_list((1, 2, 3, 4))
In fact, anything that implements __iter__() and __next__() will work. This is the contract of the type and doesn't need to be specified with an interface, superclass, or generic type.
Now back to type hinting: there is a way to specify the "duck type contract" with type hinting, but I don't know the details off the top of my head. You could do some research to find out. As @juanpa.arrivillaga posted in a comment, you can look at typing.Protocol if you are interested in learning how to do the type hinting for cases like this.
typing.Protocol for structural subtyping, which is sort of the static typing equivalent of duck typing.
typing.Protocols; if the child class of the Protocol is decorated with @typing.runtime_checkable, you can use it for isinstance/issubclass checks at runtime of arbitrary instances/classes to see if they have the methods the Protocol expects, in which case they count as virtual subclasses of the Protocol class in question; if undecorated, they're purely for static type checkers.Ok, I recently was digging in Python type hinting abilities and came up with something like that
DBModel = TypeVar('DBModel')
class BaseRepository(Generic[DBModel]):
def __init__(self):
self.model: Type[DBModel] = get_args(self.__orig_bases__[0])[0]
def get_where(self, *args) -> DBModel
... # any logic with self.model
as a base class and
class UsersRepository(BaseRepository[User]):
pass
UsersRepository will now have already implemented get_where() with User model and will also have reference for User inside self.model
I guess that's what you want. Github with source code (small project actually.)
<class_name>.__annotations__ dict for introspecting typehints and get_args in some casestyping.Generic exists for the purpose of creating type hints. But I understand what you were getting at nowclass UserRepository(BaseReporsitory, model=User) or something like that (note, prior to recent versions of Python, typing.Generic used a metaclass to do a lot of it's magic, but recent versions have allowed you to do it with special hooks, i.e. special "dunder methods" the runtime now recognizes, from the class itself)