LostInDarkMath / pedantic-python-decorators / 140

pending completion

Build # 140

Build Type

Pull #14

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/LostInDarkMath/pedantic-python-decorators/commit/<a class=hub.com/LostInDarkMath/pedantic-python-decorators/commit/946e741c77fc158f7f957c40e072587a9a810005">946e741c7<a href="https://github.com/LostInDarkMath/pedantic-python-decorators/commit/946e741c77fc158f7f957c40e072587a9a810005">">Merge </a><a class="double-link" href="https://github.com/LostInDarkMath/pedantic-python-decorators/commit/<a class="double-link" href="https://github.com/LostInDarkMath/pedantic-python-decorators/commit/cdec06113f4356c9ee1c5e470694fe31e85ce8d6">cdec06113</a>">cdec06113</a><a href="https://github.com/LostInDarkMath/pedantic-python-decorators/commit/946e741c77fc158f7f957c40e072587a9a810005"> into ac7f5e04c">ac7f5e04c</a>

Pull Request Pull Request #14: Work in progress: refactoring

Run Details

314 of 314 new or added lines in 5 files covered. (100.0%)

454 of 478 relevant lines covered (94.98%)

4.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.96

/pedantic/type_hint_parser.py

"""Idea is taken from: https://stackoverflow.com/a/55504010/10975692"""
import inspect
import typing
import collections

typing_protocol = typing.Protocol if hasattr(typing, 'Protocol') else typing._Protocol


def is_instance(obj: typing.Any, type_: typing.Any, type_vars) -> bool:
    """The main function of this module. It is called recursively for nested types."""

    assert _has_required_type_arguments(type_), \
        f'The type annotation "{type_}" misses some type arguments e.g. ' \
        f'"typing.Tuple[Any, ...]" or "typing.Callable[..., str]".'

    if type_.__module__ == 'typing':
        if _is_generic(type_):
            origin = _get_base_generic(type_)
        else:
            origin = type_
        name = _get_name(origin)

        if name in _SPECIAL_INSTANCE_CHECKERS:
            validator = _SPECIAL_INSTANCE_CHECKERS[name]
            return validator(obj, type_, type_vars)

    if _is_generic(type_):
        python_type = _get_python_type(type_)
        if not isinstance(obj, python_type):
            return False

        base = _get_base_generic(type_)
        validator = _ORIGIN_TYPE_CHECKERS[base]

        type_args = _get_subtypes(type_)
        return validator(obj, type_args, type_vars)

    if isinstance(type_, typing.TypeVar):
        if type_ in type_vars:
            other = type_vars[type_]
            assert type(obj) == type(other), \
                f'For TypeVar {type_} exists a type conflict: value {obj} has type {type(obj)} and value ' \
                f'{other} has type {type(other)}'
        else:
            type_vars[type_] = obj
        return True

    if _is_type_newtype(type_):
        return isinstance(obj, type_.__supertype__)

    return isinstance(obj, type_)


def _is_type_newtype(type_: typing.Any) -> bool:
    return type_.__qualname__ == typing.NewType('name', int).__qualname__  # arguments of NewType() are arbitrary here


def _get_name(cls: typing.Any) -> str:
    """
    Examples:
        >>> _get_name(typing.Tuple)
        'Tuple'
        >>> _get_name(typing.Callable)
        'Callable'
    """
    if hasattr(cls, '_name'):
        return cls._name
    elif hasattr(cls, '__name__'):
        return cls.__name__
    else:
        return type(cls).__name__[1:]


def _is_generic(cls: typing.Any) -> bool:
    """
    Detects any kind of generic, for example `List` or `List[int]`. This includes "special" types like
    Union and Tuple - anything that's subscriptable, basically.
    Examples:
        >>> _is_generic(int)  # float, bool, str
        False
        >>> _is_generic(typing.List[int])
        True
        >>> _is_generic(typing.List[typing.List[int]])
        True
        >>> _is_generic(typing.Any)
        False
        >>> _is_generic(typing.Callable[[int], int])
        True
    """
    if hasattr(typing, '_GenericAlias'):
        if isinstance(cls, typing._GenericAlias):
            return True

        if isinstance(cls, typing._SpecialForm):
            return cls not in {typing.Any}
    else:
        if isinstance(cls, (typing.GenericMeta, typing._Union, typing._Optional, typing._ClassVar)):
            return True
    return False


def _is_base_generic(cls: typing.Any) -> bool:
    """
        Detects generic base classes.

        Examples:
        >>> _is_base_generic(int)  # int, float, str, bool
        False
        >>> _is_base_generic(typing.List)
        True
        >>> _is_base_generic(typing.Callable)
        True
        >>> _is_base_generic(typing.List[int])
        False
        >>> _is_base_generic(typing.Callable[[int], str])
        False
        >>> _is_base_generic(typing.List[typing.List[int]])
        False
        >>> _is_base_generic(list)
        False
    """

    if hasattr(typing, '_GenericAlias'):
        if isinstance(cls, typing._GenericAlias):
            if cls.__origin__ in {typing.Generic, typing_protocol}:
                return False

            if str(cls) in ['typing.Tuple', 'typing.Callable']:
                return True

            return len(cls.__parameters__) > 0

        if isinstance(cls, typing._SpecialForm):
            return cls._name in {'ClassVar', 'Union', 'Optional'}
    else:
        if isinstance(cls, (typing.GenericMeta, typing._Union)):
            return cls.__args__ in {None, ()}

        if isinstance(cls, typing._Optional):
            return True
    return False


def _has_required_type_arguments(cls: typing.Any) -> bool:
    """Examples:
    >>> _has_required_type_arguments(typing.List)
    False
    >>> _has_required_type_arguments(typing.List[int])
    True
    >>> _has_required_type_arguments(typing.Callable[[int, float], typing.Tuple[float, str]])
    True
    """
    requirements_exact = {
        'Callable': 2,
        'List': 1,
        'Set': 1,
        'FrozenSet': 1,
        'Iterable': 1,
        'Sequence': 1,
        'Dict': 2,
        'Optional': 2,  # because typing.get_args(typing.Optional[int]) returns (int, None)
    }
    requirements_min = {
        'Tuple': 1,
        'Union': 2,
    }
    base: str = _get_name(cls=cls)

    if '[' not in str(cls) and (base in requirements_min or base in requirements_exact):
        return False

    num_type_args = len(_get_type_arguments(cls))

    if base in requirements_exact:
        return requirements_exact[base] == num_type_args
    elif base in requirements_min:
        return requirements_min[base] <= num_type_args
    else:
        return True


def _get_type_arguments(cls: typing.Any) -> typing.Tuple[typing.Any, ...]:
    """Examples:
    >>> _get_type_arguments(int)
    ()
    >>> _get_type_arguments(typing.List) # NOTE: That output here is different on different Python versions!
    (~T,)
    >>> _get_type_arguments(typing.List[int])
    (<class 'int'>,)
    >>> _get_type_arguments(typing.Callable[[int, float], str])
    ([<class 'int'>, <class 'float'>], <class 'str'>)
    >>> _get_type_arguments(typing.Callable[..., str])
    (Ellipsis, <class 'str'>)
    """
    if hasattr(typing, 'get_args'):
        # Python 3.8.0 throws index error here, for argument cls = typing.Callable (without type arguments)
        try:
            return typing.get_args(cls)
        except IndexError:
            return ()
    elif hasattr(cls, '__args__'):
        # return cls.__args__  # DOESNT WORK. So below is the modified (!) implementation of typing.get_args()

        res = cls.__args__
        if res == ():
            return ()

        # origin = _get_origin(cls)
        origin = _get_base_generic(cls)
        if ((origin is typing.Callable) or (origin is collections.abc.Callable)) and res[0] is not Ellipsis:
            res = (list(res[:-1]), res[-1])
        return res
    else:
        return ()


def _get_base_generic(cls: typing.Any) -> typing.Any:
    """
    Examples:
    >>> _get_base_generic(typing.List[float])
    typing.List
    """
    if not hasattr(typing, '_GenericAlias'):
        return cls.__origin__

    if cls._name is None:
        return cls.__origin__
    else:
        return getattr(typing, cls._name)


def _is_subtype(sub_type, super_type):
    if not _is_generic(sub_type):
        python_super = _python_type(super_type)
        python_sub = _python_type(sub_type)
        return issubclass(python_sub, python_super)

    # at this point we know `sub_type` is a generic
    python_sub = _python_type(sub_type)
    python_super = _python_type(super_type)
    if not issubclass(python_sub, python_super):
        return False

    # at this point we know that `sub_type`'s base type is a subtype of `super_type`'s base type.
    # If `super_type` isn't qualified, then there's nothing more to do.
    if not _is_generic(super_type) or _is_base_generic(super_type):
        return True

    # at this point we know that `super_type` is a qualified generic... so if `sub_type` isn't
    # qualified, it can't be a subtype.
    if _is_base_generic(sub_type):
        return False

    # at this point we know that both types are qualified generics, so we just have to
    # compare their sub-types.
    sub_args = _get_subtypes(sub_type)
    super_args = _get_subtypes(super_type)
    return all(_is_subtype(sub_arg, super_arg) for sub_arg, super_arg in zip(sub_args, super_args))


def _python_type(annotation):
    """
    Given a type annotation or a class as input, returns the corresponding python class.

    Examples:
        >>> _python_type(typing.Dict)
        <class 'dict'>
        >>> _python_type(typing.List[int])
        <class 'list'>
        >>> _python_type(int)
        <class 'int'>
        >>> _python_type(typing.Any)
        <class 'object'>
    """
    if hasattr(annotation, 'mro'):
        mro = annotation.mro()
        if typing.Type in mro:
            return annotation._python_type
        elif annotation.__module__ == 'typing':
            return _get_python_type(annotation)
        else:
            return annotation
    elif annotation == typing.Any or annotation == Ellipsis:
        return object
    else:
        return _get_python_type(annotation)


def _get_python_type(cls: typing.Any) -> typing.Any:
    """Like `python_type`, but only works with `typing` classes."""
    if hasattr(cls, '__origin__'):
        return cls.__origin__
    else:
        for typ in cls.mro():
            if typ.__module__ == 'builtins' and typ is not object:
                return typ


def _get_subtypes(cls):
    subtypes = cls.__args__

    if _get_base_generic(cls) is typing.Callable:
        if len(subtypes) != 2 or subtypes[0] is not ...:
            subtypes = (subtypes[:-1], subtypes[-1])
    return subtypes


def _instancecheck_iterable(iterable, type_args, type_vars):
    type_ = type_args[0]
    return all(is_instance(val, type_, type_vars=type_vars) for val in iterable)


def _instancecheck_mapping(mapping, type_args, type_vars):
    return _instancecheck_itemsview(mapping.items(), type_args, type_vars=type_vars)


def _instancecheck_itemsview(itemsview, type_args, type_vars):
    key_type, value_type = type_args
    return all(is_instance(key, key_type, type_vars=type_vars) and
               is_instance(val, value_type, type_vars=type_vars)
               for key, val in itemsview)


def _instancecheck_tuple(tup, type_args, type_vars) -> bool:
    """Examples:
    >>> _instancecheck_tuple(tup=(42.0, 43, 'hi', 'you'), type_args=(typing.Any, Ellipsis), type_vars={})  \
        # = Tuple[Any, ...]
    True
    """
    if Ellipsis in type_args:
        return all(is_instance(val, type_args[0], type_vars=type_vars) for val in tup)

    if len(tup) != len(type_args):
        return False

    return all(is_instance(val, type_, type_vars=type_vars) for val, type_ in zip(tup, type_args))


_ORIGIN_TYPE_CHECKERS = {}
for class_path, check_func in {
    # iterables
    'typing.Container': _instancecheck_iterable,
    'typing.Collection': _instancecheck_iterable,
    'typing.AbstractSet': _instancecheck_iterable,
    'typing.MutableSet': _instancecheck_iterable,
    'typing.Sequence': _instancecheck_iterable,
    'typing.MutableSequence': _instancecheck_iterable,
    'typing.ByteString': _instancecheck_iterable,
    'typing.Deque': _instancecheck_iterable,
    'typing.List': _instancecheck_iterable,
    'typing.Set': _instancecheck_iterable,
    'typing.FrozenSet': _instancecheck_iterable,
    'typing.KeysView': _instancecheck_iterable,
    'typing.ValuesView': _instancecheck_iterable,
    'typing.AsyncIterable': _instancecheck_iterable,

    # mappings
    'typing.Mapping': _instancecheck_mapping,
    'typing.MutableMapping': _instancecheck_mapping,
    'typing.MappingView': _instancecheck_mapping,
    'typing.ItemsView': _instancecheck_itemsview,
    'typing.Dict': _instancecheck_mapping,
    'typing.DefaultDict': _instancecheck_mapping,
    'typing.Counter': _instancecheck_mapping,
    'typing.ChainMap': _instancecheck_mapping,

    # other
    'typing.Tuple': _instancecheck_tuple,
}.items():
    try:
        class_ = eval(class_path)
    except AttributeError:
        continue

    _ORIGIN_TYPE_CHECKERS[class_] = check_func


def _instancecheck_callable(value, type_, _):
    if not callable(value):
        return False

    if _is_base_generic(type_):
        return True

    param_types, ret_type = _get_subtypes(type_)
    sig = inspect.signature(value)

    missing_annotations = []

    if param_types is not ...:
        if len(param_types) != len(sig.parameters):
            return False

        # if any of the existing annotations don't match the type, we'll return False.
        # Then, if any annotations are missing, we'll throw an exception.
        for param, expected_type in zip(sig.parameters.values(), param_types):
            param_type = param.annotation
            if param_type is inspect.Parameter.empty:
                missing_annotations.append(param)
                continue

            if not _is_subtype(param_type, expected_type):
                return False

    if sig.return_annotation is inspect.Signature.empty:
        missing_annotations.append('return')
    else:
        if not _is_subtype(sig.return_annotation, ret_type):
            return False

    assert not missing_annotations, \
        f'Parsing of type annotations failed. Maybe you are about to return a lambda expression. ' \
        f'Try returning an inner function instead. {missing_annotations}'
    return True


def _instancecheck_union(value, type_, type_vars):
    types = _get_subtypes(type_)
    return any(is_instance(value, typ, type_vars=type_vars) for typ in types)


_SPECIAL_INSTANCE_CHECKERS = {
    'Union': _instancecheck_union,
    'Callable': _instancecheck_callable,
    'Any': lambda v, t, tv: True,
}


if __name__ == "__main__":
    import doctest
    doctest.testmod()

1	"""Idea is taken from: https://stackoverflow.com/a/55504010/10975692"""
2	import inspect	5✔
3	import typing	5✔
4	import collections	5✔
5
6	typing_protocol = typing.Protocol if hasattr(typing, 'Protocol') else typing._Protocol	5✔
7
8
9	def is_instance(obj: typing.Any, type_: typing.Any, type_vars) -> bool:	5✔
10	"""The main function of this module. It is called recursively for nested types."""
11
12	assert _has_required_type_arguments(type_), \	5✔
13	f'The type annotation "{type_}" misses some type arguments e.g. ' \
14	f'"typing.Tuple[Any, ...]" or "typing.Callable[..., str]".'
15
16	if type_.__module__ == 'typing':	5✔
17	if _is_generic(type_):	5✔
18	origin = _get_base_generic(type_)	5✔
19	else:
20	origin = type_	5✔
21	name = _get_name(origin)	5✔
22
23	if name in _SPECIAL_INSTANCE_CHECKERS:	5✔
24	validator = _SPECIAL_INSTANCE_CHECKERS[name]	5✔
25	return validator(obj, type_, type_vars)	5✔
26
27	if _is_generic(type_):	5✔
28	python_type = _get_python_type(type_)	5✔
29	if not isinstance(obj, python_type):	5✔
30	return False	5✔
31
32	base = _get_base_generic(type_)	5✔
33	validator = _ORIGIN_TYPE_CHECKERS[base]	5✔
34
35	type_args = _get_subtypes(type_)	5✔
36	return validator(obj, type_args, type_vars)	5✔
37
38	if isinstance(type_, typing.TypeVar):	5✔
39	if type_ in type_vars:	5✔
40	other = type_vars[type_]	5✔
41	assert type(obj) == type(other), \	5✔
42	f'For TypeVar {type_} exists a type conflict: value {obj} has type {type(obj)} and value ' \
43	f'{other} has type {type(other)}'
44	else:
45	type_vars[type_] = obj	5✔
46	return True	5✔
47
48	if _is_type_newtype(type_):	5✔
49	return isinstance(obj, type_.__supertype__)	5✔
50
51	return isinstance(obj, type_)	5✔
52
53
54	def _is_type_newtype(type_: typing.Any) -> bool:	5✔
55	return type_.__qualname__ == typing.NewType('name', int).__qualname__ # arguments of NewType() are arbitrary here	5✔
56
57
58	def _get_name(cls: typing.Any) -> str:	5✔
59	"""
60	Examples:
61	>>> _get_name(typing.Tuple)
62	'Tuple'
63	>>> _get_name(typing.Callable)
64	'Callable'
65	"""
66	if hasattr(cls, '_name'):	5✔
67	return cls._name	4✔
68	elif hasattr(cls, '__name__'):	5✔
69	return cls.__name__	5✔
70	else:
71	return type(cls).__name__[1:]	5✔
72
73
74	def _is_generic(cls: typing.Any) -> bool:	5✔
75	"""
76	Detects any kind of generic, for example `List` or `List[int]`. This includes "special" types like
77	Union and Tuple - anything that's subscriptable, basically.
78	Examples:
79	>>> _is_generic(int) # float, bool, str
80	False
81	>>> _is_generic(typing.List[int])
82	True
83	>>> _is_generic(typing.List[typing.List[int]])
84	True
85	>>> _is_generic(typing.Any)
86	False
87	>>> _is_generic(typing.Callable[[int], int])
88	True
89	"""
90	if hasattr(typing, '_GenericAlias'):	5✔
91	if isinstance(cls, typing._GenericAlias):	4✔
92	return True	4✔
93
94	if isinstance(cls, typing._SpecialForm):	4✔
95	return cls not in {typing.Any}	4✔
96	else:
97	if isinstance(cls, (typing.GenericMeta, typing._Union, typing._Optional, typing._ClassVar)):	1✔
98	return True	1✔
99	return False	5✔
100
101
102	def _is_base_generic(cls: typing.Any) -> bool:	5✔
103	"""
104	Detects generic base classes.
105
106	Examples:
107	>>> _is_base_generic(int) # int, float, str, bool
108	False
109	>>> _is_base_generic(typing.List)
110	True
111	>>> _is_base_generic(typing.Callable)
112	True
113	>>> _is_base_generic(typing.List[int])
114	False
115	>>> _is_base_generic(typing.Callable[[int], str])
116	False
117	>>> _is_base_generic(typing.List[typing.List[int]])
118	False
119	>>> _is_base_generic(list)
120	False
121	"""
122
123	if hasattr(typing, '_GenericAlias'):	5✔
124	if isinstance(cls, typing._GenericAlias):	4✔
125	if cls.__origin__ in {typing.Generic, typing_protocol}:	4✔
126	return False	×
127
128	if str(cls) in ['typing.Tuple', 'typing.Callable']:	4✔
129	return True	×
130
131	return len(cls.__parameters__) > 0	4✔
132
133	if isinstance(cls, typing._SpecialForm):	×
134	return cls._name in {'ClassVar', 'Union', 'Optional'}	×
135	else:
136	if isinstance(cls, (typing.GenericMeta, typing._Union)):	1✔
137	return cls.__args__ in {None, ()}	1✔
138
139	if isinstance(cls, typing._Optional):	×
140	return True	×
141	return False	×
142
143
144	def _has_required_type_arguments(cls: typing.Any) -> bool:	5✔
145	"""Examples:
146	>>> _has_required_type_arguments(typing.List)
147	False
148	>>> _has_required_type_arguments(typing.List[int])
149	True
150	>>> _has_required_type_arguments(typing.Callable[[int, float], typing.Tuple[float, str]])
151	True
152	"""
153	requirements_exact = {	5✔
154	'Callable': 2,
155	'List': 1,
156	'Set': 1,
157	'FrozenSet': 1,
158	'Iterable': 1,
159	'Sequence': 1,
160	'Dict': 2,
161	'Optional': 2, # because typing.get_args(typing.Optional[int]) returns (int, None)
162	}
163	requirements_min = {	5✔
164	'Tuple': 1,
165	'Union': 2,
166	}
167	base: str = _get_name(cls=cls)	5✔
168
169	if '[' not in str(cls) and (base in requirements_min or base in requirements_exact):	5✔
170	return False	5✔
171
172	num_type_args = len(_get_type_arguments(cls))	5✔
173
174	if base in requirements_exact:	5✔
175	return requirements_exact[base] == num_type_args	5✔
176	elif base in requirements_min:	5✔
177	return requirements_min[base] <= num_type_args	5✔
178	else:
179	return True	5✔
180
181
182	def _get_type_arguments(cls: typing.Any) -> typing.Tuple[typing.Any, ...]:	5✔
183	"""Examples:
184	>>> _get_type_arguments(int)
185	()
186	>>> _get_type_arguments(typing.List) # NOTE: That output here is different on different Python versions!
187	(~T,)
188	>>> _get_type_arguments(typing.List[int])
189	(<class 'int'>,)
190	>>> _get_type_arguments(typing.Callable[[int, float], str])
191	([<class 'int'>, <class 'float'>], <class 'str'>)
192	>>> _get_type_arguments(typing.Callable[..., str])
193	(Ellipsis, <class 'str'>)
194	"""
195	if hasattr(typing, 'get_args'):	5✔
196	# Python 3.8.0 throws index error here, for argument cls = typing.Callable (without type arguments)
197	try:	3✔
198	return typing.get_args(cls)	3✔
199	except IndexError:	×
200	return ()	×
201	elif hasattr(cls, '__args__'):	2✔
202	# return cls.__args__ # DOESNT WORK. So below is the modified (!) implementation of typing.get_args()
203
204	res = cls.__args__	2✔
205	if res == ():	2✔
206	return ()	×
207
208	# origin = _get_origin(cls)
209	origin = _get_base_generic(cls)	2✔
210	if ((origin is typing.Callable) or (origin is collections.abc.Callable)) and res[0] is not Ellipsis:	2✔
211	res = (list(res[:-1]), res[-1])	2✔
212	return res	2✔
213	else:
214	return ()	2✔
215
216
217	def _get_base_generic(cls: typing.Any) -> typing.Any:	5✔
218	"""
219	Examples:
220	>>> _get_base_generic(typing.List[float])
221	typing.List
222	"""
223	if not hasattr(typing, '_GenericAlias'):	5✔
224	return cls.__origin__	1✔
225
226	if cls._name is None:	4✔
227	return cls.__origin__	4✔
228	else:
229	return getattr(typing, cls._name)	4✔
230
231
232	def _is_subtype(sub_type, super_type):	5✔
233	if not _is_generic(sub_type):	5✔
234	python_super = _python_type(super_type)	5✔
235	python_sub = _python_type(sub_type)	5✔
236	return issubclass(python_sub, python_super)	5✔
237
238	# at this point we know `sub_type` is a generic
239	python_sub = _python_type(sub_type)	5✔
240	python_super = _python_type(super_type)	5✔
241	if not issubclass(python_sub, python_super):	5✔
242	return False	×
243
244	# at this point we know that `sub_type`'s base type is a subtype of `super_type`'s base type.
245	# If `super_type` isn't qualified, then there's nothing more to do.
246	if not _is_generic(super_type) or _is_base_generic(super_type):	5✔
247	return True	×
248
249	# at this point we know that `super_type` is a qualified generic... so if `sub_type` isn't
250	# qualified, it can't be a subtype.
251	if _is_base_generic(sub_type):	5✔
252	return False	×
253
254	# at this point we know that both types are qualified generics, so we just have to
255	# compare their sub-types.
256	sub_args = _get_subtypes(sub_type)	5✔
257	super_args = _get_subtypes(super_type)	5✔
258	return all(_is_subtype(sub_arg, super_arg) for sub_arg, super_arg in zip(sub_args, super_args))	5✔
259
260
261	def _python_type(annotation):	5✔
262	"""
263	Given a type annotation or a class as input, returns the corresponding python class.
264
265	Examples:
266	>>> _python_type(typing.Dict)
267	<class 'dict'>
268	>>> _python_type(typing.List[int])
269	<class 'list'>
270	>>> _python_type(int)
271	<class 'int'>
272	>>> _python_type(typing.Any)
273	<class 'object'>
274	"""
275	if hasattr(annotation, 'mro'):	5✔
276	mro = annotation.mro()	5✔
277	if typing.Type in mro:	5✔
278	return annotation._python_type	×
279	elif annotation.__module__ == 'typing':	5✔
280	return _get_python_type(annotation)	5✔
281	else:
282	return annotation	5✔
283	elif annotation == typing.Any or annotation == Ellipsis:	5✔
284	return object	5✔
285	else:
286	return _get_python_type(annotation)	×
287
288
289	def _get_python_type(cls: typing.Any) -> typing.Any:	5✔
290	"""Like `python_type`, but only works with `typing` classes."""
291	if hasattr(cls, '__origin__'):	5✔
292	return cls.__origin__	5✔
293	else:
294	for typ in cls.mro():	×
295	if typ.__module__ == 'builtins' and typ is not object:	×
296	return typ	×
297
298
299	def _get_subtypes(cls):	5✔
300	subtypes = cls.__args__	5✔
301
302	if _get_base_generic(cls) is typing.Callable:	5✔
303	if len(subtypes) != 2 or subtypes[0] is not ...:	5✔
304	subtypes = (subtypes[:-1], subtypes[-1])	5✔
305	return subtypes	5✔
306
307
308	def _instancecheck_iterable(iterable, type_args, type_vars):	5✔
309	type_ = type_args[0]	5✔
310	return all(is_instance(val, type_, type_vars=type_vars) for val in iterable)	5✔
311
312
313	def _instancecheck_mapping(mapping, type_args, type_vars):	5✔
314	return _instancecheck_itemsview(mapping.items(), type_args, type_vars=type_vars)	5✔
315
316
317	def _instancecheck_itemsview(itemsview, type_args, type_vars):	5✔
318	key_type, value_type = type_args	5✔
319	return all(is_instance(key, key_type, type_vars=type_vars) and	5✔
320	is_instance(val, value_type, type_vars=type_vars)
321	for key, val in itemsview)
322
323
324	def _instancecheck_tuple(tup, type_args, type_vars) -> bool:	5✔
325	"""Examples:
326	>>> _instancecheck_tuple(tup=(42.0, 43, 'hi', 'you'), type_args=(typing.Any, Ellipsis), type_vars={}) \
327	# = Tuple[Any, ...]
328	True
329	"""
330	if Ellipsis in type_args:	5✔
331	return all(is_instance(val, type_args[0], type_vars=type_vars) for val in tup)	5✔
332
333	if len(tup) != len(type_args):	5✔
334	return False	×
335
336	return all(is_instance(val, type_, type_vars=type_vars) for val, type_ in zip(tup, type_args))	5✔
337
338
339	_ORIGIN_TYPE_CHECKERS = {}	5✔
340	for class_path, check_func in {	5✔
341	# iterables
342	'typing.Container': _instancecheck_iterable,
343	'typing.Collection': _instancecheck_iterable,
344	'typing.AbstractSet': _instancecheck_iterable,
345	'typing.MutableSet': _instancecheck_iterable,
346	'typing.Sequence': _instancecheck_iterable,
347	'typing.MutableSequence': _instancecheck_iterable,
348	'typing.ByteString': _instancecheck_iterable,
349	'typing.Deque': _instancecheck_iterable,
350	'typing.List': _instancecheck_iterable,
351	'typing.Set': _instancecheck_iterable,
352	'typing.FrozenSet': _instancecheck_iterable,
353	'typing.KeysView': _instancecheck_iterable,
354	'typing.ValuesView': _instancecheck_iterable,
355	'typing.AsyncIterable': _instancecheck_iterable,
356
357	# mappings
358	'typing.Mapping': _instancecheck_mapping,
359	'typing.MutableMapping': _instancecheck_mapping,
360	'typing.MappingView': _instancecheck_mapping,
361	'typing.ItemsView': _instancecheck_itemsview,
362	'typing.Dict': _instancecheck_mapping,
363	'typing.DefaultDict': _instancecheck_mapping,
364	'typing.Counter': _instancecheck_mapping,
365	'typing.ChainMap': _instancecheck_mapping,
366
367	# other
368	'typing.Tuple': _instancecheck_tuple,
369	}.items():
370	try:	5✔
371	class_ = eval(class_path)	5✔
372	except AttributeError:	×
373	continue	×
374
375	_ORIGIN_TYPE_CHECKERS[class_] = check_func	5✔
376
377
378	def _instancecheck_callable(value, type_, _):	5✔
379	if not callable(value):	5✔
380	return False	×
381
382	if _is_base_generic(type_):	5✔
383	return True	×
384
385	param_types, ret_type = _get_subtypes(type_)	5✔
386	sig = inspect.signature(value)	5✔
387
388	missing_annotations = []	5✔
389
390	if param_types is not ...:	5✔
391	if len(param_types) != len(sig.parameters):	5✔
392	return False	×
393
394	# if any of the existing annotations don't match the type, we'll return False.
395	# Then, if any annotations are missing, we'll throw an exception.
396	for param, expected_type in zip(sig.parameters.values(), param_types):	5✔
397	param_type = param.annotation	5✔
398	if param_type is inspect.Parameter.empty:	5✔
399	missing_annotations.append(param)	5✔
400	continue	5✔
401
402	if not _is_subtype(param_type, expected_type):	5✔
403	return False	5✔
404
405	if sig.return_annotation is inspect.Signature.empty:	5✔
406	missing_annotations.append('return')	5✔
407	else:
408	if not _is_subtype(sig.return_annotation, ret_type):	5✔
409	return False	5✔
410
411	assert not missing_annotations, \	5✔
412	f'Parsing of type annotations failed. Maybe you are about to return a lambda expression. ' \
413	f'Try returning an inner function instead. {missing_annotations}'
414	return True	5✔
415
416
417	def _instancecheck_union(value, type_, type_vars):	5✔
418	types = _get_subtypes(type_)	5✔
419	return any(is_instance(value, typ, type_vars=type_vars) for typ in types)	5✔
420
421
422	_SPECIAL_INSTANCE_CHECKERS = {	5✔
423	'Union': _instancecheck_union,
424	'Callable': _instancecheck_callable,
425	'Any': lambda v, t, tv: True,
426	}
427
428
429	if __name__ == "__main__":
430	import doctest
431	doctest.testmod()

LostInDarkMath / pedantic-python-decorators / 140

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous