“Ne peut pas instancier une classe abstraite ... avec des méthodes abstraites” de la classe qui ne doit avoir aucune méthode abstraite

Parce que les docs disent donc:

Ajouter dynamiquement les méthodes abstraites de la classe, ou de tenter de
modifier l'abstraction statut d'une méthode ou classe une fois qu'il est créé,
ne sont pas pris en charge. Le abstractmethod() affecte uniquement les sous-classes
dérivés de l'utilisation de l'héritage; virtuels “sous-classes”, enregistré
avec l'ABC de la méthode register() ne sont pas affectés.

Une métaclasse est seulement appelé lorsqu'une classe est définie. Lorsque abstractmethod a marqué une classe de base abstraite que le statut ne changera pas plus tard.

OriginalL'auteur Jochen Ritzel

Je sais que ce sujet est vraiment vieux, mais... C'est vraiment une bonne question.

Cela ne fonctionne pas car l'abc peut seulement vérifier les méthodes abstraites pendant instatiation de types, c'est, quand type('Derived', (FooClass,), {}) est en cours d'exécution. Tout setattr fait après ce n'est pas accessible à partir de abc.

Donc, setattr pas travailler, buuut...
Votre problème de relever le nom d'une classe qui n'a pas été préalablement déclarée ou définie semble insoluble:

J'ai écrit un petit métaclasse qui vous permet d'utiliser un espace réservé "clazz" pour accéder à toute la classe qui finira par être la méthode que vous écrivez en dehors d'une définition de classe.

De cette façon, vous n'obtiendrez pas TypeError de l'abc de plus, puisque vous pouvez maintenant définir votre méthode AVANT de instatiating votre type, et ensuite de le passer à la dict argument. Abc verront cela comme une bonne méthode de remplacement.

Aaand, avec la nouvelle métaclasse vous pouvez vous référer à l'objet de classe au cours de cette méthode.
Et c'est super, parce que maintenant vous pouvez utiliser super! =P
Je peux deviner que vous étiez inquiet au sujet de la trop...

Prendre un coup d'oeil:

import abc
import inspect
clazz = type('clazz', (object,), {})()
def clazzRef(func_obj):
func_obj.__hasclazzref__ = True
return func_obj
class MetaClazzRef(type):
"""Makes the clazz placeholder work.
Checks which of your functions or methods use the decorator clazzRef
and swaps its global reference so that "clazz" resolves to the
desired class, that is, the one where the method is set or defined.
"""
methods = {}
def __new__(mcs, name, bases, dict):
ret = super(MetaClazzRef, mcs).__new__(mcs, name, bases, dict)
for (k,f) in dict.items():
if getattr(f, '__hasclazzref__', False):
if inspect.ismethod(f):
f = f.im_func
if inspect.isfunction(f):
for (var,value) in f.func_globals.items():
if value is clazz:
f.func_globals[var] = ret
return ret
class MetaMix(abc.ABCMeta, MetaClazzRef):
pass
class FooClass(object):
__metaclass__ = MetaMix
@abc.abstractmethod
def FooMethod(self):
print 'Ooops...'
#raise NotImplementedError()
def main():
@clazzRef
def BarOverride(self):
print "Hello, world! I'm a %s but this method is from class %s!" % (type(self), clazz)
super(clazz, self).FooMethod() # Now I have SUPER!!!
derived_type = type('Derived', (FooClass,), {'FooMethod': BarOverride})
instance = derived_type()
instance.FooMethod()
class derivedDerived(derived_type):
def FooMethod(self):
print 'I inherit from derived.'
super(derivedDerived,self).FooMethod()
instance = derivedDerived()
instance.FooMethod()
main()

La sortie est:

Hello, world! I'm a <class 'clazz.Derived'> but this method is from class <class 'clazz.Derived'>!
Ooops...
I inherit from derived.
Hello, world! I'm a <class 'clazz.derivedDerived'> but this method is from class <class 'clazz.Derived'>!
Ooops...

OriginalL'auteur rbertoche