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

 def __init__(self, root):
     self.config = Config("tkc.ini")
     root.title("Tkinter Commander")
     root.protocol("WM_DELETE_WINDOW", self.on_delete)
     self.root = root
     root.geometry(self.config.get("fm_geometry"))
     root.grid_columnconfigure(0, weight=1)
     root.grid_rowconfigure(1, weight=1)
     pw = Panedwindow(root, orient="horizontal", takefocus=False)
     frame = Frame(pw)
     self.left = Panel(frame, Local_fs(), self.config)
     pw.add(frame)
     pw.pane(frame, weight=1)
     frame = Frame(pw)
     self.right = Panel(frame, Local_fs(), self.config)
     self.right.oposite = ref(self.left)
     self.left.oposite = ref(self.right)
     self.left.activate()
     pw.add(frame)
     pw.pane(frame, weight=1)
     pw.grid(column=0, row=1, columnspan=2, sticky="senw")
     self.add_menu()
     self.add_btns()
     root.tk.call(
         "wm", "iconphoto", root._w,
         PhotoImage(file=join(dirname(__file__), "data", "favicon.gif")))

    def name(self, value):
        old_name = self._name
        if value is old_name:
            return
        self._name = value
        configs = ConfigParser._named_configs

        if old_name:  # disconnect this parser from previously connected props
            _, props = configs.get(old_name, (None, []))
            for widget, prop in props:
                widget = widget()
                if widget:
                    widget.property(prop).set_config(None)
            configs[old_name] = (None, props)

        if not value:
            return

        # if given new name, connect it with property that used this name
        try:
            config, props = configs[value]
        except KeyError:
            configs[value] = (ref(self), [])
            return

        if config is not None:
            raise ValueError('A parser named {} already exists'.format(value))
        for widget, prop in props:
            widget = widget()
            if widget:
                widget.property(prop).set_config(self)
        configs[value] = (ref(self), props)

def test_supports_weakref_with_multi_level_inheritance():
    import weakref

    class PPoint(Point):
        a = field()

    weakref.ref(PPoint(x=1, y=2))

    def allocate(self, obj: object, index: Optional[int] = None) -> int:
        """Allocate a resource.

        When index is None or unspecified, a free resource value within the
        range is located and returned after it is marked allocated.
        Otherwise, it is verified unallocated, then returned.

        :param obj: The object requesting the resource.
        :param index: The resource to allocate
        :returns: The index of the allocated block.
        :raises IndexError: If there are no resources available to be
            allocated or the specified index is already used.
        """
        if index is None:
            for i in range(len(self.numAllocated)):
                r = self.numAllocated[i]
                if r is None or r() is None:
                    self.numAllocated[i] = weakref.ref(obj)
                    return i
            raise IndexError("No available resources")

        if index >= len(self.numAllocated) or index < 0:
            raise IndexError("Index %d out of range" % index)
        r = self.numAllocated[index]
        if r is not None and r() is not None:
            raise IndexError("Resource at index %d already allocated" % index)
        self.numAllocated[index] = weakref.ref(obj)
        return index

	def ref(self, callable):
		self.id = id(callable)
		try:
			self.cbref = weakref.ref(callable.__self__)
			self.meth = callable.__func__
		except AttributeError:
			self.cbref = weakref.ref(callable)