coady__multimethod-26

The user is reporting a `TypeError: unbound method type.mro() needs an argument` when using `type` (or a metaclass) as a type hint in a `@multimethod` decorated function.

Looking at the provided traceback:
```
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 174, in __missing__
    groups = groupby(signature(types).__sub__, self.parents(types))
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 17, in groupby
    groups[func(value)].append(value)
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 104, in __sub__
    return tuple(mro.index(cls if cls in mro else object) for mro, cls in zip(mros, other))
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 104, in <genexpr>
    return tuple(mro.index(cls if cls in mro else object) for mro, cls in zip(mros, other))
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 103, in <genexpr>
    mros = (subclass.mro() for subclass in self)
TypeError: unbound method type.mro() needs an argument
```

The error happens in `multimethod/__init__.py` at line 103: `mros = (subclass.mro() for subclass in self)`.
It seems `subclass` can be `type`, and `type.mro()` is an unbound method that requires an argument.
Actually, `type.mro(cls)` is how you get the MRO of `cls`. If `subclass` is `type`, `subclass.mro()` is effectively `type.mro()`, which fails.

Let's reproduce this.

{
  "command": "python3 - <<'PY'\nfrom multimethod import multimethod\n\n@multimethod\ndef f(x: type):\n    print(\"success\")\n\ntry:\n    f(int)\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

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

Wait, it succeeded?
`f(int)` printed "success".
Let me check the example again.
```python
@multimethod
def f(x: type):
    print("success")

f(int)
```
Expected: `success`
Actual: `TypeError: unbound method type.mro() needs an argument`

Why did it work for me?
Maybe the version of `multimethod` installed in the sandbox is different or the Python version is different?
Or maybe I just got lucky?

Let's check the traceback again.
The traceback says line 103 in `multimethod/__init__.py`: `mros = (subclass.mro() for subclass in self)`.

Let's read `multimethod/__init__.py` around line 103.

{
  "end_line": 120,
  "filepath": "multimethod/__init__.py",
  "start_line": 80
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "        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:",
  "start_line": 80,
  "end_line": 120,
  "total_lines": 309,
  "is_truncated": false
}

The provided `read_file` didn't reach line 120 of the original file if the lines are different.
Wait, the `read_file` output says `start_line: 80, end_line: 120`.
Line 103 should be around `distance(cls, subclass: type)` function.

```python
def distance(cls, subclass: type) -> int:
    """Return estimated distance between classes for tie-breaking."""
    if getattr(cls, '__origin__', None) is typing.Union:
        return min(distance(arg, subclass) for arg in cls.__args__)
    mro = subclass.mro()
    return mro.index(cls if cls in mro else object)
```

In the traceback provided in the issue:
```
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 104, in __sub__
    return tuple(mro.index(cls if cls in mro else object) for mro, cls in zip(mros, other))
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 104, in <genexpr>
    return tuple(mro.index(cls if cls in mro else object) for mro, cls in zip(mros, other))
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 103, in <genexpr>
    mros = (subclass.mro() for subclass in self)
TypeError: unbound method type.mro() needs an argument
```

My `read_file` for `multimethod/__init__.py` shows:
Line 103 is `mro = subclass.mro()`.
But wait, the traceback in the issue mentions `__sub__` method of `signature` class.

Let's look at `signature` class in `multimethod/__init__.py`.

{
  "end_line": 160,
  "filepath": "multimethod/__init__.py",
  "start_line": 120
}

{
  "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",
  "start_line": 120,
  "end_line": 160,
  "total_lines": 309,
  "is_truncated": false
}

Wait, the `__sub__` implementation in my `read_file` is:

```python
    def __sub__(self, other) -> tuple:
        """Return relative distances, assuming self >= other."""
        return tuple(map(distance, other, self))
```

And `distance` is:
```python
def distance(cls, subclass: type) -> int:
    """Return estimated distance between classes for tie-breaking."""
    if getattr(cls, '__origin__', None) is typing.Union:
        return min(distance(arg, subclass) for arg in cls.__args__)
    mro = subclass.mro()
    return mro.index(cls if cls in mro else object)
```

If `subclass` is `type`, `subclass.mro()` is `type.mro()`.

But why did my reproduction test succeed?
```python
from multimethod import multimethod

@multimethod
def f(x: type):
    print("success")

f(int)
```
Output was `success`.

Wait, if `f(int)` is called, then `args` is `(int,)`.
`self.get_type` is `type`.
`tuple(map(self.get_type, args))` is `(type(int),)` which is `(<class 'type'>,)`.

So `types` in `__missing__` is `(<class 'type'>,)`.
`signature(types)` will call `subtype` on each element.
`subtype(type)` returns `type`.
So `signature((type,))` behaves like a tuple containing `type`.

Then `self.parents(types)` is called.
`parents = {key for key in self if isinstance(key, signature) and key < types}`.
`key < types` calls `signature.__lt__`.
`signature.__lt__` calls `signature.__le__`.
`signature.__le__(self, other)` returns `len(self) <= len(other) and all(map(issubclass, other, self))`.

If `key` is `signature((type,))` and `types` is `(<class 'type'>,)`.
Wait, `types` in `parents(self, types)` is a tuple.
`key < types` where `key` is a `signature` instance and `types` is a tuple.
`signature.__lt__` is called.
But `types` is not a `signature` instance.
Wait, `signature` inherits from `tuple`.
So `self <= other` might call `tuple.__le__` if `other` is not a `signature`?
No, `signature.__le__` is defined.
`all(map(issubclass, other, self))` where `other` is `(<class 'type'>,)` and `self` is `(type,)`.
`issubclass(type, type)` is True.
So `key <= types` is True.

Then `self.parents(types)` returns some set of `signature` keys.
Then `groupby(signature(types).__sub__, self.parents(types))` is called.
`signature(types).__sub__` is a method.
The first argument to `__sub__` is the `signature` instance.
`signature(types).__sub__(parent)` calls `tuple(map(distance, parent, self))`.
`distance(cls, subclass)` where `cls` is from `parent` and `subclass` is from `self` (which is `types`).

In my reproduction:
`f` is defined as `@multimethod def f(x: type):`.
`self` (the `multimethod` instance) has a key `signature((type,))`.
When calling `f(int)`, `types` is `(<class 'type'>,)`.
`signature(types)` is `signature((type,))`.
The only key in `self` is `signature((type,))`.
`self.parents(types)`: `key` is `signature((type,))`, `types` is `(<class 'type'>,)`.
`key < types`?
`len(key)` is 1. `len(types)` is 1.
`key != types` is False because both are effectively `(type,)`.
So `key < types` is False.
`self.parents(types)` is empty.
`groupby` receives an empty sequence.
`__missing__` probably returns the best match.

Wait, if `self.parents(types)` is empty, it doesn't call `distance`.

Let's try a case where there are multiple overloads, so `parents` is not empty and `distance` is called.

```python
from multimethod import multimethod

@multimethod
def f(x: object):
    print("object")

@multimethod
def f(x: type):
    print("type")

f(int)
```

In this case:
`f(int)` -> `types` is `(type,)`.
`self` has keys `signature((object,))` and `signature((type,))`.
`parents` for `(type,)`:
`signature((object,)) < (type,)`?
`len` is 1 <= 1.
`issubclass(type, object)` is True.
`signature((object,)) != (type,)` is True.
So `signature((object,))` is a parent.
`signature((type,)) < (type,)` is False.
So `parents` = `{signature((object,))}`.

Now `groupby(signature((type,)).__sub__, {signature((object,))})`.
`signature((type,)).__sub__(signature((object,)))` calls `map(distance, signature((object,)), signature((type,)))`.
`distance(object, type)`:
`subclass` is `type`.
`mro = type.mro()` -> **BOOM!**

Let's test this.

{
  "command": "python3 - <<'PY'\nfrom multimethod import multimethod\n\n@multimethod\ndef f(x: object):\n    print(\"object\")\n\n@multimethod\ndef f(x: type):\n    print(\"type\")\n\ntry:\n    f(int)\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

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

Still success? Why?
Wait, I just realized a crucial thing.
In my test:
`f(int)`
`type(int)` is `type`.
`signature(types)` is `signature((type,))`.
`self` keys are `signature((object,))` and `signature((type,))`.
Wait, if the key `signature((type,))` is in `self`, is it used directly or via `__missing__`?

`multimethod.__call__` does:
`return self[tuple(map(self.get_type, args))](*args, **kwargs)`

If `tuple(map(self.get_type, args))` is `(type,)`, then `self[(type,)]` is called.
Since `multimethod` is a `dict` subclass, and it probably stores keys as `signature` objects.
Wait, does it?
`multimethod.__init__` does `self[get_types(func)] = func`.
`get_types(func)` likely returns a `signature` object.

Let's check `get_types`.

{
  "end_line": 60,
  "filepath": "multimethod/__init__.py",
  "start_line": 1
}

{
  "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):",
  "start_line": 1,
  "end_line": 60,
  "total_lines": 309,
  "is_truncated": false
}

`get_types` returns a `tuple`.
In `multimethod.__init__`:
```python
    def __init__(self, func: Callable):
        try:
            self[get_types(func)] = func
        except (NameError, AttributeError):
            self.pending.add(func)
```
Wait, `self` is a `multimethod` which is a `dict`.
If `get_types(func)` is a tuple, then `self` is keyed by tuples.

But `multimethod` might have a custom `__setitem__` or it uses the `dict` one.
It doesn't seem to have `__setitem__` in the code I've read.

Actually, look at `signature` class:
```python
class signature(tuple):
    """A tuple of types that supports partial ordering."""
    # ...
    def __new__(cls, types: Iterable):
        return tuple.__new__(cls, map(subtype, types))
```

Wait, if `get_types` returns a tuple of types, then `self[get_types(func)] = func` stores it with a tuple key.
But in `__call__`:
`return self[tuple(map(self.get_type, args))](*args, **kwargs)`
`self.get_type` is `type` by default.
So `tuple(map(type, args))` produces a tuple of types.
If this tuple is in `self`, it returns the function.

In my test:
`f(int)` -> `tuple(map(type, (int,)))` -> `(type,)`.
If `f` was defined as `def f(x: type)`, then `get_types(f)` is `(type,)`.
So `self[(type,)]` is exactly the function.
No `__missing__` is called.

To trigger `__missing__`, I need to call `f` with something that matches but isn't an exact key match.
For example:
```python
@multimethod
def f(x: object):
    print("object")

f(int)
```
`type(int)` is `type`.
Key in `self` is `(object,)`.
`(type,)` is not in `self`.
So `__missing__` is called with `key=(type,)`.

In `__missing__(self, key)`:
```python
    def __missing__(self, types: tuple):
        """Find the best match for the given types."""
        parents = self.parents(types)
        if not parents:
            raise DispatchError(f"No multimethod for types {types}")
        groups = groupby(signature(types).__sub__, parents)
        # ...
```
Wait, `self.parents(types)`:
```python
    def parents(self, types: tuple) -> set:
        """Find immediate parents of potential key."""
        parents = {key for key in self if isinstance(key, signature) and key < types}
        return parents - {ancestor for parent in parents for ancestor in parent.parents}
```
If I store keys as tuples, `isinstance(key, signature)` will be False.
Wait, I missed where the keys become `signature` objects.

Let's check `multimethod.__setitem__` if it exists, or if it's inherited.
I didn't see `__setitem__` in the `multimethod` class definition.
Wait, let me read the whole `multimethod` class.

{
  "end_line": 200,
  "filepath": "multimethod/__init__.py",
  "start_line": 140
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "            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 []",
  "start_line": 140,
  "end_line": 200,
  "total_lines": 309,
  "is_truncated": false
}

Okay, `__setitem__` converts `types` to `signature(types)`.
```python
    def __setitem__(self, types: tuple, func: Callable):
        self.clean()
        types = signature(types)
        # ...
        super().__setitem__(types, func)
```

And `multimethod.__call__` does:
`return self[tuple(map(self.get_type, args))](*args, **kwargs)`
Here `tuple(map(self.get_type, args))` is a `tuple`.
`self[tuple]` calls `dict.__getitem__`.
If the key (which is a `signature` object) matches the `tuple`, `dict.__getitem__` might work because `signature` inherits from `tuple`.
Wait, `signature` is a subclass of `tuple`.
`(type,) == signature((type,))` is True.

So if `f(int)` is called and `def f(x: type)` is registered, `dict.__getitem__` finds the key.

To trigger `__missing__`, we need a case where the exact tuple is not a key, but a more general one is.
Example:
```python
@multimethod
def f(x: object):
    print("object")

f(int)
```
Key in `self` is `signature((object,))`.
Called with `(type,)`.
`(type,)` is not in `self`.
`__missing__((type,))` is called.
`self.parents((type,))` finds `signature((object,))`.
`groupby(signature((type,)).__sub__, {signature((object,))})` is called.
`signature((type,)).__sub__(signature((object,)))` calls `map(distance, signature((object,)), signature((type,)))`.
`distance(object, type)`:
`subclass` is `type`.
`subclass.mro()` -> `type.mro()` -> **TypeError**.

Let's verify this reproduction.

{
  "command": "python3 - <<'PY'\nfrom multimethod import multimethod\n\n@multimethod\ndef f(x: object):\n    print(\"object\")\n\ntry:\n    f(int)\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

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

Still success? What is going on?
Wait, `f(int)`.
`type(int)` is `type`.
`types` is `(type,)`.
`self` key is `signature((object,))`.
`self.parents((type,))`:
`signature((object,)) < (type,)`?
`len(signature((object,)))` is 1. `len((type,))` is 1.
`all(map(issubclass, (type,), signature((object,))))` -> `issubclass(type, object)` is True.
`signature((object,)) != (type,)` is True.
So `parents` = `{signature((object,))}`.
`signature((type,)).__sub__(signature((object,)))` -> `distance(object, type)`.
`type.mro()` should fail.

Wait, maybe `type.mro()` doesn't fail in my environment?
Let's check.

{
  "command": "python3 -c \"print(type.mro())\""
}

{
  "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
  }
}

Yes, it fails.
So why did `f(int)` with `f(x: object)` succeed?

Wait, let me look at the `multimethod` source again.
`multimethod.__call__`:
`return self[tuple(map(self.get_type, args))](*args, **kwargs)`

Wait, I just noticed something.
`self.get_type` defaults to `type`.
`tuple(map(type, (int,)))` is `(type,)`.
Wait, `int` is an instance of `type`.
So `type(int)` is `type`.
So `types` is `(type,)`.

Wait, maybe `self.parents((type,))` is empty if the key is `signature((object,))`?
`parents = {key for key in self if isinstance(key, signature) and key < types}`
`key` is `signature((object,))`. `types` is `(type,)`.
`key < types` calls `signature.__lt__`.
`signature.__lt__` calls `signature.__le__`.
`signature.__le__(self, other)`:
`len(self) <= len(other) and all(map(issubclass, other, self))`
`len((object,)) <= len((type,))` is 1 <= 1 (True).
`map(issubclass, (type,), (object,))` -> `issubclass(type, object)` is True.
So `signature((object,)) <= (type,)` is True.
`signature((object,)) != (type,)` is True.
So `signature((object,)) < (type,)` is True.

So `parents` should be `{signature((object,))}`.

Wait, I'm confused. Why did it succeed?
Ah! I know!
`multimethod` instance `self` might be catching it.
Wait, `multimethod` is a `dict`.
When I call `f(int)`, I'm calling the `multimethod` instance.
The `__call__` method:
`return self[tuple(map(self.get_type, args))](*args, **kwargs)`

If `self[tuple]` triggers `__missing__` (because the exact tuple is not a key), then `__missing__` is called.
`__missing__` then finds the best match and **caches it**.

```python
    def __missing__(self, types: tuple) -> Callable:
        """Find and cache the next applicable method of given types."""
        self.evaluate()
        if types in self:
            return self[types]
        groups = groupby(signature(types).__sub__, self.parents(types))
        keys = groups[min(groups)] if groups else []
        # ... it probably caches it ...
```

Wait, I didn't see the caching part of `__missing__`. Let me read it.

{
  "end_line": 220,
  "filepath": "multimethod/__init__.py",
  "start_line": 201
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "        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",
  "start_line": 201,
  "end_line": 220,
  "total_lines": 309,
  "is_truncated": false
}

Wait, `self.setdefault(types, *funcs)`.
`types` is the tuple `(type,)`.
`funcs` is a set, so `*funcs` unpacks it.
`self.setdefault((type,), func)`.
Since `multimethod.__setitem__((type,), func)` is called, it will convert `(type,)` to `signature((type,))`.

Wait, I'm still failing to reproduce it.
Let's look at the failing case again.
`f(x: type)`
Called with `f(int)`.
`tuple(map(type, (int,)))` is `(type,)`.
`get_types(f)` for `def f(x: type)` is `(type,)`.
So `self` key is `signature((type,))`.
`self[(type,)]` should match exactly.

The issue report says:
```python
@multimethod
def f(x: type):
    print("success")
f(int)
```
The traceback says:
```
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
  File "C:\Users\Paolo\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
  File "C:\Users\Pało\Code\JB-PycharmProjects\LoveLetter\venv\lib\site-packages\multimethod\__init__.py", line 174, in __missing__
    groups = groupby(signature(types).__sub__, self.parents(types))
```
Wait! `__call__` calls itself?
No, wait. The traceback shows:
```
  File ".../multimethod/__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
  File ".../multimethod/__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
```
This look like recursion.
Wait, `self[tuple(map(self.get_type, args))]` returns a function.
Then that function is called with `(*args, **kwargs)`.
If that function is actually the `multimethod` itself (e.g. if `self` is being used as the returned value?), it would recurse.

But wait, look at the original example:
```python
@multimethod
def f(x: type):
    print("success")
```
`f` becomes a `multimethod` instance.
`f(int)` calls `multimethod.__call__`.
Inside `__call__`: `self[tuple(map(self.get_type, args))]` where `self` is the `multimethod` instance.
If `(type,)` is a key, `self[(type,)]` returns the original function `f`.
Then `f(*args, **kwargs)` is called.

BUT, what if `f` was not the original function but something else?
No, `__init__` does `self[get_types(func)] = func`.

Wait! I think I see it.
What if `self.get_type` is NOT `type`?
`self.get_type` is changed to `get_type` if any of the types are generic.
But `type` is not generic.

Let's look at the traceback again.
```
  File ".../multimethod/__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
  File ".../multimethod/__init__.py", line 184, in __call__
    return self[tuple(map(self.get_type, args))](*args, **kwargs)
```
Wait, line 184 in the traceback is `__call__`.
Is it possible that `self[tuple(map(self.get_type, args))]` returned `self` itself?
If `self[tuple]` returned `self`, then `self(*args, **kwargs)` would call `__call__` again.
But looking at `__missing__`:
```python
    def __missing__(self, types: tuple) -> Callable:
        # ...
        funcs = {self[key] for key in keys}
        if len(funcs) == 1:
            return self.setdefault(types, *funcs)
```
`self.setdefault(types, *funcs)` returns the value.

Wait! I might have an idea.
What if the `multimethod` is defined like this:
```python
@multimethod
def f(x: int):
    print("int")

f("string")
```
Then `type("string")` is `str`.
`(str,)` is not in `self`.
`__missing__((str,))` is called.
It finds `(int,)` is not a parent.
It finds nothing.
It raises `DispatchError`.

But what if we have:
```python
@multimethod
def f(x: object):
    print("object")

f(int)
```
As I thought, this should trigger `distance(object, type)`.
And I tried it and it succeeded.
Wait, maybe it succeeded because the `multimethod` instance was already initialized and cached?
No, I ran it in a fresh python script.

Let me re-run the reproduction script and REALLY check the output.

{
  "command": "python3 - <<'PY'\nfrom multimethod import multimethod\n\n@multimethod\ndef f(x: object):\n    print(\"object\")\n\nprint(\"Calling f(int)...\")\nf(int)\nprint(\"Success!\")\nPY\n"
}

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

It still succeeds.
Wait, I'll check the version of `multimethod`.

{
  "command": "pip show multimethod"
}

{
  "status": "ok",
  "stdout": "Name: multimethod\nVersion: 1.4\nSummary: Multiple argument dispatching.\nHome-page: https://github.com/coady/multimethod\nAuthor: Aric Coady\nAuthor-email: aric.coady@gmail.com\nLicense: Apache Software License\nLocation: /usr/local/lib/python3.10/site-packages\nEditable project location: /testbed\nRequires: \nRequired-by: \n",
  "stderr": "",
  "exit_code": 0
}

The version is 1.4.

Let's look at `distance` again.
```python
def distance(cls, subclass: type) -> int:
    """Return estimated distance between classes for tie-breaking."""
    if getattr(cls, '__origin__', None) is typing.Union:
        return min(distance(arg, subclass) for arg in cls.__args__)
    mro = subclass.mro()
    return mro.index(cls if cls in mro else object)
```

If `subclass` is `type`, `subclass.mro()` is `type.mro()`.
And `type.mro()` raises `TypeError: unbound method type.mro() needs an argument`.

I just ran `python3 -c "print(type.mro())"` and it failed.
So why does `f(int)` succeed when `f` is defined as `@multimethod def f(x: object):`?

Wait!
I'm calling `f(int)`.
`args` is `(int,)`.
`map(self.get_type, args)` where `self.get_type` is `type`.
`type(int)` is `type`.
So `tuple(map(self.get_type, args))` is `(type,)`.

So `self[(type,)]` is called.
The key in `self` is `signature((object,))`.
`(type,)` is not `signature((object,))`.
So `__missing__((type,))` is called.
`self.parents((type,))` is called.
`key < types` where `key` is `signature((object,))` and `types` is `(type,)`.
`signature((object,)) < (type,)` is True.
So `parents` is `{signature((object,))}`.
`groupby(signature((type,)).__sub__, {signature((object,))})` is called.
`signature((type,)).__sub__(signature((object,)))` is called.
And that calls `map(distance, signature((object,)), signature((type,)))`.
`distance(object, type)` is called.
`subclass` is `type`.
`subclass.mro()` is called.

WHY DOES IT NOT FAIL?
Wait... is it possible that `subclass` is NOT `type`?
`signature((type,))` is a tuple of `subtype` objects.
`subtype` inherits from `type`? No, let's check `subtype`.

```python
class subtype(type):
    """A normalized generic type which checks subscripts."""
    # ...
    def __new__(cls, tp, *args):
        # ...
        return type.__new__(cls, str(tp), bases, namespace)
```

If `subtype` is called with `type`, what does it return?
`tp` is `type`.
`origin = getattr(tp, '__extra__', getattr(tp, '__origin__', tp))`
`tp` has no `__extra__` or `__origin__`, so `origin` is `type`.
`args = tuple(map(cls, getattr(tp, '__args__', None) or args))`
`type` has no `__args__`, so `args` is empty.
`set(args) <= {object}` is `set() <= {object}` which is True.
`not (origin is tuple and args)` is `not (type is tuple and False)` which is True.
So it returns `origin`, which is `type`.

Wait, so `subtype(type)` returns `type`.
And `signature((type,))` is `(type,)`.

Hold on!
I'm calling `multimethod(f)(int)`.
The `multimethod` instance `self` is called.
`tuple(map(self.get_type, args))` is `(type,)`.

Is it possible the `signature((type,)).__sub__` is not what I think it is?
`signature` is a subclass of `tuple`.
`signature(types).__sub__` is a bound method.
When `groupby` calls `func(value)`, it's calls `signature((type,)).__sub__(signature((object,)))`.

Wait! Let's look at `signature.__sub__` again.
```python
    def __sub__(self, other) -> tuple:
        """Return relative distances, assuming self >= other."""
        return tuple(map(distance, other, self))
```
`self` is `signature((type,))`.
`other` is `signature((object,))`.
`map(distance, other, self)` is `map(distance, (object,), (type,))`.
So `distance(object, type)` is called.

I am absolutely baffled why this is succeeding in my environment but failing in the reported issue.
Let's try to create a minimal script that calls `distance(object, type)` directly.

{
  "command": "python3 - <<'PY'\nimport typing\nfrom multimethod import distance\n\nprint(\"Calling distance(object, type)...\")\ntry:\n    distance(object, type)\n    print(\"Success!\")\nexcept Exception as e:\n    import traceback\n    traceback.print_exc()\nPY\n"
}

{
  "status": "ok",
  "stdout": "Calling distance(object, type)...\n",
  "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 6, 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
}