home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / calibre-0.7.26.msi / file_1945 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-10-31  |  5.8 KB  |  131 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __docformat__ = 'restructuredtext en'
  5. from types import FunctionType
  6. from zope.interface import Interface, implements
  7. from IPython.kernel.task import MapTask
  8. from IPython.kernel.twistedutil import DeferredList, gatherBoth
  9. from IPython.kernel.util import printer
  10. from IPython.kernel.error import collect_exceptions
  11.  
  12. class IMapper(Interface):
  13.     
  14.     def map(func, *seqs):
  15.         pass
  16.  
  17.  
  18.  
  19. class IMultiEngineMapperFactory(Interface):
  20.     
  21.     def mapper(dist = 'b', targets = 'all', block = True):
  22.         pass
  23.  
  24.  
  25.  
  26. class ITaskMapperFactory(Interface):
  27.     
  28.     def mapper(clear_before = False, clear_after = False, retries = 0, recovery_task = None, depend = None, block = True):
  29.         pass
  30.  
  31.  
  32.  
  33. class MultiEngineMapper(object):
  34.     implements(IMapper)
  35.     
  36.     def __init__(self, multiengine, dist = 'b', targets = 'all', block = True):
  37.         self.multiengine = multiengine
  38.         self.dist = dist
  39.         self.targets = targets
  40.         self.block = block
  41.  
  42.     
  43.     def map(self, func, *sequences):
  44.         max_len = max((lambda .0: for s in .0:
  45. len(s))(sequences))
  46.         for s in sequences:
  47.             if len(s) != max_len:
  48.                 raise ValueError('all sequences must have equal length')
  49.             len(s) != max_len
  50.         
  51.         return self.multiengine.raw_map(func, sequences, dist = self.dist, targets = self.targets, block = self.block)
  52.  
  53.  
  54.  
  55. class TaskMapper(object):
  56.     
  57.     def __init__(self, task_controller, clear_before = False, clear_after = False, retries = 0, recovery_task = None, depend = None, block = True):
  58.         self.task_controller = task_controller
  59.         self.clear_before = clear_before
  60.         self.clear_after = clear_after
  61.         self.retries = retries
  62.         self.recovery_task = recovery_task
  63.         self.depend = depend
  64.         self.block = block
  65.  
  66.     
  67.     def map(self, func, *sequences):
  68.         max_len = max((lambda .0: for s in .0:
  69. len(s))(sequences))
  70.         for s in sequences:
  71.             if len(s) != max_len:
  72.                 raise ValueError('all sequences must have equal length')
  73.             len(s) != max_len
  74.         
  75.         task_args = zip(*sequences)
  76.         task_ids = []
  77.         dlist = []
  78.         for ta in task_args:
  79.             task = MapTask(func, ta, clear_before = self.clear_before, clear_after = self.clear_after, retries = self.retries, recovery_task = self.recovery_task, depend = self.depend)
  80.             dlist.append(self.task_controller.run(task))
  81.         
  82.         dlist = gatherBoth(dlist, consumeErrors = 1)
  83.         dlist.addCallback(collect_exceptions, 'map')
  84.         if self.block:
  85.             
  86.             def get_results(task_ids):
  87.                 d = self.task_controller.barrier(task_ids)
  88.                 (None, d.addCallback)((lambda _: []([ self.task_controller.get_task_result(tid) for tid in task_ids ], consumeErrors = 1)))
  89.                 d.addCallback(collect_exceptions, 'map')
  90.                 return d
  91.  
  92.             dlist.addCallback(get_results)
  93.         
  94.         return dlist
  95.  
  96.  
  97.  
  98. class SynchronousTaskMapper(object):
  99.     
  100.     def __init__(self, task_controller, clear_before = False, clear_after = False, retries = 0, recovery_task = None, depend = None, block = True):
  101.         self.task_controller = task_controller
  102.         self.clear_before = clear_before
  103.         self.clear_after = clear_after
  104.         self.retries = retries
  105.         self.recovery_task = recovery_task
  106.         self.depend = depend
  107.         self.block = block
  108.  
  109.     
  110.     def map(self, func, *sequences):
  111.         max_len = max((lambda .0: for s in .0:
  112. len(s))(sequences))
  113.         for s in sequences:
  114.             if len(s) != max_len:
  115.                 raise ValueError('all sequences must have equal length')
  116.             len(s) != max_len
  117.         
  118.         task_args = zip(*sequences)
  119.         task_ids = []
  120.         for ta in task_args:
  121.             task = MapTask(func, ta, clear_before = self.clear_before, clear_after = self.clear_after, retries = self.retries, recovery_task = self.recovery_task, depend = self.depend)
  122.             task_ids.append(self.task_controller.run(task))
  123.         
  124.         if self.block:
  125.             self.task_controller.barrier(task_ids)
  126.             task_results = [ self.task_controller.get_task_result(tid) for tid in task_ids ]
  127.             return task_results
  128.         return task_ids
  129.  
  130.  
  131.