Как реализовать интерфейс, совместимый с проверками статического типа?

Поддержка структурных подтипов была добавлена ​​PEP 544 - Протоколы: структурное подтипирование (статическая утиная типизация), начиная с Python 3.8. Для версий до 3.8 соответствующая реализация предоставляется пакетом typing-extensions на PyPI. .

Для обсуждаемого сценария имеет значение typing.Protocol, как объяснено в PEP. более подробно. Это позволяет определять неявные подтипы, что избавляет нас от конфликта метаклассов. вопрос, так как наследование не требуется. Итак, код выглядит так:

from typing import Protocol             # Python 3.8+
from typing_extensions import Protocol  # Python 3.5 - 3.7


class Fooish(Protocol):
    x : int

    def foo(self) -> int:
        raise NotImplementedError


# No inheritance required, implementing the defined protocol implicitly subtypes 'Fooish'.
class Foo:
    def __init__(self, x: int):
        self.x = x

    def foo(self):
        pass


class MyMeta(type):
    pass


class Bar(metaclass=MyMeta):
    def bar(self):
        pass


# Here, we again create an implicit subtype of 'Fooish'.
class FooBar(Bar):
    """Objects of this type are bar and they are foo-ish."""

    @property
    def x(self) -> int:
        return 0

    @x.setter
    def x(self, val):
        pass

    def foo(self):
        pass


class Worker:
    def __init__(self, obj: Fooish):
        self.x = obj.x

1. Чтобы избавиться от error: Signature of "x" incompatible with supertype "Fooish", вы можете аннотировать x: typing.Any.
2. Чтобы сделать Fooish действительно абстрактным, необходимы некоторые уловки для разрешения конфликта метаклассов. Я взял рецепт из этого ответа:

class MyABCMeta(MyMeta, abc.ABCMeta):
    pass

После этого можно создать Fooish:

class Fooish(metaclass=MyABCMeta):

Весь код, который успешно выполняется во время выполнения и не показывает ошибок от mypy:

import abc
import typing

class MyMeta(type):
    pass

class MyABCMeta(abc.ABCMeta, MyMeta):
    pass

class Fooish(metaclass=MyABCMeta):
    x : typing.Any

    @abc.abstractmethod
    def foo(self) -> int:
        raise NotImplementedError

class Bar(metaclass=MyMeta):
    def bar(self):
        pass

class Foo(Fooish):
    def __init__(self, x: int):
        self.x = x

    def foo(self):
        pass

class Worker:
    def __init__(self, obj: Fooish):
        self.x = obj.x


class FooBar(Bar, Fooish):
    """Objects of this type are bar and they are foo-ish."""

    @property
    def x(self) -> int:
        return 0

    def foo(self):
        pass

print(Worker(FooBar()))

Теперь пора подумать, действительно ли вы хотите сделать Fooish абстрактным, потому что выполнение class Fooish(metaclass=MyABCMeta): может иметь побочные эффекты, если MyMeta выполняет много трюков. Например, если MyMeta определяет __new__, вы, вероятно, можете определить __new__ в Fooish, который не вызывает MyMeta.__new__, а вызывает abc.ABCMeta.__new__. Но все может усложниться ... Так что, может быть, будет проще иметь неабстрактный Fooish.

Если я понимаю, вы могли бы добавить Union, что в основном позволяет Foo or Bar or Fooish:

from typing import Union

class Worker:
    def __init__(self, obj: Union[Bar, Fooish]):
        self.x = obj.x

# no type error
Worker(FooBar())

Со следующим:

class MyMeta(type):
    pass

class Fooish:
    x: int
    def foo(self) -> int:
        raise NotImplementedError


class Bar(metaclass=MyMeta):
    def bar(self):
        pass


class Foo:
    def __init__(self, x: int):
        self.x = x

    def foo(self):
        pass


class Worker:
    def __init__(self, obj: Union[Bar, Fooish]):
        self.x = obj.x


class FooBar(Bar, Fooish):
    """Objects of this type are bar and they are foo-ish."""

    @property
    def x(self) -> int:
        return 0

    def foo(self):
        pass

видеть:

• https://github.com/python/typing/issues/213