ActiveState Code

Reference to a bound method that permits the associated object to be garbage collected.

Comments

1. 1. At 7:22 a.m. on 10 dec 2001, Frédéric Jolliton said:

   Simpler implementation. 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
   

2. 2. At 7:44 a.m. on 10 dec 2001, Frédéric Jolliton said:

   Simpler implementation. Hum, of course it's better to handle error correctly.

   Replace

   print 'No more object'
   return
   

   with

   raise TypeError , 'Method called on dead object'
   

3. 3. At 9:32 a.m. on 10 dec 2001, Frédéric Jolliton said:

   Simpler implementation (without typo). 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 )
   

4. 4. At 10:31 a.m. on 10 dec 2001, Frédéric Jolliton said:

   Alternative implementation. 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
   

5. 5. At 6:21 a.m. on 25 jan 2004, Anonymous said:

   Another version. 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
   

Sign in to comment

Tags

• oop