Index: Tools/webchecker/wsgui.py
===================================================================
--- Tools/webchecker/wsgui.py	(revision 62992)
+++ Tools/webchecker/wsgui.py	(working copy)
@@ -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)
Index: Doc/reference/simple_stmts.rst
===================================================================
--- Doc/reference/simple_stmts.rst	(revision 62992)
+++ Doc/reference/simple_stmts.rst	(working copy)
@@ -485,7 +485,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 first expression as the exception
 object.  It must be either a subclass or an instance of :class:`BaseException`.
Index: Doc/whatsnew/2.4.rst
===================================================================
--- Doc/whatsnew/2.4.rst	(revision 62992)
+++ Doc/whatsnew/2.4.rst	(working copy)
@@ -1047,7 +1047,7 @@
      >>> 'h' in d                # search the deque
      True  
 
-  Several modules, such as the :mod:`Queue` and :mod:`threading` modules, now take
+  Several modules, such as the :mod:`queue` and :mod:`threading` modules, now take
   advantage of :class:`collections.deque` for improved performance.  (Contributed
   by Raymond Hettinger.)
 
Index: Doc/whatsnew/2.5.rst
===================================================================
--- Doc/whatsnew/2.5.rst	(revision 62992)
+++ Doc/whatsnew/2.5.rst	(working copy)
@@ -1493,7 +1493,7 @@
 * The :mod:`pyexpat` module now uses version 2.0 of the Expat parser.
   (Contributed by Trent Mick.)
 
-* The :class:`Queue` class provided by the :mod:`Queue` module gained two new
+* The :class:`Queue` class provided by the :mod:`queue` module gained two new
   methods.  :meth:`join` blocks until all items in the queue have been retrieved
   and all processing work on the items  have been completed.  Worker threads call
   the other new method,  :meth:`task_done`, to signal that processing for an item
Index: Doc/whatsnew/2.6.rst
===================================================================
--- Doc/whatsnew/2.6.rst	(revision 62992)
+++ Doc/whatsnew/2.6.rst	(working copy)
@@ -1844,7 +1844,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,
Index: Doc/tutorial/stdlib2.rst
===================================================================
--- Doc/tutorial/stdlib2.rst	(revision 62992)
+++ Doc/tutorial/stdlib2.rst	(working copy)
@@ -198,7 +198,7 @@
 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.
+: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.
 
Index: Doc/library/queue.rst
===================================================================
--- Doc/library/queue.rst	(revision 62992)
+++ Doc/library/queue.rst	(working copy)
@@ -1,12 +1,12 @@
 
-:mod:`Queue` --- A synchronized queue class
+:mod:`queue` --- A synchronized queue class
 ===========================================
 
-.. module:: Queue
+.. module:: queue
    :synopsis: A synchronized queue class.
 
 
-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
@@ -20,7 +20,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)
 
Index: Doc/library/threading.rst
===================================================================
--- Doc/library/threading.rst	(revision 62992)
+++ Doc/library/threading.rst	(working copy)
@@ -8,7 +8,7 @@
 
 This module constructs higher-level threading interfaces on top of the  lower
 level :mod:`thread` module.
-See also the :mod:`Queue` module.
+See also the :mod:`queue` module.
 
 The :mod:`dummy_threading` module is provided for situations where
 :mod:`threading` cannot be used because :mod:`thread` is missing.
Index: Lib/idlelib/rpc.py
===================================================================
--- Lib/idlelib/rpc.py	(revision 62992)
+++ 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.Empty:
                 pass
             else:
                 seq, response = qmsg
Index: Lib/idlelib/run.py
===================================================================
--- Lib/idlelib/run.py	(revision 62992)
+++ Lib/idlelib/run.py	(working copy)
@@ -5,7 +5,7 @@
 import traceback
 import thread
 import threading
-import Queue
+import queue
 
 from idlelib import CallTips
 from idlelib 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)
Index: Lib/test/test_socket.py
===================================================================
--- Lib/test/test_socket.py	(revision 62992)
+++ Lib/test/test_socket.py	(working copy)
@@ -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()
Index: Lib/test/test_queue.py
===================================================================
--- Lib/test/test_queue.py	(revision 62992)
+++ 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
@@ -112,12 +112,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, ())
@@ -129,12 +129,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',))
@@ -196,13 +196,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
 
 
 
@@ -210,21 +210,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):
 
Index: Lib/test/test_dummy_thread.py
===================================================================
--- Lib/test/test_dummy_thread.py	(revision 62992)
+++ 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 "\