2 vote(s)

Add comment

Number of comments: 5

Simpler implementation, Frédéric Jolliton, 2001/12/10
It is not exactly the same thing, but I think it's simpler for specific uses:

from weakref import ref

class X :
	def f( self , name ) : print 'hi' , name
	def __del__( self ) : print 'Bye'

class WeakMethod :
	def __init__( self , f ) :
		self.f = f.im_func
		self.c = ref( f.im_self )
	def __call__( self , *arg ) :
		if self.c() == None :
			print 'No more object'
			return
		apply( self.f , ( self.c , ) + arg )

x = X()
f = WeakMethod( x.f )
f( 'foo' )
del x
f( 'bar' )

Output is:

hi foo
Bye
No more object

Add comment

Simpler implementation, Frédéric Jolliton, 2001/12/10
Hum, of course it's better to handle error correctly. Replace

    print 'No more object'
    return

with

    raise TypeError , 'Method called on dead object'

Add comment

Simpler implementation (without typo), Frédéric Jolliton, 2001/12/10
Sorry, I've missed the dereference on self.c. The corrected class is:

import weakref

class WeakMethod :
	def __init__( self , f ) :
		self.f = f.im_func
		self.c = weakref.ref( f.im_self )
	def __call__( self , *arg ) :
		if self.c() == None :
			raise TypeError , 'Method called on dead object'
		apply( self.f , ( self.c() , ) + arg )

Add comment

Alternative implementation, Frédéric Jolliton, 2001/12/10
Here is a version (hopefully the last from me) which support both free/bounded method:

import weakref

class WeakMethodBound :
	def __init__( self , f ) :
		self.f = f.im_func
		self.c = weakref.ref( f.im_self )
	def __call__( self , *arg ) :
		if self.c() == None :
			raise TypeError , 'Method called on dead object'
		apply( self.f , ( self.c() , ) + arg )

class WeakMethodFree :
	def __init__( self , f ) :
		self.f = weakref.ref( f )
	def __call__( self , *arg ) :
		if self.f() == None :
			raise TypeError , 'Function no longer exist'
		apply( self.f() , arg )

def WeakMethod( f ) :
	try :
		f.im_func
	except AttributeError :
		return WeakMethodFree( f )
	return WeakMethodBound( f )

Example:

import WeakMethod

class X :
	def f( self , name ) : print 'hi' , name

def x( name ) : print 'hi' , name

f1 = WeakMethod.WeakMethod( x )
f1( 'foo' )
del x
f1( 'bar' ) # exception

x = X()
f2 = WeakMethod.WeakMethod( x.f )
f2( 'foo' )
del x
f2( 'bar' ) # exception

Add comment

Another version, Not specified Not specified, 2004/01/25
Here's another version, that uses module new to return a true bound-method, and works with functions and unbounded methods also.

import weakref
import new


class ref(object):

    def __init__(self, method):
        try:
            if method.im_self is not None:
                # bound method
                self._obj = weakref.ref(method.im_self)
            else:
                # unbound method
                self._obj = None
            self._func = method.im_func
            self._class = method.im_class
        except AttributeError:
            # not a method
            self._obj = None
            self._func = method
            self._class = None


    def __call__(self):
        '''Return a new bound-method like the original, or the
        original function if refers just to a function or unbound
        method.
        Returns None if the original object doesn't exist
        '''
        if self.is_dead():
            return None
        if self._obj is not None:
            # we have an instance: return a bound method
            return new.instancemethod(self._func, self._obj(), self._class)
        else:
            # we don't have an instance: return just the function
            return self._func
        

    def is_dead(self):
        '''Returns True if the referenced callable was a bound method and
        the instance no longer exists. Otherwise, return False.
        '''
        return self._obj is not None and self._obj() is None


    def __eq__(self, other):
        try:
            return type(self) is type(other) and self() == other()
        except:
            return False


    def __ne__(self, other):
        return not self == other
                                                      

Note that calling the ref has the same semanthics as calling a weakref.ref: if the referent died, it returns None. If you want something like weakref.proxy:

class proxy(ref):    
    '''Exactly like ref, but calling it will cause the referent method to
    be called with the same arguments. If the referent's object no longer lives,
    ReferenceError is raised.
    '''

    def __call__(self, *args, **kwargs):
        func = ref.__call__(self)
        if func is None:
            raise ReferenceError('object is dead')
        else:
            return func(*args, **kwargs)


    def __eq__(self, other):
        try:
            func1 = ref.__call__(self)
            func2 = ref.__call__(other)
            return type(self) == type(other) and func1 == func2
        except:
            return False 

Add comment