home *** CD-ROM | disk | FTP | other *** search
- # Source Generated with Decompyle++
- # File: in.pyo (Python 2.6)
-
- from __future__ import with_statement
- from introspect import funcinfo
- from primitives.funcs import Delegate
- from functools import wraps
- from logging import getLogger
- from traceback import print_exc
- import sys
- import threading
- log = getLogger('callbacks')
- CALLBACKS = ('success', 'error', 'timeout')
- call_later_lock = threading.Lock()
- call_laters = dict()
-
- def register_call_later(threadname, call_later):
- call_later_lock.__enter__()
-
- try:
- call_laters[threadname] = call_later
- finally:
- pass
-
-
-
- def unregister_call_later(threadname):
- call_later_lock.__enter__()
-
- try:
- call_laters.pop(threadname)
- finally:
- pass
-
-
-
- DO_NOTHING = lambda *a, **k: pass
-
- class CallLater(object):
-
- def __init__(self, cb, threadname = None):
- if not threadname:
- pass
- self.threadname = threading.currentThread().getName()
- if self.threadname not in call_laters:
-
- try:
- cb_dbg_str = ', '.join((lambda .0: for s in .0:
- str(s))([
- funcinfo(cb),
- cb.func_code.co_filename,
- cb.func_code.co_firstlineno]))
- except Exception:
- cb_dbg_str = 'Error making debug string. Repr is: {%s}' % funcinfo(cb)
-
- if cb is not DO_NOTHING:
- pass
-
-
- self.cb = cb
-
-
- def __repr__(self):
- return '<%s %s>' % (type(self).__name__, funcinfo(self.cb))
-
-
- def __call__(self, *a, **k):
- if threading.currentThread().getName() != self.threadname and self.threadname in call_laters:
-
- try:
- return (None, None, call_laters[self.threadname])((lambda : self.cb(*a, **k)))
- except Exception:
- print >>sys.stderr, 'callback is %s' % funcinfo(self.cb)
- raise
- except:
- None<EXCEPTION MATCH>Exception
-
-
- None<EXCEPTION MATCH>Exception
-
- try:
- return self.cb(*a, **k)
- except Exception:
- 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)
- raise
-
-
-
-
- class CallLaterDelegate(Delegate):
-
- def __init__(self, *a):
- Delegate.__init__(self, (lambda .0: for x in .0:
- CallLater(x))(a))
-
-
- def __iadd__(self, f):
- if isinstance(f, list):
- for thing in f:
- self += thing
-
- else:
- self.append(CallLater(f))
- return self
-
-
-
- class Callback(object):
- _callback_names = CALLBACKS
-
- def __init__(self, _cbnames = None, **cbs):
- if _cbnames is not None:
- self._callback_names = _cbnames
-
- for name, callback in cbs.iteritems():
- if not callable(callback):
- raise TypeError('keyword args to Callback must be callable: %s' % name)
- callable(callback)
- setattr(self, name, CallLaterDelegate(callback))
- attr = getattr(self, name)
-
-
-
- def __getattr__(self, attr):
-
- try:
- return object.__getattribute__(self, attr)
- except AttributeError:
- if attr in self._callback_names:
- return CallLaterDelegate()
- raise
- except:
- attr in self._callback_names
-
-
-
- def __setattr__(self, attr, val):
- object.__setattr__(self, attr, val)
-
-
- def __call__(self, *a, **k):
- return self.success(*a, **k)
-
-
- def __repr__(self):
- return '<%s %s>' % (type(self).__name__, ' '.join((lambda .0: for item in .0:
- '%s=%s' % item)(self.__dict__.items())))
-
-
- EMPTY_CALLBACK = Callback()
- DefaultCallback = EMPTY_CALLBACK
- CALLBACK_ATTR = '_iscallback'
-
- def callback_adapter(f, do_return = True):
-
- def wrapped(*a, **k):
- cb = k.pop('callback')
-
- try:
- retval = f(*a, **k)
- except Exception:
- e = None
- cb.error(e)
-
- cb.success(retval)
- if do_return:
- return retval
-
- wrapped = (None, callsback)(wrapped)
- return wrapped
-
-
- def callsback(func, callbacks_ = CALLBACKS):
-
- def wrapper(*secret_a, **secret_kws):
- cb = None
- if 'callback' in secret_kws:
- if (any,)((lambda .0: for cbname in .0:
- cbname in secret_kws)(callbacks_)):
- raise AssertionError('use callback or individual callbacks')
- (any,)((lambda .0: for cbname in .0:
- cbname in secret_kws)(callbacks_))
- cb = secret_kws['callback']
- else:
- for cbname in callbacks_:
- if cbname in secret_kws:
- if cb is None:
- cb = Callback()
-
- if not callable(secret_kws[cbname]):
- raise TypeError('%s must be callable' % cbname)
- callable(secret_kws[cbname])
- mycb = CallLaterDelegate(secret_kws[cbname])
- setattr(cb, cbname, mycb)
- del secret_kws[cbname]
- continue
-
- secret_kws['callback'] = cb
- if cb is None:
- _cbnames = None if callbacks_ is CALLBACKS else callbacks_
- secret_kws['callback'] = cb = Callback(_cbnames = _cbnames)
-
-
- try:
- val = func(*secret_a, **secret_kws)
- except Exception:
- e = None
- print_exc()
- callany = callany
- import util
- if not callany(cb.error, e):
- raise
- callany(cb.error, e)
- val = None
-
- if val is True:
- cb.success()
-
- return val
-
- wrapper = (None, wraps(func))(wrapper)
- setattr(wrapper, CALLBACK_ATTR, True)
- return wrapper
-
-
- def is_callsback(f):
- return bool(getattr(f, CALLBACK_ATTR, False))
-
-
- def named_callbacks(names = ()):
-
- def wrapper(func):
- return callsback(func, names)
-
- return wrapper
-
-
- def do_cb(seq, callback = None):
- CallbackSequence(seq, callback = callback)()
-
- do_cb = callsback(do_cb)
-
- class CallbackSequence(object):
-
- def __init__(self, sequence, callback):
- self.iter = iter(sequence)
- self.callback = callback
- self.n = 0
-
-
- def __call__(self, *a):
- self.n = self.n + 1
-
- try:
- next = self.iter.next()
- except StopIteration:
- log.debug('stop iteration, calling success: %r', funcinfo(self.callback.success))
- self.callback.success()
-
- log.debug('%s #%d: %r', funcinfo(self.callback), self.n, funcinfo(next))
- next(*a, **dict(success = self, error = self.callback.error))
-
-
-
- def do_cb_na(seq, callback = None):
- CallbackSequenceNoArgs(seq, callback = callback)()
-
- do_cb_na = callsback(do_cb_na)
-
- class CallbackSequenceNoArgs(object):
-
- def __init__(self, sequence, callback):
- self.iter = iter(sequence)
- self.callback = callback
- self.n = 0
-
-
- def __call__(self, *a):
- self.n = self.n + 1
-
- try:
- next = self.iter.next()
- except StopIteration:
- log.debug('stop iteration, calling success: %r', funcinfo(self.callback.success))
- self.callback.success()
-
- log.debug('%s #%d: %r', funcinfo(self.callback), self.n, funcinfo(next))
- next(**dict(success = self, error = self.callback.error))
-
-
-
- def wxcall(func):
-
- def wrapper(*a, **k):
- CallLater(func, threadname = 'MainThread')(*a, **k)
-
- wrapper = (wraps(func),)(wrapper)
- return wrapper
-
-
- class CallbackStream(object):
-
- class Cancel(Exception):
- pass
-
-
- def __init__(self, stream, progress, finished):
- if not progress:
- pass
- self._progress = Null
- if not finished:
- pass
- self._finished = Null
- self.cancelled = False
- self.stream = stream
-
-
- def read(self, bytes = -1):
- if self.cancelled:
- raise CallbackStream.Cancel
- self.cancelled
-
- try:
- data = self.stream.read(bytes)
- self.on_progress(self.stream.tell())
- except ValueError:
- data = ''
-
- if data == '':
- self.stream.close()
- if not self.cancelled:
- self.on_finished()
-
-
- return data
-
-
- def cancel(self):
- self.stream.close()
- self.cancelled = True
-
-
- def tell(self):
- return self.stream.tell()
-
-
- def seek(self, *a, **k):
- return self.stream.seek(*a, **k)
-
-
- def on_progress(self, num_bytes):
- self._progress(num_bytes)
-
-
- def on_finished(self):
- self._finished()
- self._progress = self._finished = Null
-
-
- def fileno(self):
- return self.stream.fileno()
-
-
- def name(self):
- return self.stream.name
-
- name = property(name)
-
- if __name__ == '__main__':
-
- class MyProtocol(object):
-
- def networkOperation(self, someArg, callback = None):
- callback.success()
-
- networkOperation = callsback(networkOperation)
-
-
- def good():
- print 'success'
-
-
- def bad():
- print 'bad'
-
- c = Callback(success = good)
- MyProtocol().networkOperation(5, callback = c)
- MyProtocol().networkOperation(5, success = good)
- MyProtocol().networkOperation(5)
-
-