Python typing 模块，GenericMeta() 实例源码

def literal_substitute(t, type_map):
    """Make substitutions in t according to type_map, returning resulting type."""
    if isinstance(t, TypeVar) and t.__name__ in type_map:
        return type_map[t.__name__]
    elif isinstance(t, TuplePlus):
        subbed_args = [literal_substitute(t1, type_map) for t1 in t.__constraints__]
        return TuplePlus('tup+', *subbed_args)
    elif isinstance(t, CallableMeta):
        args = list(literal_substitute(t1, type_map) for t1 in t.__args__[:-1])
        res = literal_substitute(t.__args__[-1], type_map)
        new_t = Callable[args, res]
        if hasattr(t, 'polymorphic_tvars'):
            new_t.polymorphic_tvars = t.polymorphic_tvars
        return new_t
    elif isinstance(t, GenericMeta) and t.__args__ is not None:
        return _gorg(t)[tuple(literal_substitute(t1, type_map) for t1 in t.__args__)]
    else:
        return t

def strcast(kind, keep_builtins=False):
    if issubclass(kind, typing.GenericMeta):
        return str(kind)[1:]
    if str(kind).startswith('~'):
        return str(kind)[1:]
    if (kind in basic_types or
            type(kind) in basic_types) and keep_builtins is False:
        return kind.__name__
    return kind

def _deserialize(data, klass):
    """
    Deserializes dict, list, str into an object.

    :param data: dict, list or str.
    :param klass: class literal, or string of class name.

    :return: object.
    """
    if data is None:
        return None

    if klass in integer_types or klass in (float, str, bool):
        return _deserialize_primitive(data, klass)
    elif klass == object:
        return _deserialize_object(data)
    elif klass == date:
        return deserialize_date(data)
    elif klass == datetime:
        return deserialize_datetime(data)
    elif type(klass) == GenericMeta:
        if klass.__extra__ == list:
            return _deserialize_list(data, klass.__args__[0])
        if klass.__extra__ == dict:
            return _deserialize_dict(data, klass.__args__[1])
    else:
        return deserialize_model(data, klass)

def _match_stub_type(stub_type):
    if not (sys.version_info.major >= 3):
        return stub_type
    # Todo: Only apply if stub-module is involved
    # Todo: Somehow cache results
    if isinstance(stub_type, TupleMeta):
        prms = pytypes.get_Tuple_params(stub_type)
        res = Tuple[(tuple(_match_stub_type(t) for t in prms))]
    elif pytypes.is_Union(stub_type):
        try:
            # Python 3.6
            res = Union[tuple(_match_stub_type(t) for t in stub_type.__args__)]
        except AttributeError:
            res = Union[tuple(_match_stub_type(t) for t in stub_type.__union_params__)]
    elif isinstance(stub_type, GenericMeta):
        if stub_type.__args__ is None:
            res = stub_type
        elif isinstance(stub_type, CallableMeta):
            if hasattr(stub_type, '__result__'):
                res = stub_type.__origin__[tuple(_match_stub_type(t) for t in stub_type.__args__)]
                res.__result__ = _match_stub_type(stub_type.__result__)
            else:
                res = stub_type.__origin__[tuple([
                        [_match_stub_type(t) for t in stub_type.__args__[:-1]],
                        _match_stub_type(stub_type.__args__[-1]) ]) ]
        else:
            res = stub_type.__origin__[tuple(_match_stub_type(t) for t in stub_type.__args__)]
    elif isclass(stub_type):
        res = stub_type._match_type if hasattr(stub_type, '_match_type') else stub_type
    else:
        res = stub_type
    return res

def _GenericMeta__new__351(cls, *args, **kwds):
        origin = None
        if len(args) >= 6:
            # origin is at index 5 in original signature:
            # name, bases, namespace, tvars=None, args=None, origin=None, extra=None, orig_bases=None
            origin = args[5]
        elif 'origin' in kwds:
            origin = kwds['origin']
        res = _GenericMeta__new__(cls, *args, **kwds)
        # we correct the hash according to the fix in https://github.com/python/typing/pull/371
        res.__tree_hash__ = (hash(res._subs_tree()) if origin else
                super(typing.GenericMeta, res).__hash__())
        return res

def lookup_method(name, caller_type, *args):
    """Lookup method with the given name for the given type."""
    if isinstance(caller_type, TupleMeta):
        caller_origin = Tuple
    elif isinstance(caller_type, GenericMeta):
        caller_origin = _gorg(caller_type)
    else:
        caller_origin = caller_type

    return TYPE_SIGNATURES[caller_origin][name]

def unify(self, t1, t2):
        if isinstance(t1, TypeVar) and isinstance(t2, TypeVar):
            if t1 == t2:
                # TODO: look into implementation of  __eq__ TVARS
                pass
            else:
                node1, node2 = self._tvar_tnode[t1], self._tvar_tnode[t2]
                self._union(node1, node2)
        elif isinstance(t1, TypeVar):
            node2 = self.add_concrete_to_sets(t2)
            node1 = self._tvar_tnode[t1]
            self._union(node1, node2)
        elif isinstance(t2, TypeVar):
            self.unify(t2, t1)
        elif isinstance(t1, GenericMeta) and isinstance(t2, GenericMeta):
            self._unify_generic(t1, t2)
        elif isinstance(t1, CallableMeta) and isinstance(t2, CallableMeta):
            rtype = self.unify_call(t1, *t2.__args__[:-1])
            self.unify(rtype, t2.__args__[-1])
        elif isinstance(t1, TupleMeta) and isinstance(t2, TupleMeta):
            self._unify_tuple(t1, t2)
        elif t1.__class__.__name__ == '_Union' or t2.__class__.__name__ == '_Union':
            pass
        elif t1 == Any or t2 == Any:
            pass
        elif isinstance(t1, _ForwardRef) and isinstance(t2, _ForwardRef) and t1 == t2:
            pass
        elif isinstance(t1, _ForwardRef) or isinstance(t2, _ForwardRef):
            raise Exception(str(t1) + ' ' + str(t2))
        elif issubclass(t1, t2) or issubclass(t2, t1):
            pass
        elif t1 != t2:
            raise TypeInferenceError(str(t1) + ' ' + str(t2))

def _unify_generic(self, t1: GenericMeta, t2: GenericMeta):
        """Unify two generic-typed nodes."""
        if _gorg(t1) is not _gorg(t2):
            raise TypeInferenceError('bad unify')
        elif t1.__args__ is not None and t2.__args__ is not None:
            for a1, a2 in zip(t1.__args__, t2.__args__):
                self.unify(a1, a2)

def least_general_unifier(self, t1, t2):
        if isinstance(t1, TypeVar) and isinstance(t2, TypeVar):
            i1 = self._find(t1)
            i2 = self._find(t2)
            if issubclass(i1, i2):
                return i2
            elif issubclass(i2, i1):
                return i1
            else:
                return Any
        elif isinstance(t1, TypeVar):
            i1 = self._find(t1)
            if issubclass(i1, t2):
                return t2
            elif issubclass(t2, i1):
                return i1
            else:
                return Any
        elif isinstance(t2, TypeVar):
            return self.least_general_unifier(t2, t1)
        elif isinstance(t1, GenericMeta) and isinstance(t2, GenericMeta):
            return self._least_general_unifier_generic(t1, t2)
        elif isinstance(t1, CallableMeta) and isinstance(t2, CallableMeta):
            rtype = self._least_general_unifier_call(t1, *t2.__args__[:-1])
            return self.least_general_unifier(rtype, t2.__args__[-1])
        elif isinstance(t1, TupleMeta) and isinstance(t2, TupleMeta):
            return self._least_general_unifier_tuple(t1, t2)
        elif t1.__class__.__name__ == '_Union' or t2.__class__.__name__ == '_Union':
            pass
        elif t1 == Any or t2 == Any:
            return Any
        elif issubclass(t1, t2):
            return t2
        elif issubclass(t2, t1):
            return t1
        elif t1 != t2:
            return Any

def _least_general_unifier_generic(self, t1: GenericMeta, t2: GenericMeta):
        """Unify two generic types."""
        if _gorg(t1) is not _gorg(t2):
            raise TypeInferenceError('bad unify')
        elif t1.__args__ is not None and t2.__args__ is not None:
            for a1, a2 in zip(t1.__args__, t2.__args__):
                return self.least_general_unifier(a1, a2)

def __new__(cls, name, bases, namespace, parameters=None):
        self = super().__new__(cls, name, bases, namespace)
        self.__iter_cnt = 0
        if not parameters:
            self.__params = None
            return self
        self.__params = []
        for arg_t in parameters:
            if arg_t is str:
                self.__params.append(str)
            elif arg_t is bool:
                self.__params.append(bool)
            elif arg_t is int:
                self.__params.append(int)
            elif arg_t is UnsignedLongLong:
                self.__params.append(UnsignedLongLong)
            elif arg_t is Double or arg_t is float:
                self.__params.append(Double)
            elif arg_t is Float:
                self.__params.append(Float)
            elif issubclass(arg_t, Tuple):
                self.__params.append(arg_t)
            elif issubclass(arg_t, list):
                self.__params.append(arg_t)
            elif issubclass(arg_t, dict):
                self.__params.append(arg_t)
            elif arg_t.__class__ is typing.GenericMeta:
                self.__params.append(arg_t)
            else:
                raise TypeError("rustypy: subtype `{t}` of Tuple type is \
                                not supported".format(t=arg_t))
        return self

def _deserialize(data, klass):
    """
    Deserializes dict, list, str into an object.

    :param data: dict, list or str.
    :param klass: class literal, or string of class name.

    :return: object.
    """
    if data is None:
        return None

    if klass in integer_types or klass in (float, str, bool):
        return _deserialize_primitive(data, klass)
    elif klass == object:
        return _deserialize_object(data)
    elif klass == date:
        return deserialize_date(data)
    elif klass == datetime:
        return deserialize_datetime(data)
    elif type(klass) == GenericMeta:
        if klass.__extra__ == list:
            return _deserialize_list(data, klass.__args__[0])
        if klass.__extra__ == dict:
            return _deserialize_dict(data, klass.__args__[1])
    else:
        return deserialize_model(data, klass)

def can_unify(self, t1, t2):
        """Return true iff given argument types can be unified."""
        if isinstance(t1, TypeVar) or isinstance(t2, TypeVar):
            return True
        elif isinstance(t1, GenericMeta) and isinstance(t2, GenericMeta):
            if _gorg(t1) is not _gorg(t2):
                return False
            elif t1.__args__ is not None and t2.__args__ is not None:
                for a1, a2 in zip(t1.__args__, t2.__args__):
                    if not self.can_unify(a1, a2):
                        return False
                return True
            else:
                return False
        elif isinstance(t1, GenericMeta):
            return False
        elif isinstance(t2, GenericMeta):
            return False
        elif t1.__class__.__name__ == '_Union' and t2.__class__.__name__ == 'Union':
            for union_type in t1.__args__:
                if union_type in t2.__args__:
                    return True
            else:
                return False
        elif t1.__class__.__name__ == '_Union':
            if t2 in t1.__args__:
                return True
            else:
                return False
        elif t2.__class__.__name__ == '_Union':
            if t1 in t2.__args__:
                return True
            else:
                return False
        elif t1 == Any or t2 == Any:
            return True
        elif (hasattr(t1, 'msg') and ('not found' in t1.msg)) or (hasattr(t2, 'msg') and ('not found' in t2.msg)):
            return False
        elif isinstance(t1, _ForwardRef) and isinstance(t2, _ForwardRef) and t1 == t2:
            return True
        elif isinstance(t1, _ForwardRef) or isinstance(t2, _ForwardRef):
            return False
        elif issubclass(t1, t2) or issubclass(t2, t1):
            return True
        elif t1 != t2:
            return False
        else:
            return True