abstractmethod signal intended function signatures

[randolf-scholz]

I seem to encounter the following problem: When creating ABC's sometimes I want @abstractmethods to have a specific signature, sometimes I want to allow subclass to have arbitrary signatures, and sometimes I want something in-between.

Here is an example of what I am talking about; Note that this not violate LSP, as ABCs cannot be instantiated.

from abc import ABC, abstractmethod

class BaseModel(ABC):
    @abstractmethod
    def __call__(self):
        """Subclasses should be allowed to have arbitrary signatures."""

    @abstractmethod
    def download(self) -> None:
        """Subclasses m̶u̶s̶t̶ should have **exactly** this signature."""

In particular, when I write an example, then

class Model(BaseModel):
    def __call__(self, x):
        pass

    def download(self, url=None) -> None:
        pass

Then

• pycharm complains that __call__ has the wrong signature
• pylint complains that download has the wrong signature (cf. False positive arguments-differ with defaults pylint-dev/pylint#5338, Allow adding parameters in an overridden method, without tripping arguments-differ pylint-dev/pylint#1556)
• mypy thinks everything is fine.

Am I missing something, or is it currently not possible to properly type hint ABCs? A possible solution I could see is if it were possible to annotate the signature of @abstractmethods, for example with Ellipsis.

class MyABC(ABC):
   def foo(self, x):
       # subclasses must have exactly 1 positional arg `x`,

   def bar(self, x, ...):
       # subclasses must have at least 1 positional arg `x`

   def baz(self, x, *, ...):
       # subclass must have exactly 1 positional arg `x` and can have arbitrary kwargs.

   def qux(self, ..., *, x):
       # subclasses can have arbitrary positional args, but must have exactly 1 kwarg `x`

These checks could be used by static code checkers to verify signatures of subclasses and be ignored at runtime.

[Akuli]

I don't see any reason why your download() method should be an error. If a function takes a BaseModel as an argument and calls foo.download(), it will work fine even with a Model. So to me, "must have exactly this signature" doesn't seem useful, and the pylint warning seems wrong.

Similarly, "must have at least 1 positional arg" doesn't make sense to me. How would you call such function? By passing it 1 argument, in which case it won't work if it takes more than 1 argument?

I think there's currently no way to say "this method must exist, but it can accept or not accept whatever arguments it wants". There's some discussion here: python/mypy#5876 Currently the best you can do is my_method: Callable[..., None], but there's no way to decorate that with @abstractmethod. You could use if TYPE_CHECKING so that you get a def statement at runtime, but then the type checker won't see the @abstractmethod.

Slightly unrelated: I often wish it was possible to separate "you get this when you explicitly inherit from this ABC" from "this functionality is required for conforming to this ABC". For example, here's discussion about how MutableMapping would ideally have def get(self, key, default=...) for subclassing, but a positional-only def pop(self, __key, __default=...) when considering whether a class is a valid MutableMapping: python/typeshed#6694