impossible to type `__prepare__` if metaclass inherits from `type`

[bwo]

and the error messages are impenetrable.

Suppose you have this file:

from typing import Tuple, Any, Mapping


reveal_type(type.__prepare__)


class Foo(type):
    @classmethod
    def __prepare__(mcls, name: str, bases: Tuple[type, ...], **kwds: Any) -> Mapping[str, Any]:
        return {}

mypy run:

 $ mypy foo.py
foo.py:4: note: Revealed type is 'def (builtins.str, builtins.tuple[builtins.type], **kwds: Any) -> typing.Mapping[builtins.str, Any]'
foo.py:9: error: Signature of "__prepare__" incompatible with supertype "type"
Found 1 error in 1 file (checked 1 source file)

But … the "revealed type" is the type I gave it? (The second reported parameter, builtins.tuple[builtins.type], is reported incorrectly; if you try to give that parameter that type, you get this message:

foo.py:9: error: Argument 2 of "__prepare__" is incompatible with supertype "type"; supertype defines the argument type as "Tuple[type, ...]"
foo.py:9: note: This violates the Liskov substitution principle

, so the "revealed type" is clearly not quite right.)

Ok, let's look in typeshed:

    def __prepare__(metacls, __name: str, __bases: Tuple[type, ...], **kwds: Any) -> Mapping[str, Any]: ...

hmmmmmm.

You can get mypy to accept this type for __prepare__—if the class inherits from object, rather than type. But metaclasses in mypy's own repo (e.g. MaybeMissingMeta) inherit from type, and, as I understand it, this is correct, since metaclasses are types of types.

cc @neilvyas

[CyberDeck]

I ran into a similar issue.

If i define the __prepare__ func as follows mypy 0.812 will accept it.

Complete minimal example:

from typing import Tuple, Mapping, Any, Dict

class MetaActions(type):
  @classmethod
  def __prepare__(mcls, __name: str, __bases: Tuple[type, ...], **kwds: Any) -> Mapping[str, Any]:
    d:Dict[str, Any] = dict()
    return d

However, if i remove from the __name or __bases parameters the trailing double-underscore it won't work and mypy fails.

[bitterteriyaki]

Hello, I hope everyone is well. Any update on resolving this bug? It's a bit annoying as I can't put the name I want in the __prepare__ parameters, and it's been several months since some update.

[erictraut]

Mypy is correct in reporting the error here. The problem is that your override method is accepting parameters name and bases by keyword, but the version of the method in the type base class does not. You can fix this by specifying that name and bases are positional-only. There are two ways to do this:

1. Add a positional-only separator parameter (/) after the bases parameter.
2. Change the name of the name and bases parameters to start with double underscores, as @CyberDeck did in the sample above.

This issue can probably be closed at this point since it's not a bug. Plus, the error message in the latest version of mypy is much more informative, so it should be easier to diagnose issues like this now.

[JelleZijlstra]

The current error message is:

main.py:4: note: Revealed type is "def (builtins.str, builtins.tuple[builtins.type], **kwds: Any) -> typing.Mapping[builtins.str, builtins.object]"
main.py:9: error: Signature of "__prepare__" incompatible with supertype "type"
main.py:9: note:      Superclass:
main.py:9: note:          @classmethod
main.py:9: note:          def __prepare__(metacls, str, Tuple[type, ...], **kwds: Any) -> Mapping[str, object]
main.py:9: note:      Subclass:
main.py:9: note:          @classmethod
main.py:9: note:          def __prepare__(mcls, name: str, bases: Tuple[type, ...], **kwds: Any) -> Mapping[str, Any]

Agree that that's much better, so closing this. Thanks @erictraut for diagnosing it!