structured_data.adt.Product.__new__() - Code Metrics - Inspection of "Factor out a unit of logic" - mwchase/python-structured-data - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( dcd100...ee2acb )

by Max

created 2019-09-02 13:53 UTC

structured_data.adt.Product.new() A

↳ Parent: structured_data.adt

Complexity

Conditions

Size

Total Lines	17
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	15
nop	2
dl	0
loc	17
rs	9.65
c	0
b	0
f	0

"""Base classes for defining abstract data types.

This module provides three public members, which are used together.

Given a structure, possibly a choice of different structures, that you'd like
to associate with a type:

- First, create a class, that subclasses the Sum class.
- Then, for each possible structure, add an attribute annotation to the class
  with the desired name of the constructor, and a type of ``Ctor``, with the
  types within the constructor as arguments.

To look inside an ADT instance, use the functions from the
:mod:`structured_data.match` module.

Putting it together:

>>> from structured_data import match
>>> class Example(Sum):
...     FirstConstructor: Ctor[int, str]
...     SecondConstructor: Ctor[bytes]
...     ThirdConstructor: Ctor
...     def __iter__(self):
...         matchable = match.Matchable(self)
...         if matchable(Example.FirstConstructor(match.pat.count, match.pat.string)):
...             count, string = matchable[match.pat.count, match.pat.string]
...             for _ in range(count):
...                 yield string
...         elif matchable(Example.SecondConstructor(match.pat.bytes)):
...             bytes_ = matchable[match.pat.bytes]
...             for byte in bytes_:
...                 yield chr(byte)
...         elif matchable(Example.ThirdConstructor()):
...             yield "Third"
...             yield "Constructor"
>>> list(Example.FirstConstructor(5, "abc"))
['abc', 'abc', 'abc', 'abc', 'abc']
>>> list(Example.SecondConstructor(b"abc"))
['a', 'b', 'c']
>>> list(Example.ThirdConstructor())
['Third', 'Constructor']
"""

import inspect
import sys
import typing

from . import _adt_constructor
from . import _ctor
from . import _prewritten_methods

_T = typing.TypeVar("_T")


if typing.TYPE_CHECKING:  # pragma: nocover

    class Ctor:
        """Dummy class for type-checking purposes."""

    class ConcreteCtor(typing.Generic[_T]):
        """Wrapper class for type-checking purposes.

        The type parameter should be a Tuple type of fixed size.
        Classes containing this annotation (meaning they haven't been
        processed by the ``adt`` decorator) should not be instantiated.
        """


else:
    from ._ctor import Ctor


# This is fine.
def _name(cls: typing.Type[_T], function) -> str:
    """Return the name of a function accessed through a descriptor."""
    return function.__get__(None, cls).__name__


# This is mostly fine, though the list of classes is somewhat ad-hoc, to say
# the least.
def _cant_set_new_functions(cls: typing.Type[_T], *functions) -> typing.Optional[str]:
    for function in functions:
        name = _name(cls, function)
        existing = getattr(cls, name, None)
        if existing not in (
            getattr(object, name, None),
            getattr(Product, name, None),
            None,
            function,
        ):
            return name
    return None


def _set_new_functions(cls: typing.Type[_T], *functions) -> typing.Optional[str]:
    """Attempt to set the attributes corresponding to the functions on cls.

    If any attributes are already defined, fail *before* setting any, and
    return the already-defined name.
    """
    cant_set = _cant_set_new_functions(cls, *functions)
    if cant_set:
        return cant_set
    for function in functions:
        setattr(cls, _name(cls, function), function)
    return None


_K = typing.TypeVar("_K")
_V = typing.TypeVar("_V")


def _nillable_write(dct: typing.Dict[_K, _V], key: _K, value: typing.Optional[_V]):
    if value is None:
        dct.pop(key, typing.cast(_V, None))
    else:
        dct[key] = value


def _sum_new(_cls: typing.Type[_T], subclasses):
    def base(cls, args):
        return super(_cls, cls).__new__(cls, args)

    new = _cls.__dict__.get("__new__", staticmethod(base))

    def __new__(cls, args):
        if cls not in subclasses:
            raise TypeError
        return new.__get__(None, cls)(cls, args)

    _cls.__new__ = staticmethod(__new__)  # type: ignore


def _product_new(
    _cls: typing.Type[_T],
    annotations: typing.Dict[str, typing.Any],
    defaults: typing.Dict[str, typing.Any],
):
    def __new__(*args, **kwargs):
        cls, *args = args
        return super(_cls, cls).__new__(cls, *args, **kwargs)

    __new__.__signature__ = inspect.signature(__new__).replace(
        parameters=[inspect.Parameter("cls", inspect.Parameter.POSITIONAL_ONLY)]
        + [
            inspect.Parameter(
                field,
                inspect.Parameter.POSITIONAL_OR_KEYWORD,
                annotation=annotation,
                default=defaults.get(field, inspect.Parameter.empty),
            )
            for (field, annotation) in annotations.items()
        ]
    )
    _cls.__new__ = __new__


def _all_annotations(
    cls: typing.Type[_T]
) -> typing.Iterator[typing.Tuple[typing.Type[_T], str, typing.Any]]:
    for superclass in reversed(cls.__mro__):
        for key, value in vars(superclass).get("__annotations__", {}).items():
            yield (superclass, key, value)


def _sum_args_from_annotations(cls: typing.Type[_T]) -> typing.Dict[str, typing.Tuple]:
    args: typing.Dict[str, typing.Tuple] = {}
    for superclass, key, value in _all_annotations(cls):
        _nillable_write(
            args, key, _ctor.get_args(value, vars(sys.modules[superclass.__module__]))
        )
    return args


def _product_args_from_annotations(
    cls: typing.Type[_T]
) -> typing.Dict[str, typing.Any]:
    args: typing.Dict[str, typing.Any] = {}
    for _, key, value in _all_annotations(cls):
        if value == "None" or _ctor.annotation_is_classvar(
            value, vars(sys.modules[cls.__module__])
        ):
            value = None
        _nillable_write(args, key, value)
    return args


def _ordering_options_are_valid(*, eq, order):
    if order and not eq:
        raise ValueError("eq must be true if order is true")


def _set_ordering(*, can_set, setter, cls, source):
    if not can_set:
        raise ValueError("Can't add ordering methods if equality methods are provided.")
    collision = setter(cls, source.__lt__, source.__le__, source.__gt__, source.__ge__)
    if collision:
        raise TypeError(
            "Cannot overwrite attribute {collision} in class "
            "{name}. Consider using functools.total_ordering".format(
                collision=collision, name=cls.__name__
            )
        )


def _extract_defaults(*, cls, annotations):
    defaults = {}
    field_names = iter(reversed(tuple(annotations)))
    for field in field_names:
        default = getattr(cls, field, inspect.Parameter.empty)
        if default is inspect.Parameter.empty:
            break
        defaults[field] = default
    for field in field_names:
        if getattr(cls, field, inspect.Parameter.empty) is not inspect.Parameter.empty:
            raise TypeError
    return defaults


def _unpack_args(*, args, kwargs, fields, values):
    fields_iter = iter(fields)
    for arg, field in zip(args, fields_iter):
        values[field] = arg
    for field in fields_iter:
        if field in values and field not in kwargs:
            continue
        values[field] = kwargs.pop(field)
    if kwargs:
        raise TypeError(kwargs)


class Sum:
    """Base class of classes with disjoint constructors.

    Examines PEP 526 __annotations__ to determine subclasses.

    If repr is true, a __repr__() method is added to the class.
    If order is true, rich comparison dunder methods are added.

    The Sum class examines the class to find Ctor annotations.
    A Ctor annotation is the adt.Ctor class itself, or the result of indexing
    the class, either with a single type hint, or a tuple of type hints.
    All other annotations are ignored.

    The subclass is not subclassable, but has subclasses at each of the
    names that had Ctor annotations. Each subclass takes a fixed number of
    arguments, corresponding to the type hints given to its annotation, if any.
    """

    __slots__ = ()

    def __new__(*args, **kwargs):  # pylint: disable=no-method-argument
        cls, *args = args
        if not issubclass(cls, _adt_constructor.ADTConstructor):
            raise TypeError
        return super(Sum, cls).__new__(cls, *args, **kwargs)

    # Both of these are for consistency with modules defined in the stdlib.
    # BOOM!
    def __init_subclass__(
        cls,
        *,
        repr=True,  # pylint: disable=redefined-builtin
        eq=True,  # pylint: disable=invalid-name
        order=False,
        **kwargs
    ):
        super().__init_subclass__(**kwargs)
        if issubclass(cls, _adt_constructor.ADTConstructor):
            return
        _ordering_options_are_valid(eq=eq, order=order)

        subclass_order: typing.List[typing.Type[_T]] = []

        for name, args in _sum_args_from_annotations(cls).items():
            _adt_constructor.make_constructor(cls, name, args, subclass_order)

        _prewritten_methods.SUBCLASS_ORDER[cls] = tuple(subclass_order)

        cls.__init_subclass__ = (
            _prewritten_methods.PrewrittenSumMethods.__init_subclass__
        )  # type: ignore

        _sum_new(cls, frozenset(subclass_order))

        _set_new_functions(
            cls,
            _prewritten_methods.PrewrittenSumMethods.__setattr__,
            _prewritten_methods.PrewrittenSumMethods.__delattr__,
        )
        _set_new_functions(cls, _prewritten_methods.PrewrittenSumMethods.__bool__)

        if repr:
            _set_new_functions(cls, _prewritten_methods.PrewrittenSumMethods.__repr__)

        equality_methods_were_set = False
        if eq:
            equality_methods_were_set = not _set_new_functions(
                cls,
                _prewritten_methods.PrewrittenSumMethods.__eq__,
                _prewritten_methods.PrewrittenSumMethods.__ne__,
            )

        if equality_methods_were_set:
            cls.__hash__ = _prewritten_methods.PrewrittenSumMethods.__hash__

        if order:
            _set_ordering(
                can_set=equality_methods_were_set,
                setter=_set_new_functions,
                cls=cls,
                source=_prewritten_methods.PrewrittenSumMethods,
            )


class Product(_adt_constructor.ADTConstructor, tuple):
    """Base class of classes with typed fields.

    Examines PEP 526 __annotations__ to determine fields.

    If repr is true, a __repr__() method is added to the class.
    If order is true, rich comparison dunder methods are added.

    The Product class examines the class to find annotations.
    Annotations with a value of "None" are discarded.
    Fields may have default values, and can be set to inspect.empty to
    indicate "no default".

    The subclass is subclassable. The implementation was designed with a focus
    on flexibility over ideals of purity, and therefore provides various
    optional facilities that conflict with, for example, Liskov
    substitutability. For the purposes of matching, each class is considered
    distinct.
    """

    __slots__ = ()

    def __new__(*args, **kwargs):  # pylint: disable=no-method-argument
        cls, *args = args
        if cls is Product:
            raise TypeError
        # Probably a result of not having positional-only args.
        values = cls.__defaults.copy()  # pylint: disable=protected-access
        _unpack_args(
            args=args,
            kwargs=kwargs,
            fields=cls.__fields,  # pylint: disable=protected-access
            values=values,
        )
        return super(Product, cls).__new__(
            cls,
            [
                values[field]
                for field in cls.__fields  # pylint: disable=protected-access
            ],
        )

    __repr = True
    __eq = True
    __order = False
    __eq_succeeded = None

    # Both of these are for consistency with modules defined in the stdlib.
    # BOOM!
    def __init_subclass__(
        cls,
        *,
        repr=None,  # pylint: disable=redefined-builtin
        eq=None,  # pylint: disable=invalid-name
        order=None,
        **kwargs
    ):
        super().__init_subclass__(**kwargs)

        if repr is not None:
            cls.__repr = repr
        if eq is not None:
            cls.__eq = eq
        if order is not None:
            cls.__order = order

        _ordering_options_are_valid(eq=cls.__eq, order=cls.__order)

        cls.__annotations = _product_args_from_annotations(cls)
        cls.__fields = {field: index for (index, field) in enumerate(cls.__annotations)}

        cls.__defaults = _extract_defaults(cls=cls, annotations=cls.__annotations)

        _product_new(cls, cls.__annotations, cls.__defaults)

        cls.__eq_succeeded = False
        if cls.__eq:
            cls.__eq_succeeded = not _cant_set_new_functions(
                cls,
                _prewritten_methods.PrewrittenProductMethods.__eq__,
                _prewritten_methods.PrewrittenProductMethods.__ne__,
            )

        if cls.__order:
            _set_ordering(
                can_set=cls.__eq_succeeded,
                setter=_cant_set_new_functions,
                cls=cls,
                source=_prewritten_methods.PrewrittenProductMethods,
            )

    def __dir__(self):
        return super().__dir__() + list(self.__fields)

    def __getattribute__(self, name):
        try:
            return super().__getattribute__(name)
        except AttributeError:
            index = self.__fields.get(name)
            if index is None:
                raise
            return tuple.__getitem__(self, index)

    __setattr__ = _prewritten_methods.PrewrittenProductMethods.__setattr__
    __delattr__ = _prewritten_methods.PrewrittenProductMethods.__delattr__
    __bool__ = _prewritten_methods.PrewrittenProductMethods.__bool__

    @property
    def __repr__(self):
        if self.__repr:
            return _prewritten_methods.PrewrittenProductMethods.__repr__.__get__(
                self, type(self)
            )
        return super().__repr__

    @property
    def __hash__(self):
        if self.__eq_succeeded:
            return _prewritten_methods.PrewrittenProductMethods.__hash__.__get__(
                self, type(self)
            )
        return super().__hash__

    @property
    def __eq__(self):  # pylint: disable=unexpected-special-method-signature
        if self.__eq_succeeded:
            # I think this is a Pylint bug, but I'm not sure how to reduce it.
            # pylint: disable=no-value-for-parameter
            return _prewritten_methods.PrewrittenProductMethods.__eq__.__get__(
                self, type(self)
            )
        return super().__eq__

    @property
    def __ne__(self):  # pylint: disable=unexpected-special-method-signature
        if self.__eq_succeeded:
            # I think this is a Pylint bug, but I'm not sure how to reduce it.
            # pylint: disable=no-value-for-parameter
            return _prewritten_methods.PrewrittenProductMethods.__ne__.__get__(
                self, type(self)
            )
        return super().__ne__

    @property
    def __lt__(self):  # pylint: disable=unexpected-special-method-signature
        if self.__order:
            # I think this is a Pylint bug, but I'm not sure how to reduce it.
            # pylint: disable=no-value-for-parameter
            return _prewritten_methods.PrewrittenProductMethods.__lt__.__get__(
                self, type(self)
            )
        return super().__lt__

    @property
    def __le__(self):  # pylint: disable=unexpected-special-method-signature
        if self.__order:
            # I think this is a Pylint bug, but I'm not sure how to reduce it.
            # pylint: disable=no-value-for-parameter
            return _prewritten_methods.PrewrittenProductMethods.__le__.__get__(
                self, type(self)
            )
        return super().__le__

    @property
    def __gt__(self):  # pylint: disable=unexpected-special-method-signature
        if self.__order:
            # I think this is a Pylint bug, but I'm not sure how to reduce it.
            # pylint: disable=no-value-for-parameter
            return _prewritten_methods.PrewrittenProductMethods.__gt__.__get__(
                self, type(self)
            )
        return super().__gt__

    @property
    def __ge__(self):  # pylint: disable=unexpected-special-method-signature
        if self.__order:
            # I think this is a Pylint bug, but I'm not sure how to reduce it.
            # pylint: disable=no-value-for-parameter
            return _prewritten_methods.PrewrittenProductMethods.__ge__.__get__(
                self, type(self)
            )
        return super().__ge__


__all__ = ["Ctor", "Product", "Sum"]


1			"""Base classes for defining abstract data types.
2
3			This module provides three public members, which are used together.
4
5			Given a structure, possibly a choice of different structures, that you'd like
6			to associate with a type:
7
8			- First, create a class, that subclasses the Sum class.
9			- Then, for each possible structure, add an attribute annotation to the class
10			with the desired name of the constructor, and a type of ``Ctor``, with the
11			types within the constructor as arguments.
12
13			To look inside an ADT instance, use the functions from the
14			:mod:`structured_data.match` module.
15
16			Putting it together:
17
18			>>> from structured_data import match
19			>>> class Example(Sum):
20			... FirstConstructor: Ctor[int, str]
21			... SecondConstructor: Ctor[bytes]
22			... ThirdConstructor: Ctor
23			... def __iter__(self):
24			... matchable = match.Matchable(self)
25			... if matchable(Example.FirstConstructor(match.pat.count, match.pat.string)):
26			... count, string = matchable[match.pat.count, match.pat.string]
27			... for _ in range(count):
28			... yield string
29			... elif matchable(Example.SecondConstructor(match.pat.bytes)):
30			... bytes_ = matchable[match.pat.bytes]
31			... for byte in bytes_:
32			... yield chr(byte)
33			... elif matchable(Example.ThirdConstructor()):
34			... yield "Third"
35			... yield "Constructor"
36			>>> list(Example.FirstConstructor(5, "abc"))
37			['abc', 'abc', 'abc', 'abc', 'abc']
38			>>> list(Example.SecondConstructor(b"abc"))
39			['a', 'b', 'c']
40			>>> list(Example.ThirdConstructor())
41			['Third', 'Constructor']
42			"""
43
44			import inspect
45			import sys
46			import typing
47
48			from . import _adt_constructor
49			from . import _ctor
50			from . import _prewritten_methods
51
52			_T = typing.TypeVar("_T")
53
54
55			if typing.TYPE_CHECKING: # pragma: nocover
56
57			class Ctor:
58			"""Dummy class for type-checking purposes."""
59
60			class ConcreteCtor(typing.Generic[_T]):
61			"""Wrapper class for type-checking purposes.
62
63			The type parameter should be a Tuple type of fixed size.
64			Classes containing this annotation (meaning they haven't been
65			processed by the ``adt`` decorator) should not be instantiated.
66			"""
67
68
69			else:
70			from ._ctor import Ctor
71
72
73			# This is fine.
74			def _name(cls: typing.Type[_T], function) -> str:
75			"""Return the name of a function accessed through a descriptor."""
76			return function.__get__(None, cls).__name__
77
78
79			# This is mostly fine, though the list of classes is somewhat ad-hoc, to say
80			# the least.
81			def _cant_set_new_functions(cls: typing.Type[_T], *functions) -> typing.Optional[str]:
82			for function in functions:
83			name = _name(cls, function)
84			existing = getattr(cls, name, None)
85			if existing not in (
86			getattr(object, name, None),
87			getattr(Product, name, None),
88			None,
89			function,
90			):
91			return name
92			return None
93
94
95			def _set_new_functions(cls: typing.Type[_T], *functions) -> typing.Optional[str]:
96			"""Attempt to set the attributes corresponding to the functions on cls.
97
98			If any attributes are already defined, fail before setting any, and
99			return the already-defined name.
100			"""
101			cant_set = _cant_set_new_functions(cls, *functions)
102			if cant_set:
103			return cant_set
104			for function in functions:
105			setattr(cls, _name(cls, function), function)
106			return None
107
108
109			_K = typing.TypeVar("_K")
110			_V = typing.TypeVar("_V")
111
112
113			def _nillable_write(dct: typing.Dict[_K, _V], key: _K, value: typing.Optional[_V]):
114			if value is None:
115			dct.pop(key, typing.cast(_V, None))
116			else:
117			dct[key] = value
118
119
120			def _sum_new(_cls: typing.Type[_T], subclasses):
121			def base(cls, args):
122			return super(_cls, cls).__new__(cls, args)
123
124			new = _cls.__dict__.get("__new__", staticmethod(base))
125
126			def __new__(cls, args):
127			if cls not in subclasses:
128			raise TypeError
129			return new.__get__(None, cls)(cls, args)
130
131			_cls.__new__ = staticmethod(__new__) # type: ignore
132
133
134			def _product_new(
135			_cls: typing.Type[_T],
136			annotations: typing.Dict[str, typing.Any],
137			defaults: typing.Dict[str, typing.Any],
138			):
139			def __new__(args, *kwargs):
140			cls, *args = args
141			return super(_cls, cls).__new__(cls, args, *kwargs)
142
143			__new__.__signature__ = inspect.signature(__new__).replace(
144			parameters=[inspect.Parameter("cls", inspect.Parameter.POSITIONAL_ONLY)]
145			+ [
146			inspect.Parameter(
147			field,
148			inspect.Parameter.POSITIONAL_OR_KEYWORD,
149			annotation=annotation,
150			default=defaults.get(field, inspect.Parameter.empty),
151			)
152			for (field, annotation) in annotations.items()
153			]
154			)
155			_cls.__new__ = __new__
156
157
158			def _all_annotations(
159			cls: typing.Type[_T]
160			) -> typing.Iterator[typing.Tuple[typing.Type[_T], str, typing.Any]]:
161			for superclass in reversed(cls.__mro__):
162			for key, value in vars(superclass).get("__annotations__", {}).items():
163			yield (superclass, key, value)
164
165
166			def _sum_args_from_annotations(cls: typing.Type[_T]) -> typing.Dict[str, typing.Tuple]:
167			args: typing.Dict[str, typing.Tuple] = {}
168			for superclass, key, value in _all_annotations(cls):
169			_nillable_write(
170			args, key, _ctor.get_args(value, vars(sys.modules[superclass.__module__]))
171			)
172			return args
173
174
175			def _product_args_from_annotations(
176			cls: typing.Type[_T]
177			) -> typing.Dict[str, typing.Any]:
178			args: typing.Dict[str, typing.Any] = {}
179			for _, key, value in _all_annotations(cls):
180			if value == "None" or _ctor.annotation_is_classvar(
181			value, vars(sys.modules[cls.__module__])
182			):
183			value = None
184			_nillable_write(args, key, value)
185			return args
186
187
188			def _ordering_options_are_valid(*, eq, order):
189			if order and not eq:
190			raise ValueError("eq must be true if order is true")
191
192
193			def _set_ordering(*, can_set, setter, cls, source):
194			if not can_set:
195			raise ValueError("Can't add ordering methods if equality methods are provided.")
196			collision = setter(cls, source.__lt__, source.__le__, source.__gt__, source.__ge__)
197			if collision:
198			raise TypeError(
199			"Cannot overwrite attribute {collision} in class "
200			"{name}. Consider using functools.total_ordering".format(
201			collision=collision, name=cls.__name__
202			)
203			)
204
205
206			def _extract_defaults(*, cls, annotations):
207			defaults = {}
208			field_names = iter(reversed(tuple(annotations)))
209			for field in field_names:
210			default = getattr(cls, field, inspect.Parameter.empty)
211			if default is inspect.Parameter.empty:
212			break
213			defaults[field] = default
214			for field in field_names:
215			if getattr(cls, field, inspect.Parameter.empty) is not inspect.Parameter.empty:
216			raise TypeError
217			return defaults
218
219
220			def _unpack_args(*, args, kwargs, fields, values):
221			fields_iter = iter(fields)
222			for arg, field in zip(args, fields_iter):
223			values[field] = arg
224			for field in fields_iter:
225			if field in values and field not in kwargs:
226			continue
227			values[field] = kwargs.pop(field)
228			if kwargs:
229			raise TypeError(kwargs)
230
231
232			class Sum:
233			"""Base class of classes with disjoint constructors.
234
235			Examines PEP 526 __annotations__ to determine subclasses.
236
237			If repr is true, a __repr__() method is added to the class.
238			If order is true, rich comparison dunder methods are added.
239
240			The Sum class examines the class to find Ctor annotations.
241			A Ctor annotation is the adt.Ctor class itself, or the result of indexing
242			the class, either with a single type hint, or a tuple of type hints.
243			All other annotations are ignored.
244
245			The subclass is not subclassable, but has subclasses at each of the
246			names that had Ctor annotations. Each subclass takes a fixed number of
247			arguments, corresponding to the type hints given to its annotation, if any.
248			"""
249
250			__slots__ = ()
251
252			def __new__(args, *kwargs): # pylint: disable=no-method-argument
253			cls, *args = args
254			if not issubclass(cls, _adt_constructor.ADTConstructor):
255			raise TypeError
256			return super(Sum, cls).__new__(cls, args, *kwargs)
257
258			# Both of these are for consistency with modules defined in the stdlib.
259			# BOOM!
260			def __init_subclass__(
261			cls,
262			*,
263			repr=True, # pylint: disable=redefined-builtin
264			eq=True, # pylint: disable=invalid-name
265			order=False,
266			**kwargs
267			):
268			super().__init_subclass__(**kwargs)
269			if issubclass(cls, _adt_constructor.ADTConstructor):
270			return
271			_ordering_options_are_valid(eq=eq, order=order)
272
273			subclass_order: typing.List[typing.Type[_T]] = []
274
275			for name, args in _sum_args_from_annotations(cls).items():
276			_adt_constructor.make_constructor(cls, name, args, subclass_order)
277
278			_prewritten_methods.SUBCLASS_ORDER[cls] = tuple(subclass_order)
279
280			cls.__init_subclass__ = (
281			_prewritten_methods.PrewrittenSumMethods.__init_subclass__
282			) # type: ignore
283
284			_sum_new(cls, frozenset(subclass_order))
285
286			_set_new_functions(
287			cls,
288			_prewritten_methods.PrewrittenSumMethods.__setattr__,
289			_prewritten_methods.PrewrittenSumMethods.__delattr__,
290			)
291			_set_new_functions(cls, _prewritten_methods.PrewrittenSumMethods.__bool__)
292
293			if repr:
294			_set_new_functions(cls, _prewritten_methods.PrewrittenSumMethods.__repr__)
295
296			equality_methods_were_set = False
297			if eq:
298			equality_methods_were_set = not _set_new_functions(
299			cls,
300			_prewritten_methods.PrewrittenSumMethods.__eq__,
301			_prewritten_methods.PrewrittenSumMethods.__ne__,
302			)
303
304			if equality_methods_were_set:
305			cls.__hash__ = _prewritten_methods.PrewrittenSumMethods.__hash__
306
307			if order:
308			_set_ordering(
309			can_set=equality_methods_were_set,
310			setter=_set_new_functions,
311			cls=cls,
312			source=_prewritten_methods.PrewrittenSumMethods,
313			)
314
315
316			class Product(_adt_constructor.ADTConstructor, tuple):
317			"""Base class of classes with typed fields.
318
319			Examines PEP 526 __annotations__ to determine fields.
320
321			If repr is true, a __repr__() method is added to the class.
322			If order is true, rich comparison dunder methods are added.
323
324			The Product class examines the class to find annotations.
325			Annotations with a value of "None" are discarded.
326			Fields may have default values, and can be set to inspect.empty to
327			indicate "no default".
328
329			The subclass is subclassable. The implementation was designed with a focus
330			on flexibility over ideals of purity, and therefore provides various
331			optional facilities that conflict with, for example, Liskov
332			substitutability. For the purposes of matching, each class is considered
333			distinct.
334			"""
335
336			__slots__ = ()
337
338			def __new__(args, *kwargs): # pylint: disable=no-method-argument
339			cls, *args = args
340			if cls is Product:
341			raise TypeError
342			# Probably a result of not having positional-only args.
343			values = cls.__defaults.copy() # pylint: disable=protected-access
344			_unpack_args(
345			args=args,
346			kwargs=kwargs,
347			fields=cls.__fields, # pylint: disable=protected-access
348			values=values,
349			)
350			return super(Product, cls).__new__(
351			cls,
352			[
353			values[field]
354			for field in cls.__fields # pylint: disable=protected-access
355			],
356			)
357
358			__repr = True
359			__eq = True
360			__order = False
361			__eq_succeeded = None
362
363			# Both of these are for consistency with modules defined in the stdlib.
364			# BOOM!
365			def __init_subclass__(
366			cls,
367			*,
368			repr=None, # pylint: disable=redefined-builtin
369			eq=None, # pylint: disable=invalid-name
370			order=None,
371			**kwargs
372			):
373			super().__init_subclass__(**kwargs)
374
375			if repr is not None:
376			cls.__repr = repr
377			if eq is not None:
378			cls.__eq = eq
379			if order is not None:
380			cls.__order = order
381
382			_ordering_options_are_valid(eq=cls.__eq, order=cls.__order)
383
384			cls.__annotations = _product_args_from_annotations(cls)
385			cls.__fields = {field: index for (index, field) in enumerate(cls.__annotations)}
386
387			cls.__defaults = _extract_defaults(cls=cls, annotations=cls.__annotations)
388
389			_product_new(cls, cls.__annotations, cls.__defaults)
390
391			cls.__eq_succeeded = False
392			if cls.__eq:
393			cls.__eq_succeeded = not _cant_set_new_functions(
394			cls,
395			_prewritten_methods.PrewrittenProductMethods.__eq__,
396			_prewritten_methods.PrewrittenProductMethods.__ne__,
397			)
398
399			if cls.__order:
400			_set_ordering(
401			can_set=cls.__eq_succeeded,
402			setter=_cant_set_new_functions,
403			cls=cls,
404			source=_prewritten_methods.PrewrittenProductMethods,
405			)
406
407			def __dir__(self):
408			return super().__dir__() + list(self.__fields)
409
410			def __getattribute__(self, name):
411			try:
412			return super().__getattribute__(name)
413			except AttributeError:
414			index = self.__fields.get(name)
415			if index is None:
416			raise
417			return tuple.__getitem__(self, index)
418
419			__setattr__ = _prewritten_methods.PrewrittenProductMethods.__setattr__
420			__delattr__ = _prewritten_methods.PrewrittenProductMethods.__delattr__
421			__bool__ = _prewritten_methods.PrewrittenProductMethods.__bool__
422
423			@property
424			def __repr__(self):
425			if self.__repr:
426			return _prewritten_methods.PrewrittenProductMethods.__repr__.__get__(
427			self, type(self)
428			)
429			return super().__repr__
430
431			@property
432			def __hash__(self):
433			if self.__eq_succeeded:
434			return _prewritten_methods.PrewrittenProductMethods.__hash__.__get__(
435			self, type(self)
436			)
437			return super().__hash__
438
439			@property
440			def __eq__(self): # pylint: disable=unexpected-special-method-signature
441			if self.__eq_succeeded:
442			# I think this is a Pylint bug, but I'm not sure how to reduce it.
443			# pylint: disable=no-value-for-parameter
444			return _prewritten_methods.PrewrittenProductMethods.__eq__.__get__(
445			self, type(self)
446			)
447			return super().__eq__
448
449			@property
450			def __ne__(self): # pylint: disable=unexpected-special-method-signature
451			if self.__eq_succeeded:
452			# I think this is a Pylint bug, but I'm not sure how to reduce it.
453			# pylint: disable=no-value-for-parameter
454			return _prewritten_methods.PrewrittenProductMethods.__ne__.__get__(
455			self, type(self)
456			)
457			return super().__ne__
458
459			@property
460			def __lt__(self): # pylint: disable=unexpected-special-method-signature
461			if self.__order:
462			# I think this is a Pylint bug, but I'm not sure how to reduce it.
463			# pylint: disable=no-value-for-parameter
464			return _prewritten_methods.PrewrittenProductMethods.__lt__.__get__(
465			self, type(self)
466			)
467			return super().__lt__
468
469			@property
470			def __le__(self): # pylint: disable=unexpected-special-method-signature
471			if self.__order:
472			# I think this is a Pylint bug, but I'm not sure how to reduce it.
473			# pylint: disable=no-value-for-parameter
474			return _prewritten_methods.PrewrittenProductMethods.__le__.__get__(
475			self, type(self)
476			)
477			return super().__le__
478
479			@property
480			def __gt__(self): # pylint: disable=unexpected-special-method-signature
481			if self.__order:
482			# I think this is a Pylint bug, but I'm not sure how to reduce it.
483			# pylint: disable=no-value-for-parameter
484			return _prewritten_methods.PrewrittenProductMethods.__gt__.__get__(
485			self, type(self)
486			)
487			return super().__gt__
488
489			@property
490			def __ge__(self): # pylint: disable=unexpected-special-method-signature
491			if self.__order:
492			# I think this is a Pylint bug, but I'm not sure how to reduce it.
493			# pylint: disable=no-value-for-parameter
494			return _prewritten_methods.PrewrittenProductMethods.__ge__.__get__(
495			self, type(self)
496			)
497			return super().__ge__
498
499
500			__all__ = ["Ctor", "Product", "Sum"]
501

mwchase / python-structured-data

Push — master ( dcd100...ee2acb )

structured_data.adt.Product.__new__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

structured_data.adt.Product.new() A