home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1889 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  8.3 KB  |  201 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __docformat__ = 'restructuredtext en'
  5. import cPickle as pickle
  6. import xmlrpclib
  7. import copy
  8. from zope.interface import Interface, implements
  9. from twisted.internet import defer
  10. from twisted.python import components, failure
  11. from foolscap import Referenceable
  12. from IPython.kernel.twistedutil import blockingCallFromThread
  13. from IPython.kernel import error, task as taskmodule, taskclient
  14. from IPython.kernel.pickleutil import can, uncan
  15. from IPython.kernel.clientinterfaces import IFCClientInterfaceProvider, IBlockingClientAdaptor
  16. from IPython.kernel.mapper import TaskMapper, ITaskMapperFactory, IMapper
  17. from IPython.kernel.parallelfunction import ParallelFunction, ITaskParallelDecorator
  18.  
  19. class IFCTaskController(Interface):
  20.     
  21.     def remote_run(binTask):
  22.         pass
  23.  
  24.     
  25.     def remote_abort(taskid):
  26.         pass
  27.  
  28.     
  29.     def remote_get_task_result(taskid, block = False):
  30.         pass
  31.  
  32.     
  33.     def remote_barrier(taskids):
  34.         pass
  35.  
  36.     
  37.     def remote_spin():
  38.         pass
  39.  
  40.     
  41.     def remote_queue_status(verbose):
  42.         pass
  43.  
  44.     
  45.     def remote_clear():
  46.         pass
  47.  
  48.  
  49.  
  50. class FCTaskControllerFromTaskController(Referenceable):
  51.     implements(IFCTaskController, IFCClientInterfaceProvider)
  52.     
  53.     def __init__(self, taskController):
  54.         self.taskController = taskController
  55.  
  56.     
  57.     def packageFailure(self, f):
  58.         f.cleanFailure()
  59.         return self.packageSuccess(f)
  60.  
  61.     
  62.     def packageSuccess(self, obj):
  63.         serial = pickle.dumps(obj, 2)
  64.         return serial
  65.  
  66.     
  67.     def remote_run(self, ptask):
  68.         
  69.         try:
  70.             task = pickle.loads(ptask)
  71.             task.uncan_task()
  72.         except:
  73.             d = defer.fail(pickle.UnpickleableError('Could not unmarshal task'))
  74.  
  75.         d = self.taskController.run(task)
  76.         d.addCallback(self.packageSuccess)
  77.         d.addErrback(self.packageFailure)
  78.         return d
  79.  
  80.     
  81.     def remote_abort(self, taskid):
  82.         d = self.taskController.abort(taskid)
  83.         d.addCallback(self.packageSuccess)
  84.         d.addErrback(self.packageFailure)
  85.         return d
  86.  
  87.     
  88.     def remote_get_task_result(self, taskid, block = False):
  89.         d = self.taskController.get_task_result(taskid, block)
  90.         d.addCallback(self.packageSuccess)
  91.         d.addErrback(self.packageFailure)
  92.         return d
  93.  
  94.     
  95.     def remote_barrier(self, taskids):
  96.         d = self.taskController.barrier(taskids)
  97.         d.addCallback(self.packageSuccess)
  98.         d.addErrback(self.packageFailure)
  99.         return d
  100.  
  101.     
  102.     def remote_spin(self):
  103.         d = self.taskController.spin()
  104.         d.addCallback(self.packageSuccess)
  105.         d.addErrback(self.packageFailure)
  106.         return d
  107.  
  108.     
  109.     def remote_queue_status(self, verbose):
  110.         d = self.taskController.queue_status(verbose)
  111.         d.addCallback(self.packageSuccess)
  112.         d.addErrback(self.packageFailure)
  113.         return d
  114.  
  115.     
  116.     def remote_clear(self):
  117.         return self.taskController.clear()
  118.  
  119.     
  120.     def remote_get_client_name(self):
  121.         return 'IPython.kernel.taskfc.FCTaskClient'
  122.  
  123.  
  124. components.registerAdapter(FCTaskControllerFromTaskController, taskmodule.ITaskController, IFCTaskController)
  125.  
  126. class FCTaskClient(object):
  127.     implements(taskmodule.ITaskController, IBlockingClientAdaptor, ITaskMapperFactory, IMapper, ITaskParallelDecorator)
  128.     
  129.     def __init__(self, remote_reference):
  130.         self.remote_reference = remote_reference
  131.  
  132.     
  133.     def unpackage(self, r):
  134.         return pickle.loads(r)
  135.  
  136.     
  137.     def run(self, task):
  138.         task.can_task()
  139.         ptask = pickle.dumps(task, 2)
  140.         task.uncan_task()
  141.         d = self.remote_reference.callRemote('run', ptask)
  142.         d.addCallback(self.unpackage)
  143.         return d
  144.  
  145.     
  146.     def get_task_result(self, taskid, block = False):
  147.         d = self.remote_reference.callRemote('get_task_result', taskid, block)
  148.         d.addCallback(self.unpackage)
  149.         return d
  150.  
  151.     
  152.     def abort(self, taskid):
  153.         d = self.remote_reference.callRemote('abort', taskid)
  154.         d.addCallback(self.unpackage)
  155.         return d
  156.  
  157.     
  158.     def barrier(self, taskids):
  159.         d = self.remote_reference.callRemote('barrier', taskids)
  160.         d.addCallback(self.unpackage)
  161.         return d
  162.  
  163.     
  164.     def spin(self):
  165.         d = self.remote_reference.callRemote('spin')
  166.         d.addCallback(self.unpackage)
  167.         return d
  168.  
  169.     
  170.     def queue_status(self, verbose = False):
  171.         d = self.remote_reference.callRemote('queue_status', verbose)
  172.         d.addCallback(self.unpackage)
  173.         return d
  174.  
  175.     
  176.     def clear(self):
  177.         d = self.remote_reference.callRemote('clear')
  178.         return d
  179.  
  180.     
  181.     def adapt_to_blocking_client(self):
  182.         IBlockingTaskClient = IBlockingTaskClient
  183.         import IPython.kernel.taskclient
  184.         return IBlockingTaskClient(self)
  185.  
  186.     
  187.     def map(self, func, *sequences):
  188.         return self.mapper().map(func, *sequences)
  189.  
  190.     
  191.     def mapper(self, clear_before = False, clear_after = False, retries = 0, recovery_task = None, depend = None, block = True):
  192.         return TaskMapper(self, clear_before = clear_before, clear_after = clear_after, retries = retries, recovery_task = recovery_task, depend = depend, block = block)
  193.  
  194.     
  195.     def parallel(self, clear_before = False, clear_after = False, retries = 0, recovery_task = None, depend = None, block = True):
  196.         mapper = self.mapper(clear_before, clear_after, retries, recovery_task, depend, block)
  197.         pf = ParallelFunction(mapper)
  198.         return pf
  199.  
  200.  
  201.