coady__multimethod-26

{
  "status": "ok",
  "stdout": "success\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "import abc\nimport collections\nimport functools\nimport inspect\nimport itertools\nimport types\nimport typing\nfrom typing import Callable, Iterable, Iterator, Mapping, Union\n\n__version__ = '1.4'\n\n\ndef groupby(func: Callable, values: Iterable) -> dict:\n    \"\"\"Return mapping of key function to values.\"\"\"\n    groups = collections.defaultdict(list)  # type: dict\n    for value in values:\n        groups[func(value)].append(value)\n    return groups\n\n\ndef get_types(func: Callable) -> tuple:\n    \"\"\"Return evaluated type hints for positional required parameters in order.\"\"\"\n    if not hasattr(func, '__annotations__'):\n        return ()\n    type_hints = typing.get_type_hints(func)\n    positionals = {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}\n    annotations = [\n        type_hints.get(param.name, object)\n        for param in inspect.signature(func).parameters.values()\n        if param.default is param.empty and param.kind in positionals\n    ]  # missing annotations are padded with `object`, but trailing objects are unnecessary\n    return tuple(itertools.dropwhile(lambda cls: cls is object, reversed(annotations)))[::-1]\n\n\nclass DispatchError(TypeError):\n    pass\n\n\nclass subtype(type):\n    \"\"\"A normalized generic type which checks subscripts.\"\"\"\n\n    __origin__: type\n    __args__: tuple\n\n    def __new__(cls, tp, *args):\n        if tp is typing.Any:\n            return object\n        if isinstance(tp, typing.TypeVar):\n            if not tp.__constraints__:\n                return object\n            tp = typing.Union[tp.__constraints__]\n        origin = getattr(tp, '__extra__', getattr(tp, '__origin__', tp))\n        args = tuple(map(cls, getattr(tp, '__args__', None) or args))\n        if set(args) <= {object} and not (origin is tuple and args):\n            return origin\n        bases = (origin,) if type(origin) is type else ()\n        namespace = {'__origin__': origin, '__args__': args}\n        return type.__new__(cls, str(tp), bases, namespace)\n\n    def __init__(self, tp, *args):\n        if isinstance(self.__origin__, abc.ABCMeta):\n            self.__origin__.register(self)\n\n    def __getstate__(self) -> tuple:\n        return self.__origin__, self.__args__\n\n    def __eq__(self, other) -> bool:\n        return isinstance(other, subtype) and self.__getstate__() == other.__getstate__()\n\n    def __hash__(self) -> int:\n        return hash(self.__getstate__())\n\n    def __subclasscheck__(self, subclass: type) -> bool:\n        origin = getattr(subclass, '__extra__', getattr(subclass, '__origin__', subclass))\n        args = getattr(subclass, '__args__', ())\n        if origin is typing.Union:\n            return all(issubclass(cls, self) for cls in args)\n        if self.__origin__ is typing.Union:\n            return issubclass(subclass, self.__args__)\n        nargs = len(self.__args__)\n        if self.__origin__ is tuple and self.__args__[-1:] == (Ellipsis,):\n            nargs -= 1\n            args = args[:nargs]\n        return (  # check args first to avoid a recursion error in ABCMeta\n            len(args) == nargs\n            and issubclass(origin, self.__origin__)\n            and all(map(issubclass, args, self.__args__))\n        )\n\n    @classmethod\n    def subcheck(cls, tp: type) -> bool:\n        \"\"\"Return whether type requires checking subscripts using `get_type`.\"\"\"\n        return isinstance(tp, cls) and (\n            tp.__origin__ is not Union or any(map(cls.subcheck, tp.__args__))\n        )\n\n\ndef distance(cls, subclass: type) -> int:\n    \"\"\"Return estimated distance between classes for tie-breaking.\"\"\"\n    if getattr(cls, '__origin__', None) is typing.Union:\n        return min(distance(arg, subclass) for arg in cls.__args__)\n    mro = subclass.mro()\n    return mro.index(cls if cls in mro else object)\n\n\nclass signature(tuple):\n    \"\"\"A tuple of types that supports partial ordering.\"\"\"\n\n    parents: set\n\n    def __new__(cls, types: Iterable):\n        return tuple.__new__(cls, map(subtype, types))\n\n    def __le__(self, other) -> bool:\n        return len(self) <= len(other) and all(map(issubclass, other, self))\n\n    def __lt__(self, other) -> bool:\n        return self != other and self <= other\n\n    def __sub__(self, other) -> tuple:\n        \"\"\"Return relative distances, assuming self >= other.\"\"\"\n        return tuple(map(distance, other, self))\n\n\nclass multimethod(dict):\n    \"\"\"A callable directed acyclic graph of methods.\"\"\"\n\n    pending: set\n\n    def __new__(cls, func):\n        namespace = inspect.currentframe().f_back.f_locals\n        self = functools.update_wrapper(dict.__new__(cls), func)\n        self.pending = set()\n        self.get_type = type  # default type checker\n        homonym = namespace.get(func.__name__, self)\n        return homonym if isinstance(homonym, multimethod) else self\n\n    def __init__(self, func: Callable):\n        try:\n            self[get_types(func)] = func\n        except (NameError, AttributeError):\n            self.pending.add(func)\n\n    def register(self, *args) -> Callable:\n        \"\"\"Decorator for registering a function.\n\n        Optionally call with types to return a decorator for unannotated functions.\n        \"\"\"\n        if len(args) == 1 and hasattr(args[0], '__annotations__'):\n            return overload.register(self, *args)  # type: ignore",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 309,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "import abc\nimport collections\nimport functools\nimport inspect\nimport itertools\nimport types\nimport typing\nfrom typing import Callable, Iterable, Iterator, Mapping, Union\n\n__version__ = '1.4'\n\n\ndef groupby(func: Callable, values: Iterable) -> dict:\n    \"\"\"Return mapping of key function to values.\"\"\"\n    groups = collections.defaultdict(list)  # type: dict\n    for value in values:\n        groups[func(value)].append(value)\n    return groups\n\n\ndef get_types(func: Callable) -> tuple:\n    \"\"\"Return evaluated type hints for positional required parameters in order.\"\"\"\n    if not hasattr(func, '__annotations__'):\n        return ()\n    type_hints = typing.get_type_hints(func)\n    positionals = {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}\n    annotations = [\n        type_hints.get(param.name, object)\n        for param in inspect.signature(func).parameters.values()\n        if param.default is param.empty and param.kind in positionals\n    ]  # missing annotations are padded with `object`, but trailing objects are unnecessary\n    return tuple(itertools.dropwhile(lambda cls: cls is object, reversed(annotations)))[::-1]\n\n\nclass DispatchError(TypeError):\n    pass\n\n\nclass subtype(type):\n    \"\"\"A normalized generic type which checks subscripts.\"\"\"\n\n    __origin__: type\n    __args__: tuple\n\n    def __new__(cls, tp, *args):\n        if tp is typing.Any:\n            return object\n        if isinstance(tp, typing.TypeVar):\n            if not tp.__constraints__:\n                return object\n            tp = typing.Union[tp.__constraints__]\n        origin = getattr(tp, '__extra__', getattr(tp, '__origin__', tp))\n        args = tuple(map(cls, getattr(tp, '__args__', None) or args))\n        if set(args) <= {object} and not (origin is tuple and args):\n            return origin\n        bases = (origin,) if type(origin) is type else ()\n        namespace = {'__origin__': origin, '__args__': args}\n        return type.__new__(cls, str(tp), bases, namespace)\n\n    def __init__(self, tp, *args):\n        if isinstance(self.__origin__, abc.ABCMeta):\n            self.__origin__.register(self)\n\n    def __getstate__(self) -> tuple:\n        return self.__origin__, self.__args__\n\n    def __eq__(self, other) -> bool:\n        return isinstance(other, subtype) and self.__getstate__() == other.__getstate__()\n\n    def __hash__(self) -> int:\n        return hash(self.__getstate__())\n\n    def __subclasscheck__(self, subclass: type) -> bool:\n        origin = getattr(subclass, '__extra__', getattr(subclass, '__origin__', subclass))\n        args = getattr(subclass, '__args__', ())\n        if origin is typing.Union:\n            return all(issubclass(cls, self) for cls in args)\n        if self.__origin__ is typing.Union:\n            return issubclass(subclass, self.__args__)\n        nargs = len(self.__args__)\n        if self.__origin__ is tuple and self.__args__[-1:] == (Ellipsis,):\n            nargs -= 1\n            args = args[:nargs]\n        return (  # check args first to avoid a recursion error in ABCMeta\n            len(args) == nargs\n            and issubclass(origin, self.__origin__)\n            and all(map(issubclass, args, self.__args__))\n        )\n\n    @classmethod\n    def subcheck(cls, tp: type) -> bool:\n        \"\"\"Return whether type requires checking subscripts using `get_type`.\"\"\"\n        return isinstance(tp, cls) and (\n            tp.__origin__ is not Union or any(map(cls.subcheck, tp.__args__))\n        )\n\n\ndef distance(cls, subclass: type) -> int:\n    \"\"\"Return estimated distance between classes for tie-breaking.\"\"\"\n    if getattr(cls, '__origin__', None) is typing.Union:\n        return min(distance(arg, subclass) for arg in cls.__args__)\n    mro = subclass.mro()\n    return mro.index(cls if cls in mro else object)\n\n\nclass signature(tuple):\n    \"\"\"A tuple of types that supports partial ordering.\"\"\"\n\n    parents: set\n\n    def __new__(cls, types: Iterable):\n        return tuple.__new__(cls, map(subtype, types))\n\n    def __le__(self, other) -> bool:\n        return len(self) <= len(other) and all(map(issubclass, other, self))\n\n    def __lt__(self, other) -> bool:\n        return self != other and self <= other\n\n    def __sub__(self, other) -> tuple:\n        \"\"\"Return relative distances, assuming self >= other.\"\"\"\n        return tuple(map(distance, other, self))\n\n\nclass multimethod(dict):\n    \"\"\"A callable directed acyclic graph of methods.\"\"\"\n\n    pending: set\n\n    def __new__(cls, func):\n        namespace = inspect.currentframe().f_back.f_locals\n        self = functools.update_wrapper(dict.__new__(cls), func)\n        self.pending = set()\n        self.get_type = type  # default type checker\n        homonym = namespace.get(func.__name__, self)\n        return homonym if isinstance(homonym, multimethod) else self\n\n    def __init__(self, func: Callable):\n        try:\n            self[get_types(func)] = func\n        except (NameError, AttributeError):\n            self.pending.add(func)\n\n    def register(self, *args) -> Callable:\n        \"\"\"Decorator for registering a function.\n\n        Optionally call with types to return a decorator for unannotated functions.\n        \"\"\"\n        if len(args) == 1 and hasattr(args[0], '__annotations__'):\n            return overload.register(self, *args)  # type: ignore",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 309,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "        return lambda func: self.__setitem__(args, func) or func\n\n    def __get__(self, instance, owner):\n        return self if instance is None else types.MethodType(self, instance)\n\n    def parents(self, types: tuple) -> set:\n        \"\"\"Find immediate parents of potential key.\"\"\"\n        parents = {key for key in self if isinstance(key, signature) and key < types}\n        return parents - {ancestor for parent in parents for ancestor in parent.parents}\n\n    def clean(self):\n        \"\"\"Empty the cache.\"\"\"\n        for key in list(self):\n            if not isinstance(key, signature):\n                super().__delitem__(key)\n\n    def copy(self):\n        \"\"\"Return a new multimethod with the same methods.\"\"\"\n        other = dict.__new__(type(self))\n        other.update(self)\n        return other\n\n    def __setitem__(self, types: tuple, func: Callable):\n        self.clean()\n        types = signature(types)\n        parents = types.parents = self.parents(types)\n        for key in self:\n            if types < key and (not parents or parents & key.parents):\n                key.parents -= parents\n                key.parents.add(types)\n        if any(map(subtype.subcheck, types)):\n            self.get_type = get_type  # switch to slower generic type checker\n        super().__setitem__(types, func)\n        self.__doc__ = self.docstring\n\n    def __delitem__(self, types: tuple):\n        self.clean()\n        super().__delitem__(types)\n        for key in self:\n            if types in key.parents:\n                key.parents = self.parents(key)\n        self.__doc__ = self.docstring\n\n    def __missing__(self, types: tuple) -> Callable:\n        \"\"\"Find and cache the next applicable method of given types.\"\"\"\n        self.evaluate()\n        if types in self:\n            return self[types]\n        groups = groupby(signature(types).__sub__, self.parents(types))\n        keys = groups[min(groups)] if groups else []\n        funcs = {self[key] for key in keys}\n        if len(funcs) == 1:\n            return self.setdefault(types, *funcs)\n        msg = f\"{self.__name__}: {len(keys)} methods found\"  # type: ignore\n        raise DispatchError(msg, types, keys)\n\n    def __call__(self, *args, **kwargs):\n        \"\"\"Resolve and dispatch to best method.\"\"\"\n        return self[tuple(map(self.get_type, args))](*args, **kwargs)\n\n    def evaluate(self):\n        \"\"\"Evaluate any pending forward references.\n\n        This can be called explicitly when using forward references,\n        otherwise cache misses will evaluate.\n        \"\"\"\n        while self.pending:\n            func = self.pending.pop()\n            self[get_types(func)] = func\n\n    @property\n    def docstring(self):\n        \"\"\"a descriptive docstring of all registered functions\"\"\"\n        docs = []\n        for func in set(self.values()):\n            try:\n                sig = inspect.signature(func)\n            except ValueError:\n                sig = ''\n            doc = func.__doc__ or ''\n            docs.append(f'{func.__name__}{sig}\\n    {doc}')\n        return '\\n\\n'.join(docs)\n\n\nclass multidispatch(multimethod):\n    \"\"\"Provisional wrapper for future compatibility with `functools.singledispatch`.\"\"\"\n\n\nget_type = multimethod(type)\nget_type.__doc__ = \"\"\"Return a generic `subtype` which checks subscripts.\"\"\"\nfor atomic in (Iterator, str, bytes):\n    get_type[(atomic,)] = type\n\n\n@multimethod  # type: ignore[no-redef]\ndef get_type(arg: tuple):\n    \"\"\"Return generic type checking all values.\"\"\"\n    return subtype(type(arg), *map(get_type, arg))\n\n\n@multimethod  # type: ignore[no-redef]\ndef get_type(arg: Mapping):\n    \"\"\"Return generic type checking first item.\"\"\"\n    return subtype(type(arg), *map(get_type, next(iter(arg.items()), ())))\n\n\n@multimethod  # type: ignore[no-redef]\ndef get_type(arg: Iterable):\n    \"\"\"Return generic type checking first value.\"\"\"\n    return subtype(type(arg), *map(get_type, itertools.islice(arg, 1)))\n\n\ndef isa(*types: type) -> Callable:\n    \"\"\"Partially bound `isinstance`.\"\"\"\n    return lambda arg: isinstance(arg, types)\n\n\nclass overload(collections.OrderedDict):\n    \"\"\"Ordered functions which dispatch based on their annotated predicates.\"\"\"\n\n    __get__ = multimethod.__get__\n\n    def __new__(cls, func):\n        namespace = inspect.currentframe().f_back.f_locals\n        self = functools.update_wrapper(super().__new__(cls), func)\n        return namespace.get(func.__name__, self)\n\n    def __init__(self, func: Callable):\n        self[inspect.signature(func)] = func\n\n    def __call__(self, *args, **kwargs):\n        \"\"\"Dispatch to first matching function.\"\"\"\n        for sig, func in reversed(self.items()):\n            arguments = sig.bind(*args, **kwargs).arguments\n            if all(\n                param.annotation(arguments[name])\n                for name, param in sig.parameters.items()\n                if param.annotation is not param.empty\n            ):\n                return func(*args, **kwargs)\n        raise DispatchError(\"No matching functions found\")\n\n    def register(self, func: Callable) -> Callable:\n        \"\"\"Decorator for registering a function.\"\"\"\n        self.__init__(func)  # type: ignore\n        return self if self.__name__ == func.__name__ else func  # type: ignore\n\n\nclass multimeta(type):\n    \"\"\"Convert all callables in namespace to multimethods.\"\"\"",
  "start_line": 151,
  "end_line": 300,
  "total_lines": 309,
  "is_truncated": true
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<string>\", line 1, in <module>\nTypeError: unbound method type.mro() needs an argument\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<string>\", line 1, in <module>\nTypeError: unbound method type.mro() needs an argument\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "object\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 3, in <module>\n  File \"/workspace/multimethod/__init__.py\", line 102, in distance\n    mro = subclass.mro()\nTypeError: unbound method type.mro() needs an argument\n",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Calling f(int)...\nobject\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 4, in <module>\nNameError: name 'multimmethod' is not defined. Did you mean: 'multimethod'?\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 4, in <module>\nNameError: name 'multimmethod' is not defined. Did you mean: 'multimethod'?\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "stdout": "Multimethod keys: dict_keys([()])\nCalling f(int)...\nobject\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "import abc\nimport collections\nimport functools\nimport inspect\nimport itertools\nimport types\nimport typing\nfrom typing import Callable, Iterable, Iterator, Mapping, Union\n\n__version__ = '1.4'\n\n\ndef groupby(func: Callable, values: Iterable) -> dict:\n    \"\"\"Return mapping of key function to values.\"\"\"\n    groups = collections.defaultdict(list)  # type: dict\n    for value in values:\n        groups[func(value)].append(value)\n    return groups\n\n\ndef get_types(func: Callable) -> tuple:\n    \"\"\"Return evaluated type hints for positional required parameters in order.\"\"\"\n    if not hasattr(func, '__annotations__'):\n        return ()\n    type_hints = typing.get_type_hints(func)\n    positionals = {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}\n    annotations = [\n        type_hints.get(param.name, object)\n        for param in inspect.signature(func).parameters.values()\n        if param.default is param.empty and param.kind in positionals\n    ]  # missing annotations are padded with `object`, but trailing objects are unnecessary\n    return tuple(itertools.dropwhile(lambda cls: cls is object, reversed(annotations)))[::-1]\n\n\nclass DispatchError(TypeError):\n    pass\n\n\nclass subtype(type):\n    \"\"\"A normalized generic type which checks subscripts.\"\"\"\n\n    __origin__: type\n    __args__: tuple\n\n    def __new__(cls, tp, *args):\n        if tp is typing.Any:\n            return object\n        if isinstance(tp, typing.TypeVar):\n            if not tp.__constraints__:\n                return object\n            tp = typing.Union[tp.__constraints__]\n        origin = getattr(tp, '__extra__', getattr(tp, '__origin__', tp))\n        args = tuple(map(cls, getattr(tp, '__args__', None) or args))\n        if set(args) <= {object} and not (origin is tuple and args):\n            return origin\n        bases = (origin,) if type(origin) is type else ()\n        namespace = {'__origin__': origin, '__args__': args}\n        return type.__new__(cls, str(tp), bases, namespace)\n\n    def __init__(self, tp, *args):\n        if isinstance(self.__origin__, abc.ABCMeta):\n            self.__origin__.register(self)\n\n    def __getstate__(self) -> tuple:\n        return self.__origin__, self.__args__\n\n    def __eq__(self, other) -> bool:\n        return isinstance(other, subtype) and self.__getstate__() == other.__getstate__()\n\n    def __hash__(self) -> int:\n        return hash(self.__getstate__())\n\n    def __subclasscheck__(self, subclass: type) -> bool:\n        origin = getattr(subclass, '__extra__', getattr(subclass, '__origin__', subclass))\n        args = getattr(subclass, '__args__', ())\n        if origin is typing.Union:\n            return all(issubclass(cls, self) for cls in args)\n        if self.__origin__ is typing.Union:\n            return issubclass(subclass, self.__args__)\n        nargs = len(self.__args__)\n        if self.__origin__ is tuple and self.__args__[-1:] == (Ellipsis,):\n            nargs -= 1\n            args = args[:nargs]\n        return (  # check args first to avoid a recursion error in ABCMeta\n            len(args) == nargs\n            and issubclass(origin, self.__origin__)\n            and all(map(issubclass, args, self.__args__))\n        )\n\n    @classmethod\n    def subcheck(cls, tp: type) -> bool:\n        \"\"\"Return whether type requires checking subscripts using `get_type`.\"\"\"\n        return isinstance(tp, cls) and (\n            tp.__origin__ is not Union or any(map(cls.subcheck, tp.__args__))\n        )\n\n\ndef distance(cls, subclass: type) -> int:\n    \"\"\"Return estimated distance between classes for tie-breaking.\"\"\"\n    if getattr(cls, '__origin__', None) is typing.Union:",
  "start_line": 1,
  "end_line": 100,
  "total_lines": 309,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "125:class multimethod(dict):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "    def __sub__(self, other) -> tuple:\n        \"\"\"Return relative distances, assuming self >= other.\"\"\"\n        return tuple(map(distance, other, self))\n\n\nclass multimethod(dict):\n    \"\"\"A callable directed acyclic graph of methods.\"\"\"\n\n    pending: set\n\n    def __new__(cls, func):\n        namespace = inspect.currentframe().f_back.f_locals\n        self = functools.update_wrapper(dict.__new__(cls), func)\n        self.pending = set()\n        self.get_type = type  # default type checker\n        homonym = namespace.get(func.__name__, self)\n        return homonym if isinstance(homonym, multimethod) else self\n\n    def __init__(self, func: Callable):\n        try:\n            self[get_types(func)] = func\n        except (NameError, AttributeError):\n            self.pending.add(func)\n\n    def register(self, *args) -> Callable:\n        \"\"\"Decorator for registering a function.\n\n        Optionally call with types to return a decorator for unannotated functions.\n        \"\"\"\n        if len(args) == 1 and hasattr(args[0], '__annotations__'):\n            return overload.register(self, *args)  # type: ignore\n        return lambda func: self.__setitem__(args, func) or func\n\n    def __get__(self, instance, owner):\n        return self if instance is None else types.MethodType(self, instance)\n\n    def parents(self, types: tuple) -> set:\n        \"\"\"Find immediate parents of potential key.\"\"\"\n        parents = {key for key in self if isinstance(key, signature) and key < types}\n        return parents - {ancestor for parent in parents for ancestor in parent.parents}\n\n    def clean(self):\n        \"\"\"Empty the cache.\"\"\"\n        for key in list(self):\n            if not isinstance(key, signature):\n                super().__delitem__(key)\n\n    def copy(self):\n        \"\"\"Return a new multimethod with the same methods.\"\"\"\n        other = dict.__new__(type(self))\n        other.update(self)\n        return other\n\n    def __setitem__(self, types: tuple, func: Callable):\n        self.clean()\n        types = signature(types)\n        parents = types.parents = self.parents(types)\n        for key in self:\n            if types < key and (not parents or parents & key.parents):\n                key.parents -= parents\n                key.parents.add(types)\n        if any(map(subtype.subcheck, types)):\n            self.get_type = get_type  # switch to slower generic type checker\n        super().__setitem__(types, func)\n        self.__doc__ = self.docstring\n\n    def __delitem__(self, types: tuple):\n        self.clean()\n        super().__delitem__(types)\n        for key in self:\n            if types in key.parents:\n                key.parents = self.parents(key)\n        self.__doc__ = self.docstring\n\n    def __missing__(self, types: tuple) -> Callable:\n        \"\"\"Find and cache the next applicable method of given types.\"\"\"\n        self.evaluate()\n        if types in self:\n            return self[types]\n        groups = groupby(signature(types).__sub__, self.parents(types))\n        keys = groups[min(groups)] if groups else []\n        funcs = {self[key] for key in keys}\n        if len(funcs) == 1:\n            return self.setdefault(types, *funcs)\n        msg = f\"{self.__name__}: {len(keys)} methods found\"  # type: ignore\n        raise DispatchError(msg, types, keys)\n\n    def __call__(self, *args, **kwargs):\n        \"\"\"Resolve and dispatch to best method.\"\"\"\n        return self[tuple(map(self.get_type, args))](*args, **kwargs)\n\n    def evaluate(self):\n        \"\"\"Evaluate any pending forward references.\n\n        This can be called explicitly when using forward references,\n        otherwise cache misses will evaluate.\n        \"\"\"\n        while self.pending:\n            func = self.pending.pop()\n            self[get_types(func)] = func\n\n    @property\n    def docstring(self):\n        \"\"\"a descriptive docstring of all registered functions\"\"\"\n        docs = []\n        for func in set(self.values()):\n            try:\n                sig = inspect.signature(func)\n            except ValueError:\n                sig = ''\n            doc = func.__doc__ or ''\n            docs.append(f'{func.__name__}{sig}\\n    {doc}')\n        return '\\n\\n'.join(docs)\n\n\nclass multidispatch(multimethod):\n    \"\"\"Provisional wrapper for future compatibility with `functools.singledispatch`.\"\"\"\n\n\nget_type = multimethod(type)\nget_type.__doc__ = \"\"\"Return a generic `subtype` which checks subscripts.\"\"\"\nfor atomic in (Iterator, str, bytes):\n    get_type[(atomic,)] = type\n\n\n@multimethod  # type: ignore[no-redef]\ndef get_type(arg: tuple):\n    \"\"\"Return generic type checking all values.\"\"\"\n    return subtype(type(arg), *map(get_type, arg))\n\n",
  "start_line": 120,
  "end_line": 250,
  "total_lines": 309,
  "is_truncated": false
}