home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1428 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  6.6 KB  |  230 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'makeRequests',
  6.     'NoResultsPending',
  7.     'NoWorkersAvailable',
  8.     'ThreadPool',
  9.     'WorkRequest',
  10.     'WorkerThread']
  11. __author__ = 'Christopher Arndt'
  12. __version__ = '1.2.3'
  13. __revision__ = '$Revision: 1.5 $'
  14. __date__ = '$Date: 2006/06/23 12:32:25 $'
  15. __license__ = 'Python license'
  16. import threading
  17. import Queue
  18.  
  19. class NoResultsPending(Exception):
  20.     pass
  21.  
  22.  
  23. class NoWorkersAvailable(Exception):
  24.     pass
  25.  
  26.  
  27. class WorkerThread(threading.Thread):
  28.     
  29.     def __init__(self, requestsQueue, resultsQueue, **kwds):
  30.         threading.Thread.__init__(self, **kwds)
  31.         self.setDaemon(1)
  32.         self.workRequestQueue = requestsQueue
  33.         self.resultQueue = resultsQueue
  34.         self._dismissed = threading.Event()
  35.         self.start()
  36.  
  37.     
  38.     def run(self):
  39.         while not self._dismissed.isSet():
  40.             request = self.workRequestQueue.get()
  41.             if self._dismissed.isSet():
  42.                 self.workRequestQueue.put(request)
  43.                 break
  44.             
  45.             
  46.             try:
  47.                 self.resultQueue.put((request, request.callable(*request.args, **request.kwds)))
  48.             continue
  49.             request.exception = True
  50.             import traceback
  51.             self.resultQueue.put((request, traceback.format_exc()))
  52.             continue
  53.  
  54.  
  55.     
  56.     def dismiss(self):
  57.         self._dismissed.set()
  58.  
  59.  
  60.  
  61. class WorkRequest:
  62.     
  63.     def __init__(self, callable, args = None, kwds = None, requestID = None, callback = None, exc_callback = None):
  64.         if requestID is None:
  65.             self.requestID = id(self)
  66.         else:
  67.             
  68.             try:
  69.                 hash(requestID)
  70.             except TypeError:
  71.                 raise TypeError('requestID must be hashable.')
  72.  
  73.             self.requestID = requestID
  74.         self.exception = False
  75.         self.callback = callback
  76.         self.exc_callback = exc_callback
  77.         self.callable = callable
  78.         if not args:
  79.             pass
  80.         self.args = []
  81.         if not kwds:
  82.             pass
  83.         self.kwds = { }
  84.  
  85.  
  86.  
  87. class ThreadPool:
  88.     
  89.     def __init__(self, num_workers, q_size = 0):
  90.         self.requestsQueue = Queue.Queue(q_size)
  91.         self.resultsQueue = Queue.Queue()
  92.         self.workers = []
  93.         self.workRequests = { }
  94.         self.createWorkers(num_workers)
  95.  
  96.     
  97.     def createWorkers(self, num_workers):
  98.         for i in range(num_workers):
  99.             self.workers.append(WorkerThread(self.requestsQueue, self.resultsQueue))
  100.         
  101.  
  102.     
  103.     def dismissWorkers(self, num_workers):
  104.         for i in range(min(num_workers, len(self.workers))):
  105.             worker = self.workers.pop()
  106.             worker.dismiss()
  107.         
  108.  
  109.     
  110.     def putRequest(self, request, block = True, timeout = 0):
  111.         self.requestsQueue.put(request, block, timeout)
  112.         self.workRequests[request.requestID] = request
  113.  
  114.     
  115.     def poll(self, block = False):
  116.         while True:
  117.             if not self.workRequests:
  118.                 raise NoResultsPending
  119.             self.workRequests
  120.             if block and not (self.workers):
  121.                 raise NoWorkersAvailable
  122.             not (self.workers)
  123.             
  124.             try:
  125.                 (request, result) = self.resultsQueue.get(block = block)
  126.                 if request.exception and request.exc_callback:
  127.                     request.exc_callback(request, result)
  128.                 
  129.                 if request.callback:
  130.                     if request.exception:
  131.                         pass
  132.                     if not (request.exc_callback):
  133.                         request.callback(request, result)
  134.                     
  135.                 del self.workRequests[request.requestID]
  136.             continue
  137.             except Queue.Empty:
  138.                 break
  139.                 continue
  140.             
  141.  
  142.             None<EXCEPTION MATCH>Queue.Empty
  143.  
  144.     
  145.     def wait(self, sleep = 0):
  146.         while None:
  147.             
  148.             try:
  149.                 self.poll(True)
  150.                 time.sleep(sleep)
  151.             continue
  152.             except NoResultsPending:
  153.                 break
  154.                 continue
  155.             
  156.  
  157.             return None
  158.  
  159.  
  160.  
  161. def makeRequests(callable, args_list, callback = None, exc_callback = None):
  162.     requests = []
  163.     for item in args_list:
  164.         if isinstance(item, tuple):
  165.             requests.append(WorkRequest(callable, item[0], item[1], callback = callback, exc_callback = exc_callback))
  166.             continue
  167.         requests.append(WorkRequest(callable, [
  168.             item], None, callback = callback, exc_callback = exc_callback))
  169.     
  170.     return requests
  171.  
  172. if __name__ == '__main__':
  173.     import random
  174.     import time
  175.     
  176.     def do_something(data):
  177.         time.sleep(random.randint(1, 5))
  178.         result = round(random.random() * data, 5)
  179.         if result > 3:
  180.             raise RuntimeError('Something extraordinary happened!')
  181.         result > 3
  182.         return result
  183.  
  184.     
  185.     def print_result(request, result):
  186.         print '**Result: %s from request #%s' % (result, request.requestID)
  187.  
  188.     
  189.     def handle_exception(request, exc_info):
  190.         print 'Exception occured in request #%s: %s' % (request.requestID, exc_info[1])
  191.  
  192.     data = [ random.randint(1, 10) for i in range(20) ]
  193.     requests = makeRequests(do_something, data, print_result, handle_exception)
  194.     data = [ ((random.randint(1, 10),), { }) for i in range(20) ]
  195.     requests.extend(makeRequests(do_something, data, print_result, handle_exception))
  196.     main = ThreadPool(3)
  197.     for req in requests:
  198.         main.putRequest(req)
  199.         print 'Work request #%s added.' % req.requestID
  200.     
  201.     i = 0
  202.     while None:
  203.         
  204.         try:
  205.             main.poll()
  206.             print 'Main thread working...'
  207.             time.sleep(0.5)
  208.             if i == 10:
  209.                 print 'Adding 3 more worker threads...'
  210.                 main.createWorkers(3)
  211.             
  212.             i += 1
  213.         continue
  214.         except KeyboardInterrupt:
  215.             []
  216.             []
  217.             []
  218.             print 'Interrupted!'
  219.             break
  220.             continue
  221.             except NoResultsPending:
  222.                 print 'All results collected.'
  223.                 break
  224.                 continue
  225.             
  226.         except:
  227.             None<EXCEPTION MATCH>NoResultsPending
  228.             return None
  229.  
  230.