structured_data._adt.prewritten_methods

Complexity

Total Complexity

28

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	PrewrittenSumMethods.__lt__()	0	9	3
A	PrewrittenProductMethods.__le__()	0	4	2
A	CommonPrewrittenMethods.__ne__()	0	4	2
A	PrewrittenProductMethods.__ge__()	0	4	2
A	PrewrittenProductMethods.__gt__()	0	4	2
A	CommonPrewrittenMethods.__repr__()	0	3	1
A	PrewrittenProductMethods.__lt__()	0	4	2
A	PrewrittenSumMethods.__ge__()	0	9	3
A	CommonPrewrittenMethods.__eq__()	0	4	2
A	CommonPrewrittenMethods.__hash__()	0	2	1
A	PrewrittenSumMethods.__gt__()	0	9	3
A	PrewrittenSumMethods.__init_subclass__()	0	2	1
A	PrewrittenSumMethods.__le__()	0	9	3

"""Methods to be added to ADT classes."""

import typing
import weakref

from .._unpack import unpack
from .constructor import ADT_BASES


def sum_base(obj):
    """Return the immediate base class of the type of a ``Sum`` instance."""
    return ADT_BASES.get(obj.__class__)


SUBCLASS_ORDER: typing.MutableMapping[
    type, typing.Tuple[type, ...]
] = weakref.WeakKeyDictionary()


class CommonPrewrittenMethods:
    """Methods to slot into various modified classes."""

    def __repr__(self):
        return "{}({})".format(
            self.__class__.__qualname__, ", ".join(repr(item) for item in unpack(self))
        )

    def __eq__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) == unpack(other)
        return False

    def __ne__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) != unpack(other)
        return True

    def __hash__(self):
        return hash(unpack(self))


class PrewrittenProductMethods(CommonPrewrittenMethods):
    """Methods for subclasses of ``structured_data.adt.Product``."""

    def __lt__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) < unpack(other)
        raise TypeError

    def __le__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) <= unpack(other)
        raise TypeError

    def __gt__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) > unpack(other)
        raise TypeError

    def __ge__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) >= unpack(other)
        raise TypeError


class PrewrittenSumMethods(CommonPrewrittenMethods):
    """Methods for subclasses of ``structured_data.adt.Sum``."""

    def __init_subclass__(cls, **kwargs):
        raise TypeError(f"Cannot further subclass the class {cls.__name__}")

    def __lt__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) < unpack(other)
        if sum_base(other) is sum_base(self):
            order = SUBCLASS_ORDER.get(sum_base(self))
            self_index = order.index(self.__class__)
            other_index = order.index(other.__class__)
            return self_index < other_index
        raise TypeError

    def __le__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) <= unpack(other)
        if sum_base(other) is sum_base(self):
            order = SUBCLASS_ORDER.get(sum_base(self))
            self_index = order.index(self.__class__)
            other_index = order.index(other.__class__)
            return self_index <= other_index
        raise TypeError

    def __gt__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) > unpack(other)
        if sum_base(other) is sum_base(self):
            order = SUBCLASS_ORDER.get(sum_base(self))
            self_index = order.index(self.__class__)
            other_index = order.index(other.__class__)
            return self_index > other_index
        raise TypeError

    def __ge__(self, other):
        if other.__class__ is self.__class__:
            return unpack(self) >= unpack(other)
        if sum_base(other) is sum_base(self):
            order = SUBCLASS_ORDER.get(sum_base(self))
            self_index = order.index(self.__class__)
            other_index = order.index(other.__class__)
            return self_index >= other_index
        raise TypeError


__all__ = ["PrewrittenProductMethods", "PrewrittenSumMethods"]