socketserver renaming reversal part 3: move the module into the right

place and fix all references to it.  Closes #2926.

Doc/library/basehttpserver.rst

@@ -21,7 +21,7 @@ Usually, this module isn't used directly, but is used as a basis for building
 functioning Web servers. See the :mod:`SimpleHTTPServer` and
 :mod:`CGIHTTPServer` modules.
 
-The first class, :class:`HTTPServer`, is a :class:`socketserver.TCPServer`
+The first class, :class:`HTTPServer`, is a :class:`SocketServer.TCPServer`
 subclass.  It creates and listens at the HTTP socket, dispatching the requests
 to a handler.  Code to create and run the server looks like this::
 

Doc/library/logging.rst

@@ -1299,17 +1299,17 @@ the receiving end. A simple way of doing this is attaching a
    logger2.warning('Jail zesty vixen who grabbed pay from quack.')
    logger2.error('The five boxing wizards jump quickly.')
 
-At the receiving end, you can set up a receiver using the :mod:`socketserver`
+At the receiving end, you can set up a receiver using the :mod:`SocketServer`
 module. Here is a basic working example::
 
    import cPickle
    import logging
    import logging.handlers
-   import socketserver
+   import SocketServer
    import struct
 
 
-   class LogRecordStreamHandler(socketserver.StreamRequestHandler):
+   class LogRecordStreamHandler(SocketServer.StreamRequestHandler):
        """Handler for a streaming logging request.
 
        This basically logs the record using whatever logging policy is
@@ -1351,7 +1351,7 @@ module. Here is a basic working example::
            # cycles and network bandwidth!
            logger.handle(record)
 
-   class LogRecordSocketReceiver(socketserver.ThreadingTCPServer):
+   class LogRecordSocketReceiver(SocketServer.ThreadingTCPServer):
        """simple TCP socket-based logging receiver suitable for testing.
        """
 
@@ -1360,7 +1360,7 @@ module. Here is a basic working example::
        def __init__(self, host='localhost',
                     port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
                     handler=LogRecordStreamHandler):
-           socketserver.ThreadingTCPServer.__init__(self, (host, port), handler)
+           SocketServer.ThreadingTCPServer.__init__(self, (host, port), handler)
            self.abort = 0
            self.timeout = 1
            self.logname = None

Doc/library/repr.rst

@@ -7,8 +7,9 @@
 .. sectionauthor:: Fred L. Drake, Jr. <fdrake@acm.org>
 
 .. note::
-   The :mod:`repr` module has been renamed to :mod:`reprlib` in
-   Python 3.0.
+   The :mod:`repr` module has been renamed to :mod:`reprlib` in Python 3.0.  The
+   :term:`2to3` tool will automatically adapt imports when converting your
+   sources to 3.0.
 
 The :mod:`repr` module provides a means for producing object representations
 with limits on the size of the resulting strings. This is used in the Python

Doc/library/simplexmlrpcserver.rst

@@ -22,7 +22,7 @@ XML-RPC servers written in Python.  Servers can either be free standing, using
    functions that can be called by the XML-RPC protocol.  The *requestHandler*
    parameter should be a factory for request handler instances; it defaults to
    :class:`SimpleXMLRPCRequestHandler`.  The *addr* and *requestHandler* parameters
-   are passed to the :class:`socketserver.TCPServer` constructor.  If *logRequests*
+   are passed to the :class:`SocketServer.TCPServer` constructor.  If *logRequests*
    is true (the default), requests will be logged; setting this parameter to false
    will turn off logging.   The *allow_none* and *encoding* parameters are passed
    on to  :mod:`xmlrpclib` and control the XML-RPC responses that will be returned
@@ -63,7 +63,7 @@ SimpleXMLRPCServer Objects
 --------------------------
 
 The :class:`SimpleXMLRPCServer` class is based on
-:class:`socketserver.TCPServer` and provides a means of creating simple, stand
+:class:`SocketServer.TCPServer` and provides a means of creating simple, stand
 alone XML-RPC servers.
 
 

Doc/library/socket.rst

@@ -481,7 +481,7 @@ The module :mod:`socket` exports the following constants and functions:
 
 .. seealso::
 
-   Module :mod:`socketserver`
+   Module :mod:`SocketServer`
       Classes that simplify writing network servers.
 
 

Doc/library/socketserver.rst

-:mod:`socketserver` --- A framework for network servers
+
+:mod:`SocketServer` --- A framework for network servers
 =======================================================
 
 .. module:: SocketServer
-   :synopsis: Old name for the socketserver module.
-
-.. module:: socketserver
    :synopsis: A framework for network servers.
 
 .. note::
-   The :mod:`SocketServer` module has been renamed to :mod:`socketserver` in
-   Python 3.0.  It is importable under both names in Python 2.6 and the rest of
-   the 2.x series.
+
+   The :mod:`SocketServer` module has been renamed to `socketserver` in Python
+   3.0.  The :term:`2to3` tool will automatically adapt imports when converting
+   your sources to 3.0.
 
 
-The :mod:`socketserver` module simplifies the task of writing network servers.
+The :mod:`SocketServer` module simplifies the task of writing network servers.
 
 There are four basic server classes: :class:`TCPServer` uses the Internet TCP
 protocol, which provides for continuous streams of data between the client and
@@ -220,7 +219,7 @@ server classes like :class:`TCPServer`; these methods aren't useful to external
 users of the server object.
 
 .. XXX should the default implementations of these be documented, or should
-   it be assumed that the user will look at socketserver.py?
+   it be assumed that the user will look at SocketServer.py?
 
 
 .. function:: finish_request()
@@ -325,14 +324,14 @@ request.
 Examples
 --------
 
-:class:`socketserver.TCPServer` Example
+:class:`SocketServer.TCPServer` Example
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 This is the server side::
 
-   import socketserver
+   import SocketServer
 
-   class MyTCPHandler(socketserver.BaseRequestHandler):
+   class MyTCPHandler(SocketServer.BaseRequestHandler):
        """
        The RequestHandler class for our server.
 
@@ -353,7 +352,7 @@ This is the server side::
        HOST, PORT = "localhost", 9999
 
        # Create the server, binding to localhost on port 9999
-       server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
+       server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)
 
        # Activate the server; this will keep running until you
        # interrupt the program with Ctrl-C
@@ -362,7 +361,7 @@ This is the server side::
 An alternative request handler class that makes use of streams (file-like
 objects that simplify communication by providing the standard file interface)::
 
-   class MyTCPHandler(socketserver.StreamRequestHandler):
+   class MyTCPHandler(SocketServer.StreamRequestHandler):
 
        def handle(self):
            # self.rfile is a file-like object created by the handler;
@@ -423,14 +422,14 @@ Client::
    Received: PYTHON IS NICE
 
 
-:class:`socketserver.UDPServer` Example
+:class:`SocketServer.UDPServer` Example
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 This is the server side::
 
-   import socketserver
+   import SocketServer
 
-   class MyUDPHandler(socketserver.BaseRequestHandler):
+   class MyUDPHandler(SocketServer.BaseRequestHandler):
        """
        This class works similar to the TCP handler class, except that
        self.request consists of a pair of data and client socket, and since
@@ -447,7 +446,7 @@ This is the server side::
 
    if __name__ == "__main__":
       HOST, PORT = "localhost", 9999
-      server = socketserver.UDPServer((HOST, PORT), BaseUDPRequestHandler)
+      server = SocketServer.UDPServer((HOST, PORT), BaseUDPRequestHandler)
       server.serve_forever()
 
 This is the client side::
@@ -482,9 +481,9 @@ An example for the :class:`ThreadingMixIn` class::
 
    import socket
    import threading
-   import socketserver
+   import SocketServer
 
-   class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
+   class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
 
        def handle(self):
            data = self.request.recv(1024)
@@ -492,7 +491,7 @@ An example for the :class:`ThreadingMixIn` class::
            response = "%s: %s" % (cur_thread.getName(), data)
            self.request.send(response)
 
-   class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
+   class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
        pass
 
    def client(ip, port, message):

Doc/whatsnew/2.6.rst

@@ -1485,6 +1485,8 @@ details.
   * :mod:`Tkinter` has become the :mod:`tkinter` package.
   * :mod:`Queue` has become :mod:`queue`.
 
+  .. XXX no warnings anymore for renamed modules!
+
   The list of deprecated modules is:
   :mod:`audiodev`,
   :mod:`bgenlocations`,
@@ -2067,7 +2069,7 @@ details.
   and connects to it using an optional timeout value, returning
   the connected socket object.
 
-* The base classes in the :mod:`socketserver` module now support
+* The base classes in the :mod:`SocketServer` module now support
   calling a :meth:`handle_timeout` method after a span of inactivity
   specified by the server's :attr:`timeout` attribute.  (Contributed
   by Michael Pomraning.)  The :meth:`serve_forever` method

Lib/BaseHTTPServer.py

@@ -74,7 +74,7 @@ import sys
 import time
 import socket # For gethostbyaddr()
 import mimetools
-import socketserver
+import SocketServer
 
 # Default error message template
 DEFAULT_ERROR_MESSAGE = """\
@@ -94,19 +94,19 @@ DEFAULT_ERROR_CONTENT_TYPE = "text/html"
 def _quote_html(html):
     return html.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
 
-class HTTPServer(socketserver.TCPServer):
+class HTTPServer(SocketServer.TCPServer):
 
     allow_reuse_address = 1    # Seems to make sense in testing environment
 
     def server_bind(self):
         """Override server_bind to store the server name."""
-        socketserver.TCPServer.server_bind(self)
+        SocketServer.TCPServer.server_bind(self)
         host, port = self.socket.getsockname()[:2]
         self.server_name = socket.getfqdn(host)
         self.server_port = port
 
 
-class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
+class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
 
     """HTTP request handler base class.
 

Lib/SimpleXMLRPCServer.py

@@ -101,7 +101,7 @@ server.handle_request()
 
 import xmlrpclib
 from xmlrpclib import Fault
-import socketserver
+import SocketServer
 import BaseHTTPServer
 import sys
 import os
@@ -512,7 +512,7 @@ class SimpleXMLRPCRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
         if self.server.logRequests:
             BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
 
-class SimpleXMLRPCServer(socketserver.TCPServer,
+class SimpleXMLRPCServer(SocketServer.TCPServer,
                          SimpleXMLRPCDispatcher):
     """Simple XML-RPC server.
 
@@ -536,7 +536,7 @@ class SimpleXMLRPCServer(socketserver.TCPServer,
         self.logRequests = logRequests
 
         SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
-        socketserver.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)
+        SocketServer.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)
 
         # [Bug #1222790] If possible, set close-on-exec flag; if a
         # method spawns a subprocess, the subprocess shouldn't have

Lib/idlelib/rpc.py

@@ -5,7 +5,7 @@ connect to the Idle process, which listens for the connection.  Since Idle has
 has only one client per server, this was not a limitation.
 
    +---------------------------------+ +-------------+
-   | socketserver.BaseRequestHandler | | SocketIO    |
+   | SocketServer.BaseRequestHandler | | SocketIO    |
    +---------------------------------+ +-------------+
                    ^                   | register()  |
                    |                   | unregister()|
@@ -31,7 +31,7 @@ import sys
 import os
 import socket
 import select
-import socketserver
+import SocketServer
 import struct
 import cPickle as pickle
 import threading
@@ -66,12 +66,12 @@ copy_reg.pickle(types.CodeType, pickle_code, unpickle_code)
 BUFSIZE = 8*1024
 LOCALHOST = '127.0.0.1'
 
-class RPCServer(socketserver.TCPServer):
+class RPCServer(SocketServer.TCPServer):
 
     def __init__(self, addr, handlerclass=None):
         if handlerclass is None:
             handlerclass = RPCHandler
-        socketserver.TCPServer.__init__(self, addr, handlerclass)
+        SocketServer.TCPServer.__init__(self, addr, handlerclass)
 
     def server_bind(self):
         "Override TCPServer method, no bind() phase for connecting entity"
@@ -492,7 +492,7 @@ class RemoteProxy(object):
     def __init__(self, oid):
         self.oid = oid
 
-class RPCHandler(socketserver.BaseRequestHandler, SocketIO):
+class RPCHandler(SocketServer.BaseRequestHandler, SocketIO):
 
     debugging = False
     location = "#S"  # Server
@@ -500,10 +500,10 @@ class RPCHandler(socketserver.BaseRequestHandler, SocketIO):
     def __init__(self, sock, addr, svr):
         svr.current_handler = self ## cgt xxx
         SocketIO.__init__(self, sock)
-        socketserver.BaseRequestHandler.__init__(self, sock, addr, svr)
+        SocketServer.BaseRequestHandler.__init__(self, sock, addr, svr)
 
     def handle(self):
-        "handle() method required by socketserver"
+        "handle() method required by SocketServer"
         self.mainloop()
 
     def get_remote_proxy(self, oid):

Lib/logging/config.py

@@ -35,7 +35,7 @@ try:
 except ImportError:
     thread = None
 
-from socketserver import ThreadingTCPServer, StreamRequestHandler
+from SocketServer import ThreadingTCPServer, StreamRequestHandler
 
 
 DEFAULT_LOGGING_CONFIG_PORT = 9030

Lib/test/test___all__.py

@@ -42,7 +42,7 @@ class AllTest(unittest.TestCase):
         self.check_all("MimeWriter")
         self.check_all("queue")
         self.check_all("SimpleHTTPServer")
-        self.check_all("socketserver")
+        self.check_all("SocketServer")
         self.check_all("StringIO")
         self.check_all("UserString")
         self.check_all("aifc")

Lib/test/test_logging.py

@@ -33,7 +33,7 @@ import os
 import re
 import select
 import socket
-from socketserver import ThreadingTCPServer, StreamRequestHandler
+from SocketServer import ThreadingTCPServer, StreamRequestHandler
 import string
 import struct
 import sys

Lib/test/test_py3kwarn.py

@@ -216,7 +216,6 @@ class TestStdlibRemovals(unittest.TestCase):
 class TestStdlibRenames(unittest.TestCase):
 
     renames = {'Queue': 'queue',
-               'SocketServer': 'socketserver',
                'ConfigParser': 'configparser',
               }
 

Lib/test/test_socketserver.py

 """
-Test suite for socketserver.
+Test suite for SocketServer.py.
 """
 
 import contextlib
@@ -13,7 +13,7 @@ import tempfile
 import threading
 import time
 import unittest
-import socketserver
+import SocketServer
 
 import test.test_support
 from test.test_support import reap_children, verbose, TestSkipped
@@ -40,12 +40,12 @@ def receive(sock, n, timeout=20):
         raise RuntimeError, "timed out on %r" % (sock,)
 
 if HAVE_UNIX_SOCKETS:
-    class ForkingUnixStreamServer(socketserver.ForkingMixIn,
-                                  socketserver.UnixStreamServer):
+    class ForkingUnixStreamServer(SocketServer.ForkingMixIn,
+                                  SocketServer.UnixStreamServer):
         pass
 
-    class ForkingUnixDatagramServer(socketserver.ForkingMixIn,
-                                    socketserver.UnixDatagramServer):
+    class ForkingUnixDatagramServer(SocketServer.ForkingMixIn,
+                                    SocketServer.UnixDatagramServer):
         pass
 
 
@@ -172,55 +172,55 @@ class SocketServerTest(unittest.TestCase):
         s.close()
 
     def test_TCPServer(self):
-        self.run_server(socketserver.TCPServer,
-                        socketserver.StreamRequestHandler,
+        self.run_server(SocketServer.TCPServer,
+                        SocketServer.StreamRequestHandler,
                         self.stream_examine)
 
     def test_ThreadingTCPServer(self):
-        self.run_server(socketserver.ThreadingTCPServer,
-                        socketserver.StreamRequestHandler,
+        self.run_server(SocketServer.ThreadingTCPServer,
+                        SocketServer.StreamRequestHandler,
                         self.stream_examine)
 
     if HAVE_FORKING:
         def test_ForkingTCPServer(self):
             with simple_subprocess(self):
-                self.run_server(socketserver.ForkingTCPServer,
-                                socketserver.StreamRequestHandler,
+                self.run_server(SocketServer.ForkingTCPServer,
+                                SocketServer.StreamRequestHandler,
                                 self.stream_examine)
 
     if HAVE_UNIX_SOCKETS:
         def test_UnixStreamServer(self):
-            self.run_server(socketserver.UnixStreamServer,
-                            socketserver.StreamRequestHandler,
+            self.run_server(SocketServer.UnixStreamServer,
+                            SocketServer.StreamRequestHandler,
                             self.stream_examine)
 
         def test_ThreadingUnixStreamServer(self):
-            self.run_server(socketserver.ThreadingUnixStreamServer,
-                            socketserver.StreamRequestHandler,
+            self.run_server(SocketServer.ThreadingUnixStreamServer,
+                            SocketServer.StreamRequestHandler,
                             self.stream_examine)
 
         if HAVE_FORKING:
             def test_ForkingUnixStreamServer(self):
                 with simple_subprocess(self):
                     self.run_server(ForkingUnixStreamServer,
-                                    socketserver.StreamRequestHandler,
+                                    SocketServer.StreamRequestHandler,
                                     self.stream_examine)
 
     def test_UDPServer(self):
-        self.run_server(socketserver.UDPServer,
-                        socketserver.DatagramRequestHandler,
+        self.run_server(SocketServer.UDPServer,
+                        SocketServer.DatagramRequestHandler,
                         self.dgram_examine)
 
     def test_ThreadingUDPServer(self):
-        self.run_server(socketserver.ThreadingUDPServer,
-                        socketserver.DatagramRequestHandler,
+        self.run_server(SocketServer.ThreadingUDPServer,
+                        SocketServer.DatagramRequestHandler,
                         self.dgram_examine)
 
     if HAVE_FORKING:
         def test_ForkingUDPServer(self):
             with simple_subprocess(self):
-                self.run_server(socketserver.ForkingUDPServer,
-                                socketserver.DatagramRequestHandler,
+                self.run_server(SocketServer.ForkingUDPServer,
+                                SocketServer.DatagramRequestHandler,
                                 self.dgram_examine)
 
     # Alas, on Linux (at least) recvfrom() doesn't return a meaningful
@@ -228,19 +228,19 @@ class SocketServerTest(unittest.TestCase):
 
     # if HAVE_UNIX_SOCKETS:
     #     def test_UnixDatagramServer(self):
-    #         self.run_server(socketserver.UnixDatagramServer,
-    #                         socketserver.DatagramRequestHandler,
+    #         self.run_server(SocketServer.UnixDatagramServer,
+    #                         SocketServer.DatagramRequestHandler,
     #                         self.dgram_examine)
     #
     #     def test_ThreadingUnixDatagramServer(self):
-    #         self.run_server(socketserver.ThreadingUnixDatagramServer,
-    #                         socketserver.DatagramRequestHandler,
+    #         self.run_server(SocketServer.ThreadingUnixDatagramServer,
+    #                         SocketServer.DatagramRequestHandler,
     #                         self.dgram_examine)
     #
     #     if HAVE_FORKING:
     #         def test_ForkingUnixDatagramServer(self):
-    #             self.run_server(socketserver.ForkingUnixDatagramServer,
-    #                             socketserver.DatagramRequestHandler,
+    #             self.run_server(SocketServer.ForkingUnixDatagramServer,
+    #                             SocketServer.DatagramRequestHandler,
     #                             self.dgram_examine)
 
 

Lib/test/test_wsgiref.py

@@ -8,7 +8,7 @@ from wsgiref.validate import validator
 from wsgiref.simple_server import WSGIServer, WSGIRequestHandler, demo_app
 from wsgiref.simple_server import make_server
 from StringIO import StringIO
-from socketserver import BaseServer
+from SocketServer import BaseServer
 import re, sys
 
 from test import test_support

Misc/NEWS

@@ -161,9 +161,6 @@ Library
 
 - The multifile module has been deprecated as per PEP 4.
 
-- The SocketServer module has been renamed 'socketserver'.  The old
-  name is now deprecated.
-
 - The imageop module has been deprecated for removal in Python 3.0.
 
 - Issue #2250: Exceptions raised during evaluation of names in

Misc/cheatsheet

@@ -1973,7 +1973,7 @@ site             Append module search paths for third-party packages to
                  sys.path.
 smtplib          SMTP Client class (RFC 821)
 sndhdr           Several routines that help recognizing sound.
-socketserver     Generic socket server classes.
+SocketServer     Generic socket server classes.
 stat             Constants and functions for interpreting stat/lstat struct.
 statcache        Maintain a cache of file stats.
 statvfs          Constants for interpreting statvfs struct as returned by