Python 2.7 Combiner abc.abstractmethod et classmethod

Voici un exemple de travail dérivé à partir du code source en Python 3.3 du abc module:

from abc import ABCMeta

class abstractclassmethod(classmethod):

    __isabstractmethod__ = True

    def __init__(self, callable):
        callable.__isabstractmethod__ = True
        super(abstractclassmethod, self).__init__(callable)

class DemoABC:

    __metaclass__ = ABCMeta

    @abstractclassmethod
    def from_int(cls, n):
        return cls()

class DemoConcrete(DemoABC):

    @classmethod
    def from_int(cls, n):
        return cls(2*n)

    def __init__(self, n):
        print 'Initializing with', n

Voici à quoi il ressemble lors de l'exécution:

>>> d = DemoConcrete(5)             # Succeeds by calling a concrete __init__()
Initializing with 5

>>> d = DemoConcrete.from_int(5)    # Succeeds by calling a concrete from_int()
Initializing with 10

>>> DemoABC()                       # Fails because from_int() is abstract    
Traceback (most recent call last):
  ...
TypeError: Can't instantiate abstract class DemoABC with abstract methods from_int

>>> DemoABC.from_int(5)             # Fails because from_int() is not implemented
Traceback (most recent call last):
  ...
TypeError: Can't instantiate abstract class DemoABC with abstract methods from_int

Noter que le dernier exemple échoue parce que cls() de ne pas instancier. ABCMeta empêche prématurée de l'instanciation de classes qui n'ont pas été définis tous les méthodes abstraites.

Une autre façon de déclencher un échec lors de la from_int() classe abstraite méthode est appelée consiste à soulever une exception:

class DemoABC:

    __metaclass__ = ABCMeta

    @abstractclassmethod
    def from_int(cls, n):
        raise NotImplementedError

La conception ABCMeta ne fait aucun effort pour empêcher toute méthode abstraite d'être appelé sur un uninstantiated classe, donc c'est à vous de déclencher un échec en invoquant cls() comme classmethods généralement de faire, ou en augmentant un NotImplementedError. De toute façon, vous obtenez une belle, propre échec.

Il est sans doute tentant d'écrire un descripteur pour intercepter un appel direct à un résumé de la méthode de classe, mais qui serait en contradiction avec la conception globale de ABCMeta (ce qui est tout au sujet de la vérification pour les méthodes requises avant l'instanciation plutôt que lorsque les méthodes sont appelées).

J'ai récemment rencontré le même problème. C'est, il me fallait un résumé classmethods, mais a été incapable d'utiliser Python 3 en raison d'autres contraintes du projet. La solution que j'ai trouvé est la suivante.

abcExtend.py:

import abc

class instancemethodwrapper(object):
    def __init__(self, callable):
        self.callable = callable
        self.__dontcall__ = False

    def __getattr__(self, key):
        return getattr(self.callable, key)

    def __call__(self, *args, **kwargs):
        if self.__dontcall__:
            raise TypeError('Attempted to call abstract method.')
        return self.callable(*args,**kwargs)

class newclassmethod(classmethod):
    def __init__(self, func):
        super(newclassmethod, self).__init__(func)
        isabstractmethod = getattr(func,'__isabstractmethod__',False)
        if isabstractmethod:
            self.__isabstractmethod__ = isabstractmethod

    def __get__(self, instance, owner):
        result = instancemethodwrapper(super(newclassmethod, self).__get__(instance, owner))
        isabstractmethod = getattr(self,'__isabstractmethod__',False)
        if isabstractmethod:
            result.__isabstractmethod__ = isabstractmethod
            abstractmethods = getattr(owner,'__abstractmethods__',None)
            if abstractmethods and result.__name__ in abstractmethods:
                result.__dontcall__ = True
        return result

class abstractclassmethod(newclassmethod):
    def __init__(self, func):
        func = abc.abstractmethod(func)
        super(abstractclassmethod,self).__init__(func)

Utilisation:

from abcExtend import abstractclassmethod

class A(object):
    __metaclass__ = abc.ABCMeta    
    @abstractclassmethod
    def foo(cls):
        return 6

class B(A):
    pass

class C(B):
    @classmethod
    def foo(cls):
        return super(C,cls).foo() + 1

try:
    a = A()
except TypeError:
    print 'Instantiating A raises a TypeError.'

try:
    A.foo()
except TypeError:
    print 'Calling A.foo raises a TypeError.'

try:
    b = B()
except TypeError:
    print 'Instantiating B also raises a TypeError because foo was not overridden.'

try:
    B.foo()
except TypeError:
    print 'As does calling B.foo.'

#But C can be instantiated because C overrides foo
c = C()

#And C.foo can be called
print C.foo()

Et voici quelques pyunit tests qui donnent une plus exhaustive de démonstration.

testAbcExtend.py:

import unittest
import abc
oldclassmethod = classmethod
from abcExtend import newclassmethod as classmethod, abstractclassmethod
class Test(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def testClassmethod(self):
class A(object):
__metaclass__ = abc.ABCMeta            
@classmethod
@abc.abstractmethod
def foo(cls):
return 6
class B(A):
@classmethod
def bar(cls):
return 5
class C(B):
@classmethod
def foo(cls):
return super(C,cls).foo() + 1
self.assertRaises(TypeError,A.foo)
self.assertRaises(TypeError,A)
self.assertRaises(TypeError,B)
self.assertRaises(TypeError,B.foo)
self.assertEqual(B.bar(),5)
self.assertEqual(C.bar(),5)
self.assertEqual(C.foo(),7)
def testAbstractclassmethod(self):
class A(object):
__metaclass__ = abc.ABCMeta    
@abstractclassmethod
def foo(cls):
return 6
class B(A):
pass
class C(B):
@oldclassmethod
def foo(cls):
return super(C,cls).foo() + 1
self.assertRaises(TypeError,A.foo)
self.assertRaises(TypeError,A)
self.assertRaises(TypeError,B)
self.assertRaises(TypeError,B.foo)
self.assertEqual(C.foo(),7)
c = C()
self.assertEqual(c.foo(),7)
if __name__ == "__main__":
#import sys;sys.argv = ['', 'Test.testName']
unittest.main()

Je n'ai pas évalué le coût de cette solution, mais cela a fonctionné pour ma part jusqu'à présent.