Crear método de instancia en metaclase usando parcial en Python 3

Question

Al usar metaclases, intento crear un método de instancia simplificando un método de instancia existente. El problema es que parcial no funciona con el método de instancia. Este es un ejemplo sencillo de lo que trato de lograr:

from functools import partial 

class Aclass(object): 

    def __init__(self, value): 
     self._value = value 

    def complex(self, a, b):            
     return a + b + self._value 

class Atype(type): 

    def __new__(cls, name, bases, attrs): 
     return super(Atype, cls).__new__(cls, name, (Aclass,) + bases, attrs) 

    def __init__(cls, name, bases, attrs): 
     setattr(cls, 'simple', partial(cls.complex, b=1)) 

class B(metaclass=Atype): 
    pass 

b = B(10) 

print(b.complex(1, 2)) 
print(b.simple(1)) 

y la salida es:

13 
Traceback (most recent call last): 
    File "metatest.py", line 22, in <module> 
    print(b.simple(1)) 
TypeError: complex() takes exactly 3 non-keyword positional arguments (1 given) 

He resuelto utilizando lambda cambiante:

setattr(cls, 'simple', partial(cls.complex, b=1)) 

a:

setattr(cls, 'simple', lambda self, x: cls.complex(self, x, b=1)) 

pero es feo d tiene problemas con los parámetros opcionales.

Podría crear estos métodos en la instancia __init__ pero supongo que tiene más sentido, y es más eficiente hacerlo en la clase __init__ usando metaclases.

¿Alguna idea de cómo hacerlo correctamente?

Answer 1

Bueno, estoy un poco familiarizado con el manejo aún método Python 3 - la cosa más simple que podía pensar está reescribiendo partial por lo que conserva el primer argumento de la llamada original, a continuación, inserta los parámetros "parciales".

Funcionó con su ejemplo, pero necesita pruebas con patrones más complejos.

from functools import wraps 

class Aclass(object): 
    def __init__(self, value): 
     self._value = value 

    def complex(self, a, b):            
     return a + b + self._value 

def repartial(func, *parameters, **kparms): 
    @wraps(func) 
    def wrapped(self, *args, **kw): 
     kw.update(kparms) 
     return func(self, *(args + parameters), **kw) 
    return wrapped 

class Atype(type): 
    def __new__(cls, name, bases, attrs): 
     return super(Atype, cls).__new__(cls, name, (Aclass,) + bases, attrs) 

    def __init__(cls, name, bases, attrs): 
     setattr(cls, 'simple', repartial(cls.complex, b=1)) 

class B(metaclass=Atype): 
    pass 

b = B(10) 

print(b.complex(1, 2)) 
print(b.simple(1)) 

Answer 2

El problema es que el objeto devuelto por functools.partial() es un objeto exigible, no una función. Así que aparentemente Python no se preocupa por una no función que intente actuar como tal en este contexto. Una solución es crear una función como un contenedor para el objeto partial. solución

class Atype(type): 

    def __init__(cls, name, bases, attrs): 
     simple = partial(cls.complex, b=1) 
     setattr(cls, 'simple', lambda cls, a: simple(cls, a)) 

de jsbueno (una reimplementación de partial que devuelve una función real) es bueno. Realmente no sé por qué functools.partial() no funciona de esa manera; no poder usarlo en este contexto es una trampa sorprendente.

Answer 3

En lugar de utilizar partial, que acababa de definir la clase Atype así:

class Atype(type): 

    def __new__(cls, name, bases, attrs): 
     return super(Atype, cls).__new__(cls, name, (Aclass,) + bases, attrs) 

    def __init__(cls, name, bases, attrs): 
     def simple(self, a): 
      return cls.complex(self, a, 1) 
     setattr(cls, 'simple', simple) 

__init__() El método también se puede escribir de forma más compacta:

def __init__(cls, name, bases, attrs): 
    setattr(cls, 'simple', lambda self, a: cls.complex(self, a, 1))