classification
Title: Abstract property setter/deleter implementation not enforced, but documented as such
Type: behavior Stage: resolved
Components: Documentation Versions: Python 3.10, Python 3.9, Python 3.8, Python 3.7
process
Status: open Resolution:
Dependencies: Superseder:
Assigned To: docs@python Nosy List: arn.vollebregt.kpn, docs@python, gvanrossum, josh.r, rhettinger
Priority: normal Keywords:

Created on 2020-02-21 10:59 by arn.vollebregt.kpn, last changed 2020-12-09 22:45 by gvanrossum.

Messages (5)
msg362403 - (view) Author: Arn Vollebregt (KPN) (arn.vollebregt.kpn) Date: 2020-02-21 10:59
When concretely implementing an abstract ABC class with an abstract property getter, setter and deleter it is not enfored that the setter and deleter are implemented. Instead, the property is treated as a read-only property (as would normally be the case without a setter/deleter definition for a property) and the setter/deleter code from the abstract class is not present in the child class.

I would expect a TypeError exception when an abstract property is defined with a getter, setter and deleter but only the getter is implemented in a subclass (as is the case when not implementing the property getter). As a fallback, I would find it acceptable the code from the abstract class to be present in the child class, so at least the code that is defined there (in this case raising a NotImplementedError exception) would be executed.

An interactive interpreter session to replicate this behavior:

arn@hacktop:~$ python3
Python 3.7.5 (default, Nov 20 2019, 09:21:52)
[GCC 9.2.1 20191008] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import abc
>>>
>>> # Define the (abstract) interface.
... class MyInterface(abc.ABC):
...
...     # Property getter.
...     @property
...     @abc.abstractmethod
...     def myProperty(self) -> str:
...         raise NotImplementedError
...
...     # Property setter.
...     @myProperty.setter
...     @abc.abstractmethod
...     def myProperty(self, value: str) -> None:
...         raise NotImplementedError
...
...     # Property deleter.
...     @myProperty.deleter
...     @abc.abstractmethod
...     def myProperty(self) -> None:
...         raise NotImplementedError
...
>>> # Implemented the interface.
... class MyImplementation(MyInterface):
...     
...     # No abstract method implementation(s).
...     pass
...
>>> # Creation of MyImplementation object raises TypeError as expected.
... obj = MyImplementation()
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: Can't instantiate abstract class MyImplementation with abstract methods myProperty
>>> import dis
>>> # The property getter code would raise an exception as defined in MyInterface.
... dis.dis(MyImplementation.myProperty.fget.__code__.co_code)
          0 LOAD_GLOBAL              0 (0)
          2 RAISE_VARARGS            1
          4 LOAD_CONST               0 (0)
          6 RETURN_VALUE
>>> # The property setter code would raise an exception as defined in MyInterface.
... dis.dis(MyImplementation.myProperty.fset.__code__.co_code)
          0 LOAD_GLOBAL              0 (0)
          2 RAISE_VARARGS            1
          4 LOAD_CONST               0 (0)
          6 RETURN_VALUE
>>> # The property deleter code would raise an exception as defined in MyInterface.
... dis.dis(MyImplementation.myProperty.fdel.__code__.co_code)
          0 LOAD_GLOBAL              0 (0)
          2 RAISE_VARARGS            1
          4 LOAD_CONST               0 (0)
          6 RETURN_VALUE
>>> # Let's reimplement with only the property getter.
... class MyImplementation(MyInterface):
...
...     # Only implement abstract property getter.
...     @property
...     def myProperty(self) -> str:
...         return "foobar"
...
>>> # Object can be created (against expectations).
... obj = MyImplementation()
>>> # The property getter works as defined.
... obj.myProperty
'foobar'
>>> # The property cannot be set (read-only).
... obj.myProperty = "barfoo"
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
AttributeError: can't set attribute
>>> # The property cannot be deleted (read-only).
... del obj.myProperty
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
AttributeError: can't delete attribute
>>> # The property getter code returns a string as defined in MyImplementation.
... type(MyImplementation.myProperty.fget)
<class 'function'>
>>> dis.dis(MyImplementation.myProperty.fget.__code__.co_code)
          0 LOAD_CONST               1 (1)
          2 RETURN_VALUE
>>> # The property setter code however does not exist, although defined in MyInterface.
... type(MyImplementation.myProperty.fset)
<class 'NoneType'>
>>> # Nor does the property deleter code, although defined in MyInterface.
... type(MyImplementation.myProperty.fdel)
<class 'NoneType'>
msg362413 - (view) Author: Raymond Hettinger (rhettinger) * (Python committer) Date: 2020-02-21 16:55
Off-hand, I don't see how this can be easily fixed because the setters and deleters are all part of a single property object.  

When the subclass defines a property without a getter and setter, the inherited abstract property (that does have a getter and setter) is masked.

Right now, ABCMeta only looks at the concrete property.  It would have to be modified to scan the next in MRO for an abstract property and the pick apart its component fget, fset, and fdel.  That would be a significant jump in complexity with only a minimal payoff.
msg362438 - (view) Author: Guido van Rossum (gvanrossum) * (Python committer) Date: 2020-02-21 22:37
I agree with Raymond here. This is a job for a static type checker like mypy. Closing.
msg382810 - (view) Author: Josh Rosenberg (josh.r) * (Python triager) Date: 2020-12-09 22:41
If this is going to be closed as rejected, I think it still needs some improvement to the documentation. Right now, the docs for abstractproperty (deprecated in favor of combining property and abstractmethod) state:

"If only some components are abstract, only those components need to be updated to create a concrete property in a subclass:"

This heavily implies that if *all* components of the property are abstract, they must *all* be updated to create a concrete property on the subclass, when that is not the case (it's documenting a special way of overriding just one component by borrowing the base class, not a normal means of defining a property). If nothing else, mentioning this quirk in the docs seems like it would save confusion (e.g. https://stackoverflow.com/questions/65224767/python-abstract-property-cant-instantiate-abstract-class-with-abstract-me ).
msg382811 - (view) Author: Guido van Rossum (gvanrossum) * (Python committer) Date: 2020-12-09 22:45
Josh, feel free to submit a PR (make sure it mentions this issue).
History
Date User Action Args
2020-12-09 22:45:34gvanrossumsetmessages: + msg382811
2020-12-09 22:41:44josh.rsetstatus: closed -> open

assignee: docs@python
components: + Documentation

title: Abstract property setter/deleter implementation not enforced. -> Abstract property setter/deleter implementation not enforced, but documented as such
nosy: + docs@python, josh.r
versions: + Python 3.8, Python 3.9, Python 3.10
messages: + msg382810
resolution: rejected ->
2020-02-21 22:37:11gvanrossumsetstatus: open -> closed
resolution: rejected
messages: + msg362438

stage: resolved
2020-02-21 16:55:49rhettingersetnosy: + gvanrossum, rhettinger
messages: + msg362413
2020-02-21 10:59:10arn.vollebregt.kpncreate