structured_data.enum._process_class() - Code Metrics - Inspection of "Factor out __new__ creation logic" - mwchase/python-structured-data - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 201ca1...2e0d62 )

by Max

created 2018-07-17 20:39 UTC

structured_data.enum._process_class() F

↳ Parent: structured_data.enum

Complexity

Conditions

Size

Total Lines	60
Code Lines	45

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	14
eloc	45
nop	4
dl	0
loc	60
rs	3.6
c	0
b	0
f	0

How to fix Long Method Complexity

"""Class decorator for defining abstract data types."""

import ast
import sys
import typing
import weakref

import astor

from ._enum_constructor import make_constructor
from ._prewritten_methods import SUBCLASS_ORDER
from ._prewritten_methods import PrewrittenMethods

_CTOR_CACHE = {}


ARGS = weakref.WeakKeyDictionary()


class Ctor:
    """Marker class for enum constructors.

    To use, index with a sequence of types, and annotate a variable in an
    enum-decorated class with it.
    """

    def __new__(cls, args):
        if args == ():
            return cls
        self = object.__new__(cls)
        ARGS[self] = args
        return _CTOR_CACHE.setdefault(args, self)

    def __init_subclass__(cls, **kwargs):
        raise TypeError

    def __class_getitem__(cls, args):
        if not isinstance(args, tuple):
            args = (args,)
        return cls(args)


ARGS[Ctor] = ()


def _args(constructor, global_ns):
    # Handle forward declarations. Needed for 3.7 compatinility.
    if isinstance(constructor, str):
        # Leverage Python's parser instead of trying to parse by hand.
        ctor_ast = ast.parse(constructor, mode='eval')
        # The top-level operation must be a subscript, with normal indexing.
        if (
                isinstance(ctor_ast.body, ast.Subscript)
                and isinstance(ctor_ast.body.slice, ast.Index)):
            # Pull out the index argument
            index = ctor_ast.body.slice.value
            # This basically gets rid of the brackets and index.
            # Next, try to evaluate the result.
            # This relies on Ctor being globally visible at definition time,
            # which seems like a reasonable requirement.
            ctor_ast.body = ctor_ast.body.value
            try:
                value = eval(
                    compile(ctor_ast, '<annotation>', 'eval'), global_ns)
            except Exception:
                # We couldn't tell what it was, so it's probably not Ctor.
                return None
            if value is Ctor:
                # Pull the information directly off a Tuple node.
                if isinstance(index, ast.Tuple):
                    return tuple(astor.to_source(elt) for elt in index.elts)
                # Otherwise, assume it's a sequence of length 1.
                # It's possible for this heuristic to return false answers, BUT
                # it seems like everywhere that AST inspection and evaluation
                # disagree, it needs syntax that breaks mypy, so it's sort of
                # like it doesn't matter.
                return (astor.to_source(index),)
        try:
            # If the above conditions didn't hold, maybe it's an alias.
            # We could try to validate the AST, but we need to know the value
            # anyway if it's valid.
            constructor = eval(constructor, global_ns)
        except Exception:
            # This return is a little concerning. It's basically for "We tried
            # to evaluate a forward reference of some kind, and failed."
            # This might reject input at runtime that mypy would accept.
            # The basic solution is to document that you can have forward
            # references FROM a Ctor, but not within a decorated class.
            return None
    # Try to interpret the current value as a Ctor
    return ARGS.get(constructor)


def _name(cls, function) -> str:
    """Return the name of a function accessed through a descriptor."""
    return function.__get__(None, cls).__name__


def _set_new_functions(cls, *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.
    """
    for function in functions:
        if _name(cls, function) in cls.__dict__:
            return _name(cls, function)
    for function in functions:
        setattr(cls, _name(cls, function), function)
    return None


def _enum_super(_cls):
    def base(cls, args):
        return super(_cls, cls).__new__(cls, args)
    return base


def _make_nested_new(_cls, subclasses, base__new__):
    @staticmethod
    def __new__(cls, args):
        if cls not in subclasses:
            raise TypeError
        return base__new__(cls, args)
    return __new__


def _process_class(_cls, _repr, eq, order):
    if order and not eq:
        raise ValueError('eq must be true if order is true')

    argses = {}
    subclasses = set()
    subclass_order = []
    for cls in reversed(_cls.__mro__):
        for key, value in getattr(cls, '__annotations__', {}).items():
            args = _args(value, vars(sys.modules[cls.__module__]))
            # Shadow redone annotations.
            if args is None:
                argses.pop(key, None)
            else:
                argses[key] = args

    for name, args in argses.items():
        make_constructor(_cls, name, args, subclasses, subclass_order)

    _cls.__init_subclass__ = PrewrittenMethods.__init_subclass__

    if _set_new_functions(_cls, _make_nested_new(_cls, subclasses, _enum_super(_cls))):
        _cls.__new__ = _make_nested_new(_cls, subclasses, _cls.__new__)

    _set_new_functions(
        _cls, PrewrittenMethods.__setattr__, PrewrittenMethods.__delattr__)
    _set_new_functions(_cls, PrewrittenMethods.__bool__)

    if _repr:
        _set_new_functions(_cls, PrewrittenMethods.__repr__)

    equality_methods_were_set = False

    if eq:
        equality_methods_were_set = not _set_new_functions(
            _cls, PrewrittenMethods.__eq__, PrewrittenMethods.__ne__)

    if equality_methods_were_set:
        _cls.__hash__ = PrewrittenMethods.__hash__

    if order:
        if not equality_methods_were_set:
            raise ValueError(
                "Can't add ordering methods if equality methods are provided.")
        collision = _set_new_functions(
            _cls,
            PrewrittenMethods.__lt__,
            PrewrittenMethods.__le__,
            PrewrittenMethods.__gt__,
            PrewrittenMethods.__ge__
            )
        if collision:
            raise TypeError(
                'Cannot overwrite attribute {collision} in class '
                '{name}. Consider using functools.total_ordering'.format(
                    collision=collision, name=_cls.__name__))

    SUBCLASS_ORDER[_cls] = tuple(subclass_order)

    return _cls


def enum(_cls=None, *, repr=True, eq=True, order=False):
    """Decorate a class to be an algebraic data type."""

    def wrap(cls):
        """Return the processed class."""
        return _process_class(cls, repr, eq, order)

    if _cls is None:
        return wrap

    return wrap(_cls)


__all__ = ['Ctor', 'enum']


1			"""Class decorator for defining abstract data types."""
2
3			import ast
4			import sys
5			import typing
6			import weakref
7
8			import astor
9
10			from ._enum_constructor import make_constructor
11			from ._prewritten_methods import SUBCLASS_ORDER
12			from ._prewritten_methods import PrewrittenMethods
13
14			_CTOR_CACHE = {}
15
16
17			ARGS = weakref.WeakKeyDictionary()
18
19
20			class Ctor:
21			"""Marker class for enum constructors.
22
23			To use, index with a sequence of types, and annotate a variable in an
24			enum-decorated class with it.
25			"""
26
27			def __new__(cls, args):
28			if args == ():
29			return cls
30			self = object.__new__(cls)
31			ARGS[self] = args
32			return _CTOR_CACHE.setdefault(args, self)
33
34			def __init_subclass__(cls, **kwargs):
35			raise TypeError
36
37			def __class_getitem__(cls, args):
38			if not isinstance(args, tuple):
39			args = (args,)
40			return cls(args)
41
42
43			ARGS[Ctor] = ()
44
45
46			def _args(constructor, global_ns):
47			# Handle forward declarations. Needed for 3.7 compatinility.
48			if isinstance(constructor, str):
49			# Leverage Python's parser instead of trying to parse by hand.
50			ctor_ast = ast.parse(constructor, mode='eval')
51			# The top-level operation must be a subscript, with normal indexing.
52			if (
53			isinstance(ctor_ast.body, ast.Subscript)
54			and isinstance(ctor_ast.body.slice, ast.Index)):
55			# Pull out the index argument
56			index = ctor_ast.body.slice.value
57			# This basically gets rid of the brackets and index.
58			# Next, try to evaluate the result.
59			# This relies on Ctor being globally visible at definition time,
60			# which seems like a reasonable requirement.
61			ctor_ast.body = ctor_ast.body.value
62			try:
63			value = eval(
64			compile(ctor_ast, '<annotation>', 'eval'), global_ns)
65			except Exception:
66			# We couldn't tell what it was, so it's probably not Ctor.
67			return None
68			if value is Ctor:
69			# Pull the information directly off a Tuple node.
70			if isinstance(index, ast.Tuple):
71			return tuple(astor.to_source(elt) for elt in index.elts)
72			# Otherwise, assume it's a sequence of length 1.
73			# It's possible for this heuristic to return false answers, BUT
74			# it seems like everywhere that AST inspection and evaluation
75			# disagree, it needs syntax that breaks mypy, so it's sort of
76			# like it doesn't matter.
77			return (astor.to_source(index),)
78			try:
79			# If the above conditions didn't hold, maybe it's an alias.
80			# We could try to validate the AST, but we need to know the value
81			# anyway if it's valid.
82			constructor = eval(constructor, global_ns)
83			except Exception:
84			# This return is a little concerning. It's basically for "We tried
85			# to evaluate a forward reference of some kind, and failed."
86			# This might reject input at runtime that mypy would accept.
87			# The basic solution is to document that you can have forward
88			# references FROM a Ctor, but not within a decorated class.
89			return None
90			# Try to interpret the current value as a Ctor
91			return ARGS.get(constructor)
92
93
94			def _name(cls, function) -> str:
95			"""Return the name of a function accessed through a descriptor."""
96			return function.__get__(None, cls).__name__
97
98
99			def _set_new_functions(cls, *functions) -> typing.Optional[str]:
100			"""Attempt to set the attributes corresponding to the functions on cls.
101
102			If any attributes are already defined, fail before setting any, and
103			return the already-defined name.
104			"""
105			for function in functions:
106			if _name(cls, function) in cls.__dict__:
107			return _name(cls, function)
108			for function in functions:
109			setattr(cls, _name(cls, function), function)
110			return None
111
112
113			def _enum_super(_cls):
114			def base(cls, args):
115			return super(_cls, cls).__new__(cls, args)
116			return base
117
118
119			def _make_nested_new(_cls, subclasses, base__new__):
120			@staticmethod
121			def __new__(cls, args):
122			if cls not in subclasses:
123			raise TypeError
124			return base__new__(cls, args)
125			return __new__
126
127
128			def _process_class(_cls, _repr, eq, order):
129			if order and not eq:
130			raise ValueError('eq must be true if order is true')
131
132			argses = {}
133			subclasses = set()
134			subclass_order = []
135			for cls in reversed(_cls.__mro__):
136			for key, value in getattr(cls, '__annotations__', {}).items():
137			args = _args(value, vars(sys.modules[cls.__module__]))
138			# Shadow redone annotations.
139			if args is None:
140			argses.pop(key, None)
141			else:
142			argses[key] = args
143
144			for name, args in argses.items():
145			make_constructor(_cls, name, args, subclasses, subclass_order)
146
147			_cls.__init_subclass__ = PrewrittenMethods.__init_subclass__
148
149			if _set_new_functions(_cls, _make_nested_new(_cls, subclasses, _enum_super(_cls))):
150			_cls.__new__ = _make_nested_new(_cls, subclasses, _cls.__new__)
151
152			_set_new_functions(
153			_cls, PrewrittenMethods.__setattr__, PrewrittenMethods.__delattr__)
154			_set_new_functions(_cls, PrewrittenMethods.__bool__)
155
156			if _repr:
157			_set_new_functions(_cls, PrewrittenMethods.__repr__)
158
159			equality_methods_were_set = False
160
161			if eq:
162			equality_methods_were_set = not _set_new_functions(
163			_cls, PrewrittenMethods.__eq__, PrewrittenMethods.__ne__)
164
165			if equality_methods_were_set:
166			_cls.__hash__ = PrewrittenMethods.__hash__
167
168			if order:
169			if not equality_methods_were_set:
170			raise ValueError(
171			"Can't add ordering methods if equality methods are provided.")
172			collision = _set_new_functions(
173			_cls,
174			PrewrittenMethods.__lt__,
175			PrewrittenMethods.__le__,
176			PrewrittenMethods.__gt__,
177			PrewrittenMethods.__ge__
178			)
179			if collision:
180			raise TypeError(
181			'Cannot overwrite attribute {collision} in class '
182			'{name}. Consider using functools.total_ordering'.format(
183			collision=collision, name=_cls.__name__))
184
185			SUBCLASS_ORDER[_cls] = tuple(subclass_order)
186
187			return _cls
188
189
190			def enum(_cls=None, *, repr=True, eq=True, order=False):
191			"""Decorate a class to be an algebraic data type."""
192
193			def wrap(cls):
194			"""Return the processed class."""
195			return _process_class(cls, repr, eq, order)
196
197			if _cls is None:
198			return wrap
199
200			return wrap(_cls)
201
202
203			__all__ = ['Ctor', 'enum']
204

mwchase / python-structured-data

Push — master ( 201ca1...2e0d62 )

structured_data.enum._process_class() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like