I’m trying to get abstract properties to work, enforcing property getter & setter definitions in downstream classes.
from abc import ABC, abstractmethod
class BaseABC(ABC):
@property
@abstractmethod
def x(self):
pass
@x.setter
@abstractmethod
def x(self, value):
pass
class MyClass(BaseABC):
def __init__(self, value):
self._x = value
@property
def x(self):
return self._x
# @x.setter
# def x(self, val):
# self._x = val
obj = MyClass(10)
print(obj.x)
obj.x = 20
print(obj.x)
Having read the documentation it seems to indicate the above should trigger a TypeError, when the class is being build, but it only triggers an AttributeError once the attribute is being set.
Why does the absent setter, explicitly defined in BaseABC through an @abstractmethod, not trigger the expected TypeError?
How does one ensure a setter is required in the daughter class?
1
There is no way to enforce what you’re looking for.
Fundamentally, overriding doesn’t happen at a fine enough level of granularity for this. When you override a property, you override the whole property, getter, setter, deleter, and all. Python doesn’t even care if you override it with another property – you could override it with the string "banana".
All the ABC machinery enforces is that subclasses have to override your abstract property with something concrete, for the subclass to be concrete. It doesn’t care whether that something is a read-write property, or a property at all – "banana" would be considered fine.
TL;DR property doesn’t just override the getter; it overrides the setter with None as well.
In MyClass, property creates a brand new property with the given getter and no setter; it doesn’t simply override the getter of the inherited property. The definition of MyClass.x is equivalent to
def x_getter(self):
return self._x
x = property(x_getter, None)
and that None as a setter is “good enough” as far as ABC is concerned with respect to overriding the abstract setter.
To “inherit” the abstract setter as well, use
class MyClass(BaseABC):
@BaseABC.x.getter
def x(self):
return self._x
This creates a new property not from scratch, but from the existing BaseABC.x property, using its (abstract) setter but a new getter (just like x.setter before created a new property using the old getter but a new setter).
To make MyClass instantiable, you still need to provide a concrete setter using x.setter.
Unfortunately, nothing forces you to to use BaseABC.x.getter in place of property. ABC only cares that x gets set to something appropriate. This is a general problem with ABC, not properties in particular. There is only so much you can do at the library level; abstract base classes are not a feature of Python itself.
9