"Impossible d'instancier une classe abstraite ... avec des méthodes abstraites" sur une classe qui ne devrait pas avoir de méthode abstraite

Eh bien, si vous devez le faire de cette façon, vous pouvez simplement passer un dict factice {'FooMethod':None} comme troisième argument à taper. Cela permet à derived_type de satisfaire à l'exigence d'ABCMeta que toutes les méthodes abstraites soient remplacées. Plus tard, vous pourrez fournir le véritable FooMethod:

def main():
  derived_type = type('Derived', (FooClass,), {'FooMethod':None})
  def BarOverride(self):
    print 'Hello, world!'
  setattr(derived_type, 'FooMethod', BarOverride)
  instance = derived_type()

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

Cela ne fonctionne pas car abc ne peut rechercher des méthodes abstraites que lors de l'instanciation de types, c'est-à-dire lorsque type('Derived', (FooClass,), {}) est en cours d'exécution. Tout getattr effectué après cela n'est pas accessible depuis abc.

Donc, setattr ne fonctionnera pas, buuut ... Votre problème d'adressage du nom d'une classe qui n'a pas été précédemment déclarée ou définie semble résoluble:

J'ai écrit une petite métaclasse qui vous permet d'utiliser un espace réservé "clazz" pour accéder à n'importe quelle classe qui obtiendra éventuellement la méthode que vous écrivez en dehors d'une définition de classe.

De cette façon, vous n'obtiendrez plus TypeError de abc, car vous pouvez maintenant définir votre méthode AVANT d'instituer votre type, puis la transmettre à type à l'argument dict. Ensuite, abc le verra comme un remplacement de méthode approprié.

Aaand, avec la nouvelle métaclasse, vous pouvez faire référence à l'objet classe pendant cette méthode. Et c'est super, car maintenant vous pouvez utiliser super! = P Je suppose que vous étiez aussi inquiet à ce sujet ...

Regarde:

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...

Jochen a raison; les méthodes abstraites sont définies lors de la création de la classe et ne seront pas modifiées simplement parce que vous réaffectez un attribut.

Vous pouvez le supprimer manuellement de la liste des méthodes abstraites en faisant

DerivedType.__abstractmethods__ = frozenset()

Ou

DerivedType.__abstractmethods__ = frozenset(
        elem for elem in DerivedType.__abstractmethods__ if elem != 'FooMethod')

Ainsi que setattr, il ne pense donc pas que FooMethod soit abstrait.