Python weakref.ref函数代码示例

 def __init__(self, c):
     if hasattr(c,'im_func'):
         self._func = weakref.ref(c.im_func)
         self._ob = weakref.ref(c.im_self)
     else:
         self._func = weakref.ref(c)
         self._ob = None

 def test_weakref_slots(self):
     """Check that classes are using slots and are weak-referenceable"""
     for cls in [self.xs_cls, self.hxs_cls, self.xxs_cls]:
         x = cls()
         weakref.ref(x)
         assert not hasattr(x, '__dict__'), "%s does not use __slots__" % \
             x.__class__.__name__

    def test_no_refcycle_through_target(self):
        class RunSelfFunction(object):
            def __init__(self, should_raise):
                # The links in this refcycle from Thread back to self
                # should be cleaned up when the thread completes.
                self.should_raise = should_raise
                self.thread = threading.Thread(target=self._run, args=(self,), kwargs={"yet_another": self})
                self.thread.start()

            def _run(self, other_ref, yet_another):
                if self.should_raise:
                    raise SystemExit

        cyclic_object = RunSelfFunction(should_raise=False)
        weak_cyclic_object = weakref.ref(cyclic_object)
        cyclic_object.thread.join()
        del cyclic_object
        self.assertIsNone(
            weak_cyclic_object(), msg=("%d references still around" % sys.getrefcount(weak_cyclic_object()))
        )

        raising_cyclic_object = RunSelfFunction(should_raise=True)
        weak_raising_cyclic_object = weakref.ref(raising_cyclic_object)
        raising_cyclic_object.thread.join()
        del raising_cyclic_object
        self.assertIsNone(
            weak_raising_cyclic_object(),
            msg=("%d references still around" % sys.getrefcount(weak_raising_cyclic_object())),
        )

    def test_compatibility_layer(self):
        # Create a new pool
        pool = Pool()
        parent_pool_ref = weakref.ref(pool)
        pool = svn_pool_create(Pool(pool))
        pool_ref = weakref.ref(pool)

        # Make sure proper exceptions are raised with incorrect input
        self.assertRaises(TypeError, lambda: svn_pool_create("abcd"))

        # Test whether pools are destroyed properly
        pool = svn_pool_create(pool)
        self.assertNotNone(pool_ref())
        self.assertNotNone(parent_pool_ref())
        del pool
        self.assertNone(pool_ref())
        self.assertNone(parent_pool_ref())

        # Ensure that AssertionErrors are raised when a pool is deleted twice
        newpool = Pool()
        newpool2 = Pool(newpool)
        svn_pool_clear(newpool)
        self.assertRaises(AssertionError, lambda: libsvn.core.apr_pool_destroy(newpool2))
        self.assertRaises(AssertionError, lambda: svn_pool_destroy(newpool2))
        svn_pool_destroy(newpool)
        self.assertRaises(AssertionError, lambda: svn_pool_destroy(newpool))

        # Try to allocate memory from a destroyed pool
        self.assertRaises(AssertionError, lambda: svn_pool_create(newpool))

        # Create and destroy a pool
        svn_pool_destroy(svn_pool_create())

        # Make sure anonymous pools are destroyed properly
        anonymous_pool_ref = weakref.ref(svn_pool_create())
        self.assertNone(anonymous_pool_ref())

        # Try to cause a segfault using apr_terminate
        apr_terminate()
        apr_initialize()
        apr_terminate()
        apr_terminate()

        # Destroy the application pool
        svn_pool_destroy(libsvn.core.application_pool)

        # Double check that the application pool has been deleted
        self.assertNone(libsvn.core.application_pool)

        # Try to allocate memory from the old application pool
        self.assertRaises(AssertionError, lambda: svn_pool_create(application_pool))

        # Bring the application pool back to life
        svn_pool_create()

        # Double check that the application pool has been created
        self.assertNotNone(libsvn.core.application_pool)

        # We can still destroy and create pools at will
        svn_pool_destroy(svn_pool_create())

def safeRef(target, onDelete = None):
    """Return a *safe* weak reference to a callable target

    target -- the object to be weakly referenced, if it's a
        bound method reference, will create a BoundMethodWeakref,
        otherwise creates a simple weakref.
    onDelete -- if provided, will have a hard reference stored
        to the callable to be called after the safe reference
        goes out of scope with the reference object, (either a
        weakref or a BoundMethodWeakref) as argument.
    """
    if hasattr(target, '__self__'):
        if target.__self__ is not None:
            # Turn a bound method into a BoundMethodWeakref instance.
            # Keep track of these instances for lookup by disconnect().
            assert hasattr(target, '__func__'), """safeRef target %r has __self__, but no __func__, don't know how to create reference"""%( target,)
            reference = get_bound_method_weakref(
                target=target,
                onDelete=onDelete
            )
            return reference
    if callable(onDelete):
        return weakref.ref(target, onDelete)
    else:
        return weakref.ref( target )

	def load(self, db):
		data = db("SELECT value FROM last_active_settlement WHERE type = \"PLAYER\"")
		self._last_player_settlement = weakref.ref(WorldObject.get_object_by_id(data[0][0])) if data else None
		data = db("SELECT value FROM last_active_settlement WHERE type = \"ANY\"")
		self._last_settlement = weakref.ref(WorldObject.get_object_by_id(data[0][0])) if data else None
		data = db("SELECT value FROM last_active_settlement WHERE type = \"LAST_NONE_FLAG\"")
		self._last_player_settlement_hovered_was_none = bool(data[0][0])

def safe_ref(target, on_delete=None):
    """Return a *safe* weak reference to a callable target.

    - ``target``: The object to be weakly referenced, if it's a bound
      method reference, will create a BoundMethodWeakref, otherwise
      creates a simple weakref.

    - ``on_delete``: If provided, will have a hard reference stored to
      the callable to be called after the safe reference goes out of
      scope with the reference object, (either a weakref or a
      BoundMethodWeakref) as argument.
    """
    try:
        im_self = get_self(target)
    except AttributeError:
        if callable(on_delete):
            return weakref.ref(target, on_delete)
        else:
            return weakref.ref(target)
    else:
        if im_self is not None:
            # Turn a bound method into a BoundMethodWeakref instance.
            # Keep track of these instances for lookup by disconnect().
            assert hasattr(target, 'im_func') or hasattr(target, '__func__'), (
                "safe_ref target %r has im_self, but no im_func, "
                "don't know how to create reference" % target)
            reference = BoundMethodWeakref(target=target, on_delete=on_delete)
            return reference

    def disableNotifications(self, observable=None, notification=None, observer=None):
        """
        Disable all posts of **notification** from **observable** posted
        to **observer** observing.

        * **observable** The object that the notification belongs to. This is optional.
          If no *observable* is given, *all* *notifications* will be disabled for *observer*.
        * **notification** The name of the notification. This is optional.
          If no *notification* is given, *all* notifications for *observable*
          will be disabled for *observer*.
        * **observer** The specific observer to not send posts to. If no
          *observer* is given, the appropriate notifications will not
          be posted to any observers.

        This object will retain a count of how many times it has been told to
        disable notifications for *notification* and *observable*. It will not
        enable new notifications until the *notification* and *observable*
        have been released the same number of times.
        """
        if observable is not None:
            observable = weakref.ref(observable)
        if observer is not None:
            observer = weakref.ref(observer)
        key = (notification, observable, observer)
        if key not in self._disabled:
            self._disabled[key] = 0
        self._disabled[key] += 1

    def addObserver(self, observer, methodName, notification=None, observable=None):
        """
        Add an observer to this notification dispatcher.

        * **observer** An object that can be referenced with weakref.
        * **methodName** A string epresenting the method to be called
          when the notification is posted.
        * **notification** The notification that the observer should
          be notified of. If this is None, all notifications for
          the *observable* will be posted to *observer*.
        * **observable** The object to observe. If this is None,
          all notifications with the name provided as *notification*
          will be posted to the *observer*.

        If None is given for both *notification* and *observable*
        **all** notifications posted will be sent to the method
        given method of the observer.

        The method that will be called as a result of the action
        must accept a single *notification* argument. This will
        be a :class:`Notification` object.
        """
        if observable is not None:
            observable = weakref.ref(observable)
        observer = weakref.ref(observer)
        key = (notification, observable)
        if key not in self._registry:
            self._registry[key] = ObserverDict()
        assert observer not in self._registry[key], "An observer is only allowed to have one callback for a given notification + observable combination."
        self._registry[key][observer] = methodName

def test_keep_alive_noleak2():
    # Even if the above would not work ...
    
    class Foo:
        pass
    
    # Create a session and an object that has a reference to it (like Model)
    session = app.Session('test')
    foo = Foo()
    foo.session = session
    
    # Let the session keep the object alive, so it keeps its reference
    session.keep_alive(foo)
    
    session_ref = weakref.ref(session)
    foo_ref = weakref.ref(foo)
    
    # Removing session wont delete it
    del session
    gc.collect()
    assert session_ref() is not None
    
    # But removing both will; gc is able to clear circular ref
    del foo
    gc.collect()
    assert session_ref() is None
    assert foo_ref() is None

    def holdNotifications(self, observable=None, notification=None, observer=None):
        """
        Hold all notifications posted to all objects observing
        **notification** in **observable**.

        * **observable** The object that the notification belongs to. This is optional.
          If no *observable* is given, *all* *notifications* will be held.
        * **notification** The name of the notification. This is optional.
          If no *notification* is given, *all* notifications for *observable*
          will be held.
         * **observer** The specific observer to not hold notifications for.
           If no *observer* is given, the appropriate notifications will be
           held for all observers.

        Held notifications will be posted after the matching *notification*
        and *observable* have been passed to :meth:`Notification.releaseHeldNotifications`.
        This object will retain a count of how many times it has been told to
        hold notifications for *notification* and *observable*. It will not
        post the notifications until the *notification* and *observable*
        have been released the same number of times.
        """
        if observable is not None:
            observable = weakref.ref(observable)
        if observer is not None:
            observer = weakref.ref(observer)
        key = (notification, observable, observer)
        if key not in self._holds:
            self._holds[key] = dict(count=0, notifications=[])
        self._holds[key]["count"] += 1

def test_keep_alive_noleak1():
    
    class Foo:
        pass
    
    # Create a session and an object that has a reference to it (like Model)
    session = app.Session('test')
    foo = Foo()
    foo.session = session
    
    # Let the session keep the object alive, so it keeps its reference
    session.keep_alive(foo)
    
    session_ref = weakref.ref(session)
    foo_ref = weakref.ref(foo)
    
    # Removing object wont delete it
    del foo
    gc.collect()
    assert foo_ref() is not None
    
    # But closing the session will; session clears up after itself
    session.close()
    gc.collect()
    assert foo_ref() is None

  def testMemoryIsFreed(self):
    # Note: we use `set` values for components and metadata because we need
    # to construct weakrefs to them.  Other builtin types, such as `list` and
    # `tuple`, do not support weakrefs.
    ct1 = CT(set([1, 2]), set(['no', 'leaks']))
    ct2 = CT(set([3, 4]), set(['no', 'leaks']))
    ct3 = CT(set([5, 6]), set(['other', 'metadata']))

    # Note: map_structure exercises flatten, pack_sequence_as, and
    # assert_same_structure.
    func = lambda x, y: x | y
    ct4 = nest.map_structure(func, ct1, ct2, expand_composites=True)

    # Check that the exception-raising path in assert_same_structure
    # doesn't leak any objects.
    with self.assertRaisesRegexp(ValueError,
                                 ".*don't have the same nested structure.*"):
      nest.map_structure(func, ct2, ct3, expand_composites=True)
    if hasattr(sys, 'exc_clear'):
      sys.exc_clear()  # Remove any references in exception stack traces.

    refs = []
    for ct in [ct1, ct2, ct3, ct4]:
      refs.append(weakref.ref(ct))
      refs.append(weakref.ref(ct.components))
      refs.append(weakref.ref(ct.metadata))
    del ct  # pylint: disable=undefined-loop-variable

    for ref in refs:
      self.assertIsNotNone(ref())

    del ct1, ct2, ct3, ct4
    gc.collect()
    for ref in refs:
      self.assertIsNone(ref())

    def test_model_garbage_collection(self):
        """
        Make sure tenant models are correctly garbage collected upon deletion.
        """
        tenant = Tenant.objects.create(name='tenant')

        # Keep weak-references to tenant and associated models to make sure
        # they have been colllected.
        tenant_wref = weakref.ref(tenant)
        models_wrefs = []
        for model in TenantModelBase.references:
            # Make sure all models have their relation tree populated.
            getattr(model._meta, '_relation_tree')
            models_wrefs.append(weakref.ref(model.for_tenant(tenant)))

        # Delete the tenant and all it's associated models.
        tenant.delete()
        del tenant

        # Force a garbage collection for the benefit of non-reference counting
        # implementations.
        gc.collect()

        # Make sure all references have been removed.
        self.assertIsNone(tenant_wref())
        for model_wref in models_wrefs:
            self.assertIsNone(model_wref())

def ViewCell(base, get_transform, set_transform, **kwargs):
    """
    A Cell whose value is always a transformation of another.
    
    TODO: Stop implementing this as LooseCell.
    """
    
    def forward(view_value):
        base_value = set_transform(view_value)
        base.set(base_value)
        actual_base_value = base.get()
        if base_value != actual_base_value:
            reverse(actual_base_value)
    
    def reverse(base_value):
        self.set(get_transform(base_value))
    
    self = LooseCell(
        value=get_transform(base.get()),
        post_hook=forward,
        **kwargs)
    
    sub = base._subscribe_immediate(reverse)
    weakref.ref(self, lambda: sub.unsubscribe())

    # Allows the cell to be put back in sync if the transform changes.
    # Not intended to be called except by the creator of the cell, but mostly harmless.
    def changed_transform():
        reverse(base.get())
    
    self.changed_transform = changed_transform  # pylint: disable=attribute-defined-outside-init
    
    return self