Come per la connessione a un segnale GObject in python, senza di essa mantenendo un riferimento al connettore?
Domanda
Il problema è fondamentalmente questo, in GObject e GTK binding di Python. Supponiamo di avere una classe che si lega a un segnale quando costruito:
class ClipboardMonitor (object):
def __init__(self):
clip = gtk.clipboard_get(gtk.gdk.SELECTION_CLIPBOARD)
clip.connect("owner-change", self._clipboard_changed)
Il problema è ora che, alcuna istanza di ClipboardMonitor potrà mai morire . Il clipboard gtk è un oggetto a livello di applicazione, e il collegamento ad essa mantiene un riferimento all'oggetto, dato che usiamo il self._clipboard_changed
callback.
sto discutendo come risolvere questo utilizzando riferimenti deboli (modulo weakref), ma devo ancora a venire con un piano. Qualcuno ha un'idea di come passare un callback per la registrazione del segnale, e lo hanno comportarsi come un riferimento debole (se la richiamata segnale viene chiamato quando l'istanza ClipboardMonitor è fuori portata, dovrebbe essere un no-op).
Aggiunta: formulata indipendentemente GObject o GTK +:
Come si fa a fornire un metodo di callback per un oggetto opaco, con la semantica weakref? Se l'oggetto di collegamento fa di portata, dovrebbe essere eliminato e il callback dovrebbe agire come un no-op; il connectee non dovrebbe contenere un riferimento al connettore.
Per chiarire: ho esplicitamente voglio evitare di dover chiamare un metodo "destructor / finalizzatore"
Soluzione
Il metodo standard è quello di scollegare il segnale. Questo però ha bisogno di avere un metodo distruttore simile nella tua classe, chiamato esplicitamente dal codice che mantiene l'oggetto. Ciò è necessario, perché altrimenti si otterrà dipendenza circolare.
class ClipboardMonitor(object):
[...]
def __init__(self):
self.clip = gtk.clipboard_get(gtk.gdk.SELECTION_CLIPBOARD)
self.signal_id = self.clip.connect("owner-change", self._clipboard_changed)
def close(self):
self.clip.disconnect(self.signal_id)
Come lei ha sottolineato, è necessario weakrefs se si vuole evitare di distruggere esplicita. Vorrei scrivere una fabbrica di callback deboli, come:
import weakref
class CallbackWrapper(object):
def __init__(self, sender, callback):
self.weak_obj = weakref.ref(callback.im_self)
self.weak_fun = weakref.ref(callback.im_func)
self.sender = sender
self.handle = None
def __call__(self, *things):
obj = self.weak_obj()
fun = self.weak_fun()
if obj is not None and fun is not None:
return fun(obj, *things)
elif self.handle is not None:
self.sender.disconnect(self.handle)
self.handle = None
self.sender = None
def weak_connect(sender, signal, callback):
wrapper = CallbackWrapper(sender, callback)
wrapper.handle = sender.connect(signal, wrapper)
return wrapper
(questo è un codice di prova, funziona per me - probabilmente si dovrebbe adattare questo pezzo alle proprie esigenze). Alcune note:
- Sto Memorizzazione oggetto callback e la funzione separatelly. Non si può semplicemente fare un weakref di un metodo vincolato, perché i metodi bound sono oggetti molto temporanei. In realtà
weakref.ref(obj.method)
distruggerà l'oggetto metodo vincolato immediatamente dopo aver creato un weakref. Non ho controllato se è necessario per memorizzare un weakref alla funzione di troppo ... Credo che se il codice è statico, probabilmente si può evitare questo. - L'avvolgitore oggetto verrà sottrarsi mittente segnale quando rileva che il riferimento debole cessato di esistere. Ciò è necessario anche per distruggere la dipendenza circolare tra la CallbackWrapper e l'oggetto segnale mittente.
Altri suggerimenti
(Questa risposta tracce mio progresso)
Questa seconda versione sarà scollegare pure; Ho una funzione convenienza per gobjects, ma in realtà ho bisogno di questa classe per un caso più generale -. Sia per callback di segnale D-Bus e callback GObject
In ogni caso, ciò che si può chiamare lo stile di implementazione WeakCallback
? Si tratta di un incapsulamento molto pulita della richiamata debole, ma con la specializzazione gobject / dbus unnoticeably appiccicato. Batte scrivendo due sottoclassi per quei due casi.
import weakref
class WeakCallback (object):
"""A Weak Callback object that will keep a reference to
the connecting object with weakref semantics.
This allows to connect to gobject signals without it keeping
the connecting object alive forever.
Will use @gobject_token or @dbus_token if set as follows:
sender.disconnect(gobject_token)
dbus_token.remove()
"""
def __init__(self, obj, attr):
"""Create a new Weak Callback calling the method @obj.@attr"""
self.wref = weakref.ref(obj)
self.callback_attr = attr
self.gobject_token = None
self.dbus_token = None
def __call__(self, *args, **kwargs):
obj = self.wref()
if obj:
attr = getattr(obj, self.callback_attr)
attr(*args, **kwargs)
elif self.gobject_token:
sender = args[0]
sender.disconnect(self.gobject_token)
self.gobject_token = None
elif self.dbus_token:
self.dbus_token.remove()
self.dbus_token = None
def gobject_connect_weakly(sender, signal, connector, attr, *user_args):
"""Connect weakly to GObject @sender's @signal,
with a callback in @connector named @attr.
"""
wc = WeakCallback(connector, attr)
wc.gobject_token = sender.connect(signal, wc, *user_args)
in realtà non ancora provato, ma:
class WeakCallback(object):
"""
Used to wrap bound methods without keeping a ref to the underlying object.
You can also pass in user_data and user_kwargs in the same way as with
rpartial. Note that refs will be kept to everything you pass in other than
the callback, which will have a weakref kept to it.
"""
def __init__(self, callback, *user_data, **user_kwargs):
self.im_self = weakref.proxy(callback.im_self, self._invalidated)
self.im_func = weakref.proxy(callback.im_func)
self.user_data = user_data
self.user_kwargs = user_kwargs
def __call__(self, *args, **kwargs):
kwargs.update(self.user_kwargs)
args += self.user_data
self.im_func(self.im_self, *args, **kwargs)
def _invalidated(self, im_self):
"""Called by the weakref.proxy object."""
cb = getattr(self, 'cancel_callback', None)
if cb is not None:
cb()
def add_cancel_function(self, cancel_callback):
"""
A ref will be kept to cancel_callback. It will be called back without
any args when the underlying object dies.
You can wrap it in WeakCallback if you want, but that's a bit too
self-referrential for me to do by default. Also, that would stop you
being able to use a lambda as the cancel_callback.
"""
self.cancel_callback = cancel_callback
def weak_connect(sender, signal, callback):
"""
API-compatible with the function described in
http://stackoverflow.com/questions/1364923/. Mostly used as an example.
"""
cb = WeakCallback(callback)
handle = sender.connect(signal, cb)
cb.add_cancel_function(WeakCallback(sender.disconnect, handle))