217 lines
7.0 KiB
Plaintext
217 lines
7.0 KiB
Plaintext
Metadata-Version: 2.1
|
|
Name: typish
|
|
Version: 1.9.3
|
|
Summary: Functionality for types
|
|
Home-page: https://github.com/ramonhagenaars/typish
|
|
Author: Ramon Hagenaars
|
|
Author-email: ramon.hagenaars@gmail.com
|
|
License: MIT
|
|
Platform: UNKNOWN
|
|
Classifier: Intended Audience :: Developers
|
|
Classifier: License :: OSI Approved :: MIT License
|
|
Classifier: Operating System :: OS Independent
|
|
Classifier: Natural Language :: English
|
|
Classifier: Programming Language :: Python
|
|
Classifier: Programming Language :: Python :: 3
|
|
Classifier: Programming Language :: Python :: 3.5
|
|
Classifier: Programming Language :: Python :: 3.6
|
|
Classifier: Programming Language :: Python :: 3.7
|
|
Classifier: Programming Language :: Python :: 3.8
|
|
Classifier: Programming Language :: Python :: 3.9
|
|
Description-Content-Type: text/markdown
|
|
Provides-Extra: test
|
|
Requires-Dist: numpy ; extra == 'test'
|
|
Requires-Dist: nptyping (>=1.3.0) ; extra == 'test'
|
|
Requires-Dist: pycodestyle ; extra == 'test'
|
|
Requires-Dist: pylint ; extra == 'test'
|
|
Requires-Dist: mypy ; extra == 'test'
|
|
Requires-Dist: pytest ; extra == 'test'
|
|
Requires-Dist: coverage ; extra == 'test'
|
|
Requires-Dist: codecov ; extra == 'test'
|
|
|
|
[](https://pypi.org/project/typish/)
|
|
[](https://pepy.tech/project/typish)
|
|
[](https://badge.fury.io/py/typish)
|
|
[](https://codecov.io/gh/ramonhagenaars/typish)
|
|
[](https://scrutinizer-ci.com/g/ramonhagenaars/typish/?branch=master)
|
|
|
|
# Typish
|
|
|
|
* Functions for thorough checks on types
|
|
* Instance checks considering generics
|
|
* Typesafe Duck-typing
|
|
|
|
## Example
|
|
|
|
```python
|
|
>>> 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.
|
|
|
|
```python
|
|
@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:*
|
|
```python
|
|
class MyClass(metaclass=SubscriptableType):
|
|
...
|
|
```
|
|
Now you can do:
|
|
```python
|
|
MyClass2 = MyClass['some args']
|
|
print(MyClass2.__args__)
|
|
print(MyClass2.__origin__)
|
|
```
|
|
Output:
|
|
```
|
|
some args
|
|
<class '__main__.MyClass'>
|
|
```
|
|
|
|
#### Something
|
|
Define an interface with ``typish.Something``.
|
|
|
|
*Example:*
|
|
```python
|
|
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:*
|
|
```python
|
|
|
|
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:*
|
|
|
|
```python
|
|
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.
|
|
|
|
|