def is_issubclass_case(cls: type, clsinfo: type) -> bool:
# Return whether subclass_of(cls, clsinfo) holds a case that can be handled
# by the builtin issubclass.
from typish.functions._is_from_typing import is_from_typing
return (not is_from_typing(clsinfo) and isinstance(cls, type)
and clsinfo is not type and '__subclasscheck__' in dir(clsinfo))
def _instance_of(obj: object, clsinfo: object, state: State = DEFAULT) -> bool:
from typish.classes._literal import LiteralAlias, is_literal_type
from typish.functions._subclass_of import subclass_of
from typish.functions._get_type import get_type
from typish.functions._is_from_typing import is_from_typing
if not is_from_typing(clsinfo) and '__instancecheck__' in dir(clsinfo):
return isinstance(obj, clsinfo)
if is_literal_type(clsinfo):
alias = LiteralAlias.from_literal(clsinfo)
return isinstance(obj, alias)
type_ = get_type(obj, use_union=True, state=state)
return subclass_of(type_, clsinfo)
def get_origin(t: type) -> type:
"""
Return the origin of the given (generic) type. For example, for
``t=List[str]``, the result would be ``list``.
:param t: the type of which the origin is to be found.
:return: the origin of ``t`` or ``t`` if it is not generic.
"""
from typish.functions._get_simple_name import get_simple_name
simple_name = get_simple_name(t)
result = _type_per_alias.get(simple_name, None)
if isclass(t) and not is_from_typing(t):
result = t
elif not result:
result = getattr(typing, simple_name, t)
return result
def get_alias(cls: T) -> typing.Optional[T]:
"""
Return the alias from the ``typing`` module for ``cls``. For example, for
``cls=list``, the result would be ``typing.List``. If ``cls`` is
parameterized (>=3.9), then a parameterized ``typing`` equivalent is
returned. If no alias exists for ``cls``, then ``None`` is returned.
If ``cls`` already is from ``typing`` it is returned as is.
:param cls: the type for which the ``typing`` equivalent is to be found.
:return: the alias from ``typing``.
"""
if is_from_typing(cls):
return cls
alias = _alias_per_type.get(cls.__name__, None)
if alias:
args = getattr(cls, '__args__', tuple())
if args:
alias = alias[args]
return alias