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

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from time import time as _time
  5. from collections import deque
  6. import heapq
  7. __all__ = [
  8.     'Empty',
  9.     'Full',
  10.     'Queue',
  11.     'PriorityQueue',
  12.     'LifoQueue']
  13.  
  14. class Empty(Exception):
  15.     pass
  16.  
  17.  
  18. class Full(Exception):
  19.     pass
  20.  
  21.  
  22. class Queue:
  23.     
  24.     def __init__(self, maxsize = 0):
  25.         
  26.         try:
  27.             import threading
  28.         except ImportError:
  29.             import dummy_threading as threading
  30.  
  31.         self.maxsize = maxsize
  32.         self._init(maxsize)
  33.         self.mutex = threading.Lock()
  34.         self.not_empty = threading.Condition(self.mutex)
  35.         self.not_full = threading.Condition(self.mutex)
  36.         self.all_tasks_done = threading.Condition(self.mutex)
  37.         self.unfinished_tasks = 0
  38.  
  39.     
  40.     def task_done(self):
  41.         self.all_tasks_done.acquire()
  42.         
  43.         try:
  44.             unfinished = self.unfinished_tasks - 1
  45.             if unfinished <= 0:
  46.                 if unfinished < 0:
  47.                     raise ValueError('task_done() called too many times')
  48.                 unfinished < 0
  49.                 self.all_tasks_done.notify_all()
  50.             
  51.             self.unfinished_tasks = unfinished
  52.         finally:
  53.             self.all_tasks_done.release()
  54.  
  55.  
  56.     
  57.     def join(self):
  58.         self.all_tasks_done.acquire()
  59.         
  60.         try:
  61.             while self.unfinished_tasks:
  62.                 self.all_tasks_done.wait()
  63.         finally:
  64.             self.all_tasks_done.release()
  65.  
  66.  
  67.     
  68.     def qsize(self):
  69.         self.mutex.acquire()
  70.         n = self._qsize()
  71.         self.mutex.release()
  72.         return n
  73.  
  74.     
  75.     def empty(self):
  76.         self.mutex.acquire()
  77.         n = not self._qsize()
  78.         self.mutex.release()
  79.         return n
  80.  
  81.     
  82.     def full(self):
  83.         self.mutex.acquire()
  84.         n = None if self.maxsize < self.maxsize else self.maxsize == self._qsize()
  85.         self.mutex.release()
  86.         return n
  87.  
  88.     
  89.     def put(self, item, block = True, timeout = None):
  90.         self.not_full.acquire()
  91.         
  92.         try:
  93.             if self.maxsize > 0:
  94.                 if not block:
  95.                     if self._qsize() == self.maxsize:
  96.                         raise Full
  97.                     self._qsize() == self.maxsize
  98.                 elif timeout is None:
  99.                     while self._qsize() == self.maxsize:
  100.                         self.not_full.wait()
  101.                 elif timeout < 0:
  102.                     raise ValueError("'timeout' must be a positive number")
  103.                 else:
  104.                     endtime = _time() + timeout
  105.                     while self._qsize() == self.maxsize:
  106.                         remaining = endtime - _time()
  107.                         if remaining <= 0:
  108.                             raise Full
  109.                         remaining <= 0
  110.                         self.not_full.wait(remaining)
  111.             
  112.             self._put(item)
  113.             self.unfinished_tasks += 1
  114.             self.not_empty.notify()
  115.         finally:
  116.             self.not_full.release()
  117.  
  118.  
  119.     
  120.     def put_nowait(self, item):
  121.         return self.put(item, False)
  122.  
  123.     
  124.     def get(self, block = True, timeout = None):
  125.         self.not_empty.acquire()
  126.         
  127.         try:
  128.             if not block:
  129.                 if not self._qsize():
  130.                     raise Empty
  131.                 self._qsize()
  132.             elif timeout is None:
  133.                 while not self._qsize():
  134.                     self.not_empty.wait()
  135.             elif timeout < 0:
  136.                 raise ValueError("'timeout' must be a positive number")
  137.             else:
  138.                 endtime = _time() + timeout
  139.                 while not self._qsize():
  140.                     remaining = endtime - _time()
  141.                     if remaining <= 0:
  142.                         raise Empty
  143.                     remaining <= 0
  144.                     self.not_empty.wait(remaining)
  145.             item = self._get()
  146.             self.not_full.notify()
  147.             return item
  148.         finally:
  149.             self.not_empty.release()
  150.  
  151.  
  152.     
  153.     def get_nowait(self):
  154.         return self.get(False)
  155.  
  156.     
  157.     def _init(self, maxsize):
  158.         self.queue = deque()
  159.  
  160.     
  161.     def _qsize(self, len = len):
  162.         return len(self.queue)
  163.  
  164.     
  165.     def _put(self, item):
  166.         self.queue.append(item)
  167.  
  168.     
  169.     def _get(self):
  170.         return self.queue.popleft()
  171.  
  172.  
  173.  
  174. class PriorityQueue(Queue):
  175.     
  176.     def _init(self, maxsize):
  177.         self.queue = []
  178.  
  179.     
  180.     def _qsize(self, len = len):
  181.         return len(self.queue)
  182.  
  183.     
  184.     def _put(self, item, heappush = heapq.heappush):
  185.         heappush(self.queue, item)
  186.  
  187.     
  188.     def _get(self, heappop = heapq.heappop):
  189.         return heappop(self.queue)
  190.  
  191.  
  192.  
  193. class LifoQueue(Queue):
  194.     
  195.     def _init(self, maxsize):
  196.         self.queue = []
  197.  
  198.     
  199.     def _qsize(self, len = len):
  200.         return len(self.queue)
  201.  
  202.     
  203.     def _put(self, item):
  204.         self.queue.append(item)
  205.  
  206.     
  207.     def _get(self):
  208.         return self.queue.pop()
  209.  
  210.  
  211.