Esempio n. 1
0
 def test_weakref_subclassing(self):
     import _weakref, gc
     class A(object):
         pass
     class Ref(_weakref.ref):
         def __init__(self, ob, callback=None, **other):
             self.__dict__.update(other)
     def callable(ref):
         b.a = 42
     a = A()
     b = A()
     b.a = 1
     w = Ref(a, callable, x=1, y=2)
     assert w.x == 1
     assert w.y == 2
     assert a.__weakref__ is w
     assert b.__weakref__ is None
     w1 = _weakref.ref(a)
     w2 = _weakref.ref(a, callable)
     assert a.__weakref__ is w1
     del a
     gc.collect()
     assert w1() is None
     assert w() is None
     assert w2() is None
     assert b.a == 42
Esempio n. 2
0
def weakref_data(data, destroy_cb = None):
    if type(data) in (str, int, long, types.NoneType, types.FunctionType):
        # Naive optimization for common immutable cases.
        return data
    elif type(data) == types.MethodType:
        cb = WeakCallback(data)
        if destroy_cb:
            cb.weakref_destroyed_cb = destroy_cb
            cb.ignore_caller_args = True
        return cb
    elif type(data) in (list, tuple):
        d = []
        for item in data:
            d.append(weakref_data(item, destroy_cb))
        if type(data) == tuple:
            d = tuple(d)
        return d
    elif type(data) == dict:
        d = {}
        for key, val in data.items():
            d[weakref_data(key)] = weakref_data(val, destroy_cb)
        return d
    else:
        try:
            if destroy_cb:
                return _weakref.ref(data, destroy_cb)
            return _weakref.ref(data)
        except TypeError:
            pass

    return data
Esempio n. 3
0
 def test_weakref_equality(self):
     import _weakref, gc
     class A(object):
         def __eq__(self, other):
             return True
         def __ne__(self, other):
             return False
     a1 = A()
     a2 = A()
     ref1 = _weakref.ref(a1)
     ref2 = _weakref.ref(a2)
     assert ref1 == ref2
     assert not (ref1 != ref2)
     assert not (ref1 == [])
     assert ref1 != []
     del a1
     gc.collect()
     assert not ref1 == ref2
     assert ref1 != ref2
     assert not (ref1 == [])
     assert ref1 != []
     del a2
     gc.collect()
     assert not ref1 == ref2
     assert ref1 != ref2
     assert not (ref1 == [])
     assert ref1 != []
Esempio n. 4
0
 def setdefault(self, key, default):
     try:
         ref = self.data[key]
     except KeyError:
         def remove(o, data=self.data, key=key):
             del data[key]
         ref = ref(default, remove)
         self.data[key] = ref
         return default
     else:
         return ref()
Esempio n. 5
0
 def test_weakref_reusing(self):
     import _weakref, gc
     class A(object):
         pass
     a = A()
     ref1 = _weakref.ref(a)
     ref2 = _weakref.ref(a)
     assert ref1 is ref2
     class wref(_weakref.ref):
         pass
     wref1 = wref(a)
     assert isinstance(wref1, wref)
Esempio n. 6
0
    def Startup(self, slimItem):
        sm.RegisterNotify(self)
        self.ball = _weakref.ref(sm.GetService('michelle').GetBall(slimItem.itemID))
        self.slimItem = _weakref.ref(slimItem)
        self.id = slimItem.itemID
        self.itemID = slimItem.itemID
        self.updatedamage = slimItem.categoryID != const.categoryAsteroid and slimItem.groupID != const.groupHarvestableCloud and slimItem.groupID != const.groupOrbitalTarget
        self.AddUIObjects(slimItem, self.itemID)
        iconPar = self.sr.iconPar
        barAndImageCont = self.barAndImageCont
        barAndImageCont.isDragObject = True
        barAndImageCont.GetDragData = self.GetTargetDragData
        barAndImageCont.OnMouseDown = self.OnTargetMouseDown
        barAndImageCont.OnClick = self.OnTargetClick
        barAndImageCont.GetMenu = self.GetTargetMenu
        barAndImageCont.OnMouseEnter = self.OnTargetMouseEnter
        barAndImageCont.OnMouseExit = self.OnTargetMouseExit
        self.sr.activeTarget = uicls.ActiveTargetOnBracket(parent=iconPar, itemID=self.itemID)
        self.slimForFlag = slimItem
        self.SetStandingIcon()
        self.sr.hilite = uiprimitives.Sprite(name='hiliteSprite', parent=iconPar, left=-3, top=-3, width=100, height=100, texturePath='res:/UI/Texture/classes/Target/targetUnderlay.png', color=(1.0, 1.0, 1.0, 0.05))
        self.sr.activeTarget.RotateArrows()
        labelClass = uicontrols.EveLabelSmall
        labelContainer = uicontrols.ContainerAutoSize(parent=self, name='labelContainer', align=uiconst.TOTOP)
        self.sr.label = labelClass(text=' ', parent=labelContainer, align=uiconst.TOTOP, state=uiconst.UI_DISABLED, maxLines=1)
        self.sr.label2 = labelClass(text=' ', parent=labelContainer, align=uiconst.TOTOP, state=uiconst.UI_DISABLED, maxLines=1)
        self.sr.shipLabel = labelClass(text=' ', parent=labelContainer, align=uiconst.TOTOP, state=uiconst.UI_DISABLED, maxLines=1)
        self.sr.distanceLabel = labelClass(text=' ', parent=labelContainer, align=uiconst.TOTOP, state=uiconst.UI_DISABLED, maxLines=1)
        self.SetTargetLabel()
        self.sr.assignedPar = uiprimitives.Container(name='assignedPar', align=uiconst.TOTOP, parent=self, height=32)
        self.sr.assigned = uiprimitives.Container(name='assigned', align=uiconst.CENTERTOP, parent=self.sr.assignedPar, height=32)
        self.sr.updateTimer = base.AutoTimer(random.randint(750, 1000), self.UpdateData)
        self.UpdateData()
        selected = sm.GetService('state').GetExclState(state.selected)
        self.Select(selected == slimItem.itemID)
        hilited = sm.GetService('state').GetExclState(state.mouseOver)
        self.Hilite(hilited == slimItem.itemID)
        activeTargetID = sm.GetService('target').GetActiveTargetID()
        self.ActiveTarget(activeTargetID == slimItem.itemID)
        drones = sm.GetService('michelle').GetDrones()
        for key in drones:
            droneState = drones[key]
            if droneState.targetID == self.id:
                self.drones[droneState.droneID] = droneState.typeID

        self.UpdateDrones()
        for moduleInfo in sm.GetService('godma').GetStateManager().GetActiveModulesOnTargetID(slimItem.itemID):
            if moduleInfo:
                moduleID = moduleInfo.itemID
                if moduleID and moduleID not in self.activeModules:
                    self.AddWeapon(moduleInfo)
                    self.activeModules[moduleID] = moduleInfo
Esempio n. 7
0
 def test_correct_weakrefcount_after_death(self):
     import _weakref, gc
     class A(object):
         pass
     a = A()
     ref1 = _weakref.ref(a)
     ref2 = _weakref.ref(a)
     assert _weakref.getweakrefcount(a) == 1
     del ref1
     gc.collect()
     assert _weakref.getweakrefcount(a) == 1
     del ref2
     gc.collect()
     assert _weakref.getweakrefcount(a) == 0
Esempio n. 8
0
 def test_hashing(self):
     import _weakref, gc
     class A(object):
         def __hash__(self):
             return 42
     a = A()
     w = _weakref.ref(a)
     assert hash(a) == hash(w)
     del a
     gc.collect()
     assert hash(w) == 42
     w = _weakref.ref(A())
     gc.collect()
     raises(TypeError, hash, w)
Esempio n. 9
0
 def test_callback_cannot_ressurect(self):
     import _weakref, gc
     class A(object):
         pass
     a = A()
     alive = A()
     alive.a = 1
     def callback(ref2):
         alive.a = ref1()
     ref1 = _weakref.ref(a, callback)
     ref2 = _weakref.ref(a, callback)
     del a
     gc.collect()
     assert alive.a is None
Esempio n. 10
0
    def test_eq(self):
        import _weakref
        class A(object):
            pass

        a = A()
        assert not(_weakref.ref(a) == a)
        assert _weakref.ref(a) != a

        class A(object):
            def __eq__(self, other):
                return True

        a = A()
        assert _weakref.ref(a) == a
Esempio n. 11
0
    def __init__(self, callback, *args, **kwargs):
        super(WeakCallback, self).__init__(callback, *args, **kwargs)
        if type(callback) == types.MethodType:
            # For methods
            self._instance = _weakref.ref(callback.im_self, self._weakref_destroyed)
            self._callback = callback.im_func.func_name
        else:
            self._instance = None
            # Don't weakref lambdas.
            if not hasattr(callback, 'func_name') or callback.func_name != '<lambda>':
                self._callback = _weakref.ref(callback, self._weakref_destroyed)

        self._args = weakref_data(args, self._weakref_destroyed)
        self._kwargs = weakref_data(kwargs, self._weakref_destroyed)
        self._weakref_destroyed_user_cb = None
Esempio n. 12
0
 def test_callback(self):
     import _weakref, gc
     class A(object):
         pass
     a1 = A()
     a2 = A()
     def callback(ref):
         a2.ref = ref()
     ref1 = _weakref.ref(a1, callback)
     ref2 = _weakref.ref(a1)
     assert _weakref.getweakrefcount(a1) == 2
     del a1
     gc.collect()
     assert ref1() is None
     assert a2.ref is None
Esempio n. 13
0
 def test_callback_order(self):
     import _weakref, gc
     class A(object):
         pass
     a1 = A()
     a2 = A()
     def callback1(ref):
         a2.x = 42
     def callback2(ref):
         a2.x = 43
     ref1 = _weakref.ref(a1, callback1)
     ref2 = _weakref.ref(a1, callback2)
     del a1
     gc.collect()
     assert a2.x == 42
Esempio n. 14
0
 def discard_member(self,member,safemode=False):
     if not self._remember:
         if safemode:
             return
         else:
             raise GroupError("This group does not remember its members")
     self.__delete_member_by_ref(weakref.ref(member))
Esempio n. 15
0
 def _remove(item, selfref=ref(self)):
     self = selfref()
     if self is not None:
         if self._iterating:
             self._pending_removals.append(item)
         else:
             self.data.discard(item)
Esempio n. 16
0
    def __contains__(self, item):
        try:
            wr = ref(item)
        except TypeError:
            return False

        return wr in self.data
Esempio n. 17
0
 def keys(self):
     L = []
     for ref in self.data.keys():
         o = ref()
         if o is not None:
             L.append(o)
     return L
Esempio n. 18
0
File: object.py Progetto: clones/kaa
    def _get_cached_value(self, prop, child, otherkey = None):
        if child:
            child = _weakref.ref(child)

        if (prop, child, otherkey) in self._values_cache:
            #print "CACHE HIT", self, prop, child, otherkey
            return self._values_cache[(prop, child, otherkey)]
Esempio n. 19
0
 def test_ne(self):
     import _weakref
     class X(object):
         pass
     ref1 = _weakref.ref(X())
     assert ref1.__eq__(X()) is NotImplemented
     assert ref1.__ne__(X()) is NotImplemented
Esempio n. 20
0
 def remove(wr, selfref=ref(self)):
     self = selfref()
     if self is not None:
         try:
             del self.data[wr.key]
         except KeyError:
             pass
Esempio n. 21
0
    def has_key(self, key):
        try:
            wr = ref(key)
        except TypeError:
            return 0

        return wr in self.data
Esempio n. 22
0
 def remove(wr, selfref=ref(self)):
     self = selfref()
     if self is not None:
         if self._iterating:
             self._pending_removals.append(wr.key)
         else:
             del self.data[wr.key]
Esempio n. 23
0
 def remove(k, selfref=ref(self)):
     self = selfref()
     if self is not None:
         if self._iterating:
             self._pending_removals.append(k)
         else:
             del self.data[k]
Esempio n. 24
0
        def test_runner():
            import _weakref
            global called
            called = 0
            a = IronPythonTest.Events()

            # wire up an event w/ a circular reference
            # back to the object, ensure the event
            # is delivered
            def foo():
                global called
                called += 1

            foo.abc = a
            a.InstanceTest += foo

            a.CallInstance()
            self.assertEqual(called, 1)

            ret_val = _weakref.ref(foo)
            #self.assertTrue(hasattr(ret_val, "abc")) #BUG
            keep_alive(foo)

            # ensure as long as the objects are still alive the event
            # handler remains alive
            import gc
            for i in xrange(10):
                gc.collect()

            a.CallInstance()
            self.assertEqual(called, 2)

            return ret_val
Esempio n. 25
0
 def copy(self):
     new = WeakValueDictionary()
     for key, ref in self.data.items():
         o = ref()
         if o is not None:
             new[key] = o
     return new
Esempio n. 26
0
 def update(self, dict):
     d = self.data
     L = []
     for key, value in dict.items():
         L.append((ref(key, self._remove), value))
     for key, r in L:
         d[key] = r
Esempio n. 27
0
    def __contains__(self, key):
        try:
            wr = ref(key)
        except TypeError:
            return 0

        return wr in self.data
Esempio n. 28
0
 def items(self):
     L = []
     for key, ref in self.data.items():
         o = ref()
         if o is not None:
             L.append((key, o))
     return L
Esempio n. 29
0
 def test_method_weakrefable(self):
     import _weakref, gc
     class A(object):
         def f(self):
             return 42
     a = A()
     meth = A.f
     w_unbound = _weakref.ref(meth)
     assert w_unbound()(A()) == 42
     meth = A().f
     w_bound = _weakref.ref(meth)
     assert w_bound()() == 42
     del meth
     gc.collect()
     assert w_unbound() is None
     assert w_bound() is None
 def symmetric_difference_update(self, other):
     if self._pending_removals:
         self._commit_removals()
     if self is other:
         self.data.clear()
     else:
         self.data.symmetric_difference_update(ref(item) for item in other)
Esempio n. 31
0
 def get(self, key, default=None):
     return self.data.get(ref(key), default)
Esempio n. 32
0
 def __contains__(self, key):
     try:
         wr = ref(key)
     except TypeError:
         return 0
     return wr in self.data
Esempio n. 33
0
 def __eq__(self, other):
     if not isinstance(other, self.__class__):
         return NotImplemented
     return self.data == set(ref(item) for item in other)
Esempio n. 34
0
 def __delitem__(self, key):
     self._dirty_len = True
     del self.data[ref(key)]
Esempio n. 35
0
 def __isub__(self, other):
     if self is other:
         self.data.clear()
     else:
         self.data.difference_update(ref(item) for item in other)
     return self
Esempio n. 36
0
 def issubset(self, other):
     return self.data.issubset(ref(item) for item in other)
Esempio n. 37
0
 def __iand__(self, other):
     if self._pending_removals:
         self._commit_removals()
     self.data.intersection_update(ref(item) for item in other)
     return self
Esempio n. 38
0
 def __init__(self, weakcontainer):
     # Don't create cycles
     self.weakcontainer = ref(weakcontainer)
Esempio n. 39
0
 def discard(self, item):
     if self._pending_removals:
         self._commit_removals()
     self.data.discard(ref(item))
Esempio n. 40
0
 def remove(self, item):
     if self._pending_removals:
         self._commit_removals()
     self.data.remove(ref(item))
Esempio n. 41
0
 def pop(self, key, *args):
     self._dirty_len = True
     return self.data.pop(ref(key), *args)
Esempio n. 42
0
 def add(self, item):
     if self._pending_removals:
         self._commit_removals()
     self.data.add(ref(item, self._remove))
Esempio n. 43
0
 def __setattr__(self, name, val):
     if callable(val):
         ref = CallableWeakRef(val)
     else:
         ref = _weakref.ref(val)
     self.__dict__[name] = ref
Esempio n. 44
0
 def setdefault(self, key, default=None):
     return self.data.setdefault(ref(key, self._remove), default)
Esempio n. 45
0
 def __contains__(self, item):
     return ref(item) in self.data
Esempio n. 46
0
 def __ge__(self, other):
     return self.data >= set(ref(item) for item in other)
Esempio n. 47
0
 def __setitem__(self, key, value):
     self.data[key] = ref(value, self.__makeremove(key))
Esempio n. 48
0
 def update(self, dict):
     d = self.data
     for key, value in dict.items():
         d[ref(key, self._remove)] = value
Esempio n. 49
0
    def throw(self, type=None, value=None, tb=None, aborted=False):
        """
        This method should be called when the owner (creator) of the InProgress is
        finished because it raised an exception.

        Any callbacks connected to the :attr:`~kaa.InProgress.exception` signal will
        then be emitted with the arguments passed to this method.

        The parameters correspond to sys.exc_info().  If they are not specified
        then the current exception in sys.exc_info() will be used; this is
        analogous to a naked ``raise`` within an ``except`` block.

        :param type: the class of the exception
        :param value: the instance of the exception
        :param tb: the traceback object representing where the exception took place
        """
        # This function must deal with a tricky problem.  See:
        # http://mail.python.org/pipermail/python-dev/2005-September/056091.html
        #
        # Ideally, we want to store the traceback object so we can defer the
        # exception handling until some later time.  The problem is that by
        # storing the traceback, we create some ridiculously deep circular
        # references.
        #
        # The way we deal with this is to pass along the traceback object to
        # any handler that can handle the exception immediately, and then
        # discard the traceback.  A stringified formatted traceback is attached
        # to the exception in the formatted_traceback attribute.
        #
        # The above URL suggests a possible non-trivial workaround: create a
        # custom traceback object in C code that preserves the parts of the
        # stack frames needed for printing tracebacks, but discarding objects
        # that would create circular references.  This might be a TODO.
        if type is None:
            type, value, tb = sys.exc_info()
            if value is None:
                raise ValueError(
                    'throw() with no parameters but there is no current exception'
                )
        self._exception = type, value, tb
        self._unhandled_exception = True
        stack = traceback.extract_tb(tb)

        # Attach a stringified traceback to the exception object.  Right now,
        # this is the best we can do for asynchronous handlers.
        trace = ''.join(traceback.format_exception(*self._exception)).strip()
        value.formatted_traceback = trace

        # Wake any threads waiting on us.  We've initialized _exception with
        # the traceback object, so any threads that access the result property
        # between now and the end of this function will have an opportunity to
        # get the live traceback.
        self._finished_event_poke(set=True)

        if self._exception_signal.count() == 0:
            # There are no exception handlers, so we know we will end up
            # queuing the traceback in the exception signal.  Set it to None
            # to prevent that.
            tb = None

        if self._exception_signal.emit_when_handled(type, value, tb) == False:
            # A handler has acknowledged handling this exception by returning
            # False.  So we won't log it.
            self._unhandled_exception = None

        # If we were thrown an InProgressAborted, the likely reason is an InProgress
        # we were waiting on has been aborted.  In this case, we emit the abort
        # signal and clear _unhandled_exception, provided we are abortable (which
        # by default is true as long as there are any callbacks connected to the
        # abort signal.  Otherwise, do not clear _unhandled_exception so that it
        # gets logged.
        if isinstance(value, InProgressAborted) and self.abortable:
            if not aborted:
                self.signals['abort'].emit(value)
            self._unhandled_exception = None

        if self._unhandled_exception:
            # This exception was not handled synchronously, so we set up a
            # weakref object with a finalize callback to a function that
            # logs the exception.  We could do this in __del__, except that
            # the gc refuses to collect objects with a destructor.  The weakref
            # kludge lets us accomplish the same thing without actually using
            # __del__.
            #
            # If the exception is passed back via result property, then it is
            # considered handled, and it will not be logged.
            cb = Callable(InProgress._log_exception, trace, value, self._stack)
            self._unhandled_exception = _weakref.ref(self, cb)

        # Remove traceback from stored exception.  If any waiting threads
        # haven't gotten it by now, it's too late.
        if not isinstance(value, AsyncExceptionBase):
            value = AsyncException(value, stack)
        if hasattr(value, 'with_traceback'):
            # Remove traceback attached to exception objects in Python 3.
            value = value.with_traceback(None)
        self._exception = value.__class__, value, None

        # cleanup
        self.disconnect_all()
        self._exception_signal.disconnect_all()
        self.signals['abort'].disconnect_all()

        # We return False here so that if we've received a thrown exception
        # from another InProgress we're waiting on, we essentially inherit
        # the exception from it and indicate to it that we'll handle it
        # from here on.  (Otherwise the linked InProgress would figure
        # nobody handled it and would dump out an unhandled async exception.)
        return False
Esempio n. 50
0
 def pop(self, key, *args):
     return self.data.pop(ref(key), *args)
Esempio n. 51
0
 def __getitem__(self, key):
     return self.data[ref(key)]
Esempio n. 52
0
 def remove(o, selfref=ref(self), key=key):
     self = selfref()
     if self is not None:
         del self.data[key]
Esempio n. 53
0
 def __delitem__(self, key):
     for ref in self.data.iterkeys():
         o = ref()
         if o == key:
             del self.data[ref]
             return
Esempio n. 54
0
 def __contains__(self, item):
     try:
         wr = ref(item)
     except TypeError:
         return False
     return wr in self.data
Esempio n. 55
0
 def remove(k, selfref=ref(self)):
     self = selfref()
     if self is not None:
         del self.data[k]
Esempio n. 56
0
 def has_key(self, key):
     try:
         wr = ref(key)
     except TypeError:
         return 0
     return wr in self.data
Esempio n. 57
0
 def update(self, dict):
     d = self.data
     for key, o in dict.items():
         d[key] = ref(o, self.__makeremove(key))
Esempio n. 58
0
 def __delitem__(self, key):
     del self.data[ref(key)]
Esempio n. 59
0
 def difference_update(self, other):
     if self is other:
         self.data.clear()
     else:
         self.data.difference_update(ref(item) for item in other)
Esempio n. 60
0
 def __setitem__(self, key, value):
     self.data[ref(key, self._remove)] = value