Maximum CD 2009 June/maximum-cd-2009-06.iso/DiscContents/digsby_setup.exe/lib/util/observe/observabledict.pyo

Python Compiled Bytecode | 2009-02-26 | 7.2 KB | 240 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.5)

from observable import ObservableBase
from weakref import WeakValueDictionary
from collections import defaultdict
from traceback import print_exc
from util.primitives import better_ref
from peak.util.imports import whenImported
_usingWX = False

def _setup_usingWX(_mod):

    try:
        import wx
        globals()['wx'] = wx
        EvtHandler = EvtHandler
        import wx
        globals()['EvtHandler'] = EvtHandler
        PyDeadObjectError = PyDeadObjectError
        import wx
        globals()['PyDeadObjectError'] = PyDeadObjectError
    except ImportError:
        pass

    globals()['_usingWX'] = True


class PyDeadObjectError(object):
    pass

whenImported('wx', _setup_usingWX)

class Linked(object):
    __slots__ = ('dict', 'thread', 'attr', 'ref')

    def __init__(self, dict, thread, attr, ref):
        self.dict = dict
        self.thread = thread
        self.attr = attr
        self.ref = ref


    def unlink(self):
        links = self.dict._links[self.thread]
        if self.attr in links:

            try:
                links[self.attr].remove(self.ref)
            except ValueError:
                pass
            except:
                None<EXCEPTION MATCH>ValueError


        None<EXCEPTION MATCH>ValueError



class DictWatcher(object):

    def __init__(self, srcdict, child_callback, *attrs):
        srcdict.add_observer(self.on_dict_changed)
        self.srcdict = srcdict
        self.dictcopy = srcdict.copy()
        self.child_args = [
            child_callback] + list(attrs)
        for key, child in srcdict.items():
            child.add_observer(*self.child_args)



    def unbind_children(self):
        for key, child in self.srcdict.items():
            child.remove_observer(*self.child_args)

        self.srcdict.clear()
        del self.srcdict


    def on_dict_changed(self, src, attr, old, new):
        if src != getattr(self, 'srcdict', None):
            raise PyDeadObjectError

        new = set(src.keys())
        old = set(self.dictcopy.keys())
        for newkey in new - old:
            src[newkey].add_observer(*self.child_args)

        for oldkey in old - new:
            self.dictcopy[oldkey].remove_observer(*self.child_args)

        self.dictcopy = src.copy()



class ObservableDict(dict, ObservableBase):
    _dict_observers = WeakValueDictionary()

    def __init__(self, *args):
        ObservableBase.__init__(self)
        dict.__init__(self, *args)


    def __setitem__(self, key, val):
        old = self.get(key, None)
        retval = dict.__setitem__(self, key, val)
        self.notify(key, old, val)
        return retval


    def secret_set(self, key, val):
        return dict.__setitem__(self, key, val)


    def remove_dict_observer(self, dict_changed, child_changed):
        watcher = self._dict_observers.pop((dict_changed, child_changed), None)
        if watcher:
            watcher.unbind_children()
            del watcher



    def link(self, key, callback, callnow = True, obj = None, thread = 'gui'):

        try:
            links = self._links
        except AttributeError:
            links = self._setup_links()


        try:
            thread_links = links[thread]
        except KeyError:
            thread_links = links[thread] = defaultdict(list)

        if obj is None:
            obj = callback.im_self

        ref = better_ref(callback, obj = obj)
        thread_links[key].append(ref)
        if callnow:
            callback(self[key])

        return Linked(self, thread, key, ref)


    def _setup_links(self):
        print 'in _setup_links for object at %s' % id(self)
        links = { }
        object.__setattr__(self, '_links', links)
        self.add_observer(self._link_watcher)
        return links


    def _link_watcher(self, src, attr, old, new):
        for thread_name, callbacks in self._links.items():
            if attr in callbacks:

                def later(cbs = (callbacks[attr],)):
                    for cb_ref in list(cbs):
                        cb = cb_ref()
                        if cb is None:

                            try:
                                cbs.remove(cb)
                            except ValueError:
                                pass
                            except:
                                None<EXCEPTION MATCH>ValueError


                        None<EXCEPTION MATCH>ValueError

                        try:
                            cb(new)
                        continue
                        except Exception:
                            print_exc()
                            continue




                if thread_name == 'gui':
                    wx.CallAfter(later)

            thread_name == 'gui'



    def clear(self):
        keys = self.keys()
        old_vals = [ self[k] for k in keys ]
        dict.clear(self)
        self.notify()


    def update(self, mapping):
        keys = mapping.keys()
        old_vals = [ self.get(k, None) for k in keys ]
        new_vals = [ mapping.get(k) for k in keys ]
        dict.update(self, mapping)
        self.notifyall(keys, old_vals, new_vals)


    def __delitem__(self, key):
        old_val = self[key]
        retval = dict.__delitem__(self, key)
        self.notify(key, old_val, None)
        return retval


    def setdefault(self, k, x = None):
        if k not in self:
            retval = dict.setdefault(self, k, x)
            self.notify(k, None, x)
            return retval
        else:
            return self[k]


    def pop(self, k, x = None):
        if k in self:
            val = self[k]
            dict.pop(self, k, x)
            self.notify(k, val, None)
            return val
        else:
            return x


    def popitem(self):
        (k, v) = dict.popitem(self)
        self.notify(k, v, None)
        return (k, v)


observable_dict = ObservableDict