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

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import threading
  6. from IPython.ultraTB import AutoFormattedTB
  7. from IPython.genutils import warn, error
  8.  
  9. class BackgroundJobManager:
  10.     
  11.     def __init__(self):
  12.         self.jobs_run = []
  13.         self.jobs_comp = []
  14.         self.jobs_dead = []
  15.         self.jobs_all = { }
  16.         self._comp_report = []
  17.         self._dead_report = []
  18.         self._s_created = BackgroundJobBase.stat_created_c
  19.         self._s_running = BackgroundJobBase.stat_running_c
  20.         self._s_completed = BackgroundJobBase.stat_completed_c
  21.         self._s_dead = BackgroundJobBase.stat_dead_c
  22.  
  23.     
  24.     def new(self, func_or_exp, *args, **kwargs):
  25.         if callable(func_or_exp):
  26.             kw = kwargs.get('kw', { })
  27.             job = BackgroundJobFunc(func_or_exp, *args, **kw)
  28.         elif isinstance(func_or_exp, basestring):
  29.             if not args:
  30.                 frame = sys._getframe(1)
  31.                 glob = frame.f_globals
  32.                 loc = frame.f_locals
  33.             elif len(args) == 1:
  34.                 glob = loc = args[0]
  35.             elif len(args) == 2:
  36.                 (glob, loc) = args
  37.             else:
  38.                 raise ValueError, 'Expression jobs take at most 2 args (globals,locals)'
  39.             job = args(func_or_exp, glob, loc)
  40.         else:
  41.             raise 
  42.         jkeys = callable(func_or_exp).jobs_all.keys()
  43.         if jkeys:
  44.             job.num = max(jkeys) + 1
  45.         else:
  46.             job.num = 0
  47.         self.jobs_run.append(job)
  48.         self.jobs_all[job.num] = job
  49.         print 'Starting job # %s in a separate thread.' % job.num
  50.         job.start()
  51.         return job
  52.  
  53.     
  54.     def __getitem__(self, key):
  55.         return self.jobs_all[key]
  56.  
  57.     
  58.     def __call__(self):
  59.         return self.status()
  60.  
  61.     
  62.     def _update_status(self):
  63.         run = self._s_running
  64.         comp = self._s_completed
  65.         dead = self._s_dead
  66.         jobs_run = self.jobs_run
  67.         for num in range(len(jobs_run)):
  68.             job = jobs_run[num]
  69.             stat = job.stat_code
  70.             if stat == run:
  71.                 continue
  72.                 continue
  73.             if stat == comp:
  74.                 self.jobs_comp.append(job)
  75.                 self._comp_report.append(job)
  76.                 jobs_run[num] = False
  77.                 continue
  78.             if stat == dead:
  79.                 self.jobs_dead.append(job)
  80.                 self._dead_report.append(job)
  81.                 jobs_run[num] = False
  82.                 continue
  83.         
  84.         self.jobs_run = filter(None, self.jobs_run)
  85.  
  86.     
  87.     def _group_report(self, group, name):
  88.         if group:
  89.             print '%s jobs:' % name
  90.             for job in group:
  91.                 print '%s : %s' % (job.num, job)
  92.             
  93.             print 
  94.             return True
  95.  
  96.     
  97.     def _group_flush(self, group, name):
  98.         njobs = len(group)
  99.         if njobs:
  100.             plural = {
  101.                 1: '' }.setdefault(njobs, 's')
  102.             print 'Flushing %s %s job%s.' % (njobs, name, plural)
  103.             group[:] = []
  104.             return True
  105.  
  106.     
  107.     def _status_new(self):
  108.         self._update_status()
  109.         new_comp = self._group_report(self._comp_report, 'Completed')
  110.         new_dead = self._group_report(self._dead_report, 'Dead, call jobs.traceback() for details')
  111.         self._comp_report[:] = []
  112.         self._dead_report[:] = []
  113.         if not new_comp:
  114.             pass
  115.         return new_dead
  116.  
  117.     
  118.     def status(self, verbose = 0):
  119.         self._update_status()
  120.         self._group_report(self.jobs_run, 'Running')
  121.         self._group_report(self.jobs_comp, 'Completed')
  122.         self._group_report(self.jobs_dead, 'Dead')
  123.         self._comp_report[:] = []
  124.         self._dead_report[:] = []
  125.  
  126.     
  127.     def remove(self, num):
  128.         
  129.         try:
  130.             job = self.jobs_all[num]
  131.         except KeyError:
  132.             error('Job #%s not found' % num)
  133.  
  134.         stat_code = job.stat_code
  135.         if stat_code == self._s_running:
  136.             error('Job #%s is still running, it can not be removed.' % num)
  137.             return None
  138.         if stat_code == self._s_completed:
  139.             self.jobs_comp.remove(job)
  140.         elif stat_code == self._s_dead:
  141.             self.jobs_dead.remove(job)
  142.         
  143.  
  144.     
  145.     def flush_finished(self):
  146.         if self._status_new():
  147.             error('New jobs completed since last _status_new(), aborting flush.')
  148.             return None
  149.         jobs_all = self.jobs_all
  150.         for job in self.jobs_comp + self.jobs_dead:
  151.             del jobs_all[job.num]
  152.         
  153.         fl_comp = self._group_flush(self.jobs_comp, 'Completed')
  154.         fl_dead = self._group_flush(self.jobs_dead, 'Dead')
  155.  
  156.     
  157.     def result(self, num):
  158.         
  159.         try:
  160.             return self.jobs_all[num].result
  161.         except KeyError:
  162.             error('Job #%s not found' % num)
  163.  
  164.  
  165.     
  166.     def traceback(self, num):
  167.         
  168.         try:
  169.             self.jobs_all[num].traceback()
  170.         except KeyError:
  171.             error('Job #%s not found' % num)
  172.  
  173.  
  174.  
  175.  
  176. class BackgroundJobBase(threading.Thread):
  177.     stat_created = 'Created'
  178.     stat_created_c = 0
  179.     stat_running = 'Running'
  180.     stat_running_c = 1
  181.     stat_completed = 'Completed'
  182.     stat_completed_c = 2
  183.     stat_dead = 'Dead (Exception), call jobs.traceback() for details'
  184.     stat_dead_c = -1
  185.     
  186.     def __init__(self):
  187.         raise NotImplementedError, 'This class can not be instantiated directly.'
  188.  
  189.     
  190.     def _init(self):
  191.         for attr in [
  192.             'call',
  193.             'strform']:
  194.             pass
  195.         
  196.         self.num = None
  197.         self.status = BackgroundJobBase.stat_created
  198.         self.stat_code = BackgroundJobBase.stat_created_c
  199.         self.finished = False
  200.         self.result = '<BackgroundJob has not completed>'
  201.         
  202.         try:
  203.             self._make_tb = __IPYTHON__.InteractiveTB.text
  204.         except:
  205.             self._make_tb = AutoFormattedTB(mode = 'Context', color_scheme = 'NoColor', tb_offset = 1).text
  206.  
  207.         self._tb = None
  208.         threading.Thread.__init__(self)
  209.  
  210.     
  211.     def __str__(self):
  212.         return self.strform
  213.  
  214.     
  215.     def __repr__(self):
  216.         return '<BackgroundJob: %s>' % self.strform
  217.  
  218.     
  219.     def traceback(self):
  220.         print self._tb
  221.  
  222.     
  223.     def run(self):
  224.         
  225.         try:
  226.             self.status = BackgroundJobBase.stat_running
  227.             self.stat_code = BackgroundJobBase.stat_running_c
  228.             self.result = self.call()
  229.         except:
  230.             self.status = BackgroundJobBase.stat_dead
  231.             self.stat_code = BackgroundJobBase.stat_dead_c
  232.             self.finished = None
  233.             self.result = '<BackgroundJob died, call jobs.traceback() for details>'
  234.             self._tb = self._make_tb()
  235.  
  236.         self.status = BackgroundJobBase.stat_completed
  237.         self.stat_code = BackgroundJobBase.stat_completed_c
  238.         self.finished = True
  239.  
  240.  
  241.  
  242. class BackgroundJobExpr(BackgroundJobBase):
  243.     
  244.     def __init__(self, expression, glob = None, loc = None):
  245.         self.code = compile(expression, '<BackgroundJob compilation>', 'eval')
  246.         if glob is None:
  247.             glob = { }
  248.         
  249.         if loc is None:
  250.             loc = { }
  251.         
  252.         self.expression = self.strform = expression
  253.         self.glob = glob
  254.         self.loc = loc
  255.         self._init()
  256.  
  257.     
  258.     def call(self):
  259.         return eval(self.code, self.glob, self.loc)
  260.  
  261.  
  262.  
  263. class BackgroundJobFunc(BackgroundJobBase):
  264.     
  265.     def __init__(self, func, *args, **kwargs):
  266.         if args is None:
  267.             args = []
  268.         
  269.         if kwargs is None:
  270.             kwargs = { }
  271.         
  272.         self.func = func
  273.         self.args = args
  274.         self.kwargs = kwargs
  275.         self.strform = str(func)
  276.         self._init()
  277.  
  278.     
  279.     def call(self):
  280.         return self.func(*self.args, **self.kwargs)
  281.  
  282.  
  283. if __name__ == '__main__':
  284.     import time
  285.     
  286.     def sleepfunc(interval = 2, *a, **kw):
  287.         args = dict(interval = interval, args = a, kwargs = kw)
  288.         time.sleep(interval)
  289.         return args
  290.  
  291.     
  292.     def diefunc(interval = 2, *a, **kw):
  293.         time.sleep(interval)
  294.         die
  295.  
  296.     
  297.     def printfunc(interval = 1, reps = 5):
  298.         for n in range(reps):
  299.             time.sleep(interval)
  300.             print 'In the background...'
  301.         
  302.  
  303.     jobs = BackgroundJobManager()
  304.     jobs.new(sleepfunc, 4)
  305.     jobs.new(sleepfunc, kw = {
  306.         'reps': 2 })
  307.     jobs.new(diefunc, 1)
  308.     jobs.new('printfunc(1,3)')
  309.     print jobs[1].status
  310.     jobs[1].traceback()
  311.     print 'The result of job #0 is:', jobs[0].result
  312.  
  313.