8

Using metaclasses, I am trying to create an instance method by simplifying an existing instance method. The problem is that partial does not work with instance method. This is a simple example of what I try to achieve:

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

and the output is:

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)

I have solved using lambda changing:

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

to:

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

but it is ugly and has problems with optional parameters.

I could create these method at the instance __init__ but I guess it makes more sense, and is more efficient to do it on class __init__using metaclasses.

Any ideas how to do it properly?

martineau
  • 119,623
  • 25
  • 170
  • 301
Hernan
  • 5,811
  • 10
  • 51
  • 86
  • @martineau: I am all for using the python-3.x tag, but I don't see any reason for not using "python" alongside it. Also - would not "python3" be a cleaner tag? – jsbueno Mar 02 '11 at 01:15
  • @jsbueno: Agreed -- but it won't let me change python-3.x to python3. – martineau Mar 02 '11 at 01:54
  • @jsbueno: The tag is python-3.x, I don't know how (if at all) these things are decided. I suspect it could be discussed on meta, and then changed if there is support for it. In any case python3 is a synonym, so you can type it in, it will be remapped. – Lennart Regebro Mar 02 '11 at 08:10

3 Answers3

6

Well, I am a bit unfamiliar with Python 3 method handling yet - the simplest thing I could think of is rewriting partial so that it preserves the first argument from the original call, then inserts the "partial" parameters.

It worked with your example, but it needs testing with more complex patterns.

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))
jsbueno
  • 99,910
  • 10
  • 151
  • 209
  • I think `wrapper()` would be a better -- as in more descriptive and correct -- name for the nested function you've called `wrapped()` in `repartial()`. Just a nit-pick for an otherwise excellent answer. – martineau Feb 08 '12 at 14:23
3

Instead of using partial, I'd just define class Atype like this:

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)

The __init__() method can also be written more compactly:

def __init__(cls, name, bases, attrs):
    setattr(cls, 'simple', lambda self, a: cls.complex(self, a, 1))
martineau
  • 119,623
  • 25
  • 170
  • 301
  • Yes, I don't really think a metaclass (or `functools.partial()`) is needed here. Perhaps this was just a simple example that demonstrated the problem, however, and metaclasses are really needed in user482819's actual application. – kindall Mar 02 '11 at 14:29
  • Indeed,. I need to create instance methods dynamically based on specific properties of the class using the metaclass. – Hernan Mar 02 '11 at 19:21
1

The problem is that the object returned by functools.partial() is a callable object, not a function. So apparently Python doesn't care for a non-function trying to act like one in this context. One solution is to create a function as a wrapper for the partial object.

class Atype(type):

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

jsbueno's solution (a reimplementation of partial that returns a real function) is good though. I really don't know why functools.partial() doesn't work that way; not being able to use it in this context is a surprising pitfall.

kindall
  • 178,883
  • 35
  • 278
  • 309
  • 1
    This is a good way to workaround `partial`'s pitfall, but I think my own answer is better ;-) because, for one thing, it has less function-call overhead. BTW, another cause of the problem no one has mentioned so far is that `cls.complex` is an unbound method. – martineau Mar 02 '11 at 02:05
  • 1
    In Python 3 it doesn't appear that there are unbound methods; `Aclass.complex` is a function. – kindall Mar 02 '11 at 05:15
  • 1
    It is interesting that when the partial is given as fset or fget of a property, then it works fine. – Hernan Mar 02 '11 at 22:06
  • 1
    I have just found this article from Guido and it is very relevant to this post: http://python-history.blogspot.com/2010/06/inside-story-on-new-style-classes.html – Hernan Mar 02 '11 at 22:47
  • So `functools.partial()` needs to return an object with a `__get()__` method that does the right thing... – kindall Mar 02 '11 at 23:19