structured_data.match.names() - Code Metrics - Inspection of "Factor common logic of the utility functions toget..." - mwchase/python-structured-data - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 2e0d62...d2554f )

by Max

created 2018-07-17 21:59 UTC

structured_data.match.names() B

↳ Parent: structured_data.match

Complexity

Conditions

Size

Total Lines	19
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	18
nop	1
dl	0
loc	19
rs	8.5666
c	0
b	0
f	0

import collections
import keyword
import weakref

from ._enum_constructor import EnumConstructor
from ._unpack import unpack

ATTRIBUTE_CONSTRUCTORS = weakref.WeakKeyDictionary()
ATTRIBUTE_CACHE = weakref.WeakKeyDictionary()


class AttributeConstructor:

    __slots__ = ('__weakref__',)

    def __init__(self, constructor):
        ATTRIBUTE_CONSTRUCTORS[self] = constructor
        ATTRIBUTE_CACHE[self] = {}

    def __getattribute__(self, name):
        return ATTRIBUTE_CACHE[self].setdefault(
            name, ATTRIBUTE_CONSTRUCTORS[self](name))


class MatchFailure(BaseException):
    """An exception that signals a failure in ADT matching."""


def desugar(constructor: type, instance: tuple) -> tuple:
    """Return the inside of an ADT instance, given its constructor."""
    if instance.__class__ is not constructor:
        raise MatchFailure
    return unpack(instance)


DISCARD = object()


class Pattern(tuple):
    """A matcher that binds a value to a name."""

    __slots__ = ()

    def __new__(cls, name: str):
        if name == '_':
            return DISCARD
        if not name.isidentifier():
            raise ValueError
        if keyword.iskeyword(name):
            raise ValueError
        return super().__new__(cls, (name,))

    @property
    def name(self):
        """Return the name of the matcher."""
        return self[0]

    def __matmul__(self, other):
        return AsPattern(self, other)


class AsPattern(tuple):
    """A matcher that contains further bindings."""

    __slots__ = ()

    def __new__(cls, matcher: Pattern, match):
        if match is DISCARD:
            return matcher
        return super().__new__(cls, (matcher, match))

    @property
    def matcher(self):
        """Return the left-hand-side of the as-match."""
        return self[0]

    @property
    def match(self):
        """Return the right-hand-side of the as-match."""
        return self[1]


def isinstance_predicate(typ):
    def predicate(target):
        return isinstance(target, typ)
    return predicate


def as_pattern_processor(target):
    def processor(value):
        if target is value:
            yield target.match
            yield target.matcher
        else:
            yield value
            yield value
    return processor


def enum_processor(target):
    def processor(value):
        yield from reversed(desugar(type(target), value))
    return processor


def tuple_processor(target):
    def processor(value):
        if isinstance(value, target.__class__) and len(target) == len(value):
            yield from reversed(value)
        else:
            raise MatchFailure
    return processor


PROCESSORS = (
    (isinstance_predicate(AsPattern), as_pattern_processor),
    (isinstance_predicate(EnumConstructor), enum_processor),
    (isinstance_predicate(tuple), tuple_processor),
)


def names(target):
    """Return every name bound by a target."""
    name_list = []
    names_seen = set()
    to_process = [target]
    while to_process:
        item = to_process.pop()
        if isinstance(item, Pattern):
            if item.name in names_seen:
                raise ValueError
            names_seen.add(item.name)
            name_list.append(item.name)
            continue
        for predicate, meta in PROCESSORS:
            if predicate(item):
                processor = meta(item)
                to_process.extend(processor(item))
                break
    return name_list


class MatchDict(collections.abc.MutableMapping):

    def __init__(self):
        self.data = {}

    def __getitem__(self, key):
        if isinstance(key, Pattern):
            key = key.name
        if isinstance(key, str):
            return self.data[key]
        if isinstance(key, tuple):
            return tuple(self[sub_key] for sub_key in key)
        raise KeyError(key)

    def __setitem__(self, key, value):
        if isinstance(key, Pattern):
            key = key.name
        if not isinstance(key, str):
            raise TypeError
        self.data[key] = value

    def __delitem__(self, key):
        if isinstance(key, Pattern):
            key = key.name
        del self.data[key]

    def __iter__(self):
        yield from self.data

    def __len__(self):
        return len(self.data)


def _match(target, value):
    match_dict = MatchDict()
    to_process = [(target, value)]
    while to_process:
        target, value = to_process.pop()
        if target is DISCARD:
            continue
        if isinstance(target, Pattern):
            if target.name in match_dict:
                raise ValueError
            match_dict[target.name] = value
            continue
        for predicate, meta in PROCESSORS:
            if predicate(target):
                processor = meta(target)
                to_process.extend(zip(processor(target), processor(value)))
                break
        else:
            if target != value:
                raise MatchFailure
    return match_dict


class ValueMatcher:
    """Given a value, attempt to match against a target."""

    def __init__(self, value):
        self.value = value
        self.matches = None

    def match(self, target):
        """Match against target, generating a set of bindings."""
        try:
            self.matches = _match(target, self.value)
        except MatchFailure:
            self.matches = None
        return self.matches is not None


pat = AttributeConstructor(Pattern)


__all__ = ['MatchFailure', 'Pattern', 'ValueMatcher', 'desugar', 'names', 'pat']


1			import collections
2			import keyword
3			import weakref
4
5			from ._enum_constructor import EnumConstructor
6			from ._unpack import unpack
7
8			ATTRIBUTE_CONSTRUCTORS = weakref.WeakKeyDictionary()
9			ATTRIBUTE_CACHE = weakref.WeakKeyDictionary()
10
11
12			class AttributeConstructor:
13
14			__slots__ = ('__weakref__',)
15
16			def __init__(self, constructor):
17			ATTRIBUTE_CONSTRUCTORS[self] = constructor
18			ATTRIBUTE_CACHE[self] = {}
19
20			def __getattribute__(self, name):
21			return ATTRIBUTE_CACHE[self].setdefault(
22			name, ATTRIBUTE_CONSTRUCTORS[self](name))
23
24
25			class MatchFailure(BaseException):
26			"""An exception that signals a failure in ADT matching."""
27
28
29			def desugar(constructor: type, instance: tuple) -> tuple:
30			"""Return the inside of an ADT instance, given its constructor."""
31			if instance.__class__ is not constructor:
32			raise MatchFailure
33			return unpack(instance)
34
35
36			DISCARD = object()
37
38
39			class Pattern(tuple):
40			"""A matcher that binds a value to a name."""
41
42			__slots__ = ()
43
44			def __new__(cls, name: str):
45			if name == '_':
46			return DISCARD
47			if not name.isidentifier():
48			raise ValueError
49			if keyword.iskeyword(name):
50			raise ValueError
51			return super().__new__(cls, (name,))
52
53			@property
54			def name(self):
55			"""Return the name of the matcher."""
56			return self[0]
57
58			def __matmul__(self, other):
59			return AsPattern(self, other)
60
61
62			class AsPattern(tuple):
63			"""A matcher that contains further bindings."""
64
65			__slots__ = ()
66
67			def __new__(cls, matcher: Pattern, match):
68			if match is DISCARD:
69			return matcher
70			return super().__new__(cls, (matcher, match))
71
72			@property
73			def matcher(self):
74			"""Return the left-hand-side of the as-match."""
75			return self[0]
76
77			@property
78			def match(self):
79			"""Return the right-hand-side of the as-match."""
80			return self[1]
81
82
83			def isinstance_predicate(typ):
84			def predicate(target):
85			return isinstance(target, typ)
86			return predicate
87
88
89			def as_pattern_processor(target):
90			def processor(value):
91			if target is value:
92			yield target.match
93			yield target.matcher
94			else:
95			yield value
96			yield value
97			return processor
98
99
100			def enum_processor(target):
101			def processor(value):
102			yield from reversed(desugar(type(target), value))
103			return processor
104
105
106			def tuple_processor(target):
107			def processor(value):
108			if isinstance(value, target.__class__) and len(target) == len(value):
109			yield from reversed(value)
110			else:
111			raise MatchFailure
112			return processor
113
114
115			PROCESSORS = (
116			(isinstance_predicate(AsPattern), as_pattern_processor),
117			(isinstance_predicate(EnumConstructor), enum_processor),
118			(isinstance_predicate(tuple), tuple_processor),
119			)
120
121
122			def names(target):
123			"""Return every name bound by a target."""
124			name_list = []
125			names_seen = set()
126			to_process = [target]
127			while to_process:
128			item = to_process.pop()
129			if isinstance(item, Pattern):
130			if item.name in names_seen:
131			raise ValueError
132			names_seen.add(item.name)
133			name_list.append(item.name)
134			continue
135			for predicate, meta in PROCESSORS:
136			if predicate(item):
137			processor = meta(item)
138			to_process.extend(processor(item))
139			break
140			return name_list
141
142
143			class MatchDict(collections.abc.MutableMapping):
144
145			def __init__(self):
146			self.data = {}
147
148			def __getitem__(self, key):
149			if isinstance(key, Pattern):
150			key = key.name
151			if isinstance(key, str):
152			return self.data[key]
153			if isinstance(key, tuple):
154			return tuple(self[sub_key] for sub_key in key)
155			raise KeyError(key)
156
157			def __setitem__(self, key, value):
158			if isinstance(key, Pattern):
159			key = key.name
160			if not isinstance(key, str):
161			raise TypeError
162			self.data[key] = value
163
164			def __delitem__(self, key):
165			if isinstance(key, Pattern):
166			key = key.name
167			del self.data[key]
168
169			def __iter__(self):
170			yield from self.data
171
172			def __len__(self):
173			return len(self.data)
174
175
176			def _match(target, value):
177			match_dict = MatchDict()
178			to_process = [(target, value)]
179			while to_process:
180			target, value = to_process.pop()
181			if target is DISCARD:
182			continue
183			if isinstance(target, Pattern):
184			if target.name in match_dict:
185			raise ValueError
186			match_dict[target.name] = value
187			continue
188			for predicate, meta in PROCESSORS:
189			if predicate(target):
190			processor = meta(target)
191			to_process.extend(zip(processor(target), processor(value)))
192			break
193			else:
194			if target != value:
195			raise MatchFailure
196			return match_dict
197
198
199			class ValueMatcher:
200			"""Given a value, attempt to match against a target."""
201
202			def __init__(self, value):
203			self.value = value
204			self.matches = None
205
206			def match(self, target):
207			"""Match against target, generating a set of bindings."""
208			try:
209			self.matches = _match(target, self.value)
210			except MatchFailure:
211			self.matches = None
212			return self.matches is not None
213
214
215			pat = AttributeConstructor(Pattern)
216
217
218			__all__ = ['MatchFailure', 'Pattern', 'ValueMatcher', 'desugar', 'names', 'pat']
219

mwchase / python-structured-data

Push — master ( 2e0d62...d2554f )

structured_data.match.names() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like