def __init__(self, method, notifyDead=None): """The method must be bound. notifyDead will be called when object that method is bound to dies. """ assert ismethod(method) if method.im_self is None: raise ValueError, "We need a bound method!" if notifyDead is None: self.objRef = WeakRef(method.im_self) else: self.objRef = WeakRef(method.im_self, notifyDead) self.fun = method.im_func self.cls = method.im_class
def apply(widget: tkImgWidgetsT, img: Handle | None) -> tkImgWidgetsT: """Set the image in a widget. This tracks the widget, so later reloads will affect the widget. If the image is None, it is instead unset. """ ref = WeakRef(widget, _label_destroyed) if img is None: widget['image'] = None try: old = _wid_tk.pop(ref) except KeyError: pass else: old._decref(ref) return widget try: old = _wid_tk[ref] except KeyError: pass else: if old is img: # Unchanged. return widget old._decref(ref) img._incref(ref) _wid_tk[ref] = img cached_img = img._cached_tk if cached_img is not None: widget['image'] = cached_img else: # Need to load. widget['image'] = img._request_load() return widget
def __init__(self, method, notifyDead=None): """The method must be bound. notifyDead will be called when object that method is bound to dies. """ assert ismethod(method) if method.__self__ is None: raise ValueError('Unbound methods cannot be weak-referenced.') self.notifyDead = None if notifyDead is None: self.objRef = WeakRef(method.__self__) else: self.notifyDead = notifyDead self.objRef = WeakRef(method.__self__, self.__onNotifyDeadObj) self.fun = method.__func__ self.cls = method.__self__.__class__
def _register_watcher(self, python_watcher, ffi_watcher): self._active_watchers[ffi_watcher] = WeakRef( python_watcher, self.__make_watcher_ref_callback(type(python_watcher), self._active_watchers, ffi_watcher, repr(python_watcher)))
def test_full_sweep_clears_weakrefs(self, sweep_method='incrgc'): # like test_full_sweep_clears_weakrefs_in_interface, # but directly using a weakref. This is the simplest version of the test. from weakref import ref as WeakRef gc.disable() self.addCleanup(gc.enable) jar = ClosedConnection(self) cache = self._makeOne(jar, 0) # Make a persistent object, put it in the cache as saved class P(self._getRealPersistentClass()): """A real persistent object that can be weak referenced.""" p = P() p._p_jar = jar p._p_oid = b'\x01' * 8 cache[p._p_oid] = p p._p_changed = False # Now, take a weak reference to it ref = WeakRef(p) # Remove the original object del p # Sweep the cache. getattr(cache, sweep_method)() # Now, try to use that weak reference; it should be gone. p = ref() self.assertIsNone(p)
def testTreeNode(): class WS: def __init__(self, s): self.s = s def __call__(self, msg): print 'WS#', self.s, ' received msg ', msg def __str__(self): return self.s def testPreNotifyRoot(dead): print 'testPreNotifyROOT heard notification of', ` dead ` node = _TopicTreeNode((ALL_TOPICS, ), WeakRef(testPreNotifyRoot)) boo, baz, bid = WS('boo'), WS('baz'), WS('bid') node.addCallable(boo) node.addCallable(baz) node.addCallable(boo) assert node.getCallables() == [boo, baz] assert node.hasCallable(boo) node.removeCallable(bid) # no-op assert node.hasCallable(baz) assert node.getCallables() == [boo, baz] node.removeCallable(boo) assert node.getCallables() == [baz] assert node.hasCallable(baz) assert not node.hasCallable(boo) node.removeCallable(baz) assert node.getCallables() == [] assert not node.hasCallable(baz) node2 = node.createSubtopic('st1', ('st1', )) node3 = node.createSubtopic('st2', ('st2', )) cb1, cb2, cb = WS('st1_cb1'), WS('st1_cb2'), WS('st2_cb') node2.addCallable(cb1) node2.addCallable(cb2) node3.addCallable(cb) node2.createSubtopic('st3', ('st1', 'st3')) node2.createSubtopic('st4', ('st1', 'st4')) print str(node) assert str( node) == ' (st1: st1_cb1 st1_cb2 (st4: ) (st3: )) (st2: st2_cb )' # verify send message, and that a dead listener does not get sent one delivered = node2.sendMessage('hello') assert delivered == 2 del cb1 delivered = node2.sendMessage('hello') assert delivered == 1 assert _NodeCallback.notified == 1 done('testTreeNode')
def addTopic(self, topic, listener): """Add topic to tree if doesnt exist, and add listener to topic node""" assert isinstance(topic, tuple) topicNode = self.__getTreeNode(topic, make=True) weakCB = topicNode.addCallable(listener) assert topicNode.hasCallable(listener) theList = self.__callbackDict.setdefault(weakCB, []) assert self.__callbackDict.has_key(weakCB) # add it only if we don't already have it try: weakTopicNode = WeakRef(topicNode) theList.index(weakTopicNode) except ValueError: theList.append(weakTopicNode) assert self.__callbackDict[weakCB].index(weakTopicNode) >= 0
def unsubAll(self, topicList, onNoSuchTopic): """Unsubscribe all listeners registered for any topic in topicList. If a topic in the list does not exist, and onNoSuchTopic is not None, a call to onNoSuchTopic(topic) is done for that topic.""" for topic in topicList: node = self.__getTreeNode(topic) if node is not None: weakCallables = node.clearCallables() for callable in weakCallables: weakNodes = self.__callbackDict[callable] success = _removeItem(WeakRef(node), weakNodes) assert success == True if weakNodes == []: del self.__callbackDict[callable] elif onNoSuchTopic is not None: onNoSuchTopic(topic)
def __new__(klass, publisher, target, method): self = Handle.__new__(klass, publisher) self.__target = WeakRef(target) self.__method = method return self
def __new__(klass, publisher, function): self = Handle.__new__(klass, publisher) self.__function = WeakRef(function) return self
def __init__(self, obj: Component) -> None: self._uid = UniqueIdentifier[obj] self._ref = WeakRef(obj)