Functionality for types
Project description
Typish
- Functions for thorough checks on types
- Instance checks considering generics
- Typesafe Duck-typing
Example
>>> from typing import Iterable
>>> from typish import instance_of
>>> instance_of([1, 2, 3], Iterable[int])
True
Installation
pip install typish
Content
Functions
Function | Description |
---|---|
subclass_of(cls: type, *args: type) -> bool |
Returns whether cls is a sub type of all types in args |
instance_of(obj: object, *args: type) -> bool |
Returns whether cls is an instance of all types in args |
get_origin(t: type) -> type |
Return the "origin" of a generic type. E.g. get_origin(List[str]) gives list . |
get_args(t: type) -> typing.Tuple[type, ...] |
Return the arguments of a generic type. E.g. get_args(List[str]) gives (str, ) . |
get_alias(cls: T) -> typing.Optional[T] |
Return the typing alias for a type. E.g get_alias(list) gives List . |
get_type(inst: T, use_union: bool = False) -> typing.Type[T] |
Return the (generic) type of an instance. E.g. a list of ints will give List[int] . |
common_ancestor(*args: object) -> type |
Return the closest common ancestor of the given instances. |
common_ancestor_of_types(*args: type) -> type |
Return the closest common ancestor of the given classes. |
get_args_and_return_type(hint: typing.Type[typing.Callable]) -> typing.Tuple[typing.Optional[typing.Tuple[type]], typing.Optional[type]] |
Get the argument types and the return type of a callable type hint (e.g. Callable[[int], str] ). |
get_type_hints_of_callable(func: typing.Callable) -> typing.Dict[str, type] |
Return the type hints of the parameters of the given callable. |
is_type_annotation(item: typing.Any) -> bool |
Returns whether item is a type or a typing type. |
is_from_typing(cls: type) -> bool |
Returns whether cls is from the typing module. |
is_optional_type(cls: type) -> bool |
Returns whether cls is considered to be an optional type. |
get_mro(obj: typing.Any) -> typing.Tuple[type, ...] |
Wrapper around getmro from inspect to also support typing types. |
Types
Type | Description |
---|---|
T |
A generic Type var. |
KT |
A Type var for keys in a dict. |
VT |
A type var for values in a dict. |
Empty |
The type of emptiness (= Parameter.empty ). |
Unknown |
The type of something unknown. |
Module |
The type of a module. |
NoneType |
The type of None . |
EllipsisType |
The type of ... . |
Decorators
hintable
This decorator allows one to capture the type hint of a variable that calls a function. If no hint is provided, None
is passed as a value for hint
.
Just remember: with great power comes great responsibility. Use this functionality wisely. You may want to make sure
that if you hinted a variable with a certain type, your hintable
function does indeed return a value of that type.
@hintable
def cast(arg: Any, hint: Type[T]) -> T:
return hint(arg)
# The type hint on x is passed to cast:
x: int = cast('42')
# It works with MyPy hints as well:
y = cast('42') # type: int
# Not something you would normally do, but the type hint takes precedence:
z: int = cast('42') # type: str
Classes
SubscriptableType
This metaclass allows a type to become subscriptable.
Example:
class MyClass(metaclass=SubscriptableType):
...
Now you can do:
MyClass2 = MyClass['some args']
print(MyClass2.__args__)
print(MyClass2.__origin__)
Output:
some args
<class '__main__.MyClass'>
Something
Define an interface with typish.Something
.
Example:
Duck = Something['walk': Callable[[], None],
'quack': Callable[[], None]]
Anything that has the attributes defined in Something
with the right type is
considered an instance of that Something
(classes, objects, even modules...).
The builtin isinstance
is supported as well as typish.instance_of
.
ClsDict
A dictionary that uses instance checking to determine which value to return. It only accepts types as keys.
This is particularly useful when a function accepts multiple types for an argument and you want to split the implementation into separate functions.
Example:
def _handle_str(item):
...
def _handle_int(item):
...
def func(item):
# Suppose item can be a string or an int, you can use ClsDict to
# pick a handler function.
cd = ClsDict({
str: _handle_str,
int: _handle_int,
})
handler = cd[item] # Pick the right handler.
handler(item) # Call that handler.
ClsFunction
A callable that uses ClsDict
to call the right function.
Below is the same example as above, but slightly modified in
that it uses ClsFunction
.
Example:
def _handle_str(item):
...
def _handle_int(item):
...
def func(item):
# Suppose item can be a string or an int, you can use ClsFunction to
# delegate to the right handler function.
function = ClsFunction({
str: _handle_str,
int: _handle_int,
})
function(item)
Literal
A backwards compatible variant of typing.Literal (Python3.8). When importing
Literal
from typish
, you will get the typing.Literal
if it is available.
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distributions
Built Distribution
File details
Details for the file typish-1.9.3-py3-none-any.whl
.
File metadata
- Download URL: typish-1.9.3-py3-none-any.whl
- Upload date:
- Size: 45.1 kB
- Tags: Python 3
- Uploaded using Trusted Publishing? No
- Uploaded via: twine/1.13.0 pkginfo/1.5.0.1 requests/2.22.0 setuptools/41.0.1 requests-toolbelt/0.9.1 tqdm/4.32.2 CPython/3.7.3
File hashes
Algorithm | Hash digest | |
---|---|---|
SHA256 | 03cfee5e6eb856dbf90244e18f4e4c41044c8790d5779f4e775f63f982e2f896 |
|
MD5 | ea0489e00f8f7a3bb8b2eb0eff6ebecf |
|
BLAKE2b-256 | 9dd63f56c9c0c12adf61dfcf4ed5c8ffd2c431db8dd85592067a57e8e1968565 |