coady__multimethod-26

The user is reporting a `TypeError` when using `type` or another metaclass as a type hint in a `multimethod`.
The traceback indicates the error occurs in `multimethod/__init__.py` at line 103, inside a generator expression calling `subclass.mro()`.

Traceback analysis:
```python
  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__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 issue is that `subclass.mro()` is called on something that might be `type` itself.
When `subclass` is `type`, `type.mro()` is an unbound method. To get the MRO of `type`, you should call `type.mro(type)` or more simply use `type.__mro__` or `inspect.getmro()`.
Actually, `type` doesn't have a `mro()` method like classes do (which is inherited from `type`). Wait, `type` is the metaclass.
For a class `C`, `C.mro()` returns the MRO of `C`.
For `type` itself, `type.mro()` is the function defined in `type` that is used by classes to get their MRO.
If `subclass` is `type`, calling `subclass.mro()` is calling `type.mro()`, which expects an argument (the class for which to compute the MRO).

So, if `subclass` is `type`, we should probably use `type.mro(type)` or just access `type.__mro__`.
Wait, any class `C` has `C.mro()`. `type` is also a class (its own metaclass).
Let's try it in a python shell:
```python
>>> class A: pass
>>> A.mro()
[<class '__main__.A'>, <class 'object'>]
>>> type.mro()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method type.mro() needs an argument
>>> type.mro(type)
[<class 'type'>, <class 'object'>]
```

So the fix is likely to ensure that if `subclass` is `type`, we handle it correctly.

Let's start by reproducing this.

{
  "command": "python3 - <<'PY'\nfrom multimethod import multimethod\n\n@multimethod\ndef f(x: type):\n    print(\"success\")\n\ntry:\n    f(int)\n    print(\"Test Passed\")\nexcept TypeError as e:\n    print(f\"Test Failed: {e}\")\nPY\n"
}

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

Wait, it passed?
The problem description says:
```python
@multimethod
def f(x: type):
    print("success")

>>> f(int)
TypeError: unbound method type.mro() needs an argument
```
But in my reproduction it passed.
Maybe it's the version of python? Or maybe `multimethod` has been updated?
Wait, I am running it in the workspace. Let me check the `multimethod` version or content.

Wait, the traceback in the issue description shows:
`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)`

Let me read `multimethod/__init__.py` around line 104.

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

I need to see the implementation of `__sub__`.

{
  "end_line": 150,
  "filepath": "multimethod/__init__.py",
  "start_line": 121
}

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

Wait, the traceback says line 103: `mros = (subclass.mro() for subclass in self)`.
But looking at the file content I got:
Line 103 in my first `read_file` was:
`mro = subclass.mro()` (inside `distance` function)
Let's re-examine the first `read_file` output.

```python
101: def distance(cls, subclass: type) -> int:
102:     """Return estimated distance between classes for tie-breaking."""
103:     if getattr(cls, '__origin__', None) is typing.Union:
104:         return min(distance(arg, subclass) for arg in cls.__args__)
105:     mro = subclass.mro()
106:     return mro.index(cls if cls in mro else object)
```
Wait, my `read_file` returned:
```python
101: def distance(cls, subclass: type) -> int:
102:     """Return estimated distance between classes for tie-breaking."""
103:     if getattr(cls, '__origin__', None) is typing.Union:
104:         return min(distance(arg, subclass) for arg in cls.__args__)
105:     mro = subclass.mro()
106:     return mro.index(cls if cls in mro else object)
```
Wait, I'm miscounting. Let's look at the output of the first `read_file` again.

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

The traceback said:
```
  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)
```
But my `read_file` output shows `distance` at line 101.
And an `__sub__` method in `signature` class starts at line 119.
Wait, the line numbers in the traceback from the issue report might be different from the current code.

Let's look at `signature.__sub__`:
```python
119:     def __sub__(self, other) -> tuple:
120:         """Return relative distances, assuming self >= other."""
121:         return tuple(map(distance, other, self))
```
Ah! `distance` is called here.
And `distance` is defined as:
```python
101: def distance(cls, subclass: type) -> int:
102:     """Return estimated distance between classes for tie-breakng."""
103:     if getattr(cls, '__origin__', None) is typing.Union:
104:         return min(distance(arg, subclass) for arg in cls.__args__)
105:     mro = subclass.mro()
106:     return mro.index(cls if cls in mro else object)
```

Now I see where the `subclass.mro()` call is. It's at line 105 in the current version of the code.

Wait, why did my reproduction test pass?
```python
@multimethod
def f(x: type):
    print("success")

f(int)
```
In this case, `f` is called with `int`.
`f` is a `multimethod` object.
The `__call__` method:
```python
    def __call__(self, *args, **kwargs):
        return self[tuple(map(self.get_type, args))](*args, **kwargs)
```
`self.get_type` is `type` by default. So `map(type, (int,))` returns `(type(int),)` which is `(type,)`.
So it calls `self[(type,)]`.
The `multimethod` object is a `dict`. The keys are the signatures (tuples of types).
The registered signature was `get_types(f)`, which is `(type,)`.
So `self[(type,)]` finds the function `f`.

In the case where it should fail, we would need to have multiple overloads, and the dispatch process needs to find the best fit, which involves calculating the distance.

The `distance` function is used when there are multiple candidates and we need to pick the most specific one.
Let's try a reproduction case with multiple overloads.

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

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

f(int)
```
In this case, `int` matches both `object` and `type`.
`type` is more specific than `object`.
The dispatch process should calculate the distance.

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)\n    print(\"Test Passed\")\nexcept TypeError as e:\n    print(f\"Test Failed: {e}\")\nPY\n"
}

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

Still passed. Why?
Wait, maybe because `int` is an instance of `type`.
Let's look at how `multimethod` decides which one to call.
If it finds an exact match, it might just use it without calculating distance.

In the case above:
`f(int)`
`args` = `(int,)`
`map(self.get_type, args)` = `(type(int),)` = `(type,)`
The `multimethod` dict contains:
`{(object,): f_object, (type,): f_type}`
`self[(type,)]` is an exact match! So it returns `f_type` immediately.
It doesn't call `__missing__` or `distance`.

The `distance` function is called when there is no exact match and it needs to look for the best candidate among candidates that are supertypes of the arguments.

Actually, it's in `__missing__`.
Let's find `__missing__` in `multimethod/__init__.py`.

{
  "filepath": "multimethod/__init__.py",
  "start_line": 170
}

{
  "status": "ok",
  "filepath": "multimethod/__init__.py",
  "content": "        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.\"\"\"\n\n    class __prepare__(dict):\n        def __init__(*args):\n            pass\n\n        def __setitem__(self, key, value):\n            if callable(value):\n                value = getattr(self.get(key), 'register', multimethod)(value)\n            super().__setitem__(key, value)",
  "start_line": 170,
  "end_line": 309,
  "total_lines": 309,
  "is_truncated": false
}

To trigger `__missing__`, we need to call the multimethod with types that are not exactly matched in the dict, but are subtypes of some keys.

If I have:
```python
@multimethod
def f(x: object):
    print("object")

@multimethod
def f(x: type):
    print("type")
```
And call `f(int)`, it's an exact match for `(type,)`.
But if I call `f(1)`, it's an exact match for `(int,)` if registered, or it should match `(object,)`.
`f(1)`: `type(1)` is `int`. `(int,)` is not in the dict. `__missing__` is called.
It looks for candidates. Candidates are `(object,)` and `(type,)`.
`int` is a subclass of `object`, but not `type`. So only `(object,)` matches.

To trigger the bug, we need `subclass` in `distance` to be `type`.
`distance` is called via `signature.__sub__` which is called in `__missing__`.
`groups = groupby(signature(types).__sub__, self.parents(types))`
`signature(types).__sub__` is a function that calculates distance.

Wait, `signature(types).__sub__` is:
```python
    def __sub__(self, other) -> tuple:
        """Return relative distances, assuming self >= other."""
        return tuple(map(distance, other, self))
```
The `other` argument is `self.parents(types)`.
`distance` is called as `distance(cls, subclass)`.
Here `cls` comes from `other` (the candidate signature types) and `subclass` comes from `self` (the actual types of the arguments).

So if the argument passed to the function is a class, `self.get_type(arg)` will be `type(arg)`.
If `arg` is `int`, `type(arg)` is `type`.
Then in `distance(cls, subclass)`, `subclass` will be `type`.
And `subclass.mro()` will be `type.mro()`, which fails.

So let's try this:
```python
@multimethod
def f(x: object):
    print("object")

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

# We need a case where it doesn't match exactly (type,)
# but it does match (object,) and (type,). 
# Wait, if I call f(int), types is (type,). 
# Since (type,) is already in the dict, it doesn't go to __missing__.
```

Actually, if I don't register `(type,)` but I register `(object,)` and `(type,)`... no that's impossible.
If I register `(object,)` and some other type that is a supertype of `type`.
Wait, `type` is a subclass of `object`.
If I register `(object,)` and I call `f(int)`, `type(int)` is `type`.
`(type,)` is not in the dict.
`__missing__` is called with `types = (type,)`.
`self.parents((type,))` will return `{(type,), (object,)}`? No, `parents` returns the signatures that are supertypes.
Wait, let's check `parents` implementation.

{
  "command": "grep -rn \"def parents\" multimethod/__init__.py"
}

{
  "status": "ok",
  "stdout": "156:    def parents(self, types: tuple) -> set:\n",
  "stderr": "",
  "exit_code": 0
}

Let's read `parents` implementation.

{
  "end_line": 170,
  "filepath": "multimethod/__init__.py",
  "start_line": 150
}

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

And `signature.__le__` (used in `key < types`):
```python
    def __le__(self, other) -> bool:
        return len(self) <= len(other) and all(map(issubclass, other, self))
```
Wait, `key < types` means `key <= types` and `key != types`.
`key <= types` means `all(map(issubclass, types, key))`.
Wait, the `map` is `map(issubclass, other, self)`.
If `other` is `types` and `self` is `key`:
`issubclass(types[0], key[0]), issubclass(types[1], key[1]), ...`
So `key` is a supertype of `types`.

Back to my reproduction:
```python
@multimethod
def f(x: object):
    print("object")

f(int)
```
1. `f` is registered with signature `(object,)`.
2. `f(int)` is called. `args = (int,)`.
3. `type(int)` is `type`.
4. `self[(type,)]` is looked up. It's not there.
5. `__missing__((type,))` is called.
6. `self.parents((type,))`:
   - `key` is `(object,)`.
   - `(object,) <= (type,)` is `issubclass(type, object)`, which is `True`.
   - `(object,) != (type,)` is `True`.
   - So `(object,)` is a parent.
7. `groups = groupby(signature((type,)).__sub__, {(object,)})`
8. `signature((type,)).__sub__((object,))` is called.
9. This calls `map(distance, (object,), (type,))`.
10. `distance(object, type)` is called.
11. `mro = type.mro()`.
12. **BOOM!** `TypeError: unbound method type.mro() needs an argument`.

Let's test this reproduction.

{
  "command": "python3 - <<'PY'\nfrom multimethod import multimethod\n\n@multimmethod\ndef f(x: object):\n    print(\"object\")\n\ntry:\n    f(int)\n    print(\"Test Passed\")\nexcept TypeError as e:\n    print(f\"Test Failed: {e}\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 3, 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 3, in <module>\nNameError: name 'multimmethod' is not defined. Did you mean: 'multimethod'?\n",
    "exit_code": 1
  }
}

Whoops, typo in `multimmethod`.

{
  "command": "python3 - <<'PY'\nfrom multimethod import multimethod\n\n@multimethod\ndef f(x: object):\n    print(\"object\")\n\ntry:\n    f(int)\n    print(\"Test Passed\")\nexcept TypeError as e:\n    print(f\"Test Failed: {e}\")\nPY\n"
}

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

Still passed! Why?
Wait, I just said:
`f(int)` -> `type(int)` is `type`.
`self[(type,)]` is missing.
`__missing__((type,))` is called.
`self.parents((type,))` finds `(object,)`.
`distance(object, type)` is called.
`type.mro()` should be called.

Let's debug why `distance` is not called.
Maybe `self.parents((type,))` is empty?
In `parents`:
```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}
```
`key` is `(object,)`. `types` is `(type,)`.
Is `(object,) < (type,)`?
`signature.__le__`:
```python
    def __le__(self, other) -> bool:
        return len(self) <= len(other) and all(map(issubclass, other, self))
```
`len((object,))` (1) <= `len((type,))` (1).
`map(issubclass, (type,), (object,))` -> `issubclass(type, object)`.
`issubclass(type, object)` is `True`.
So `(object,) <= (type,)`.
And `(object,) != (type,)`.
So `(object,) < (type,)`.

Wait, I might be misinterpreting how `multimethod` is implemented.
Let's look at `multimethod`'s `__init__`.
```python
    def __init__(self, func: Callable):
        try:
            self[get_types(func)] = func
        except (NameError, AttributeError):
            self.pending.add(func)
```
And `__setitem__`:
```python
    def __setitem__(self, types: tuple, func: Callable):
        self.clean()
        types = signature(types)
        # ...
        super().__setitem__(types, func)
```
So the keys in the `multimethod` dict are `signature` objects.

In my reproduction:
```python
@multimethod
def f(x: object):
    print("object")
```
The key is `signature((object,))`.

When I call `f(int)`:
`args` is `(int,)`.
`map(self.get_type, args)` is `(type(int),)` = `(type,)`.
Wait, `self.get_type` is `type` by default.
So `self[(type,)]` is called.
`(type,)` is a tuple, not a `signature` object.
The dict `multimethod` (which is a `dict` subclass) is indexed with `(type,)`.
But the key in the dict is `signature((object,))`.
So `self[(type,)]` will fail to find the key.
Then `__missing__((type,))` is called.

Wait, I just ran it and it printed "object".
This means `__missing__((type,))` definitely worked and found `signature((object,))`.

Let's look at `__missing__` again.
```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 []
        funcs = {self[key] for key in keys}
        if len(funcs) == 1:
            return self.setdefault(types, *funcs)
        # ...
```
`signature(types).__sub__` is passed to `groupby`.
`groupby` is:
```python
def groupby(func, values):
    groups = collections.defaultdict(list)
    for value in values:
        groups[func(value)].append(value)
    return groups
```
So it calls `signature(types).__sub__(value)` for each `value` in `self.parents(types)`.
And `signature(types).__sub__(value)` calls `distance`.

So why is it not crashing?
Maybe `self.parents((type,))` is empty?
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 `key` is `signature((object,))` and `types` is `(type,)`.
Is `key < types`?
`signature.__le__`:
```python
    def __le__(self, other) -> bool:
        return len(self) <= len(other) and all(map(issubclass, other, self))
```
Here `self` is `key` (signature((object,))) and `other` is `types` ((type,)).
`all(map(issubclass, (type,), (object,)))` -> `issubclass(type, object)` -> `True`.

Wait! I might have found the reason it doesn't crash in my current environment.
Is it possible that `type.mro()` works in some Python versions?
No, in Python 3 it should fail.
Let me double check with a simple script.

{
  "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 as expected.
So why did my reproduction `f(int)` not fail?

Wait, I know!
`self.setdefault(types, *funcs)`
In `__missing__`:
```python
        if len(funcs) == 1:
            return self.setdefault(types, *funcs)
```
`self` is a `multimethod` object. `self.setdefault` is the `dict.setdefault` method?
No, `multimethod` inherits from `dict`.
Wait, `setdefault` on `dict` takes two arguments: `key, default`.
`self.setdefault(types, *funcs)` is called with `funcs` which is a set of one function.
So it's `self.setdefault((type,), func)`.
Wait, this call to `setdefault` adds `(type,)` as a key to the dict.
Next time `f(int)` is called, it's an exact match: `self[(type,)]` will find the result!

But the *first* time it was called, it should have gone through `__missing__` and `distance`.
Ah, I see. I only called it once in my reproduction.
Wait, I called it once, it should have gone through `__missing__` the first time.

Wait... I'm calling `f(int)`.
`f` was created by `@multimethod`.
```python
@multimethod
def f(x: object):
    print("object")
```
This calls `multimethod(f)`.
In `multimethod.__init__`:
```python
    def __init__(self, func: Callable):
        try:
            self[get_types(func)] = func
        except (NameError, AttributeError):
            self.pending.add(func)
```
`get_types(f)` returns `(object,)`.
Then `self[(object,)] = f` is called.
This calls `__setitem__((object,), f)`.
In `__setitem__`:
```python
    def __setitem__(self, types: tuple, func: Callable):
        self.clean()
        types = signature(types)
        parents = types.parents = self.parents(types)
C...
        super().__setitem__(types, func)
```
`types` is `signature((object,))`.
`self.parents(signature((object,)))` is called.
In `parents(types)`:
```python
    def parents(self, types: tuple) -> set:
        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}
```
At this point, `self` is empty. So `parents` is empty.

Now I call `f(int)`.
1. `self[(type,)]` is looked up. `(type,)` is not in the dict. (Keys are `signature` objects).
2. `__missing__((type,))` is called.
3. `self.parents((type,))` is called.
   - `key` is `signature((object,))`.
   - `(object,) < (type,)` is `True`.
   - So `parents` = `{signature((object,))}`.
4. `groups = groupby(signature((type,)).__sub__, {signature((object,))})`
5. `signature((type,)).__sub__(signature((object,)))` is called.
6. `map(distance, (object,), (type,))` is called.
7. `distance(object, type)` is called.
8. `type.mro()` is called.
9. **CRASH!**

Why did it not crash in my reproduction?
Wait... maybe `self.get_type` is not `type`?
In `multimethod.__new__`:
```python
        self.get_type = type  # default type checker
```
Yes, it is `type`.

Wait! I suspect a very subtle thing.
In my reproduction:
```python
@multimethod
def f(x: object):
    print("object")
```
Is `f` a `multimethod` instance?
Yes.

Let me try to print the keys of `f` before calling it.

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

{
  "status": "ok",
  "stdout": "Keys: [()]\nobject\n",
  "stderr": "",
  "exit_code": 0
}

Wait! `Keys: [()]`.
What?? Where did `()` come from?
The signature of `f(x: object)` should be `(object,)`.

Let's look at `get_types`.

{
  "command": "grep -rn \"def get_types\" multimethod/__init__.py"
}

{
  "status": "ok",
  "stdout": "21:def get_types(func: Callable) -> tuple:\n",
  "stderr": "",
  "exit_code": 0
}

Let's read `get_types`.

{
  "end_line": 40,
  "filepath": "multimethod/__init__.py",
  "start_line": 21
}

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