comment here

.CondaPkg/env/lib/python3.11/site-packages/typish-1.9.3.dist-info/METADATA

@@ -0,0 +1,216 @@
+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'
+
+[![image](https://img.shields.io/pypi/pyversions/typish.svg)](https://pypi.org/project/typish/)
+[![Downloads](https://pepy.tech/badge/typish)](https://pepy.tech/project/typish)
+[![Pypi version](https://badge.fury.io/py/typish.svg)](https://badge.fury.io/py/typish)
+[![codecov](https://codecov.io/gh/ramonhagenaars/typish/branch/master/graph/badge.svg)](https://codecov.io/gh/ramonhagenaars/typish)
+[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/ramonhagenaars/typish/badges/quality-score.png?b=master)](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.
+
+