home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / util / callbacks.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  12.4 KB  |  400 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from __future__ import with_statement
  5. from introspect import funcinfo
  6. from primitives.funcs import Delegate
  7. from functools import wraps
  8. from logging import getLogger
  9. from traceback import print_exc
  10. import sys
  11. import threading
  12. log = getLogger('callbacks')
  13. CALLBACKS = ('success', 'error', 'timeout')
  14. call_later_lock = threading.Lock()
  15. call_laters = dict()
  16.  
  17. def register_call_later(threadname, call_later):
  18.     call_later_lock.__enter__()
  19.     
  20.     try:
  21.         call_laters[threadname] = call_later
  22.     finally:
  23.         pass
  24.  
  25.  
  26.  
  27. def unregister_call_later(threadname):
  28.     call_later_lock.__enter__()
  29.     
  30.     try:
  31.         call_laters.pop(threadname)
  32.     finally:
  33.         pass
  34.  
  35.  
  36.  
  37. DO_NOTHING = lambda *a, **k: pass
  38.  
  39. class CallLater(object):
  40.     
  41.     def __init__(self, cb, threadname = None):
  42.         if not threadname:
  43.             pass
  44.         self.threadname = threading.currentThread().getName()
  45.         if self.threadname not in call_laters:
  46.             
  47.             try:
  48.                 cb_dbg_str = ', '.join((lambda .0: for s in .0:
  49. str(s))([
  50.                     funcinfo(cb),
  51.                     cb.func_code.co_filename,
  52.                     cb.func_code.co_firstlineno]))
  53.             except Exception:
  54.                 cb_dbg_str = 'Error making debug string. Repr is: {%s}' % funcinfo(cb)
  55.  
  56.             if cb is not DO_NOTHING:
  57.                 pass
  58.             
  59.         
  60.         self.cb = cb
  61.  
  62.     
  63.     def __repr__(self):
  64.         return '<%s %s>' % (type(self).__name__, funcinfo(self.cb))
  65.  
  66.     
  67.     def __call__(self, *a, **k):
  68.         if threading.currentThread().getName() != self.threadname and self.threadname in call_laters:
  69.             
  70.             try:
  71.                 return (None, None, call_laters[self.threadname])((lambda : self.cb(*a, **k)))
  72.             except Exception:
  73.                 print >>sys.stderr, 'callback is %s' % funcinfo(self.cb)
  74.                 raise 
  75.             except:
  76.                 None<EXCEPTION MATCH>Exception
  77.             
  78.  
  79.         None<EXCEPTION MATCH>Exception
  80.         
  81.         try:
  82.             return self.cb(*a, **k)
  83.         except Exception:
  84.             print >>sys.stderr, '%s in %s (%s). args/kwargs are: %r,%r' % (getattr(self.cb, '__name__', funcinfo(self.cb)), self.cb.__module__, funcinfo(self.cb), a, k)
  85.             raise 
  86.  
  87.  
  88.  
  89.  
  90. class CallLaterDelegate(Delegate):
  91.     
  92.     def __init__(self, *a):
  93.         Delegate.__init__(self, (lambda .0: for x in .0:
  94. CallLater(x))(a))
  95.  
  96.     
  97.     def __iadd__(self, f):
  98.         if isinstance(f, list):
  99.             for thing in f:
  100.                 self += thing
  101.             
  102.         else:
  103.             self.append(CallLater(f))
  104.         return self
  105.  
  106.     
  107.     def remove(self, x):
  108.         for y in self:
  109.             if y.cb == x:
  110.                 return super(CallLaterDelegate, self).remove(y)
  111.         else:
  112.             return super(CallLaterDelegate, self).remove(x)
  113.         return y.cb == x
  114.  
  115.  
  116.  
  117. class Callback(object):
  118.     _callback_names = CALLBACKS
  119.     
  120.     def __init__(self, _cbnames = None, **cbs):
  121.         if _cbnames is not None:
  122.             self._callback_names = _cbnames
  123.         
  124.         for name, callback in cbs.iteritems():
  125.             if not callable(callback):
  126.                 raise TypeError('keyword args to Callback must be callable: %s' % name)
  127.             callable(callback)
  128.             setattr(self, name, CallLaterDelegate(callback))
  129.             attr = getattr(self, name)
  130.         
  131.  
  132.     
  133.     def __getattr__(self, attr):
  134.         
  135.         try:
  136.             return object.__getattribute__(self, attr)
  137.         except AttributeError:
  138.             if attr in self._callback_names:
  139.                 return CallLaterDelegate()
  140.             raise 
  141.         except:
  142.             attr in self._callback_names
  143.  
  144.  
  145.     
  146.     def __setattr__(self, attr, val):
  147.         object.__setattr__(self, attr, val)
  148.  
  149.     
  150.     def __call__(self, *a, **k):
  151.         return self.success(*a, **k)
  152.  
  153.     
  154.     def __repr__(self):
  155.         return '<%s %s>' % (type(self).__name__, ' '.join((lambda .0: for item in .0:
  156. '%s=%s' % item)(self.__dict__.items())))
  157.  
  158.  
  159. EMPTY_CALLBACK = Callback()
  160. DefaultCallback = EMPTY_CALLBACK
  161. CALLBACK_ATTR = '_iscallback'
  162.  
  163. def callback_adapter(f, do_return = True):
  164.     
  165.     def wrapped(*a, **k):
  166.         cb = k.pop('callback')
  167.         
  168.         try:
  169.             retval = f(*a, **k)
  170.         except Exception:
  171.             e = None
  172.             cb.error(e)
  173.  
  174.         cb.success(retval)
  175.         if do_return:
  176.             return retval
  177.  
  178.     wrapped = (None, callsback)(wrapped)
  179.     return wrapped
  180.  
  181.  
  182. def callsback(func, callbacks_ = CALLBACKS):
  183.     
  184.     def wrapper(*secret_a, **secret_kws):
  185.         cb = None
  186.         if 'callback' in secret_kws:
  187.             if (any,)((lambda .0: for cbname in .0:
  188. cbname in secret_kws)(callbacks_)):
  189.                 raise AssertionError('use callback or individual callbacks')
  190.             (any,)((lambda .0: for cbname in .0:
  191. cbname in secret_kws)(callbacks_))
  192.             cb = secret_kws['callback']
  193.         else:
  194.             for cbname in callbacks_:
  195.                 if cbname in secret_kws:
  196.                     if cb is None:
  197.                         cb = Callback()
  198.                     
  199.                     if not callable(secret_kws[cbname]):
  200.                         raise TypeError('%s must be callable' % cbname)
  201.                     callable(secret_kws[cbname])
  202.                     mycb = CallLaterDelegate(secret_kws[cbname])
  203.                     setattr(cb, cbname, mycb)
  204.                     del secret_kws[cbname]
  205.                     continue
  206.             
  207.             secret_kws['callback'] = cb
  208.         if cb is None:
  209.             _cbnames = None if callbacks_ is CALLBACKS else callbacks_
  210.             secret_kws['callback'] = cb = Callback(_cbnames = _cbnames)
  211.         
  212.         
  213.         try:
  214.             val = func(*secret_a, **secret_kws)
  215.         except Exception:
  216.             e = None
  217.             print_exc()
  218.             callany = callany
  219.             import util
  220.             if not callany(cb.error, e):
  221.                 raise 
  222.             callany(cb.error, e)
  223.             val = None
  224.  
  225.         if val is True:
  226.             cb.success()
  227.         
  228.         return val
  229.  
  230.     wrapper = (None, wraps(func))(wrapper)
  231.     setattr(wrapper, CALLBACK_ATTR, True)
  232.     return wrapper
  233.  
  234.  
  235. def is_callsback(f):
  236.     return bool(getattr(f, CALLBACK_ATTR, False))
  237.  
  238.  
  239. def named_callbacks(names = ()):
  240.     
  241.     def wrapper(func):
  242.         return callsback(func, names)
  243.  
  244.     return wrapper
  245.  
  246.  
  247. def do_cb(seq, callback = None):
  248.     CallbackSequence(seq, callback = callback)()
  249.  
  250. do_cb = callsback(do_cb)
  251.  
  252. class CallbackSequence(object):
  253.     
  254.     def __init__(self, sequence, callback):
  255.         self.iter = iter(sequence)
  256.         self.callback = callback
  257.         self.n = 0
  258.  
  259.     
  260.     def __call__(self, *a):
  261.         self.n = self.n + 1
  262.         
  263.         try:
  264.             next = self.iter.next()
  265.         except StopIteration:
  266.             log.debug('stop iteration, calling success: %r', funcinfo(self.callback.success))
  267.             self.callback.success()
  268.  
  269.         log.debug('%s #%d: %r', funcinfo(self.callback), self.n, funcinfo(next))
  270.         next(*a, **dict(success = self, error = self.callback.error))
  271.  
  272.  
  273.  
  274. def do_cb_na(seq, callback = None):
  275.     CallbackSequenceNoArgs(seq, callback = callback)()
  276.  
  277. do_cb_na = callsback(do_cb_na)
  278.  
  279. class CallbackSequenceNoArgs(object):
  280.     
  281.     def __init__(self, sequence, callback):
  282.         self.iter = iter(sequence)
  283.         self.callback = callback
  284.         self.n = 0
  285.  
  286.     
  287.     def __call__(self, *a):
  288.         self.n = self.n + 1
  289.         
  290.         try:
  291.             next = self.iter.next()
  292.         except StopIteration:
  293.             log.debug('stop iteration, calling success: %r', funcinfo(self.callback.success))
  294.             self.callback.success()
  295.  
  296.         log.debug('%s #%d: %r', funcinfo(self.callback), self.n, funcinfo(next))
  297.         next(**dict(success = self, error = self.callback.error))
  298.  
  299.  
  300.  
  301. def wxcall(func):
  302.     
  303.     def wrapper(*a, **k):
  304.         CallLater(func, threadname = 'MainThread')(*a, **k)
  305.  
  306.     wrapper = (wraps(func),)(wrapper)
  307.     return wrapper
  308.  
  309.  
  310. class CallbackStream(object):
  311.     
  312.     class Cancel(Exception):
  313.         pass
  314.  
  315.     
  316.     def __init__(self, stream, progress, finished):
  317.         if not progress:
  318.             pass
  319.         self._progress = Null
  320.         if not finished:
  321.             pass
  322.         self._finished = Null
  323.         self.cancelled = False
  324.         self.stream = stream
  325.  
  326.     
  327.     def read(self, bytes = -1):
  328.         if self.cancelled:
  329.             raise CallbackStream.Cancel
  330.         self.cancelled
  331.         
  332.         try:
  333.             data = self.stream.read(bytes)
  334.             self.on_progress(self.stream.tell())
  335.         except ValueError:
  336.             data = ''
  337.  
  338.         if data == '':
  339.             self.stream.close()
  340.             if not self.cancelled:
  341.                 self.on_finished()
  342.             
  343.         
  344.         return data
  345.  
  346.     
  347.     def cancel(self):
  348.         self.stream.close()
  349.         self.cancelled = True
  350.  
  351.     
  352.     def tell(self):
  353.         return self.stream.tell()
  354.  
  355.     
  356.     def seek(self, *a, **k):
  357.         return self.stream.seek(*a, **k)
  358.  
  359.     
  360.     def on_progress(self, num_bytes):
  361.         self._progress(num_bytes)
  362.  
  363.     
  364.     def on_finished(self):
  365.         self._finished()
  366.         self._progress = self._finished = Null
  367.  
  368.     
  369.     def fileno(self):
  370.         return self.stream.fileno()
  371.  
  372.     
  373.     def name(self):
  374.         return self.stream.name
  375.  
  376.     name = property(name)
  377.  
  378. if __name__ == '__main__':
  379.     
  380.     class MyProtocol(object):
  381.         
  382.         def networkOperation(self, someArg, callback = None):
  383.             callback.success()
  384.  
  385.         networkOperation = callsback(networkOperation)
  386.  
  387.     
  388.     def good():
  389.         print 'success'
  390.  
  391.     
  392.     def bad():
  393.         print 'bad'
  394.  
  395.     c = Callback(success = good)
  396.     MyProtocol().networkOperation(5, callback = c)
  397.     MyProtocol().networkOperation(5, success = good)
  398.     MyProtocol().networkOperation(5)
  399.  
  400.