want to be able to delay a call like ``foo(spam, badger)`` by dumping
``foo``, ``spam`` and ``badger`` to disk and loading them again later.
Sometimes the callable ``foo`` is actually a bound method, e.g.
``bar.baz``, but in such cases, pickle doesn't work by default because
it doesn't know how to pickle/unpickle instancemethod objects.
I was thinking of doing something like::
.... func_name = method.im_func.__name__>>def pickle_instancemethod(method):
.... cls = method.im_class
.... obj = method.im_self
.... return unpickle_instancemethod, (func_name, cls, obj)
....
.... if obj is None:>>def unpickle_instancemethod(func_name, cls, obj):
.... return getattr(cls, func_name)
.... else:
.... return getattr(obj, func_name)
....
.... def __init__(self, foo, bar):>>class C(object):
.... self.foo = foo
.... self.bar = bar
.... def baz(self):
.... return self.foo, self.bar
....
.... pickle_instancemethod,>>copy_reg.pickle(type(C.baz),
.... unpickle_instancemethod)
This seems to basically do the right thing on the few simple things I've
tried::
(42, 'badger')>>c = C(42, 'badger')
new_c_baz = pickle.loads(pickle.dumps(c.baz))
new_c_baz()
('eki', 'fekang')>>new_C_baz = pickle.loads(pickle.dumps(C.baz))
new_C_baz(C('eki', 'fekang'))
Does this approach seem sound? Am I going to run into some weird
problems doing it this way?
Thanks,
STeVe