Python generico metaclasse per tenere traccia delle sottoclassi

Question

sto cercando di scrivere un metaclasse generico per il monitoraggio sottoclassi

Dal momento che voglio che questo sia generica, non ho voglia di codificare qualsiasi nome di classe all'interno di questa metaclasse, quindi, mi si avvicinò con una funzione che genera il corretto metaclasse, qualcosa di simile:

def make_subtracker(root): 
    class SubclassTracker(type): 
     def __init__(cls, name, bases, dct): 
      print('registering %s' % (name,)) 
      root._registry.append(cls) 
      super(SubclassTracker, cls).__init__(name, bases, dct) 
    return SubclassTracker 

questo modo ho potuto invocare per generare un metaclasse per una specifica radice classe con:

__metaclass__ = make_subtracker(Root) 

Ecco dove mi imbatto in un problema. Non posso fare questo:

class Root(object): 
    _registry = [] 
    __metaclass__ = make_subtracker(Root) 

... perché Root non è ancora definita quando uso make_subtracker(Root). Ho provato ad aggiungere la metaclasse attributo successivamente, in modo che almeno può essere applicato in sottoclassi:

class Root(object): 
    _registry = [] 

Root.__metaclass__ = make_subtracker(Root) 

... ma questo non funziona. metaclasse ha un trattamento speciale quando la definizione della classe viene letta, come definito nella http://docs.python.org/reference/datamodel.html#customizing-class-creation

Sto cercando suggerimenti per fare questo (o cambiare un metaclasse di classe in fase di esecuzione in un modo che si applica a le sue sottoclassi o qualsiasi altra alternativa).

Answer 1

Python fa automaticamente per classi di nuovo stile, come accennato in questo answer al queston simile How can I find all subclasses of a given class in Python? qui.

Answer 2

Penso che si desidera qualcosa di simile (non testata):

class SubclassTracker(type): 
    def __init__(cls, name, bases, dct): 
     if not hasattr(cls, '_registry'): 
      cls._registry = [] 
     print('registering %s' % (name,)) 
     cls._registry.append(cls) 
     super(SubclassTracker, cls).__init__(name, bases, dct) 

Poi, per Python 2, è possibile richiamare le cose come:

class Root(object): 
    __metaclass__ = SubclassTracker 

per Python 3

class Root(object, metaclass=SubclassTracker): 

Nota che non è necessario attaccare l'attributo _registry lì perché roba del genere è ciò che metaclas ses sono per. Dal momento che ne hai già uno in giro ...;)

Nota anche che potresti voler spostare il codice di registrazione in una clausola else in modo che la classe non si registri come sottoclasse.

Answer 3

Ecco qualcosa che ho giocato in giro con (che funziona):