Maximum CD 2010 November/maximum-cd-2010-11.iso/DiscContents/calibre-0.7.13.msi/file_647

Python Compiled Bytecode | 2010-08-06 | 10.6 KB | 380 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.6)

__all__ = [
    'Queue',
    'SimpleQueue',
    'JoinableQueue']
import sys
import os
import threading
import collections
import time
import atexit
import weakref
from Queue import Empty, Full
import _multiprocessing
from multiprocessing import Pipe
from multiprocessing.synchronize import Lock, BoundedSemaphore, Semaphore, Condition
from multiprocessing.util import debug, info, Finalize, register_after_fork
from multiprocessing.forking import assert_spawning

class Queue(object):

    def __init__(self, maxsize = 0):
        if maxsize <= 0:
            maxsize = _multiprocessing.SemLock.SEM_VALUE_MAX

        self._maxsize = maxsize
        (self._reader, self._writer) = Pipe(duplex = False)
        self._rlock = Lock()
        self._opid = os.getpid()
        if sys.platform == 'win32':
            self._wlock = None
        else:
            self._wlock = Lock()
        self._sem = BoundedSemaphore(maxsize)
        self._after_fork()
        if sys.platform != 'win32':
            register_after_fork(self, Queue._after_fork)



    def __getstate__(self):
        assert_spawning(self)
        return (self._maxsize, self._reader, self._writer, self._rlock, self._wlock, self._sem, self._opid)


    def __setstate__(self, state):
        (self._maxsize, self._reader, self._writer, self._rlock, self._wlock, self._sem, self._opid) = state
        self._after_fork()


    def _after_fork(self):
        debug('Queue._after_fork()')
        self._notempty = threading.Condition(threading.Lock())
        self._buffer = collections.deque()
        self._thread = None
        self._jointhread = None
        self._joincancelled = False
        self._closed = False
        self._close = None
        self._send = self._writer.send
        self._recv = self._reader.recv
        self._poll = self._reader.poll


    def put(self, obj, block = True, timeout = None):
        if not self._sem.acquire(block, timeout):
            raise Full
        self._sem.acquire(block, timeout)
        self._notempty.acquire()

        try:
            if self._thread is None:
                self._start_thread()

            self._buffer.append(obj)
            self._notempty.notify()
        finally:
            self._notempty.release()



    def get(self, block = True, timeout = None):
        if block and timeout is None:
            self._rlock.acquire()

            try:
                res = self._recv()
                self._sem.release()
                return res
            finally:
                self._rlock.release()

        elif block:
            deadline = time.time() + timeout

        if not self._rlock.acquire(block, timeout):
            raise Empty
        self._rlock.acquire(block, timeout)

        try:
            if not block or deadline - time.time():
                pass
            if not self._poll(0):
                raise Empty
            self._poll(0)
            res = self._recv()
            self._sem.release()
            return res
        finally:
            self._rlock.release()



    def qsize(self):
        return self._maxsize - self._sem._semlock._get_value()


    def empty(self):
        return not self._poll()


    def full(self):
        return self._sem._semlock._is_zero()


    def get_nowait(self):
        return self.get(False)


    def put_nowait(self, obj):
        return self.put(obj, False)


    def close(self):
        self._closed = True
        self._reader.close()
        if self._close:
            self._close()



    def join_thread(self):
        debug('Queue.join_thread()')
        if self._jointhread:
            self._jointhread()



    def cancel_join_thread(self):
        debug('Queue.cancel_join_thread()')
        self._joincancelled = True

        try:
            self._jointhread.cancel()
        except AttributeError:
            pass



    def _start_thread(self):
        debug('Queue._start_thread()')
        self._buffer.clear()
        self._thread = threading.Thread(target = Queue._feed, args = (self._buffer, self._notempty, self._send, self._wlock, self._writer.close), name = 'QueueFeederThread')
        self._thread.daemon = True
        debug('doing self._thread.start()')
        self._thread.start()
        debug('... done self._thread.start()')
        created_by_this_process = self._opid == os.getpid()
        if not (self._joincancelled) and not created_by_this_process:
            self._jointhread = Finalize(self._thread, Queue._finalize_join, [
                weakref.ref(self._thread)], exitpriority = -5)

        self._close = Finalize(self, Queue._finalize_close, [
            self._buffer,
            self._notempty], exitpriority = 10)


    def _finalize_join(twr):
        debug('joining queue thread')
        thread = twr()
        if thread is not None:
            thread.join()
            debug('... queue thread joined')
        else:
            debug('... queue thread already dead')

    _finalize_join = staticmethod(_finalize_join)

    def _finalize_close(buffer, notempty):
        debug('telling queue thread to quit')
        notempty.acquire()

        try:
            buffer.append(_sentinel)
            notempty.notify()
        finally:
            notempty.release()


    _finalize_close = staticmethod(_finalize_close)

    def _feed(buffer, notempty, send, writelock, close):
        debug('starting thread to feed data to pipe')
        is_exiting = is_exiting
        import util
        nacquire = notempty.acquire
        nrelease = notempty.release
        nwait = notempty.wait
        bpopleft = buffer.popleft
        sentinel = _sentinel
        if sys.platform != 'win32':
            wacquire = writelock.acquire
            wrelease = writelock.release
        else:
            wacquire = None

        try:
            while None:

                try:
                    if not buffer:
                        nwait()
                finally:
                    nrelease()


                try:
                    while None:
                        obj = bpopleft()
                        if obj is sentinel:
                            debug('feeder thread got sentinel -- exiting')
                            close()
                            return None
                        if wacquire is None:
                            send(obj)
                            continue
                        wacquire()

                        try:
                            send(obj)
                        finally:
                            wrelease()

                    continue
                    except IndexError:
                        continue

                except Exception:
                    e = None

                    try:
                        if is_exiting():
                            info('error in queue thread: %s', e)
                        else:
                            import traceback
                            traceback.print_exc()
                    except Exception:
                        pass
                    except:
                        None<EXCEPTION MATCH>Exception


                    None<EXCEPTION MATCH>Exception

                return None


    _feed = staticmethod(_feed)

_sentinel = object()

class JoinableQueue(Queue):

    def __init__(self, maxsize = 0):
        Queue.__init__(self, maxsize)
        self._unfinished_tasks = Semaphore(0)
        self._cond = Condition()


    def __getstate__(self):
        return Queue.__getstate__(self) + (self._cond, self._unfinished_tasks)


    def __setstate__(self, state):
        Queue.__setstate__(self, state[:-2])
        (self._cond, self._unfinished_tasks) = state[-2:]


    def put(self, obj, block = True, timeout = None):
        if not self._sem.acquire(block, timeout):
            raise Full
        self._sem.acquire(block, timeout)
        self._notempty.acquire()
        self._cond.acquire()

        try:
            if self._thread is None:
                self._start_thread()

            self._buffer.append(obj)
            self._unfinished_tasks.release()
            self._notempty.notify()
        finally:
            self._cond.release()
            self._notempty.release()



    def task_done(self):
        self._cond.acquire()

        try:
            if not self._unfinished_tasks.acquire(False):
                raise ValueError('task_done() called too many times')
            self._unfinished_tasks.acquire(False)
            if self._unfinished_tasks._semlock._is_zero():
                self._cond.notify_all()
        finally:
            self._cond.release()



    def join(self):
        self._cond.acquire()

        try:
            if not self._unfinished_tasks._semlock._is_zero():
                self._cond.wait()
        finally:
            self._cond.release()




class SimpleQueue(object):

    def __init__(self):
        (self._reader, self._writer) = Pipe(duplex = False)
        self._rlock = Lock()
        if sys.platform == 'win32':
            self._wlock = None
        else:
            self._wlock = Lock()
        self._make_methods()


    def empty(self):
        return not self._reader.poll()


    def __getstate__(self):
        assert_spawning(self)
        return (self._reader, self._writer, self._rlock, self._wlock)


    def __setstate__(self, state):
        (self._reader, self._writer, self._rlock, self._wlock) = state
        self._make_methods()


    def _make_methods(self):
        recv = self._reader.recv
        racquire = self._rlock.acquire
        rrelease = self._rlock.release

        def get():
            racquire()

            try:
                return recv()
            finally:
                rrelease()


        self.get = get