python - ¿Metaclass Mixin o encadenamiento?

Question

¿Es posible encadenar metaclases?

Tengo un Model clase que usa __metaclass__=ModelBase para procesar su __metaclass__=ModelBase de espacio de nombres. Voy a heredar de él y "enlazar" otra metaclase para que no oculte el original.

El primer acercamiento es a la class MyModelBase(ModelBase) subclase class MyModelBase(ModelBase) :

MyModel(Model):
    __metaclass__ = MyModelBase # inherits from `ModelBase`

Pero, ¿es posible simplemente encadenarlos como mixins, sin subclasificación explícita? Algo como

class MyModel(Model):
    __metaclass__ = (MyMixin, super(Model).__metaclass__)

... o incluso mejor: cree un MixIn que usará __metaclass__ del padre directo de la clase que lo usa:

class MyModel(Model):
    __metaclass__ = MyMetaMixin, # Automagically uses `Model.__metaclass__`

La razón: para obtener más flexibilidad en la extensión de las aplicaciones existentes, quiero crear un mecanismo global para conectar el proceso de definiciones de Model , Form , ... en Django para que se pueda cambiar en tiempo de ejecución.

Un mecanismo común sería mucho mejor que implementar múltiples metaclases con mixins de devolución de llamada.

Con su ayuda, finalmente logré encontrar una solución: MetaProxy .

La idea es: crear una metaclase que invoque una devolución de llamada para modificar el espacio de nombres de la clase que se está creando, luego, con la ayuda de __new__ , mutar en una metaclase de uno de los padres

#!/usr/bin/env python
#-*- coding: utf-8 -*-

# Magical metaclass
class MetaProxy(type):
    """ Decorate the class being created & preserve __metaclass__ of the parent

        It executes two callbacks: before & after creation of a class, 
        that allows you to decorate them.

        Between two callbacks, it tries to locate any `__metaclass__` 
        in the parents (sorted in MRO). 
        If found — with the help of `__new__` method it
        mutates to the found base metaclass. 
        If not found — it just instantiates the given class.
        """

    @classmethod
    def pre_new(cls, name, bases, attrs):
        """ Decorate a class before creation """
        return (name, bases, attrs)

    @classmethod
    def post_new(cls, newclass):
        """ Decorate a class after creation """
        return newclass

    @classmethod
    def _mrobases(cls, bases):
        """ Expand tuple of base-classes ``bases`` in MRO """
        mrobases = []
        for base in bases:
            if base is not None: # We don''t like `None` :)
                mrobases.extend(base.mro())
        return mrobases

    @classmethod
    def _find_parent_metaclass(cls, mrobases):
        """ Find any __metaclass__ callable in ``mrobases`` """
        for base in mrobases:
            if hasattr(base, ''__metaclass__''):
                metacls = base.__metaclass__
                if metacls and not issubclass(metacls, cls): # don''t call self again
                    return metacls#(name, bases, attrs)
        # Not found: use `type`
        return lambda name,bases,attrs: type.__new__(type, name, bases, attrs)

    def __new__(cls, name, bases, attrs):
        mrobases = cls._mrobases(bases)
        name, bases, attrs = cls.pre_new(name, bases, attrs) # Decorate, pre-creation
        newclass = cls._find_parent_metaclass(mrobases)(name, bases, attrs)
        return cls.post_new(newclass) # Decorate, post-creation



# Testing
if __name__ == ''__main__'':
    # Original classes. We won''t touch them
    class ModelMeta(type):
        def __new__(cls, name, bases, attrs):
            attrs[''parentmeta''] = name
            return super(ModelMeta, cls).__new__(cls, name, bases, attrs)

    class Model(object):
        __metaclass__ = ModelMeta
        # Try to subclass me but don''t forget about `ModelMeta`

    # Decorator metaclass
    class MyMeta(MetaProxy):
        """ Decorate a class

            Being a subclass of `MetaProxyDecorator`,
                it will call base metaclasses after decorating
            """
        @classmethod
        def pre_new(cls, name, bases, attrs):
            """ Set `washere` to classname """
            attrs[''washere''] = name
            return super(MyMeta, cls).pre_new(name, bases, attrs)

        @classmethod
        def post_new(cls, newclass):
            """ Append ''!'' to `.washere` """
            newclass.washere += ''!''
            return super(MyMeta, cls).post_new(newclass)

    # Here goes the inheritance...
    class MyModel(Model):
        __metaclass__ = MyMeta
        a=1
    class MyNewModel(MyModel):
        __metaclass__ = MyMeta # Still have to declare it: __metaclass__ do not inherit
        a=2
    class MyNewNewModel(MyNewModel):
        # Will use the original ModelMeta
        a=3

    class A(object):
        __metaclass__ = MyMeta # No __metaclass__ in parents: just instantiate
        a=4
    class B(A): 
        pass # MyMeta is not called until specified explicitly



    # Make sure we did everything right
    assert MyModel.a == 1
    assert MyNewModel.a == 2
    assert MyNewNewModel.a == 3
    assert A.a == 4

    # Make sure callback() worked
    assert hasattr(MyModel, ''washere'')
    assert hasattr(MyNewModel, ''washere'')
    assert hasattr(MyNewNewModel, ''washere'') # inherited
    assert hasattr(A, ''washere'')

    assert MyModel.washere == ''MyModel!''
    assert MyNewModel.washere == ''MyNewModel!''
    assert MyNewNewModel.washere == ''MyNewModel!'' # inherited, so unchanged
    assert A.washere == ''A!''

Answer 1

No conozco ninguna forma de "mezclar" las metaclases, pero puede heredarlas y anularlas como lo haría con las clases normales.

Digamos que tengo un modelo base:

class BaseModel(object):
    __metaclass__ = Blah

y ahora desea heredar esto en una nueva clase llamada MyModel, pero desea insertar alguna funcionalidad adicional en la metaclase, pero de lo contrario, deje intacta la funcionalidad original. Para hacer eso, harías algo como:

class MyModelMetaClass(BaseModel.__metaclass__):
    def __init__(cls, *args, **kwargs):
        do_custom_stuff()
        super(MyModelMetaClass, cls).__init__(*args, **kwargs)
        do_more_custom_stuff()

class MyModel(BaseModel):
    __metaclass__ = MyModelMetaClass

Answer 2

No creo que puedas encadenarlos así, y tampoco sé cómo funcionaría eso.

Pero puedes hacer nuevas metaclases durante el tiempo de ejecución y usarlas. Pero eso es un horrible truco. :)

zope.interface hace algo similar, tiene una metaclase asesora, que solo hará algunas cosas a la clase después de la construcción. Si ya existía una metclase, una de las cosas que hará será establecer esa metaclase anterior como la metaclase una vez que haya terminado.

(Sin embargo, evite hacer este tipo de cosas a menos que tenga que hacerlo o piense que es divertido).

Answer 3

Un tipo solo puede tener una metaclase, porque una metaclase simplemente establece lo que hace la declaración de clase: tener más de uno no tendría sentido. Por la misma razón, el "encadenamiento" no tiene sentido: la primera metaclase crea el tipo, entonces, ¿qué se supone que debe hacer la segunda?

Tendrá que fusionar las dos metaclases (al igual que con cualquier otra clase). Pero eso puede ser complicado, especialmente si realmente no sabes lo que hacen.

class MyModelBase(type):
    def __new__(cls, name, bases, attr):
        attr[''MyModelBase''] = ''was here''
        return type.__new__(cls,name, bases, attr)

class MyMixin(type):
    def __new__(cls, name, bases, attr):
        attr[''MyMixin''] = ''was here''
        return type.__new__(cls, name, bases, attr)

class ChainedMeta(MyModelBase, MyMixin):
    def __init__(cls, name, bases, attr):
        # call both parents
        MyModelBase.__init__(cls,name, bases, attr)
        MyMixin.__init__(cls,name, bases, attr)

    def __new__(cls, name, bases, attr):
        # so, how is the new type supposed to look?
        # maybe create the first
        t1 = MyModelBase.__new__(cls, name, bases, attr)
        # and pass it''s data on to the next?
        name = t1.__name__
        bases = tuple(t1.mro())
        attr = t1.__dict__.copy()
        t2 = MyMixin.__new__(cls, name, bases, attr)
        return t2

class Model(object):
    __metaclass__ = MyModelBase # inherits from `ModelBase`

class MyModel(Model):
    __metaclass__ = ChainedMeta

print MyModel.MyModelBase
print MyModel.MyMixin

Como puede ver, esto ya implica algunas conjeturas, ya que realmente no sabe lo que hacen las otras metaclases. Si ambas metaclases son realmente simples, esto podría funcionar, pero no tendría demasiada confianza en una solución como esta.

Escribir una metaclase para las metaclases que fusiona múltiples bases se deja como un ejercicio para el lector;