Improving property to accept abstract methods

Lib/abc.py

 # Copyright 2007 Google, Inc. All Rights Reserved.
 # Licensed to PSF under a Contributor Agreement.
 
 """Abstract Base Classes (ABCs) according to PEP 3119."""
 
 from _weakrefset import WeakSet
 
 def abstractmethod(funcobj):
     """A decorator indicating abstract methods.
 
     Requires that the metaclass is ABCMeta or derived from it.  A
     class that has a metaclass derived from ABCMeta cannot be
     instantiated unless all of its abstract methods are overridden.
     The abstract methods can be called using any of the normal
     'super' call mechanisms.
 
     Usage:
 
         class C(metaclass=ABCMeta):
             @abstractmethod
             def my_abstract_method(self, ...):
                 ...
     """
     funcobj.__isabstractmethod__ = True
     return funcobj
 
 
 class abstractclassmethod(classmethod):
-    """A decorator indicating abstract classmethods.
+    """
+    A decorator indicating abstract classmethods.
 
     Similar to abstractmethod.
 
     Usage:
 
         class C(metaclass=ABCMeta):
             @abstractclassmethod
             def my_abstract_classmethod(cls, ...):
                 ...
+
+    'abstractclassmethod' is deprecated. Use 'classmethod' with
+    'abstractmethod' instead.
     """
 
     __isabstractmethod__ = True
 
     def __init__(self, callable):
         callable.__isabstractmethod__ = True
         super().__init__(callable)
 
 
 class abstractstaticmethod(staticmethod):
-    """A decorator indicating abstract staticmethods.
+    """
+    A decorator indicating abstract staticmethods.
 
     Similar to abstractmethod.
 
     Usage:
 
         class C(metaclass=ABCMeta):
             @abstractstaticmethod
             def my_abstract_staticmethod(...):
                 ...
+
+    'abstractstaticmethod' is deprecated. Use 'staticmethod' with
+    'abstractmethod' instead.
     """
 
     __isabstractmethod__ = True
 
     def __init__(self, callable):
         callable.__isabstractmethod__ = True
         super().__init__(callable)
 
 
 class abstractproperty(property):
-    """A decorator indicating abstract properties.
+    """
+    A decorator indicating abstract properties.
 
     Requires that the metaclass is ABCMeta or derived from it.  A
     class that has a metaclass derived from ABCMeta cannot be
     instantiated unless all of its abstract properties are overridden.
     The abstract properties can be called using any of the normal
     'super' call mechanisms.
 
     Usage:
 
         class C(metaclass=ABCMeta):
             @abstractproperty
             def my_abstract_property(self):
                 ...
 
     This defines a read-only property; you can also define a read-write
     abstract property using the 'long' form of property declaration:
 
         class C(metaclass=ABCMeta):
             def getx(self): ...
             def setx(self, value): ...
             x = abstractproperty(getx, setx)
-    """
-    warnings.warn(

[durban, 2011/03/19 21:36:09]

warnings is not imported.  Also if you put the warn call here, the warning will
get issued when the class statement is executed (when the module is imported
first), not when the user tries to use abstractproperty.  (And again, I don't
think it should be deprecated.)

[dsdale24, 2011/03/19 22:13:42]

Good point.

-        "abstractproperty will be removed in future versions.  "
-        "Use 'property' in conjunction with 'abstractmethod' instead.",
-        DeprecationWarning, stacklevel=2
-        )
+
+    'abstractproperty' is deprecated. Use 'property' with 'abstractmethod'
+    instead.
+    """
+
     __isabstractmethod__ = True
 
 
 class ABCMeta(type):
 
     """Metaclass for defining Abstract Base Classes (ABCs).
 
     Use this metaclass to create an ABC.  An ABC can be subclassed
     directly, and then acts as a mix-in class.  You can also register
     unrelated concrete classes (even built-in classes) and unrelated
@@ skipping 104 matching lines @@
                 cls._abc_cache.add(subclass)
                 return True
         # Check if it's a subclass of a subclass (recursive)
         for scls in cls.__subclasses__():
             if issubclass(subclass, scls):
                 cls._abc_cache.add(subclass)
                 return True
         # No dice; update negative cache
         cls._abc_negative_cache.add(subclass)
         return False