Index: Lib/idlelib/rpc.py =================================================================== --- Lib/idlelib/rpc.py (revision 59312) +++ Lib/idlelib/rpc.py (working copy) @@ -35,7 +35,7 @@ import struct import pickle import threading -import Queue +import queue import traceback import copy_reg import types @@ -117,8 +117,8 @@ #----------------- end class RPCServer -------------------- objecttable = {} -request_queue = Queue.Queue(0) -response_queue = Queue.Queue(0) +request_queue = queue.Queue(0) +response_queue = queue.Queue(0) class SocketIO(object): @@ -413,7 +413,7 @@ # send queued response if there is one available try: qmsg = response_queue.get(0) - except Queue.Empty: + except queue.Empty: pass else: seq, response = qmsg Index: Lib/idlelib/run.py =================================================================== --- Lib/idlelib/run.py (revision 59312) +++ Lib/idlelib/run.py (working copy) @@ -6,7 +6,7 @@ import traceback import thread import threading -import Queue +import queue from idlelib import CallTips from idlelib import AutoComplete @@ -86,7 +86,7 @@ continue try: seq, request = rpc.request_queue.get(block=True, timeout=0.05) - except Queue.Empty: + except queue.Empty: continue method, args, kwargs = request ret = method(*args, **kwargs) @@ -152,7 +152,7 @@ sys.last_type, sys.last_value, sys.last_traceback = excinfo tbe = traceback.extract_tb(tb) print('Traceback (most recent call last):', file=efile) - exclude = ("run.py", "rpc.py", "threading.py", "Queue.py", + exclude = ("run.py", "rpc.py", "threading.py", "queue.py", "RemoteDebugger.py", "bdb.py") cleanup_traceback(tbe, exclude) traceback.print_list(tbe, file=efile) Index: Lib/Queue.py =================================================================== --- Lib/Queue.py (revision 59312) +++ Lib/Queue.py (working copy) @@ -1,215 +0,0 @@ -"""A multi-producer, multi-consumer queue.""" - -from time import time as _time -from collections import deque - -__all__ = ['Empty', 'Full', 'Queue'] - -class Empty(Exception): - "Exception raised by Queue.get(block=0)/get_nowait()." - pass - -class Full(Exception): - "Exception raised by Queue.put(block=0)/put_nowait()." - pass - -class Queue: - """Create a queue object with a given maximum size. - - If maxsize is <= 0, the queue size is infinite. - """ - def __init__(self, maxsize=0): - try: - import threading - except ImportError: - import dummy_threading as threading - self._init(maxsize) - # mutex must be held whenever the queue is mutating. All methods - # that acquire mutex must release it before returning. mutex - # is shared between the three conditions, so acquiring and - # releasing the conditions also acquires and releases mutex. - self.mutex = threading.Lock() - # Notify not_empty whenever an item is added to the queue; a - # thread waiting to get is notified then. - self.not_empty = threading.Condition(self.mutex) - # Notify not_full whenever an item is removed from the queue; - # a thread waiting to put is notified then. - self.not_full = threading.Condition(self.mutex) - # Notify all_tasks_done whenever the number of unfinished tasks - # drops to zero; thread waiting to join() is notified to resume - self.all_tasks_done = threading.Condition(self.mutex) - self.unfinished_tasks = 0 - - def task_done(self): - """Indicate that a formerly enqueued task is complete. - - Used by Queue consumer threads. For each get() used to fetch a task, - a subsequent call to task_done() tells the queue that the processing - on the task is complete. - - If a join() is currently blocking, it will resume when all items - have been processed (meaning that a task_done() call was received - for every item that had been put() into the queue). - - Raises a ValueError if called more times than there were items - placed in the queue. - """ - self.all_tasks_done.acquire() - try: - unfinished = self.unfinished_tasks - 1 - if unfinished <= 0: - if unfinished < 0: - raise ValueError('task_done() called too many times') - self.all_tasks_done.notifyAll() - self.unfinished_tasks = unfinished - finally: - self.all_tasks_done.release() - - def join(self): - """Blocks until all items in the Queue have been gotten and processed. - - The count of unfinished tasks goes up whenever an item is added to the - queue. The count goes down whenever a consumer thread calls task_done() - to indicate the item was retrieved and all work on it is complete. - - When the count of unfinished tasks drops to zero, join() unblocks. - """ - self.all_tasks_done.acquire() - try: - while self.unfinished_tasks: - self.all_tasks_done.wait() - finally: - self.all_tasks_done.release() - - def qsize(self): - """Return the approximate size of the queue (not reliable!).""" - self.mutex.acquire() - n = self._qsize() - self.mutex.release() - return n - - def empty(self): - """Return True if the queue is empty, False otherwise (not reliable!).""" - self.mutex.acquire() - n = self._empty() - self.mutex.release() - return n - - def full(self): - """Return True if the queue is full, False otherwise (not reliable!).""" - self.mutex.acquire() - n = self._full() - self.mutex.release() - return n - - def put(self, item, block=True, timeout=None): - """Put an item into the queue. - - If optional args 'block' is true and 'timeout' is None (the default), - block if necessary until a free slot is available. If 'timeout' is - a positive number, it blocks at most 'timeout' seconds and raises - the Full exception if no free slot was available within that time. - Otherwise ('block' is false), put an item on the queue if a free slot - is immediately available, else raise the Full exception ('timeout' - is ignored in that case). - """ - self.not_full.acquire() - try: - if not block: - if self._full(): - raise Full - elif timeout is None: - while self._full(): - self.not_full.wait() - else: - if timeout < 0: - raise ValueError("'timeout' must be a positive number") - endtime = _time() + timeout - while self._full(): - remaining = endtime - _time() - if remaining <= 0.0: - raise Full - self.not_full.wait(remaining) - self._put(item) - self.unfinished_tasks += 1 - self.not_empty.notify() - finally: - self.not_full.release() - - def put_nowait(self, item): - """Put an item into the queue without blocking. - - Only enqueue the item if a free slot is immediately available. - Otherwise raise the Full exception. - """ - return self.put(item, False) - - def get(self, block=True, timeout=None): - """Remove and return an item from the queue. - - If optional args 'block' is true and 'timeout' is None (the default), - block if necessary until an item is available. If 'timeout' is - a positive number, it blocks at most 'timeout' seconds and raises - the Empty exception if no item was available within that time. - Otherwise ('block' is false), return an item if one is immediately - available, else raise the Empty exception ('timeout' is ignored - in that case). - """ - self.not_empty.acquire() - try: - if not block: - if self._empty(): - raise Empty - elif timeout is None: - while self._empty(): - self.not_empty.wait() - else: - if timeout < 0: - raise ValueError("'timeout' must be a positive number") - endtime = _time() + timeout - while self._empty(): - remaining = endtime - _time() - if remaining <= 0.0: - raise Empty - self.not_empty.wait(remaining) - item = self._get() - self.not_full.notify() - return item - finally: - self.not_empty.release() - - def get_nowait(self): - """Remove and return an item from the queue without blocking. - - Only get an item if one is immediately available. Otherwise - raise the Empty exception. - """ - return self.get(False) - - # Override these methods to implement other queue organizations - # (e.g. stack or priority queue). - # These will only be called with appropriate locks held - - # Initialize the queue representation - def _init(self, maxsize): - self.maxsize = maxsize - self.queue = deque() - - def _qsize(self): - return len(self.queue) - - # Check whether the queue is empty - def _empty(self): - return not self.queue - - # Check whether the queue is full - def _full(self): - return self.maxsize > 0 and len(self.queue) == self.maxsize - - # Put a new item in the queue - def _put(self, item): - self.queue.append(item) - - # Get an item from the queue - def _get(self): - return self.queue.popleft() Index: Lib/test/test_socket.py =================================================================== --- Lib/test/test_socket.py (revision 59312) +++ Lib/test/test_socket.py (working copy) @@ -7,7 +7,7 @@ import select import time import thread, threading -import Queue +import queue import sys from weakref import proxy import signal @@ -97,7 +97,7 @@ self.server_ready = threading.Event() self.client_ready = threading.Event() self.done = threading.Event() - self.queue = Queue.Queue(1) + self.queue = queue.Queue(1) # Do some munging to start the client test. methodname = self.id() Index: Lib/test/test_queue.py =================================================================== --- Lib/test/test_queue.py (revision 59312) +++ Lib/test/test_queue.py (working copy) @@ -1,6 +1,6 @@ # Some simple Queue module tests, plus some failure conditions # to ensure the Queue locks remain stable. -import Queue +import queue import sys import threading import time @@ -79,21 +79,21 @@ class FailingQueueException(Exception): pass -class FailingQueue(Queue.Queue): +class FailingQueue(queue.Queue): def __init__(self, *args): self.fail_next_put = False self.fail_next_get = False - Queue.Queue.__init__(self, *args) + queue.Queue.__init__(self, *args) def _put(self, item): if self.fail_next_put: self.fail_next_put = False raise FailingQueueException("You Lose") - return Queue.Queue._put(self, item) + return queue.Queue._put(self, item) def _get(self): if self.fail_next_get: self.fail_next_get = False raise FailingQueueException("You Lose") - return Queue.Queue._get(self) + return queue.Queue._get(self) def FailingQueueTest(q): if not q.empty(): @@ -193,12 +193,12 @@ try: q.put("full", block=0) raise TestFailed("Didn't appear to block with a full queue") - except Queue.Full: + except queue.Full: pass try: q.put("full", timeout=0.01) raise TestFailed("Didn't appear to time-out with a full queue") - except Queue.Full: + except queue.Full: pass # Test a blocking put _doBlockingTest(q.put, ("full",), q.get, ()) @@ -210,12 +210,12 @@ try: q.get(block=0) raise TestFailed("Didn't appear to block with an empty queue") - except Queue.Empty: + except queue.Empty: pass try: q.get(timeout=0.01) raise TestFailed("Didn't appear to time-out with an empty queue") - except Queue.Empty: + except queue.Empty: pass # Test a blocking get _doBlockingTest(q.get, (), q.put, ('empty',)) @@ -260,13 +260,13 @@ raise TestFailed("Did not detect task count going negative") def test(): - q = Queue.Queue() + q = queue.Queue() QueueTaskDoneTest(q) QueueJoinTest(q) QueueJoinTest(q) QueueTaskDoneTest(q) - q = Queue.Queue(QUEUE_SIZE) + q = queue.Queue(QUEUE_SIZE) # Do it a couple of times on the same queue SimpleQueueTest(q) SimpleQueueTest(q) Index: Lib/test/test_dummy_thread.py =================================================================== --- Lib/test/test_dummy_thread.py (revision 59312) +++ Lib/test/test_dummy_thread.py (working copy) @@ -7,7 +7,7 @@ """ import dummy_thread as _thread import time -import Queue +import queue import random import unittest from test import test_support @@ -124,7 +124,7 @@ """Use to test _thread.start_new_thread() passes args properly.""" queue.put((arg1, arg2)) - testing_queue = Queue.Queue(1) + testing_queue = queue.Queue(1) _thread.start_new_thread(arg_tester, (testing_queue, True, True)) result = testing_queue.get() self.failUnless(result[0] and result[1], @@ -148,7 +148,7 @@ queue.put(_thread.get_ident()) thread_count = 5 - testing_queue = Queue.Queue(thread_count) + testing_queue = queue.Queue(thread_count) if test_support.verbose: print() print("*** Testing multiple thread creation "\ Index: Lib/test/test___all__.py =================================================================== --- Lib/test/test___all__.py (revision 59312) +++ Lib/test/test___all__.py (working copy) @@ -33,7 +33,7 @@ self.check_all("CGIHTTPServer") self.check_all("ConfigParser") self.check_all("Cookie") - self.check_all("Queue") + self.check_all("queue") self.check_all("SimpleHTTPServer") self.check_all("SocketServer") self.check_all("UserString")