home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1867 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  25.2 KB  |  749 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __docformat__ = 'restructuredtext en'
  5. __test__ = { }
  6. import copy
  7. import sys
  8. import cPickle as pickle
  9. from twisted.application import service
  10. from twisted.internet import defer, reactor
  11. from twisted.python import log, failure, components
  12. import zope.interface as zi
  13. from IPython.kernel.core.interpreter import Interpreter
  14. from IPython.kernel import newserialized, error
  15.  
  16. class IEngineCore(zi.Interface):
  17.     id = zi.interface.Attribute('the id of the Engine object')
  18.     properties = zi.interface.Attribute('A dict of properties of the Engine')
  19.     
  20.     def execute(lines):
  21.         pass
  22.  
  23.     
  24.     def push(namespace):
  25.         pass
  26.  
  27.     
  28.     def pull(keys):
  29.         pass
  30.  
  31.     
  32.     def push_function(namespace):
  33.         pass
  34.  
  35.     
  36.     def pull_function(keys):
  37.         pass
  38.  
  39.     
  40.     def get_result(i = None):
  41.         pass
  42.  
  43.     
  44.     def reset():
  45.         pass
  46.  
  47.     
  48.     def kill():
  49.         pass
  50.  
  51.     
  52.     def keys():
  53.         pass
  54.  
  55.  
  56.  
  57. class IEngineSerialized(zi.Interface):
  58.     
  59.     def push_serialized(namespace):
  60.         pass
  61.  
  62.     
  63.     def pull_serialized(keys):
  64.         pass
  65.  
  66.  
  67.  
  68. class IEngineProperties(zi.Interface):
  69.     properties = zi.Attribute('A StrictDict object, containing the properties')
  70.     
  71.     def set_properties(properties):
  72.         pass
  73.  
  74.     
  75.     def get_properties(keys = None):
  76.         pass
  77.  
  78.     
  79.     def del_properties(keys):
  80.         pass
  81.  
  82.     
  83.     def has_properties(keys):
  84.         pass
  85.  
  86.     
  87.     def clear_properties():
  88.         pass
  89.  
  90.  
  91.  
  92. class IEngineBase(IEngineCore, IEngineSerialized, IEngineProperties):
  93.     pass
  94.  
  95.  
  96. class IEngineQueued(IEngineBase):
  97.     
  98.     def clear_queue():
  99.         pass
  100.  
  101.     
  102.     def queue_status():
  103.         pass
  104.  
  105.     
  106.     def register_failure_observer(obs):
  107.         pass
  108.  
  109.     
  110.     def unregister_failure_observer(obs):
  111.         pass
  112.  
  113.  
  114.  
  115. class IEngineThreaded(zi.Interface):
  116.     pass
  117.  
  118.  
  119. class StrictDict(dict):
  120.     
  121.     def __init__(self, *args, **kwargs):
  122.         dict.__init__(self, *args, **kwargs)
  123.         self.modified = True
  124.  
  125.     
  126.     def __getitem__(self, key):
  127.         return copy.deepcopy(dict.__getitem__(self, key))
  128.  
  129.     
  130.     def __setitem__(self, key, value):
  131.         
  132.         try:
  133.             pickle.dumps(key, 2)
  134.             pickle.dumps(value, 2)
  135.             newvalue = copy.deepcopy(value)
  136.         except Exception:
  137.             e = None
  138.             raise error.InvalidProperty("can't be a value: %r" % value)
  139.  
  140.         dict.__setitem__(self, key, newvalue)
  141.         self.modified = True
  142.  
  143.     
  144.     def __delitem__(self, key):
  145.         dict.__delitem__(self, key)
  146.         self.modified = True
  147.  
  148.     
  149.     def update(self, dikt):
  150.         for k, v in dikt.iteritems():
  151.             self[k] = v
  152.         
  153.  
  154.     
  155.     def pop(self, key):
  156.         self.modified = True
  157.         return dict.pop(self, key)
  158.  
  159.     
  160.     def popitem(self):
  161.         self.modified = True
  162.         return dict.popitem(self)
  163.  
  164.     
  165.     def clear(self):
  166.         self.modified = True
  167.         dict.clear(self)
  168.  
  169.     
  170.     def subDict(self, *keys):
  171.         d = { }
  172.         for key in keys:
  173.             d[key] = self[key]
  174.         
  175.         return d
  176.  
  177.  
  178.  
  179. class EngineAPI(object):
  180.     _fix = False
  181.     
  182.     def __init__(self, id):
  183.         self.id = id
  184.         self.properties = StrictDict()
  185.         self._fix = True
  186.  
  187.     
  188.     def __setattr__(self, k, v):
  189.         if self._fix:
  190.             raise error.KernelError('I am protected!')
  191.         self._fix
  192.         object.__setattr__(self, k, v)
  193.  
  194.     
  195.     def __delattr__(self, key):
  196.         raise error.KernelError('I am protected!')
  197.  
  198.  
  199. _apiDict = { }
  200.  
  201. def get_engine(id):
  202.     if not _apiDict.get(id):
  203.         _apiDict[id] = EngineAPI(id)
  204.     
  205.     return _apiDict[id]
  206.  
  207.  
  208. def drop_engine(id):
  209.     if _apiDict.has_key(id):
  210.         del _apiDict[id]
  211.     
  212.  
  213.  
  214. class EngineService(object, service.Service):
  215.     zi.implements(IEngineBase)
  216.     name = 'EngineService'
  217.     
  218.     def __init__(self, shellClass = Interpreter, mpi = None):
  219.         self.shellClass = shellClass
  220.         self.shell = self.shellClass()
  221.         self.mpi = mpi
  222.         self.id = None
  223.         self.properties = get_engine(self.id).properties
  224.         if self.mpi is not None:
  225.             log.msg('MPI started with rank = %i and size = %i' % (self.mpi.rank, self.mpi.size))
  226.             self.id = self.mpi.rank
  227.         
  228.         self._seedNamespace()
  229.  
  230.     
  231.     def _setID(self, id):
  232.         self._id = id
  233.         self.properties = get_engine(id).properties
  234.         self.shell.push({
  235.             'id': id })
  236.  
  237.     
  238.     def _getID(self):
  239.         return self._id
  240.  
  241.     id = property(_getID, _setID)
  242.     
  243.     def _seedNamespace(self):
  244.         self.shell.push({
  245.             'mpi': self.mpi,
  246.             'id': self.id })
  247.  
  248.     
  249.     def executeAndRaise(self, msg, callable, *args, **kwargs):
  250.         d = defer.Deferred()
  251.         
  252.         try:
  253.             result = callable(*args, **kwargs)
  254.         except:
  255.             (et, ev, tb) = sys.exc_info()
  256.             (et, ev, tb) = self.shell.formatTraceback(et, ev, tb, msg)
  257.             ev._ipython_engine_info = msg
  258.             f = failure.Failure(ev, et, None)
  259.             d.errback(f)
  260.  
  261.         d.callback(result)
  262.         return d
  263.  
  264.     
  265.     def execute(self, lines):
  266.         msg = {
  267.             'engineid': self.id,
  268.             'method': 'execute',
  269.             'args': [
  270.                 lines] }
  271.         d = self.executeAndRaise(msg, self.shell.execute, lines)
  272.         d.addCallback(self.addIDToResult)
  273.         return d
  274.  
  275.     
  276.     def addIDToResult(self, result):
  277.         result['id'] = self.id
  278.         return result
  279.  
  280.     
  281.     def push(self, namespace):
  282.         msg = {
  283.             'engineid': self.id,
  284.             'method': 'push',
  285.             'args': [
  286.                 repr(namespace.keys())] }
  287.         d = self.executeAndRaise(msg, self.shell.push, namespace)
  288.         return d
  289.  
  290.     
  291.     def pull(self, keys):
  292.         msg = {
  293.             'engineid': self.id,
  294.             'method': 'pull',
  295.             'args': [
  296.                 repr(keys)] }
  297.         d = self.executeAndRaise(msg, self.shell.pull, keys)
  298.         return d
  299.  
  300.     
  301.     def push_function(self, namespace):
  302.         msg = {
  303.             'engineid': self.id,
  304.             'method': 'push_function',
  305.             'args': [
  306.                 repr(namespace.keys())] }
  307.         d = self.executeAndRaise(msg, self.shell.push_function, namespace)
  308.         return d
  309.  
  310.     
  311.     def pull_function(self, keys):
  312.         msg = {
  313.             'engineid': self.id,
  314.             'method': 'pull_function',
  315.             'args': [
  316.                 repr(keys)] }
  317.         d = self.executeAndRaise(msg, self.shell.pull_function, keys)
  318.         return d
  319.  
  320.     
  321.     def get_result(self, i = None):
  322.         msg = {
  323.             'engineid': self.id,
  324.             'method': 'get_result',
  325.             'args': [
  326.                 repr(i)] }
  327.         d = self.executeAndRaise(msg, self.shell.getCommand, i)
  328.         d.addCallback(self.addIDToResult)
  329.         return d
  330.  
  331.     
  332.     def reset(self):
  333.         msg = {
  334.             'engineid': self.id,
  335.             'method': 'reset',
  336.             'args': [] }
  337.         del self.shell
  338.         self.shell = self.shellClass()
  339.         self.properties.clear()
  340.         d = self.executeAndRaise(msg, self._seedNamespace)
  341.         return d
  342.  
  343.     
  344.     def kill(self):
  345.         drop_engine(self.id)
  346.         
  347.         try:
  348.             reactor.stop()
  349.         except RuntimeError:
  350.             log.msg('The reactor was not running apparently.')
  351.             return defer.fail()
  352.  
  353.         return defer.succeed(None)
  354.  
  355.     
  356.     def keys(self):
  357.         remotes = []
  358.         for k in self.shell.user_ns.iterkeys():
  359.             if k not in ('__name__', '_ih', '_oh', '__builtins__', 'In', 'Out', '_', '__', '___', '__IP', 'input', 'raw_input'):
  360.                 remotes.append(k)
  361.                 continue
  362.         
  363.         return defer.succeed(remotes)
  364.  
  365.     
  366.     def set_properties(self, properties):
  367.         msg = {
  368.             'engineid': self.id,
  369.             'method': 'set_properties',
  370.             'args': [
  371.                 repr(properties.keys())] }
  372.         return self.executeAndRaise(msg, self.properties.update, properties)
  373.  
  374.     
  375.     def get_properties(self, keys = None):
  376.         msg = {
  377.             'engineid': self.id,
  378.             'method': 'get_properties',
  379.             'args': [
  380.                 repr(keys)] }
  381.         if keys is None:
  382.             keys = self.properties.keys()
  383.         
  384.         return self.executeAndRaise(msg, self.properties.subDict, *keys)
  385.  
  386.     
  387.     def _doDel(self, keys):
  388.         for key in keys:
  389.             del self.properties[key]
  390.         
  391.  
  392.     
  393.     def del_properties(self, keys):
  394.         msg = {
  395.             'engineid': self.id,
  396.             'method': 'del_properties',
  397.             'args': [
  398.                 repr(keys)] }
  399.         return self.executeAndRaise(msg, self._doDel, keys)
  400.  
  401.     
  402.     def _doHas(self, keys):
  403.         return [ self.properties.has_key(key) for key in keys ]
  404.  
  405.     
  406.     def has_properties(self, keys):
  407.         msg = {
  408.             'engineid': self.id,
  409.             'method': 'has_properties',
  410.             'args': [
  411.                 repr(keys)] }
  412.         return self.executeAndRaise(msg, self._doHas, keys)
  413.  
  414.     
  415.     def clear_properties(self):
  416.         msg = {
  417.             'engineid': self.id,
  418.             'method': 'clear_properties',
  419.             'args': [] }
  420.         return self.executeAndRaise(msg, self.properties.clear)
  421.  
  422.     
  423.     def push_serialized(self, sNamespace):
  424.         msg = {
  425.             'engineid': self.id,
  426.             'method': 'push_serialized',
  427.             'args': [
  428.                 repr(sNamespace.keys())] }
  429.         ns = { }
  430.         for k, v in sNamespace.iteritems():
  431.             
  432.             try:
  433.                 unserialized = newserialized.IUnSerialized(v)
  434.                 ns[k] = unserialized.getObject()
  435.             continue
  436.             return defer.fail()
  437.  
  438.         
  439.         return self.executeAndRaise(msg, self.shell.push, ns)
  440.  
  441.     
  442.     def pull_serialized(self, keys):
  443.         msg = {
  444.             'engineid': self.id,
  445.             'method': 'pull_serialized',
  446.             'args': [
  447.                 repr(keys)] }
  448.         if isinstance(keys, str):
  449.             keys = [
  450.                 keys]
  451.         
  452.         if len(keys) == 1:
  453.             d = self.executeAndRaise(msg, self.shell.pull, keys)
  454.             d.addCallback(newserialized.serialize)
  455.             return d
  456.         if len(keys) > 1:
  457.             d = self.executeAndRaise(msg, self.shell.pull, keys)
  458.             
  459.             def packThemUp(values):
  460.                 serials = []
  461.                 for v in values:
  462.                     
  463.                     try:
  464.                         serials.append(newserialized.serialize(v))
  465.                     continue
  466.                     return defer.fail(failure.Failure())
  467.  
  468.                 
  469.                 return serials
  470.  
  471.             packThemUp = d.addCallback(packThemUp)
  472.             return packThemUp
  473.  
  474.  
  475.  
  476. def queue(methodToQueue):
  477.     
  478.     def queuedMethod(this, *args, **kwargs):
  479.         name = methodToQueue.__name__
  480.         return this.submitCommand(Command(name, *args, **kwargs))
  481.  
  482.     return queuedMethod
  483.  
  484.  
  485. class QueuedEngine(object):
  486.     zi.implements(IEngineQueued)
  487.     
  488.     def __init__(self, engine):
  489.         self.engine = engine
  490.         self.id = engine.id
  491.         self.queued = []
  492.         self.history = { }
  493.         self.engineStatus = { }
  494.         self.currentCommand = None
  495.         self.failureObservers = []
  496.  
  497.     
  498.     def _get_properties(self):
  499.         return self.engine.properties
  500.  
  501.     properties = property(_get_properties, (lambda self, _: pass))
  502.     
  503.     def submitCommand(self, cmd):
  504.         d = defer.Deferred()
  505.         cmd.setDeferred(d)
  506.         if self.currentCommand is not None:
  507.             if self.currentCommand.finished:
  508.                 self.currentCommand = cmd
  509.                 self.runCurrentCommand()
  510.             else:
  511.                 self.queued.append(cmd)
  512.         else:
  513.             self.currentCommand = cmd
  514.             self.runCurrentCommand()
  515.         return d
  516.  
  517.     
  518.     def runCurrentCommand(self):
  519.         cmd = self.currentCommand
  520.         f = getattr(self.engine, cmd.remoteMethod, None)
  521.         if f:
  522.             d = f(*cmd.args, **cmd.kwargs)
  523.             if cmd.remoteMethod is 'execute':
  524.                 d.addCallback(self.saveResult)
  525.             
  526.             d.addCallback(self.finishCommand)
  527.             d.addErrback(self.abortCommand)
  528.         else:
  529.             return defer.fail(AttributeError(cmd.remoteMethod))
  530.         return f
  531.  
  532.     
  533.     def _flushQueue(self):
  534.         if len(self.queued) > 0:
  535.             self.currentCommand = self.queued.pop(0)
  536.             self.runCurrentCommand()
  537.         
  538.  
  539.     
  540.     def saveResult(self, result):
  541.         self.history[result['number']] = result
  542.         return result
  543.  
  544.     
  545.     def finishCommand(self, result):
  546.         self.currentCommand.handleResult(result)
  547.         self.currentCommand.finished = True
  548.         self._flushQueue()
  549.         return result
  550.  
  551.     
  552.     def abortCommand(self, reason):
  553.         self.currentCommand.finished = True
  554.         s = '%r %r %r' % (self.currentCommand.remoteMethod, self.currentCommand.args, self.currentCommand.kwargs)
  555.         self.clear_queue(msg = s)
  556.         self.currentCommand.handleError(reason)
  557.  
  558.     
  559.     def execute(self, lines):
  560.         pass
  561.  
  562.     execute = queue(execute)
  563.     
  564.     def push(self, namespace):
  565.         pass
  566.  
  567.     push = queue(push)
  568.     
  569.     def pull(self, keys):
  570.         pass
  571.  
  572.     pull = queue(pull)
  573.     
  574.     def push_function(self, namespace):
  575.         pass
  576.  
  577.     push_function = queue(push_function)
  578.     
  579.     def pull_function(self, keys):
  580.         pass
  581.  
  582.     pull_function = queue(pull_function)
  583.     
  584.     def get_result(self, i = None):
  585.         if i is None:
  586.             i = max(self.history.keys() + [
  587.                 None])
  588.         
  589.         cmd = self.history.get(i, None)
  590.         if cmd is None:
  591.             return self.submitCommand(Command('get_result', i))
  592.         return defer.succeed(cmd)
  593.  
  594.     
  595.     def reset(self):
  596.         self.clear_queue()
  597.         self.history = { }
  598.         return self.submitCommand(Command('reset'))
  599.  
  600.     
  601.     def kill(self):
  602.         self.clear_queue()
  603.         return self.submitCommand(Command('kill'))
  604.  
  605.     
  606.     def keys(self):
  607.         pass
  608.  
  609.     keys = queue(keys)
  610.     
  611.     def push_serialized(self, namespace):
  612.         pass
  613.  
  614.     push_serialized = queue(push_serialized)
  615.     
  616.     def pull_serialized(self, keys):
  617.         pass
  618.  
  619.     pull_serialized = queue(pull_serialized)
  620.     
  621.     def set_properties(self, namespace):
  622.         pass
  623.  
  624.     set_properties = queue(set_properties)
  625.     
  626.     def get_properties(self, keys = None):
  627.         pass
  628.  
  629.     get_properties = queue(get_properties)
  630.     
  631.     def del_properties(self, keys):
  632.         pass
  633.  
  634.     del_properties = queue(del_properties)
  635.     
  636.     def has_properties(self, keys):
  637.         pass
  638.  
  639.     has_properties = queue(has_properties)
  640.     
  641.     def clear_properties(self):
  642.         pass
  643.  
  644.     clear_properties = queue(clear_properties)
  645.     
  646.     def clear_queue(self, msg = ''):
  647.         for cmd in self.queued:
  648.             cmd.deferred.errback(failure.Failure(error.QueueCleared(msg)))
  649.         
  650.         self.queued = []
  651.         return defer.succeed(None)
  652.  
  653.     
  654.     def queue_status(self):
  655.         if self.currentCommand is not None:
  656.             if self.currentCommand.finished:
  657.                 pending = repr(None)
  658.             else:
  659.                 pending = repr(self.currentCommand)
  660.         else:
  661.             pending = repr(None)
  662.         dikt = {
  663.             'queue': map(repr, self.queued),
  664.             'pending': pending }
  665.         return defer.succeed(dikt)
  666.  
  667.     
  668.     def register_failure_observer(self, obs):
  669.         self.failureObservers.append(obs)
  670.  
  671.     
  672.     def unregister_failure_observer(self, obs):
  673.         self.failureObservers.remove(obs)
  674.  
  675.  
  676. components.registerAdapter(QueuedEngine, IEngineBase, IEngineQueued)
  677.  
  678. class Command(object):
  679.     
  680.     def __init__(self, remoteMethod, *args, **kwargs):
  681.         self.remoteMethod = remoteMethod
  682.         self.args = args
  683.         self.kwargs = kwargs
  684.         self.finished = False
  685.  
  686.     
  687.     def setDeferred(self, d):
  688.         self.deferred = d
  689.  
  690.     
  691.     def __repr__(self):
  692.         if not self.args:
  693.             args = ''
  694.         else:
  695.             args = str(self.args)[1:-2]
  696.         for k, v in self.kwargs.iteritems():
  697.             if args:
  698.                 args += ', '
  699.             
  700.             args += '%s=%r' % (k, v)
  701.         
  702.         return '%s(%s)' % (self.remoteMethod, args)
  703.  
  704.     
  705.     def handleResult(self, result):
  706.         self.deferred.callback(result)
  707.  
  708.     
  709.     def handleError(self, reason):
  710.         self.deferred.errback(reason)
  711.  
  712.  
  713.  
  714. class ThreadedEngineService(EngineService):
  715.     zi.implements(IEngineBase)
  716.     
  717.     def __init__(self, shellClass = Interpreter, mpi = None):
  718.         EngineService.__init__(self, shellClass, mpi)
  719.  
  720.     
  721.     def wrapped_execute(self, msg, lines):
  722.         
  723.         try:
  724.             result = self.shell.execute(lines)
  725.         except Exception:
  726.             e = None
  727.             (et, ev, tb) = sys.exc_info()
  728.             (et, ev, tb) = self.shell.formatTraceback(et, ev, tb, msg)
  729.             e = et(ev._ipython_traceback_text)
  730.             e._ipython_engine_info = msg
  731.             raise e
  732.  
  733.         return result
  734.  
  735.     
  736.     def execute(self, lines):
  737.         threads = threads
  738.         import twisted.internet
  739.         msg = {
  740.             'engineid': self.id,
  741.             'method': 'execute',
  742.             'args': [
  743.                 lines] }
  744.         d = threads.deferToThread(self.wrapped_execute, msg, lines)
  745.         d.addCallback(self.addIDToResult)
  746.         return d
  747.  
  748.  
  749.