typish._classes._SomethingMeta.__hash__() - Code Metrics - Inspection of "Hotfix for hashing with Python 3.5 and Python 3.6." - ramonhagenaars/typish - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 2f33ee...d68237 )

by Ramon

created 2019-11-23 18:55 UTC

typish._classes._SomethingMeta.hash() A

↳ Parent: typish._classes

Complexity

Conditions

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

"""
PRIVATE MODULE: do not import (from) it directly.

This module contains class implementations.
"""
import types
import warnings
from collections import OrderedDict
from typing import Any, Callable, Dict, Tuple

from typish._functions import (
    get_type,
    subclass_of,
    instance_of,
    get_args_and_return_type,
)


class _SubscribedType(type):
    """
    This class is a placeholder to let the IDE know the attributes of the
    returned type after a __getitem__.
    """
    __origin__ = None
    __args__ = None


class SubscriptableType(type):
    """
    This metaclass will allow a type to become subscriptable.

    >>> class SomeType(metaclass=SubscriptableType):
    ...     pass
    >>> SomeTypeSub = SomeType['some args']
    >>> SomeTypeSub.__args__
    'some args'
    >>> SomeTypeSub.__origin__.__name__
    'SomeType'
    """
    def __init_subclass__(mcs, **kwargs):
        mcs._hash = None
        mcs.__args__ = None
        mcs.__origin__ = None

    def __getitem__(self, item) -> _SubscribedType:
        body = {
            **self.__dict__,
            '__args__': item,
            '__origin__': self,
        }
        bases = self, *self.__bases__
        result = type(self.__name__, bases, body)
        if hasattr(result, '_after_subscription'):
            # TODO check if _after_subscription is static
            result._after_subscription(item)
        return result

    def __eq__(self, other):
        self_args = getattr(self, '__args__', None)
        self_origin = getattr(self, '__origin__', None)
        other_args = getattr(other, '__args__', None)
        other_origin = getattr(other, '__origin__', None)
        return self_args == other_args and self_origin == other_origin

    def __hash__(self):
        if not getattr(self, '_hash', None):
            self._hash = hash('{}{}'.format(self.__origin__, self.__args__))
        return self._hash


class _SomethingMeta(SubscriptableType):
    """
    This metaclass is coupled to ``Interface``.
    """
    def __instancecheck__(self, instance: object) -> bool:
        # Check if all attributes from self.signature are also present in
        # instance and also check that their types correspond.
        sig = self.signature()
        for key in sig:
            attr = getattr(instance, key, None)
            if not attr or not instance_of(attr, sig[key]):
                return False
        return True

    def __subclasscheck__(self, subclass: type) -> bool:
        # If an instance of type subclass is an instance of self, then subclass
        # is a sub class of self.
        self_sig = self.signature()
        other_sig = Something.like(subclass).signature()
        for attr in self_sig:
            if attr in other_sig:
                attr_sig = other_sig[attr]
                if (not isinstance(subclass.__dict__[attr], staticmethod)
                        and not isinstance(subclass.__dict__[attr], classmethod)
                        and subclass_of(attr_sig, Callable)):
                    # The attr must be a regular method or class method, so the
                    # first parameter should be ignored.
                    args, rt = get_args_and_return_type(attr_sig)
                    attr_sig = Callable[list(args[1:]), rt]
                if not subclass_of(attr_sig, self_sig[attr]):
                    return False
        return True

    def __eq__(self, other: 'Something') -> bool:
        return (isinstance(other, _SomethingMeta)
                and self.signature() == other.signature())

    def __repr__(self):
        sig = self.signature()
        sig_ = ', '.join(["'{}': {}".format(k, self._type_repr(sig[k]))
                          for k in sig])
        return 'typish.Something[{}]'.format(sig_)

    def __hash__(self):
        # This explicit super call is required for Python 3.5 and 3.6.
        return super.__hash__(self)

    def _type_repr(self, obj):
        """Return the repr() of an object, special-casing types (internal helper).

        If obj is a type, we return a shorter version than the default
        type.__repr__, based on the module and qualified name, which is
        typically enough to uniquely identify a type.  For everything
        else, we fall back on repr(obj).
        """
        if isinstance(obj, type) and not issubclass(obj, Callable):
            if obj.__module__ == 'builtins':
                return obj.__qualname__
            return '{}.{}'.format(obj.__module__, obj.__qualname__)
        if obj is ...:
            return '...'
        if isinstance(obj, types.FunctionType):
            return obj.__name__
        return repr(obj)


class Something(type, metaclass=_SomethingMeta):
    """
    This class allows one to define an interface for something that has some
    attributes, such as objects or classes or maybe even modules.
    """
    @classmethod
    def signature(mcs) -> Dict[str, type]:
        """
        Return the signature of this ``Something`` as a dict.
        :return: a dict with attribute names as keys and types as values.
        """
        result = OrderedDict()
        args = mcs.__args__
        if isinstance(mcs.__args__, slice):
            args = (mcs.__args__,)

        arg_keys = sorted(args)
        if isinstance(mcs.__args__, dict):
            for key in arg_keys:
                result[key] = mcs.__args__[key]
        else:
            for slice_ in arg_keys:
                result[slice_.start] = slice_.stop
        return result

    def __getattr__(cls, item):
        # This method exists solely to fool the IDE into believing that
        # Something can have any attribute.
        return type.__getattr__(cls, item)

    @staticmethod
    def of(obj: Any, exclude_privates: bool = True) -> 'Something':
        warnings.warn('Something.of is deprecated and will be removed in the '
                      'next minor release. Use Something.like instead.',
                      category=DeprecationWarning, stacklevel=2)
        return Something.like(obj, exclude_privates)

    @staticmethod
    def like(obj: Any, exclude_privates: bool = True) -> 'Something':
        """
        Return a ``Something`` for the given ``obj``.
        :param obj: the object of which a ``Something`` is to be made.
        :param exclude_privates: if ``True``, private variables are excluded.
        :return: a ``Something`` that corresponds to ``obj``.
        """
        signature = {attr: get_type(getattr(obj, attr)) for attr in dir(obj)
                     if not exclude_privates or not attr.startswith('_')}
        return Something[signature]


TypingType = Something['__origin__': type, '__args__': Tuple[type, ...]]


1			"""
2			PRIVATE MODULE: do not import (from) it directly.
3
4			This module contains class implementations.
5			"""
6			import types
7			import warnings
8			from collections import OrderedDict
9			from typing import Any, Callable, Dict, Tuple
10
11			from typish._functions import (
12			get_type,
13			subclass_of,
14			instance_of,
15			get_args_and_return_type,
16			)
17
18
19			class _SubscribedType(type):
20			"""
21			This class is a placeholder to let the IDE know the attributes of the
22			returned type after a __getitem__.
23			"""
24			__origin__ = None
25			__args__ = None
26
27
28			class SubscriptableType(type):
29			"""
30			This metaclass will allow a type to become subscriptable.
31
32			>>> class SomeType(metaclass=SubscriptableType):
33			... pass
34			>>> SomeTypeSub = SomeType['some args']
35			>>> SomeTypeSub.__args__
36			'some args'
37			>>> SomeTypeSub.__origin__.__name__
38			'SomeType'
39			"""
40			def __init_subclass__(mcs, **kwargs):
41			mcs._hash = None
42			mcs.__args__ = None
43			mcs.__origin__ = None
44
45			def __getitem__(self, item) -> _SubscribedType:
46			body = {
47			**self.__dict__,
48			'__args__': item,
49			'__origin__': self,
50			}
51			bases = self, *self.__bases__
52			result = type(self.__name__, bases, body)
53			if hasattr(result, '_after_subscription'):
54			# TODO check if _after_subscription is static
55			result._after_subscription(item)
56			return result
57
58			def __eq__(self, other):
59			self_args = getattr(self, '__args__', None)
60			self_origin = getattr(self, '__origin__', None)
61			other_args = getattr(other, '__args__', None)
62			other_origin = getattr(other, '__origin__', None)
63			return self_args == other_args and self_origin == other_origin
64
65			def __hash__(self):
66			if not getattr(self, '_hash', None):
67			self._hash = hash('{}{}'.format(self.__origin__, self.__args__))
68			return self._hash
69
70
71			class _SomethingMeta(SubscriptableType):
72			"""
73			This metaclass is coupled to ``Interface``.
74			"""
75			def __instancecheck__(self, instance: object) -> bool:
76			# Check if all attributes from self.signature are also present in
77			# instance and also check that their types correspond.
78			sig = self.signature()
79			for key in sig:
80			attr = getattr(instance, key, None)
81			if not attr or not instance_of(attr, sig[key]):
82			return False
83			return True
84
85			def __subclasscheck__(self, subclass: type) -> bool:
86			# If an instance of type subclass is an instance of self, then subclass
87			# is a sub class of self.
88			self_sig = self.signature()
89			other_sig = Something.like(subclass).signature()
90			for attr in self_sig:
91			if attr in other_sig:
92			attr_sig = other_sig[attr]
93			if (not isinstance(subclass.__dict__[attr], staticmethod)
94			and not isinstance(subclass.__dict__[attr], classmethod)
95			and subclass_of(attr_sig, Callable)):
96			# The attr must be a regular method or class method, so the
97			# first parameter should be ignored.
98			args, rt = get_args_and_return_type(attr_sig)
99			attr_sig = Callable[list(args[1:]), rt]
100			if not subclass_of(attr_sig, self_sig[attr]):
101			return False
102			return True
103
104			def __eq__(self, other: 'Something') -> bool:
105			return (isinstance(other, _SomethingMeta)
106			and self.signature() == other.signature())
107
108			def __repr__(self):
109			sig = self.signature()
110			sig_ = ', '.join(["'{}': {}".format(k, self._type_repr(sig[k]))
111			for k in sig])
112			return 'typish.Something[{}]'.format(sig_)
113
114			def __hash__(self):
115			# This explicit super call is required for Python 3.5 and 3.6.
116			return super.__hash__(self)
117
118			def _type_repr(self, obj):
119			"""Return the repr() of an object, special-casing types (internal helper).
120
121			If obj is a type, we return a shorter version than the default
122			type.__repr__, based on the module and qualified name, which is
123			typically enough to uniquely identify a type. For everything
124			else, we fall back on repr(obj).
125			"""
126			if isinstance(obj, type) and not issubclass(obj, Callable):
127			if obj.__module__ == 'builtins':
128			return obj.__qualname__
129			return '{}.{}'.format(obj.__module__, obj.__qualname__)
130			if obj is ...:
131			return '...'
132			if isinstance(obj, types.FunctionType):
133			return obj.__name__
134			return repr(obj)
135
136
137			class Something(type, metaclass=_SomethingMeta):
138			"""
139			This class allows one to define an interface for something that has some
140			attributes, such as objects or classes or maybe even modules.
141			"""
142			@classmethod
143			def signature(mcs) -> Dict[str, type]:
144			"""
145			Return the signature of this ``Something`` as a dict.
146			:return: a dict with attribute names as keys and types as values.
147			"""
148			result = OrderedDict()
149			args = mcs.__args__
150			if isinstance(mcs.__args__, slice):
151			args = (mcs.__args__,)
152
153			arg_keys = sorted(args)
154			if isinstance(mcs.__args__, dict):
155			for key in arg_keys:
156			result[key] = mcs.__args__[key]
157			else:
158			for slice_ in arg_keys:
159			result[slice_.start] = slice_.stop
160			return result
161
162			def __getattr__(cls, item):
163			# This method exists solely to fool the IDE into believing that
164			# Something can have any attribute.
165			return type.__getattr__(cls, item)
166
167			@staticmethod
168			def of(obj: Any, exclude_privates: bool = True) -> 'Something':
169			warnings.warn('Something.of is deprecated and will be removed in the '
170			'next minor release. Use Something.like instead.',
171			category=DeprecationWarning, stacklevel=2)
172			return Something.like(obj, exclude_privates)
173
174			@staticmethod
175			def like(obj: Any, exclude_privates: bool = True) -> 'Something':
176			"""
177			Return a ``Something`` for the given ``obj``.
178			:param obj: the object of which a ``Something`` is to be made.
179			:param exclude_privates: if ``True``, private variables are excluded.
180			:return: a ``Something`` that corresponds to ``obj``.
181			"""
182			signature = {attr: get_type(getattr(obj, attr)) for attr in dir(obj)
183			if not exclude_privates or not attr.startswith('_')}
184			return Something[signature]
185
186
187			TypingType = Something['__origin__': type, '__args__': Tuple[type, ...]]
188

ramonhagenaars / typish

Push — master ( 2f33ee...d68237 )

typish._classes._SomethingMeta.__hash__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

typish._classes._SomethingMeta.hash() A