Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-27 02:58
📄 __init__.py from typish._meta import __version__ from typish._types import ( T, KT, VT, Empty, Unknown, Module, NoneType, Ellipsis_, EllipsisType, ) from typish.classes._cls_dict import ClsDict from typish.classes._cls_function import ClsFunction from typish.classes._literal import Literal, LiteralAlias, is_literal_type from typish.classes._something import Something, TypingType from typish.classes._subscriptable_type import SubscriptableType from typish.classes._union_type import UnionType from typish.decorators._hintable import hintable from typish.functions._common_ancestor import ( common_ancestor, common_ancestor_of_types ) from typish.functions._get_alias import get_alias from typish.functions._get_args import get_args from typish.functions._get_mro import get_mro from typish.functions._get_origin import get_origin from typish.functions._get_simple_name import get_simple_name from typish.functions._get_type import get_type from typish.functions._get_type_hints_of_callable import ( get_args_and_return_type, get_type_hints_of_callable ) from typish.functions._instance_of import instance_of from typish.functions._is_type_annotation import is_type_annotation from typish.functions._is_optional_type import is_optional_type from typish.functions._subclass_of import subclass_of from typish.functions._is_from_typing import is_from_typing from typish._state import State, register_get_type	1.45 KB	2025-05-25 12:26
📁 __pycache__	-	2025-05-25 12:26
📄 _classes.py """ PRIVATE MODULE: do not import (from) it directly. This module contains class implementations. """ import inspect import types from collections import OrderedDict from typing import Any, Callable, Dict, Tuple, Optional, Union, List, Iterable from typish._types import Empty from typish._functions import ( get_type, subclass_of, instance_of, get_args_and_return_type, is_type_annotation, ) 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 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] class ClsDict(OrderedDict): """ ClsDict is a dict that accepts (only) types as keys and will return its values depending on instance checks rather than equality checks. """ def __new__(cls, args, kwargs): """ Construct a new instance of ``ClsDict``. :param args: a dict. :param kwargs: any kwargs that ``dict`` accepts. :return: a ``ClsDict``. """ if len(args) > 1: raise TypeError('TypeDict accepts only one positional argument, ' 'which must be a dict.') if args and not isinstance(args[0], dict): raise TypeError('TypeDict accepts only a dict as positional ' 'argument.') if not all([is_type_annotation(key) for key in args[0]]): raise TypeError('The given dict must only hold types as keys.') return super().__new__(cls, args[0], kwargs) def __getitem__(self, item: Any) -> Any: """ Return the value of the first encounter of a key for which ``is_instance(item, key)`` holds ``True``. :param item: any item. :return: the value of which the type corresponds with item. """ item_type = get_type(item, use_union=True) for key, value in self.items(): if subclass_of(item_type, key): return value raise KeyError('No match for {}'.format(item)) def get(self, item: Any, default: Any = None) -> Optional[Any]: try: return self.__getitem__(item) except KeyError: return default class ClsFunction: """ ClsDict is a callable that takes a ClsDict or a dict. When called, it uses the first argument to check for the right function in its body, executes it and returns the result. """ def __init__(self, body: Union[ClsDict, dict, Iterable[Callable]]): if isinstance(body, ClsDict): self.body = body elif isinstance(body, dict): self.body = ClsDict(body) elif instance_of(body, Iterable[Callable]): list_of_tuples = [] for func in body: signature = inspect.signature(func) params = list(signature.parameters.keys()) if not params: raise TypeError('ClsFunction expects callables that take ' 'at least one parameter, {} does not.' .format(func.__name__)) first_param = signature.parameters[params[0]] hint = first_param.annotation key = Any if hint == Empty else hint list_of_tuples.append((key, func)) self.body = ClsDict(OrderedDict(list_of_tuples)) else: raise TypeError('ClsFunction expects a ClsDict or a dict that can ' 'be turned to a ClsDict or an iterable of ' 'callables.') if not all(isinstance(value, Callable) for value in self.body.values()): raise TypeError('ClsFunction expects a dict or ClsDict with only ' 'callables as values.') def understands(self, item: Any) -> bool: """ Check to see if this ClsFunction can take item. :param item: the item that is checked. :return: True if this ClsFunction can take item. """ try: self.body[item] return True except KeyError: return False def __call__(self, args, kwargs): if not args: raise TypeError('ClsFunction must be called with at least 1 ' 'positional argument.') callable_ = self.body[args[0]] try: return callable_(args, **kwargs) except TypeError as err: raise TypeError('Unable to call function for \'{}\': {}' .format(args[0], err.args[0])) class _LiteralMeta(SubscriptableType): """ A Metaclass that exists to serve Literal and alter the __args__ attribute. """ def __getattribute__(cls, item): """ This method makes sure that __args__ is a tuple, like with typing.Literal. :param item: the name of the attribute that is obtained. :return: the attribute. """ if item == '__args__': try: result = SubscriptableType.__getattribute__(cls, item), except AttributeError: # In case of Python 3.5 result = tuple() elif item == '__origin__': result = 'Literal' else: result = SubscriptableType.__getattribute__(cls, item) return result class Literal(metaclass=_LiteralMeta): """ This is a backwards compatible variant of typing.Literal (Python 3.8+). """ _name = 'Literal'	11.35 KB	2025-05-25 12:26
📄 _decorators.py """ PRIVATE MODULE: do not import (from) it directly. This module contains decorators. """ import inspect from typish._functions import _map_empty, instance_of def typechecked(decorated): sig = inspect.signature(decorated) param_names = list(sig.parameters) def _wrapper(args, kwargs): for i, arg in enumerate(args): param = sig.parameters[param_names[i]] param_type = _map_empty(param.annotation) if not instance_of(arg, param_type): raise TypeError('Value {} for \'{}\' is not of type \'{}\'' .format(arg, param.name, param_type)) return decorated(args, **kwargs) return _wrapper	734 B	2025-05-25 12:26
📄 _functions.py """ PRIVATE MODULE: do not import (from) it directly. This module contains the implementation of all functions of typish. """ import inspect import types import typing from collections import deque, defaultdict from collections.abc import Set from functools import lru_cache from inspect import getmro from typish._types import T, KT, VT, NoneType, Unknown, Empty def subclass_of(cls: type, args: type) -> bool: """ Return whether ``cls`` is a subclass of all types in ``args`` while also considering generics. :param cls: the subject. :param args: the super types. :return: True if ``cls`` is a subclass of all types in ``args`` while also considering generics. """ if args and _is_literal(args[0]): return _check_literal(cls, subclass_of, args) if len(args) > 1: result = subclass_of(cls, args[0]) and subclass_of(cls, args[1:]) else: if args[0] == cls: return True result = _subclass_of(cls, args[0]) return result def instance_of(obj: object, args: type) -> bool: """ Check whether ``obj`` is an instance of all types in ``args``, while also considering generics. :param obj: the object in subject. :param args: the type(s) of which ``obj`` is an instance or not. :return: ``True`` if ``obj`` is an instance of all types in ``args``. """ if args and _is_literal(args[0]): return _check_literal(obj, instance_of, args) type_ = get_type(obj, use_union=True) return subclass_of(type_, args) 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. """ simple_name = _get_simple_name(t) result = _type_per_alias.get(simple_name, None) if not result: result = getattr(typing, simple_name, t) return result def get_args(t: type) -> typing.Tuple[type, ...]: """ Get the arguments from a collection type (e.g. ``typing.List[int]``) as a ``tuple``. :param t: the collection type. :return: a ``tuple`` containing types. """ args_ = getattr(t, '__args__', tuple()) or tuple() args = tuple([attr for attr in args_ if type(attr) != typing.TypeVar]) return args @lru_cache() 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 no alias exists for ``cls``, then ``None`` is returned. :param cls: the type for which the ``typing`` equivalent is to be found. :return: the alias from ``typing``. """ return _alias_per_type.get(cls.__name__, None) def get_type(inst: T, use_union: bool = False) -> typing.Type[T]: """ Return a type, complete with generics for the given ``inst``. :param inst: the instance for which a type is to be returned. :param use_union: if ``True``, the resulting type can contain a union. :return: the type of ``inst``. """ if inst is typing.Any: return typing.Any if str(inst).startswith('typing.Union'): return getattr(typing, '_GenericAlias', getattr(typing, 'GenericMeta', type)) result = type(inst) super_types = [ (dict, _get_type_dict), (tuple, _get_type_tuple), (str, lambda inst_, _: result), (typing.Iterable, _get_type_iterable), (types.FunctionType, _get_type_callable), (types.MethodType, _get_type_callable), (type, lambda inst_, _: typing.Type[inst]), ] try: for super_type, func in super_types: if isinstance(inst, super_type): result = func(inst, use_union) break except Exception: # If anything went wrong, return the regular type. # This is to support 3rd party libraries. return type(inst) return result def common_ancestor(args: object) -> type: """ Get the closest common ancestor of the given objects. :param args: any objects. :return: the ``type`` of the closest common ancestor of the given ``args``. """ return _common_ancestor(args, False) def common_ancestor_of_types(args: type) -> type: """ Get the closest common ancestor of the given classes. :param args: any classes. :return: the ``type`` of the closest common ancestor of the given ``args``. """ return _common_ancestor(args, True) def get_args_and_return_type(hint: typing.Type[typing.Callable]) \ -> typing.Tuple[typing.Optional[typing.Tuple[type]], typing.Optional[type]]: """ Get the argument types and the return type of a callable type hint (e.g. ``Callable[[int], str]``). Example: ``` arg_types, return_type = get_args_and_return_type(Callable[[int], str]) # args_types is (int, ) # return_type is str ``` Example for when ``hint`` has no generics: ``` arg_types, return_type = get_args_and_return_type(Callable) # args_types is None # return_type is None ``` :param hint: the callable type hint. :return: a tuple of the argument types (as a tuple) and the return type. """ if hint in (callable, typing.Callable): arg_types = None return_type = None elif hasattr(hint, '__result__'): arg_types = hint.__args__ return_type = hint.__result__ else: arg_types = hint.__args__[0:-1] return_type = hint.__args__[-1] return arg_types, return_type def get_type_hints_of_callable( func: typing.Callable) -> typing.Dict[str, type]: """ Return the type hints of the parameters of the given callable. :param func: the callable of which the type hints are to be returned. :return: a dict with parameter names and their types. """ # Python3.5: get_type_hints raises on classes without explicit constructor try: result = typing.get_type_hints(func) except AttributeError: result = {} return result def is_type_annotation(item: typing.Any) -> bool: """ Return whether item is a type annotation (a ``type`` or a type from ``typing``, such as ``List``). :param item: the item in question. :return: ``True`` is ``item`` is a type annotation. """ # Use _GenericAlias for Python 3.7+ and use GenericMeta for the rest. super_cls = getattr(typing, '_GenericAlias', getattr(typing, 'GenericMeta', None)) return (item is typing.Any or instance_of(item, type) or instance_of(item, super_cls)) def _subclass_of_generic( cls: type, info_generic_type: type, info_args: typing.Tuple[type, ...]) -> bool: # Check if cls is a subtype of info_generic_type, knowing that the latter # is a generic type. result = False cls_origin, cls_args = _split_generic(cls) if info_generic_type is tuple: # Special case. result = (subclass_of(cls_origin, tuple) and _subclass_of_tuple(cls_args, info_args)) elif cls_origin is tuple and info_generic_type is typing.Iterable: # Another special case. args = get_args(cls) if len(args) > 1 and args[1] is ...: args = [args[0]] ancestor = common_ancestor_of_types(args) result = subclass_of(typing.Iterable[ancestor], typing.Iterable[args[0]]) elif info_generic_type is typing.Union: # Another special case. result = _subclass_of_union(cls, info_args) elif (subclass_of(cls_origin, info_generic_type) and cls_args and len(cls_args) == len(info_args)): for tup in zip(cls_args, info_args): if not subclass_of(tup): result = False break else: result = True # Note that issubtype(list, List[...]) is always False. # Note that the number of arguments must be equal. return result def _subclass_of_tuple( cls_args: typing.Tuple[type, ...], info_args: typing.Tuple[type, ...]) -> bool: result = False if len(info_args) == 2 and info_args[1] is ...: type_ = get_origin(info_args[0]) if type_ is typing.Union: # A heterogeneous tuple: check each element if it subclasses the # union. result = all([subclass_of(elem, info_args[0]) for elem in cls_args]) else: result = subclass_of(common_ancestor_of_types(cls_args), info_args[0]) elif len(cls_args) == len(info_args): for c1, c2 in zip(cls_args, info_args): if not subclass_of(c1, c2): break else: result = True return result def _split_generic(t: type) -> \ typing.Tuple[type, typing.Optional[typing.Tuple[type, ...]]]: # Split the given generic type into the type and its args. return get_origin(t), get_args(t) def _get_type_iterable(inst: typing.Iterable, use_union: bool): typing_type = get_alias(type(inst)) common_cls = Unknown if inst: if use_union: types = [get_type(elem) for elem in inst] common_cls = typing.Union[tuple(types)] else: common_cls = common_ancestor(inst) if typing_type: if issubclass(common_cls, typing.Iterable) and typing_type is not str: # Get to the bottom of it; obtain types recursively. common_cls = get_type(common_cls(_flatten(inst))) result = typing_type[common_cls] return result def _get_type_tuple(inst: tuple, use_union: bool) -> typing.Dict[KT, VT]: args = [get_type(elem) for elem in inst] return typing.Tuple[tuple(args)] def _get_type_callable( inst: typing.Callable, use_union: bool) -> typing.Type[typing.Dict[KT, VT]]: if 'lambda' in str(inst): result = _get_type_lambda(inst, use_union) else: result = typing.Callable sig = inspect.signature(inst) args = [_map_empty(param.annotation) for param in sig.parameters.values()] return_type = NoneType if sig.return_annotation != Empty: return_type = sig.return_annotation if args or return_type != NoneType: if inspect.iscoroutinefunction(inst): return_type = typing.Awaitable[return_type] result = typing.Callable[args, return_type] return result def _map_empty(annotation: type) -> type: result = annotation if annotation == Empty: result = typing.Any return result def _get_type_lambda( inst: typing.Callable, use_union: bool) -> typing.Type[typing.Dict[KT, VT]]: args = [Unknown for _ in inspect.signature(inst).parameters] return_type = Unknown return typing.Callable[args, return_type] def _get_type_dict(inst: typing.Dict[KT, VT], use_union: bool) -> typing.Type[typing.Dict[KT, VT]]: t_list_k = _get_type_iterable(list(inst.keys()), use_union) t_list_v = _get_type_iterable(list(inst.values()), use_union) _, t_k_tuple = _split_generic(t_list_k) _, t_v_tuple = _split_generic(t_list_v) return typing.Dict[t_k_tuple[0], t_v_tuple[0]] def _flatten(l: typing.Iterable[typing.Iterable[typing.Any]]) -> typing.List[typing.Any]: result = [] for x in l: result += [x] return result def _common_ancestor(args: typing.Sequence[object], types: bool) -> type: if len(args) < 1: raise TypeError('common_ancestor() requires at least 1 argument') tmap = (lambda x: x) if types else get_type mros = [_get_mro(tmap(elem)) for elem in args] for cls in mros[0]: for mro in mros: if cls not in mro: break else: # cls is in every mro; a common ancestor is found! return cls def _subclass_of(cls: type, clsinfo: type) -> bool: # Check whether cls is a subtype of clsinfo. clsinfo_origin, info_args = _split_generic(clsinfo) cls_origin = get_origin(cls) if cls is Unknown or clsinfo in (typing.Any, object): result = True elif cls_origin is typing.Union: # cls is a Union; all options of that Union must subclass clsinfo. _, cls_args = _split_generic(cls) result = all([subclass_of(elem, clsinfo) for elem in cls_args]) elif info_args: result = _subclass_of_generic(cls, clsinfo_origin, info_args) else: try: result = issubclass(cls_origin, clsinfo_origin) except TypeError: result = False return result def _subclass_of_union( cls: type, info_args: typing.Tuple[type, ...]) -> bool: # Handle subclass_of(, union) result = True for cls_ in info_args: if subclass_of(cls, cls_): break else: result = False return result @lru_cache() def _get_simple_name(cls: type) -> str: if cls is None: cls = type(cls) cls_name = getattr(cls, '__name__', None) if not cls_name: cls_name = getattr(cls, '_name', None) if not cls_name: cls_name = repr(cls) cls_name = cls_name.split('[')[0] # Remove generic types. cls_name = cls_name.split('.')[-1] # Remove any . caused by repr. cls_name = cls_name.split(r"'>")[0] # Remove any '>. return cls_name def _get_mro(cls: type) -> typing.Tuple[type, ...]: # Wrapper around ``getmro`` to allow types from ``Typing``. if cls is ...: return Ellipsis, object elif cls is typing.Union: # For Python <3.7, we cannot use mro. super_cls = getattr(typing, '_GenericAlias', getattr(typing, 'GenericMeta', None)) return (typing.Union, super_cls, object) origin, args = _split_generic(cls) if origin != cls: return _get_mro(origin) return getmro(cls) def _is_literal(arg: typing.Any) -> bool: # Return True if arg is a Literal. origin = get_origin(arg) return getattr(origin, '_name', None) == 'Literal' def _check_literal(obj: object, func: typing.Callable, args: type) -> bool: # Instance or subclass check for Literal. literal = args[0] leftovers = args[1:] literal_args = getattr(literal, '__args__', None) if literal_args: literal_arg = literal_args[0] return obj == literal_arg and (not leftovers or func(obj, leftovers)) return False _alias_per_type = { 'list': typing.List, 'tuple': typing.Tuple, 'dict': typing.Dict, 'set': typing.Set, 'frozenset': typing.FrozenSet, 'deque': typing.Deque, 'defaultdict': typing.DefaultDict, 'type': typing.Type, 'Set': typing.AbstractSet, } _type_per_alias = { 'List': list, 'Tuple': tuple, 'Dict': dict, 'Set': set, 'FrozenSet': frozenset, 'Deque': deque, 'DefaultDict': defaultdict, 'Type': type, 'AbstractSet': Set, }	15.25 KB	2025-05-25 12:26
📄 _meta.py __title__ = 'typish' __version__ = '1.9.3' __author__ = 'Ramon Hagenaars' __author_email__ = 'ramon.hagenaars@gmail.com' __description__ = 'Functionality for types' __url__ = 'https://github.com/ramonhagenaars/typish' __license__ = 'MIT'	245 B	2025-05-25 12:26
📄 _state.py from typing import Callable from typish import T class State: """ A class which instances hold any state that may be used by typish. """ def __init__(self) -> None: """ Constructor. """ self.get_type_per_cls = {} def register_get_type( self, cls: T, get_type_function: Callable[[T], type]) -> None: """ Register a callable for some type that is to be used when calling typish.get_type. :param cls: the type for which that given callable is to be called. :param get_type_function: the callable to call for that type. :return: None. """ self.get_type_per_cls[cls] = get_type_function DEFAULT = State() def register_get_type( cls: T, get_type_function: Callable[[T], type], state: State = DEFAULT) -> None: """ Register a callable for some type that is to be used when calling typish.get_type. :param cls: the type for which that given callable is to be called. :param get_type_function: the callable to call for that type. :param state: any state that is used by typish. :return: None. """ state.register_get_type(cls, get_type_function)	1.27 KB	2025-05-25 12:26
📄 _types.py """ PRIVATE MODULE: do not import (from) it directly. This module contains types that are not available by default. """ import typing from inspect import Parameter T = typing.TypeVar('T') KT = typing.TypeVar('KT') VT = typing.TypeVar('VT') Empty = Parameter.empty Unknown = type('Unknown', (Empty, ), {}) Module = type(typing) NoneType = type(None) Ellipsis_ = type(...) # Use EllipsisType instead. EllipsisType = type(...)	446 B	2025-05-25 12:26
📁 classes	-	2025-05-25 12:26
📁 decorators	-	2025-05-25 12:26
📄 effe.py from typing import Tuple, Type from typish import instance_of, subclass_of, TypingType # Kijk hier effe naar: # # A supertype for types like: list, tuple, set, ... (not str!) # Aggregation = type('Aggegation', (object, ), {}) # # # A supertype for types like: List[...], Tuple[...], Set[...] # GenericAggregation = type('GenericAggregation', (Aggregation,), {}) # # # if __name__ == '__main__': # # # # # # print(isinstance(Tuple[int, str], GenericCollectionType)) # def test_is_something_hashable(self): # Sequence[Something['attr': int]] # TODO # # # def test_instance_of_tuple(self): # Tuple[type, ...] # TODO dit dus... # print( instance_of((1, 2, 3), Tuple[int, ...]) ) # print( subclass_of(Tuple[int, ...], Tuple[int, ...]) ) # print( instance_of(Tuple[int], Type[Tuple[int]]) )	841 B	2025-05-25 12:26
📁 functions	-	2025-05-25 12:26

Terminal