home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / util / observe / observabledict.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  7.5 KB  |  248 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from observable import ObservableBase
  5. from weakref import WeakValueDictionary
  6. from collections import defaultdict
  7. from traceback import print_exc
  8. from util.primitives.refs import better_ref
  9. from peak.util.imports import whenImported
  10. _usingWX = False
  11.  
  12. def _setup_usingWX(_mod):
  13.     
  14.     try:
  15.         import wx
  16.         globals()['wx'] = wx
  17.         EvtHandler = EvtHandler
  18.         import wx
  19.         globals()['EvtHandler'] = EvtHandler
  20.         PyDeadObjectError = PyDeadObjectError
  21.         import wx
  22.         globals()['PyDeadObjectError'] = PyDeadObjectError
  23.     except ImportError:
  24.         pass
  25.  
  26.     globals()['_usingWX'] = True
  27.  
  28.  
  29. class PyDeadObjectError(object):
  30.     pass
  31.  
  32. whenImported('wx', _setup_usingWX)
  33.  
  34. class Linked(object):
  35.     __slots__ = ('dict', 'thread', 'attr', 'ref')
  36.     
  37.     def __init__(self, dict, thread, attr, ref):
  38.         self.dict = dict
  39.         self.thread = thread
  40.         self.attr = attr
  41.         self.ref = ref
  42.  
  43.     
  44.     def unlink(self):
  45.         links = self.dict._links[self.thread]
  46.         if self.attr in links:
  47.             
  48.             try:
  49.                 links[self.attr].remove(self.ref)
  50.             except ValueError:
  51.                 pass
  52.             except:
  53.                 None<EXCEPTION MATCH>ValueError
  54.             
  55.  
  56.         None<EXCEPTION MATCH>ValueError
  57.  
  58.  
  59.  
  60. class DictWatcher(object):
  61.     
  62.     def __init__(self, srcdict, child_callback, *attrs):
  63.         srcdict.add_observer(self.on_dict_changed)
  64.         self.srcdict = srcdict
  65.         self.dictcopy = srcdict.copy()
  66.         self.child_args = [
  67.             child_callback] + list(attrs)
  68.         for key, child in srcdict.items():
  69.             child.add_observer(*self.child_args)
  70.         
  71.  
  72.     
  73.     def unbind_children(self):
  74.         for key, child in self.srcdict.items():
  75.             child.remove_observer(*self.child_args)
  76.         
  77.         self.srcdict.clear()
  78.         del self.srcdict
  79.  
  80.     
  81.     def on_dict_changed(self, src, attr, old, new):
  82.         if src != getattr(self, 'srcdict', None):
  83.             raise PyDeadObjectError
  84.         src != getattr(self, 'srcdict', None)
  85.         new = set(src.keys())
  86.         old = set(self.dictcopy.keys())
  87.         for newkey in new - old:
  88.             src[newkey].add_observer(*self.child_args)
  89.         
  90.         for oldkey in old - new:
  91.             self.dictcopy[oldkey].remove_observer(*self.child_args)
  92.         
  93.         self.dictcopy = src.copy()
  94.  
  95.  
  96.  
  97. class ObservableDict(dict, ObservableBase):
  98.     _dict_observers = WeakValueDictionary()
  99.     
  100.     def __init__(self, *args):
  101.         ObservableBase.__init__(self)
  102.         dict.__init__(self, *args)
  103.  
  104.     
  105.     def __setitem__(self, key, val):
  106.         old = self.get(key, None)
  107.         retval = dict.__setitem__(self, key, val)
  108.         self.notify(key, old, val)
  109.         return retval
  110.  
  111.     
  112.     def secret_set(self, key, val):
  113.         return dict.__setitem__(self, key, val)
  114.  
  115.     
  116.     def remove_dict_observer(self, dict_changed, child_changed):
  117.         watcher = self._dict_observers.pop((dict_changed, child_changed), None)
  118.         if watcher:
  119.             watcher.unbind_children()
  120.             del watcher
  121.         
  122.  
  123.     
  124.     def link(self, key, callback, callnow = True, obj = None, thread = 'gui'):
  125.         
  126.         try:
  127.             links = self._links
  128.         except AttributeError:
  129.             links = self._setup_links()
  130.  
  131.         
  132.         try:
  133.             thread_links = links[thread]
  134.         except KeyError:
  135.             thread_links = links[thread] = defaultdict(list)
  136.  
  137.         if obj is None:
  138.             obj = callback.im_self
  139.         
  140.         
  141.         def on_weakref_dead(wref):
  142.             live = []
  143.             for r in thread_links[key]:
  144.                 if getattr(r, 'object', None) is wref:
  145.                     r.destroy()
  146.                     continue
  147.                 live.append(r)
  148.             
  149.             thread_links[key][:] = live
  150.  
  151.         ref = better_ref(callback, cb = on_weakref_dead, obj = obj)
  152.         thread_links[key].append(ref)
  153.         if callnow:
  154.             callback(self[key])
  155.         
  156.         return Linked(self, thread, key, ref)
  157.  
  158.     
  159.     def _setup_links(self):
  160.         links = { }
  161.         object.__setattr__(self, '_links', links)
  162.         self.add_observer(self._link_watcher)
  163.         return links
  164.  
  165.     
  166.     def _link_watcher(self, src, attr, old, new):
  167.         for thread_name, callbacks in self._links.items():
  168.             if attr in callbacks:
  169.                 
  170.                 def later(cbs = (callbacks[attr],)):
  171.                     for cb_ref in list(cbs):
  172.                         cb = cb_ref()
  173.                         if cb is None:
  174.                             
  175.                             try:
  176.                                 cbs.remove(cb)
  177.                             except ValueError:
  178.                                 pass
  179.                             except:
  180.                                 None<EXCEPTION MATCH>ValueError
  181.                             
  182.  
  183.                         None<EXCEPTION MATCH>ValueError
  184.                         
  185.                         try:
  186.                             cb(new)
  187.                         continue
  188.                         except Exception:
  189.                             print_exc()
  190.                             continue
  191.                         
  192.  
  193.                     
  194.  
  195.                 if thread_name == 'gui':
  196.                     wx.CallAfter(later)
  197.                 
  198.             thread_name == 'gui'
  199.         
  200.  
  201.     
  202.     def clear(self):
  203.         keys = self.keys()
  204.         old_vals = [ self[k] for k in keys ]
  205.         dict.clear(self)
  206.         self.notify()
  207.  
  208.     
  209.     def update(self, mapping):
  210.         keys = mapping.keys()
  211.         old_vals = [ self.get(k, None) for k in keys ]
  212.         new_vals = [ mapping.get(k) for k in keys ]
  213.         dict.update(self, mapping)
  214.         self.notifyall(keys, old_vals, new_vals)
  215.  
  216.     
  217.     def __delitem__(self, key):
  218.         old_val = self[key]
  219.         retval = dict.__delitem__(self, key)
  220.         self.notify(key, old_val, None)
  221.         return retval
  222.  
  223.     
  224.     def setdefault(self, k, x = None):
  225.         if k not in self:
  226.             retval = dict.setdefault(self, k, x)
  227.             self.notify(k, None, x)
  228.             return retval
  229.         return self[k]
  230.  
  231.     
  232.     def pop(self, k, x = None):
  233.         if k in self:
  234.             val = self[k]
  235.             dict.pop(self, k, x)
  236.             self.notify(k, val, None)
  237.             return val
  238.         return x
  239.  
  240.     
  241.     def popitem(self):
  242.         (k, v) = dict.popitem(self)
  243.         self.notify(k, v, None)
  244.         return (k, v)
  245.  
  246.  
  247. observable_dict = ObservableDict
  248.