[Python-checkins] r63603 - in python/trunk: Doc/library/queue.rst Doc/library/threading.rst Doc/reference/simple_stmts.rst Doc/tutorial/stdlib2.rst Doc/whatsnew/2.6.rst Lib/Queue.py Lib/idlelib/rpc.py Lib/idlelib/run.py Lib/lib-old/Queue.py Lib/test/test___all__.py Lib/test/test_dummy_thread.py Lib/test/test_py3kwarn.py Lib/test/test_queue.py Lib/test/test_socket.py Misc/cheatsheet Tools/webchecker/wsgui.py
georg.brandl
python-checkins at python.org
Sun May 25 09:20:15 CEST 2008
Author: georg.brandl
Date: Sun May 25 09:20:14 2008
New Revision: 63603
Log:
Queue renaming reversal part 3: move module into place and
change imports and other references. Closes #2925.
Added:
python/trunk/Lib/Queue.py
- copied unchanged from r63600, /python/trunk/Lib/lib-old/Queue.py
Removed:
python/trunk/Lib/lib-old/Queue.py
Modified:
python/trunk/Doc/library/queue.rst
python/trunk/Doc/library/threading.rst
python/trunk/Doc/reference/simple_stmts.rst
python/trunk/Doc/tutorial/stdlib2.rst
python/trunk/Doc/whatsnew/2.6.rst
python/trunk/Lib/idlelib/rpc.py
python/trunk/Lib/idlelib/run.py
python/trunk/Lib/test/test___all__.py
python/trunk/Lib/test/test_dummy_thread.py
python/trunk/Lib/test/test_py3kwarn.py
python/trunk/Lib/test/test_queue.py
python/trunk/Lib/test/test_socket.py
python/trunk/Misc/cheatsheet
python/trunk/Tools/webchecker/wsgui.py
Modified: python/trunk/Doc/library/queue.rst
==============================================================================
--- python/trunk/Doc/library/queue.rst (original)
+++ python/trunk/Doc/library/queue.rst Sun May 25 09:20:14 2008
@@ -2,17 +2,15 @@
===========================================
.. module:: Queue
- :synopsis: Old name for the queue module.
-
-.. module:: queue
:synopsis: A synchronized queue class.
.. note::
- The :mod:`Queue` module has been renamed to :mod:`queue` in Python 3.0. It
- is importable under both names in Python 2.6 and the rest of the 2.x series.
+ The :mod:`Queue` module has been renamed to :mod:`queue` in Python 3.0. The
+ :term:`2to3` tool will automatically adapt imports when converting your
+ sources to 3.0.
-The :mod:`queue` module implements multi-producer, multi-consumer queues.
+The :mod:`Queue` module implements multi-producer, multi-consumer queues.
It is especially useful in threaded programming when information must be
exchanged safely between multiple threads. The :class:`Queue` class in this
module implements all the required locking semantics. It depends on the
@@ -26,7 +24,7 @@
the entries are kept sorted (using the :mod:`heapq` module) and the
lowest valued entry is retrieved first.
-The :mod:`queue` module defines the following classes and exceptions:
+The :mod:`Queue` module defines the following classes and exceptions:
.. class:: Queue(maxsize)
@@ -75,7 +73,7 @@
-------------
Queue objects (:class:`Queue`, :class:`LifoQueue`, or :class:`PriorityQueue`)
-provide the public methods described below.
+provide the public methods described below.
.. method:: Queue.qsize()
@@ -170,20 +168,20 @@
Example of how to wait for enqueued tasks to be completed::
- def worker():
- while True:
- item = q.get()
- do_work(item)
- q.task_done()
+ def worker():
+ while True:
+ item = q.get()
+ do_work(item)
+ q.task_done()
- q = Queue()
- for i in range(num_worker_threads):
+ q = Queue()
+ for i in range(num_worker_threads):
t = Thread(target=worker)
t.setDaemon(True)
- t.start()
+ t.start()
for item in source():
- q.put(item)
+ q.put(item)
q.join() # block until all tasks are done
Modified: python/trunk/Doc/library/threading.rst
==============================================================================
--- python/trunk/Doc/library/threading.rst (original)
+++ python/trunk/Doc/library/threading.rst Sun May 25 09:20:14 2008
@@ -8,7 +8,7 @@
This module constructs higher-level threading interfaces on top of the lower
level :mod:`thread` module.
-See also the :mod:`mutex` and :mod:`queue` modules.
+See also the :mod:`mutex` and :mod:`Queue` modules.
The :mod:`dummy_threading` module is provided for situations where
:mod:`threading` cannot be used because :mod:`thread` is missing.
Modified: python/trunk/Doc/reference/simple_stmts.rst
==============================================================================
--- python/trunk/Doc/reference/simple_stmts.rst (original)
+++ python/trunk/Doc/reference/simple_stmts.rst Sun May 25 09:20:14 2008
@@ -534,7 +534,7 @@
If no expressions are present, :keyword:`raise` re-raises the last exception
that was active in the current scope. If no exception is active in the current
scope, a :exc:`TypeError` exception is raised indicating that this is an error
-(if running under IDLE, a :exc:`queue.Empty` exception is raised instead).
+(if running under IDLE, a :exc:`Queue.Empty` exception is raised instead).
Otherwise, :keyword:`raise` evaluates the expressions to get three objects,
using ``None`` as the value of omitted expressions. The first two objects are
Modified: python/trunk/Doc/tutorial/stdlib2.rst
==============================================================================
--- python/trunk/Doc/tutorial/stdlib2.rst (original)
+++ python/trunk/Doc/tutorial/stdlib2.rst Sun May 25 09:20:14 2008
@@ -16,7 +16,7 @@
The :mod:`repr` module provides a version of :func:`repr` customized for
abbreviated displays of large or deeply nested containers::
- >>> import repr
+ >>> import repr
>>> repr.repr(set('supercalifragilisticexpialidocious'))
"set(['a', 'c', 'd', 'e', 'f', 'g', ...])"
@@ -174,7 +174,7 @@
class AsyncZip(threading.Thread):
def __init__(self, infile, outfile):
- threading.Thread.__init__(self)
+ threading.Thread.__init__(self)
self.infile = infile
self.outfile = outfile
def run(self):
@@ -198,9 +198,9 @@
While those tools are powerful, minor design errors can result in problems that
are difficult to reproduce. So, the preferred approach to task coordination is
to concentrate all access to a resource in a single thread and then use the
-:mod:`queue` module to feed that thread with requests from other threads.
-Applications using :class:`Queue` objects for inter-thread communication and
-coordination are easier to design, more readable, and more reliable.
+:mod:`Queue` module to feed that thread with requests from other threads.
+Applications using :class:`Queue.Queue` objects for inter-thread communication
+and coordination are easier to design, more readable, and more reliable.
.. _tut-logging:
@@ -358,11 +358,11 @@
results in decimal floating point and binary floating point. The difference
becomes significant if the results are rounded to the nearest cent::
- >>> from decimal import *
+ >>> from decimal import *
>>> Decimal('0.70') * Decimal('1.05')
Decimal("0.7350")
>>> .70 * 1.05
- 0.73499999999999999
+ 0.73499999999999999
The :class:`Decimal` result keeps a trailing zero, automatically inferring four
place significance from multiplicands with two place significance. Decimal
@@ -380,7 +380,7 @@
>>> sum([Decimal('0.1')]*10) == Decimal('1.0')
True
>>> sum([0.1]*10) == 1.0
- False
+ False
The :mod:`decimal` module provides arithmetic with as much precision as needed::
Modified: python/trunk/Doc/whatsnew/2.6.rst
==============================================================================
--- python/trunk/Doc/whatsnew/2.6.rst (original)
+++ python/trunk/Doc/whatsnew/2.6.rst Sun May 25 09:20:14 2008
@@ -1965,7 +1965,7 @@
used to hold character data.
(Contributed by Achim Gaedke; :issue:`1137`.)
-* The :mod:`queue` module now provides queue classes that retrieve entries
+* The :mod:`Queue` module now provides queue classes that retrieve entries
in different orders. The :class:`PriorityQueue` class stores
queued items in a heap and retrieves them in priority order,
and :class:`LifoQueue` retrieves the most recently added entries first,
Modified: python/trunk/Lib/idlelib/rpc.py
==============================================================================
--- python/trunk/Lib/idlelib/rpc.py (original)
+++ python/trunk/Lib/idlelib/rpc.py Sun May 25 09:20:14 2008
@@ -35,7 +35,7 @@
import struct
import cPickle as 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
Modified: python/trunk/Lib/idlelib/run.py
==============================================================================
--- python/trunk/Lib/idlelib/run.py (original)
+++ python/trunk/Lib/idlelib/run.py Sun May 25 09:20:14 2008
@@ -5,7 +5,7 @@
import traceback
import thread
import threading
-import queue
+import Queue
import CallTips
import AutoComplete
@@ -85,7 +85,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)
Deleted: python/trunk/Lib/lib-old/Queue.py
==============================================================================
--- python/trunk/Lib/lib-old/Queue.py Sun May 25 09:20:14 2008
+++ (empty file)
@@ -1,244 +0,0 @@
-"""A multi-producer, multi-consumer queue."""
-
-from time import time as _time
-from collections import deque
-import heapq
-
-__all__ = ['Empty', 'Full', 'Queue', 'PriorityQueue', 'LifoQueue']
-
-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.maxsize = maxsize
- 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 = not self._qsize()
- self.mutex.release()
- return n
-
- def full(self):
- """Return True if the queue is full, False otherwise (not reliable!)."""
- self.mutex.acquire()
- n = 0 < self.maxsize == self._qsize()
- 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 self.maxsize > 0:
- if not block:
- if self._qsize() == self.maxsize:
- raise Full
- elif timeout is None:
- while self._qsize() == self.maxsize:
- self.not_full.wait()
- elif timeout < 0:
- raise ValueError("'timeout' must be a positive number")
- else:
- endtime = _time() + timeout
- while self._qsize() == self.maxsize:
- 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 not self._qsize():
- raise Empty
- elif timeout is None:
- while not self._qsize():
- self.not_empty.wait()
- elif timeout < 0:
- raise ValueError("'timeout' must be a positive number")
- else:
- endtime = _time() + timeout
- while not self._qsize():
- 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.queue = deque()
-
- def _qsize(self, len=len):
- return len(self.queue)
-
- # 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()
-
-
-class PriorityQueue(Queue):
- '''Variant of Queue that retrieves open entries in priority order (lowest first).
-
- Entries are typically tuples of the form: (priority number, data).
- '''
-
- def _init(self, maxsize):
- self.queue = []
-
- def _qsize(self, len=len):
- return len(self.queue)
-
- def _put(self, item, heappush=heapq.heappush):
- heappush(self.queue, item)
-
- def _get(self, heappop=heapq.heappop):
- return heappop(self.queue)
-
-
-class LifoQueue(Queue):
- '''Variant of Queue that retrieves most recently added entries first.'''
-
- def _init(self, maxsize):
- self.queue = []
-
- def _qsize(self, len=len):
- return len(self.queue)
-
- def _put(self, item):
- self.queue.append(item)
-
- def _get(self):
- return self.queue.pop()
Modified: python/trunk/Lib/test/test___all__.py
==============================================================================
--- python/trunk/Lib/test/test___all__.py (original)
+++ python/trunk/Lib/test/test___all__.py Sun May 25 09:20:14 2008
@@ -40,7 +40,7 @@
self.check_all("configparser")
self.check_all("Cookie")
self.check_all("MimeWriter")
- self.check_all("queue")
+ self.check_all("Queue")
self.check_all("SimpleHTTPServer")
self.check_all("SocketServer")
self.check_all("StringIO")
Modified: python/trunk/Lib/test/test_dummy_thread.py
==============================================================================
--- python/trunk/Lib/test/test_dummy_thread.py (original)
+++ python/trunk/Lib/test/test_dummy_thread.py Sun May 25 09:20:14 2008
@@ -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 "\
Modified: python/trunk/Lib/test/test_py3kwarn.py
==============================================================================
--- python/trunk/Lib/test/test_py3kwarn.py (original)
+++ python/trunk/Lib/test/test_py3kwarn.py Sun May 25 09:20:14 2008
@@ -215,9 +215,7 @@
class TestStdlibRenames(unittest.TestCase):
- renames = {'Queue': 'queue',
- 'ConfigParser': 'configparser',
- }
+ renames = {'ConfigParser': 'configparser'}
def check_rename(self, module_name, new_module_name):
"""Make sure that:
Modified: python/trunk/Lib/test/test_queue.py
==============================================================================
--- python/trunk/Lib/test/test_queue.py (original)
+++ python/trunk/Lib/test/test_queue.py Sun May 25 09:20:14 2008
@@ -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
@@ -107,12 +107,12 @@
try:
q.put("full", block=0)
self.fail("Didn't appear to block with a full queue")
- except queue.Full:
+ except Queue.Full:
pass
try:
q.put("full", timeout=0.01)
self.fail("Didn't appear to time-out with a full queue")
- except queue.Full:
+ except Queue.Full:
pass
# Test a blocking put
self.do_blocking_test(q.put, ("full",), q.get, ())
@@ -124,12 +124,12 @@
try:
q.get(block=0)
self.fail("Didn't appear to block with an empty queue")
- except queue.Empty:
+ except Queue.Empty:
pass
try:
q.get(timeout=0.01)
self.fail("Didn't appear to time-out with an empty queue")
- except queue.Empty:
+ except Queue.Empty:
pass
# Test a blocking get
self.do_blocking_test(q.get, (), q.put, ('empty',))
@@ -191,13 +191,13 @@
class QueueTest(BaseQueueTest):
- type2test = queue.Queue
+ type2test = Queue.Queue
class LifoQueueTest(BaseQueueTest):
- type2test = queue.LifoQueue
+ type2test = Queue.LifoQueue
class PriorityQueueTest(BaseQueueTest):
- type2test = queue.PriorityQueue
+ type2test = Queue.PriorityQueue
@@ -205,21 +205,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)
class FailingQueueTest(unittest.TestCase, BlockingTestMixin):
Modified: python/trunk/Lib/test/test_socket.py
==============================================================================
--- python/trunk/Lib/test/test_socket.py (original)
+++ python/trunk/Lib/test/test_socket.py Sun May 25 09:20:14 2008
@@ -9,7 +9,7 @@
import thread, threading
import time
import traceback
-import queue
+import Queue
import sys
import os
import array
@@ -96,7 +96,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()
Modified: python/trunk/Misc/cheatsheet
==============================================================================
--- python/trunk/Misc/cheatsheet (original)
+++ python/trunk/Misc/cheatsheet Sun May 25 09:20:14 2008
@@ -1044,7 +1044,7 @@
super(type) Create an unbound super object. Used to call cooperative
superclass methods.
sum(sequence, Add the values in the sequence and return the sum.
- [start])
+ [start])
tuple(sequence) Creates a tuple with same elements as sequence. If already
a tuple, return itself (not a copy).
Returns a type object [see module types] representing
@@ -1952,7 +1952,7 @@
pyexpat Interface to the Expay XML parser.
py_compile Routine to "compile" a .py file to a .pyc file.
pyclbr Parse a Python file and retrieve classes and methods.
-queue A multi-producer, multi-consumer queue.
+Queue A multi-producer, multi-consumer queue.
quopri Conversions to/from quoted-printable transport encoding.
rand Don't use unless you want compatibility with C's rand().
random Random variable generators
Modified: python/trunk/Tools/webchecker/wsgui.py
==============================================================================
--- python/trunk/Tools/webchecker/wsgui.py (original)
+++ python/trunk/Tools/webchecker/wsgui.py Sun May 25 09:20:14 2008
@@ -10,7 +10,7 @@
import websucker
import os
import threading
-import queue
+import Queue
import time
VERBOSE = 2
@@ -139,7 +139,7 @@
def go(self, event=None):
if not self.msgq:
- self.msgq = queue.Queue(0)
+ self.msgq = Queue.Queue(0)
self.check_msgq()
if not self.sucker:
self.sucker = SuckerThread(self.msgq)
More information about the Python-checkins
mailing list