558212668

Build Type

push

travis-pro

Committed by GitHub

Commit Message

<a href="https://github.com/santinic/pampy/commit/<a class=hub.com/santinic/pampy/commit/7073e6f9deff7480f07c16b2ec27f06a17fd1d61">7073e6f9d<a href="https://github.com/santinic/pampy/commit/7073e6f9deff7480f07c16b2ec27f06a17fd1d61">">Merge </a><a class="double-link" href="https://github.com/santinic/pampy/commit/<a class="double-link" href="https://github.com/santinic/pampy/commit/2bafe3dda541b06387c8d9c09f54628bcd180d0f">2bafe3dda</a>">2bafe3dda</a><a href="https://github.com/santinic/pampy/commit/7073e6f9deff7480f07c16b2ec27f06a17fd1d61"> into a2d8efb21">a2d8efb21</a>

Run Details

231 of 231 new or added lines in 4 files covered. (100.0%)

701 of 728 relevant lines covered (96.29%)

0.96 hits per line

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

95.5

/pampy/pampy.py

from collections.abc import (
    Iterable,
    Mapping,
    Callable as ACallable,
)
from itertools import zip_longest
from enum import Enum
from typing import (
    Any,
    Generic,
    TypeVar,
    Tuple,
    List,
    Pattern as RegexPattern,
    Callable,
)
import inspect

from pampy.helpers import (
    UnderscoreType,
    HeadType,
    TailType,
    get_lambda_args_error_msg,
    BoxedArgs,
    PaddedValue,
    NoDefault,
    is_typing_stuff,
    is_dataclass,
    is_generic,
    is_newtype,
    is_union,
    pairwise,
    peek,
    get_real_type,
    get_extra,
)

T = TypeVar('T')
_ = ANY = UnderscoreType()
HEAD = HeadType()
REST = TAIL = TailType()


def run(action, var):
    if callable(action):
        if isinstance(var, Iterable):
            try:
                return action(*var)
            except TypeError as err:
                raise MatchError(get_lambda_args_error_msg(action, var, err))
        elif isinstance(var, BoxedArgs):
            return action(var.get())
        else:
            return action(var)
    else:
        return action


def match_value(pattern, value) -> Tuple[bool, List]:
    if value is PaddedValue:
        return False, []
    elif is_typing_stuff(pattern):
        return match_typing_stuff(pattern, value)
    elif isinstance(pattern, (int, float, str, bool, Enum)):
        eq = pattern == value
        type_eq = type(pattern) == type(value)
        return eq and type_eq, []
    elif pattern is None:
        return value is None, []
    elif isinstance(pattern, type):
        if isinstance(value, pattern):
            return True, [value]
    elif isinstance(pattern, (list, tuple)):
        return match_iterable(pattern, value)
    elif isinstance(pattern, dict):
        return match_dict(pattern, value)
    elif callable(pattern):
        return_value = pattern(value)

        if isinstance(return_value, bool):
            return return_value, [value]
        elif isinstance(return_value, tuple) and len(return_value) == 2 \
                and isinstance(return_value[0], bool) and isinstance(return_value[1], list):
            return return_value
        else:
            raise MatchError("Warning! pattern function %s is not returning a boolean "
                             "nor a tuple of (boolean, list), but instead %s" %
                             (pattern, return_value))
    elif isinstance(pattern, RegexPattern):
        rematch = pattern.search(value)
        if rematch is not None:
            return True, list(rematch.groups())
    elif pattern is _:
        return True, [value]
    elif pattern is HEAD or pattern is TAIL:
        raise MatchError("HEAD or TAIL should only be used inside an Iterable (list or tuple).")
    elif is_dataclass(pattern) and pattern.__class__ == value.__class__:
        return match_dict(pattern.__dict__, value.__dict__)
    return False, []


def match_dict(pattern, value) -> Tuple[bool, List]:
    if not isinstance(value, dict) or not isinstance(pattern, dict):
        return False, []

    total_extracted = []
    still_usable_value_keys = set(value.keys())
    still_usable_pattern_keys = set(pattern.keys())
    for pkey, pval in pattern.items():
        if pkey not in still_usable_pattern_keys:
            continue
        matched_left_and_right = False
        for vkey, vval in value.items():
            if vkey not in still_usable_value_keys:
                continue
            if pkey not in still_usable_pattern_keys:
                continue
            key_matched, key_extracted = match_value(pkey, vkey)
            if key_matched:
                value_matched, value_extracted = match_value(pval, vval)
                if value_matched:
                    total_extracted += key_extracted + value_extracted
                    matched_left_and_right = True
                    still_usable_pattern_keys.remove(pkey)
                    still_usable_value_keys.remove(vkey)
                    break
        if not matched_left_and_right:
            return False, []
    return True, total_extracted


def only_padded_values_follow(padded_pairs, i):
    i += 1
    while i < len(padded_pairs):
        pattern, value = padded_pairs[i]
        if pattern is not PaddedValue:
            return False
        i += 1
    return True


def match_iterable(patterns, values) -> Tuple[bool, List]:
    if not isinstance(patterns, Iterable) or not isinstance(values, Iterable):
        return False, []

    total_extracted = []
    padded_pairs = list(zip_longest(patterns, values, fillvalue=PaddedValue))

    for i, (pattern, value) in enumerate(padded_pairs):
        if pattern is HEAD:
            if i != 0:
                raise MatchError("HEAD can only be in first position of a pattern.")
            else:
                if value is PaddedValue:
                    return False, []
                else:
                    total_extracted += [value]
        elif pattern is TAIL:
            if not only_padded_values_follow(padded_pairs, i):
                raise MatchError("TAIL must me in last position of the pattern.")
            else:
                tail = [value for (pattern, value) in padded_pairs[i:] if value is not PaddedValue]
                total_extracted.append(tail)
                break
        else:
            matched, extracted = match_value(pattern, value)
            if not matched:
                return False, []
            else:
                total_extracted += extracted
    return True, total_extracted


def match_typing_stuff(pattern, value) -> Tuple[bool, List]:
    if pattern == Any:
        return match_value(ANY, value)
    elif is_union(pattern):
        for subpattern in pattern.__args__:
            is_matched, extracted = match_value(subpattern, value)
            if is_matched:
                return True, extracted
        else:
            return False, []
    elif is_newtype(pattern):
        return match_value(pattern.__supertype__, value)
    elif is_generic(pattern):
        return match_generic(pattern, value)
    else:
        return False, []


def match_generic(pattern: Generic[T], value) -> Tuple[bool, List]:
    if get_extra(pattern) == type:       # Type[int] for example
        real_value = None
        if is_newtype(value):
            real_value = value
            value = get_real_type(value)
        if not inspect.isclass(value):
            return False, []

        type_ = pattern.__args__[0]
        if type_ == Any:
            return True, [real_value or value]
        if is_newtype(type_):   # NewType case
            type_ = get_real_type(type_)

        if issubclass(value, type_):
            return True, [real_value or value]
        else:
            return False, []

    elif get_extra(pattern) == ACallable:
        if callable(value):
            spec = inspect.getfullargspec(value)
            annotations = spec.annotations
            artgtypes = [annotations.get(arg, Any) for arg in spec.args]
            ret_type = annotations.get('return', Any)
            if pattern == Callable[[*artgtypes], ret_type]:
                return True, [value]
            else:
                return False, []
        else:
            return False, []

    elif get_extra(pattern) == tuple:
        return match_value(pattern.__args__, value)

    elif issubclass(get_extra(pattern), Mapping):
        type_matched, _captured = match_value(get_extra(pattern), value)
        if not type_matched:
            return False, []
        k_type, v_type = pattern.__args__

        key_example = peek(value)
        key_matched, _captured = match_value(k_type, key_example)
        if not key_matched:
            return False, []

        value_matched, _captured = match_value(v_type, value[key_example])
        if not value_matched:
            return False, []
        else:
            return True, [value]

    elif issubclass(get_extra(pattern), Iterable):
        type_matched, _captured = match_value(get_extra(pattern), value)
        if not type_matched:
            return False, []
        v_type, = pattern.__args__
        v = peek(value)
        value_matched, _captured = match_value(v_type, v)
        if not value_matched:
            return False, []
        else:
            return True, [value]
    else:
        return False, []


def match(var, *args, default=NoDefault, strict=True):
    """
    Match `var` against a number of potential patterns.

    Example usage:
    ```
    match(x,
        3,              "this matches the number 3",
        int,            "matches any integer",
        (str, int),     lambda a, b: "a tuple (a, b) you can use in a function",
        [1, 2, _],      "any list of 3 elements that begins with [1, 2]",
        {'x': _},       "any dict with a key 'x' and any value associated",
        _,              "anything else"
    )
    ```

    :param var: The variable to test patterns against.
    :param args: Alternating patterns and actions. There must be an action for every pattern specified.
                 Patterns can take many forms, see README.md for examples.
                 Actions can be either a literal value or a callable which will be called with the arguments that were
                    matched in corresponding pattern.
    :param default: If `default` is specified then it will be returned if none of the patterns match.
                    If `default` is unspecified then a `MatchError` will be thrown instead.
    :return: The result of the action which corresponds to the first matching pattern.
    """
    if len(args) % 2 != 0:
        raise MatchError("Every guard must have an action.")

    if default is NoDefault and strict is False:
        default = False

    pairs = list(pairwise(args))
    patterns = [patt for (patt, action) in pairs]

    for patt, action in pairs:
        matched_as_value, args = match_value(patt, var)

        if matched_as_value:
            lambda_args = args if len(args) > 0 else BoxedArgs(var)
            return run(action, lambda_args)

    if default is NoDefault:
        if _ not in patterns:
            raise MatchError("'_' not provided. This case is not handled:\n%s" % str(var))
    else:
        return default


class MatchError(Exception):
    def __init__(self, msg):
        super().__init__(msg)

1	from collections.abc import (	1✔
2	Iterable,
3	Mapping,
4	Callable as ACallable,
5	)
6	from itertools import zip_longest	1✔
7	from enum import Enum	1✔
8	from typing import (	1✔
9	Any,
10	Generic,
11	TypeVar,
12	Tuple,
13	List,
14	Pattern as RegexPattern,
15	Callable,
16	)
17	import inspect	1✔
18
19	from pampy.helpers import (	1✔
20	UnderscoreType,
21	HeadType,
22	TailType,
23	get_lambda_args_error_msg,
24	BoxedArgs,
25	PaddedValue,
26	NoDefault,
27	is_typing_stuff,
28	is_dataclass,
29	is_generic,
30	is_newtype,
31	is_union,
32	pairwise,
33	peek,
34	get_real_type,
35	get_extra,
36	)
37
38	T = TypeVar('T')	1✔
39	_ = ANY = UnderscoreType()	1✔
40	HEAD = HeadType()	1✔
41	REST = TAIL = TailType()	1✔
42
43
44	def run(action, var):	1✔
45	if callable(action):	1✔
46	if isinstance(var, Iterable):	1✔
47	try:	1✔
48	return action(*var)	1✔
49	except TypeError as err:	1✔
50	raise MatchError(get_lambda_args_error_msg(action, var, err))	1✔
51	elif isinstance(var, BoxedArgs):	1✔
52	return action(var.get())	1✔
53	else:
54	return action(var)	×
55	else:
56	return action	1✔
57
58
59	def match_value(pattern, value) -> Tuple[bool, List]:	1✔
60	if value is PaddedValue:	1✔
61	return False, []	1✔
62	elif is_typing_stuff(pattern):	1✔
63	return match_typing_stuff(pattern, value)	1✔
64	elif isinstance(pattern, (int, float, str, bool, Enum)):	1✔
65	eq = pattern == value	1✔
66	type_eq = type(pattern) == type(value)	1✔
67	return eq and type_eq, []	1✔
68	elif pattern is None:	1✔
69	return value is None, []	1✔
70	elif isinstance(pattern, type):	1✔
71	if isinstance(value, pattern):	1✔
72	return True, [value]	1✔
73	elif isinstance(pattern, (list, tuple)):	1✔
74	return match_iterable(pattern, value)	1✔
75	elif isinstance(pattern, dict):	1✔
76	return match_dict(pattern, value)	1✔
77	elif callable(pattern):	1✔
78	return_value = pattern(value)	1✔
79
80	if isinstance(return_value, bool):	1✔
81	return return_value, [value]	1✔
82	elif isinstance(return_value, tuple) and len(return_value) == 2 \	1✔
83	and isinstance(return_value[0], bool) and isinstance(return_value[1], list):
84	return return_value	1✔
85	else:
86	raise MatchError("Warning! pattern function %s is not returning a boolean "	×
87	"nor a tuple of (boolean, list), but instead %s" %
88	(pattern, return_value))
89	elif isinstance(pattern, RegexPattern):	1✔
90	rematch = pattern.search(value)	1✔
91	if rematch is not None:	1✔
92	return True, list(rematch.groups())	1✔
93	elif pattern is _:	1✔
94	return True, [value]	1✔
95	elif pattern is HEAD or pattern is TAIL:	1✔
96	raise MatchError("HEAD or TAIL should only be used inside an Iterable (list or tuple).")	×
97	elif is_dataclass(pattern) and pattern.__class__ == value.__class__:	1✔
98	return match_dict(pattern.__dict__, value.__dict__)	1✔
99	return False, []	1✔
100
101
102	def match_dict(pattern, value) -> Tuple[bool, List]:	1✔
103	if not isinstance(value, dict) or not isinstance(pattern, dict):	1✔
104	return False, []	1✔
105
106	total_extracted = []	1✔
107	still_usable_value_keys = set(value.keys())	1✔
108	still_usable_pattern_keys = set(pattern.keys())	1✔
109	for pkey, pval in pattern.items():	1✔
110	if pkey not in still_usable_pattern_keys:	1✔
111	continue	×
112	matched_left_and_right = False	1✔
113	for vkey, vval in value.items():	1✔
114	if vkey not in still_usable_value_keys:	1✔
115	continue	1✔
116	if pkey not in still_usable_pattern_keys:	1✔
117	continue	×
118	key_matched, key_extracted = match_value(pkey, vkey)	1✔
119	if key_matched:	1✔
120	value_matched, value_extracted = match_value(pval, vval)	1✔
121	if value_matched:	1✔
122	total_extracted += key_extracted + value_extracted	1✔
123	matched_left_and_right = True	1✔
124	still_usable_pattern_keys.remove(pkey)	1✔
125	still_usable_value_keys.remove(vkey)	1✔
126	break	1✔
127	if not matched_left_and_right:	1✔
128	return False, []	1✔
129	return True, total_extracted	1✔
130
131
132	def only_padded_values_follow(padded_pairs, i):	1✔
133	i += 1	1✔
134	while i < len(padded_pairs):	1✔
135	pattern, value = padded_pairs[i]	1✔
136	if pattern is not PaddedValue:	1✔
137	return False	1✔
138	i += 1	1✔
139	return True	1✔
140
141
142	def match_iterable(patterns, values) -> Tuple[bool, List]:	1✔
143	if not isinstance(patterns, Iterable) or not isinstance(values, Iterable):	1✔
144	return False, []	1✔
145
146	total_extracted = []	1✔
147	padded_pairs = list(zip_longest(patterns, values, fillvalue=PaddedValue))	1✔
148
149	for i, (pattern, value) in enumerate(padded_pairs):	1✔
150	if pattern is HEAD:	1✔
151	if i != 0:	1✔
152	raise MatchError("HEAD can only be in first position of a pattern.")	1✔
153	else:
154	if value is PaddedValue:	1✔
155	return False, []	1✔
156	else:
157	total_extracted += [value]	1✔
158	elif pattern is TAIL:	1✔
159	if not only_padded_values_follow(padded_pairs, i):	1✔
160	raise MatchError("TAIL must me in last position of the pattern.")	1✔
161	else:
162	tail = [value for (pattern, value) in padded_pairs[i:] if value is not PaddedValue]	1✔
163	total_extracted.append(tail)	1✔
164	break	1✔
165	else:
166	matched, extracted = match_value(pattern, value)	1✔
167	if not matched:	1✔
168	return False, []	1✔
169	else:
170	total_extracted += extracted	1✔
171	return True, total_extracted	1✔
172
173
174	def match_typing_stuff(pattern, value) -> Tuple[bool, List]:	1✔
175	if pattern == Any:	1✔
176	return match_value(ANY, value)	1✔
177	elif is_union(pattern):	1✔
178	for subpattern in pattern.__args__:	1✔
179	is_matched, extracted = match_value(subpattern, value)	1✔
180	if is_matched:	1✔
181	return True, extracted	1✔
182	else:
183	return False, []	1✔
184	elif is_newtype(pattern):	1✔
185	return match_value(pattern.__supertype__, value)	1✔
186	elif is_generic(pattern):	1✔
187	return match_generic(pattern, value)	1✔
188	else:
189	return False, []	×
190
191
192	def match_generic(pattern: Generic[T], value) -> Tuple[bool, List]:	1✔
193	if get_extra(pattern) == type: # Type[int] for example	1✔
194	real_value = None	1✔
195	if is_newtype(value):	1✔
196	real_value = value	1✔
197	value = get_real_type(value)	1✔
198	if not inspect.isclass(value):	1✔
199	return False, []	1✔
200
201	type_ = pattern.__args__[0]	1✔
202	if type_ == Any:	1✔
203	return True, [real_value or value]	1✔
204	if is_newtype(type_): # NewType case	1✔
205	type_ = get_real_type(type_)	1✔
206
207	if issubclass(value, type_):	1✔
208	return True, [real_value or value]	1✔
209	else:
210	return False, []	1✔
211
212	elif get_extra(pattern) == ACallable:	1✔
213	if callable(value):	1✔
214	spec = inspect.getfullargspec(value)	1✔
215	annotations = spec.annotations	1✔
216	artgtypes = [annotations.get(arg, Any) for arg in spec.args]	1✔
217	ret_type = annotations.get('return', Any)	1✔
218	if pattern == Callable[[*artgtypes], ret_type]:	1✔
219	return True, [value]	1✔
220	else:
221	return False, []	1✔
222	else:
223	return False, []	1✔
224
225	elif get_extra(pattern) == tuple:	1✔
226	return match_value(pattern.__args__, value)	1✔
227
228	elif issubclass(get_extra(pattern), Mapping):	1✔
229	type_matched, _captured = match_value(get_extra(pattern), value)	1✔
230	if not type_matched:	1✔
231	return False, []	×
232	k_type, v_type = pattern.__args__	1✔
233
234	key_example = peek(value)	1✔
235	key_matched, _captured = match_value(k_type, key_example)	1✔
236	if not key_matched:	1✔
237	return False, []	1✔
238
239	value_matched, _captured = match_value(v_type, value[key_example])	1✔
240	if not value_matched:	1✔
241	return False, []	1✔
242	else:
243	return True, [value]	1✔
244
245	elif issubclass(get_extra(pattern), Iterable):	1✔
246	type_matched, _captured = match_value(get_extra(pattern), value)	1✔
247	if not type_matched:	1✔
248	return False, []	1✔
249	v_type, = pattern.__args__	1✔
250	v = peek(value)	1✔
251	value_matched, _captured = match_value(v_type, v)	1✔
252	if not value_matched:	1✔
253	return False, []	1✔
254	else:
255	return True, [value]	1✔
256	else:
257	return False, []	×
258
259
260	def match(var, *args, default=NoDefault, strict=True):	1✔
261	"""
262	Match `var` against a number of potential patterns.
263
264	Example usage:
265	```
266	match(x,
267	3, "this matches the number 3",
268	int, "matches any integer",
269	(str, int), lambda a, b: "a tuple (a, b) you can use in a function",
270	[1, 2, _], "any list of 3 elements that begins with [1, 2]",
271	{'x': _}, "any dict with a key 'x' and any value associated",
272	_, "anything else"
273	)
274	```
275
276	:param var: The variable to test patterns against.
277	:param args: Alternating patterns and actions. There must be an action for every pattern specified.
278	Patterns can take many forms, see README.md for examples.
279	Actions can be either a literal value or a callable which will be called with the arguments that were
280	matched in corresponding pattern.
281	:param default: If `default` is specified then it will be returned if none of the patterns match.
282	If `default` is unspecified then a `MatchError` will be thrown instead.
283	:return: The result of the action which corresponds to the first matching pattern.
284	"""
285	if len(args) % 2 != 0:	1✔
286	raise MatchError("Every guard must have an action.")	×
287
288	if default is NoDefault and strict is False:	1✔
289	default = False	1✔
290
291	pairs = list(pairwise(args))	1✔
292	patterns = [patt for (patt, action) in pairs]	1✔
293
294	for patt, action in pairs:	1✔
295	matched_as_value, args = match_value(patt, var)	1✔
296
297	if matched_as_value:	1✔
298	lambda_args = args if len(args) > 0 else BoxedArgs(var)	1✔
299	return run(action, lambda_args)	1✔
300
301	if default is NoDefault:	1✔
302	if _ not in patterns:	1✔
303	raise MatchError("'_' not provided. This case is not handled:\n%s" % str(var))	1✔
304	else:
305	return default	1✔
306
307
308	class MatchError(Exception):	1✔
309	def __init__(self, msg):	1✔
310	super().__init__(msg)	1✔

santinic / pampy / 558212668

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