Revert copy_reg -> copyreg rename.

14 files changed, 61 insertions, 69 deletions

diff --git a/Lib/copy.py b/Lib/copy.py
index 26ab366..f3871e5 100644
--- a/Lib/copy.py
+++ b/Lib/copy.py
@@ -49,7 +49,7 @@ __getstate__() and __setstate__().  See the documentation for module
 """
 
 import types
-from copyreg import dispatch_table
+from copy_reg import dispatch_table
 
 class Error(Exception):
     pass
diff --git a/Lib/copyreg.py b/Lib/copy_reg.py
index bf8827e..db17150 100644
--- a/Lib/copyreg.py
+++ b/Lib/copy_reg.py
@@ -13,7 +13,7 @@ dispatch_table = {}
 
 def pickle(ob_type, pickle_function, constructor_ob=None):
     if type(ob_type) is _ClassType:
-        raise TypeError("copyreg is not intended for use with classes")
+        raise TypeError("copy_reg is not intended for use with classes")
 
     if not hasattr(pickle_function, '__call__'):
         raise TypeError("reduction functions must be callable")
diff --git a/Lib/idlelib/rpc.py b/Lib/idlelib/rpc.py
index a8c6afb..e0bcf2c 100644
--- a/Lib/idlelib/rpc.py
+++ b/Lib/idlelib/rpc.py
@@ -37,7 +37,7 @@ import cPickle as pickle
 import threading
 import queue
 import traceback
-import copyreg
+import copy_reg
 import types
 import marshal
 
@@ -60,8 +60,8 @@ def pickle_code(co):
 #      assert isinstance(fn, type.FunctionType)
 #      return repr(fn)
 
-copyreg.pickle(types.CodeType, pickle_code, unpickle_code)
-# copyreg.pickle(types.FunctionType, pickle_function, unpickle_function)
+copy_reg.pickle(types.CodeType, pickle_code, unpickle_code)
+# copy_reg.pickle(types.FunctionType, pickle_function, unpickle_function)
 
 BUFSIZE = 8*1024
 LOCALHOST = '127.0.0.1'
diff --git a/Lib/lib-old/copy_reg.py b/Lib/lib-old/copy_reg.py
deleted file mode 100644
index 700698c..0000000
--- a/Lib/lib-old/copy_reg.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import sys
-from warnings import warnpy3k
-
-warnpy3k("the copy_reg module has been renamed "
-         "to 'copyreg' in Python 3.0", stacklevel=2)
-
-import copyreg
-sys.modules[__name__] = copyreg
diff --git a/Lib/os.py b/Lib/os.py
index f938962..def448f 100644
--- a/Lib/os.py
+++ b/Lib/os.py
@@ -715,7 +715,7 @@ if _exists("fork"):
             return p.stdin, p.stdout
         __all__.append("popen4")
 
-import copyreg as _copy_reg
+import copy_reg as _copy_reg
 
 def _make_stat_result(tup, dict):
     return stat_result(tup, dict)
diff --git a/Lib/pickle.py b/Lib/pickle.py
index ddb2c81..02a1b1d 100644
--- a/Lib/pickle.py
+++ b/Lib/pickle.py
@@ -1,7 +1,7 @@
 """Create portable serialized representations of Python objects.
 
 See module cPickle for a (much) faster implementation.
-See module copyreg for a mechanism for registering custom picklers.
+See module copy_reg for a mechanism for registering custom picklers.
 See module pickletools source for extensive comments.
 
 Classes:
@@ -27,8 +27,8 @@ Misc variables:
 __version__ = "$Revision$"       # Code version
 
 from types import *
-from copyreg import dispatch_table
-from copyreg import _extension_registry, _inverted_registry, _extension_cache
+from copy_reg import dispatch_table
+from copy_reg import _extension_registry, _inverted_registry, _extension_cache
 import marshal
 import sys
 import struct
@@ -295,7 +295,7 @@ class Pickler:
             self.save_global(obj)
             return
 
-        # Check copyreg.dispatch_table
+        # Check copy_reg.dispatch_table
         reduce = dispatch_table.get(t)
         if reduce:
             rv = reduce(obj)
diff --git a/Lib/pickletools.py b/Lib/pickletools.py
index 623dd16..ae02a36 100644
--- a/Lib/pickletools.py
+++ b/Lib/pickletools.py
@@ -136,7 +136,7 @@ this and there isn't a use case that warrants the expense of such an
 analysis.
 
 To this end, all tests for __safe_for_unpickling__ or for
-copyreg.safe_constructors are removed from the unpickling code.
+copy_reg.safe_constructors are removed from the unpickling code.
 References to these variables in the descriptions below are to be seen
 as describing unpickling in Python 2.2 and before.
 """
@@ -1525,7 +1525,7 @@ opcodes = [
       BUILD opcode to apply  __setstate__ to that argument.
 
       If type(callable) is not ClassType, REDUCE complains unless the
-      callable has been registered with the copyreg module's
+      callable has been registered with the copy_reg module's
       safe_constructors dict, or the callable has a magic
       '__safe_for_unpickling__' attribute with a true value.  I'm not sure
       why it does this, but I've sure seen this complaint often enough when
diff --git a/Lib/re.py b/Lib/re.py
index 3f4f02c..1d9c987 100644
--- a/Lib/re.py
+++ b/Lib/re.py
@@ -278,12 +278,12 @@ def _subx(pattern, template):
 
 # register myself for pickling
 
-import copyreg
+import copy_reg
 
 def _pickle(p):
     return _compile, (p.pattern, p.flags)
 
-copyreg.pickle(_pattern_type, _pickle, _compile)
+copy_reg.pickle(_pattern_type, _pickle, _compile)
 
 # --------------------------------------------------------------------
 # experimental stuff (see python-dev discussions for details)
diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py
index ed3b626..e1bc078 100644
--- a/Lib/test/pickletester.py
+++ b/Lib/test/pickletester.py
@@ -2,7 +2,7 @@ import unittest
 import pickle
 import cPickle
 import pickletools
-import copyreg
+import copy_reg
 
 from test.test_support import TestFailed, have_unicode, TESTFN, \
                               run_with_locale
@@ -44,21 +44,21 @@ class ExtensionSaver:
     # there is one).
     def __init__(self, code):
         self.code = code
-        if code in copyreg._inverted_registry:
-            self.pair = copyreg._inverted_registry[code]
-            copyreg.remove_extension(self.pair[0], self.pair[1], code)
+        if code in copy_reg._inverted_registry:
+            self.pair = copy_reg._inverted_registry[code]
+            copy_reg.remove_extension(self.pair[0], self.pair[1], code)
         else:
             self.pair = None
 
     # Restore previous registration for code.
     def restore(self):
         code = self.code
-        curpair = copyreg._inverted_registry.get(code)
+        curpair = copy_reg._inverted_registry.get(code)
         if curpair is not None:
-            copyreg.remove_extension(curpair[0], curpair[1], code)
+            copy_reg.remove_extension(curpair[0], curpair[1], code)
         pair = self.pair
         if pair is not None:
-            copyreg.add_extension(pair[0], pair[1], code)
+            copy_reg.add_extension(pair[0], pair[1], code)
 
 class C:
     def __cmp__(self, other):
@@ -690,14 +690,14 @@ class AbstractPickleTests(unittest.TestCase):
                 self.assertEqual(B(x), B(y), detail)
                 self.assertEqual(x.__dict__, y.__dict__, detail)
 
-    # Register a type with copyreg, with extension code extcode.  Pickle
+    # Register a type with copy_reg, with extension code extcode.  Pickle
     # an object of that type.  Check that the resulting pickle uses opcode
     # (EXT[124]) under proto 2, and not in proto 1.
 
     def produce_global_ext(self, extcode, opcode):
         e = ExtensionSaver(extcode)
         try:
-            copyreg.add_extension(__name__, "MyList", extcode)
+            copy_reg.add_extension(__name__, "MyList", extcode)
             x = MyList([1, 2, 3])
             x.foo = 42
             x.bar = "hello"
diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py
index 85df78e..7aa22ed 100755
--- a/Lib/test/regrtest.py
+++ b/Lib/test/regrtest.py
@@ -629,7 +629,7 @@ def cleanup_test_droppings(testname, verbose):
 
 def dash_R(the_module, test, indirect_test, huntrleaks):
     # This code is hackish and inelegant, but it seems to do the job.
-    import copyreg, _abcoll, io
+    import copy_reg, _abcoll, io
 
     if not hasattr(sys, 'gettotalrefcount'):
         raise Exception("Tracking reference leaks requires a debug build "
@@ -637,7 +637,7 @@ def dash_R(the_module, test, indirect_test, huntrleaks):
 
     # Save current values for dash_R_cleanup() to restore.
     fs = warnings.filters[:]
-    ps = copyreg.dispatch_table.copy()
+    ps = copy_reg.dispatch_table.copy()
     pic = sys.path_importer_cache.copy()
     abcs = {}
     modules = _abcoll, io
@@ -677,7 +677,7 @@ def dash_R(the_module, test, indirect_test, huntrleaks):
         refrep.close()
 
 def dash_R_cleanup(fs, ps, pic, abcs):
-    import gc, copyreg
+    import gc, copy_reg
     import _strptime, linecache
     dircache = test_support.import_module('dircache', deprecated=True)
     import urlparse, urllib, urllib2, mimetypes, doctest
@@ -691,8 +691,8 @@ def dash_R_cleanup(fs, ps, pic, abcs):
 
     # Restore some original values.
     warnings.filters[:] = fs
-    copyreg.dispatch_table.clear()
-    copyreg.dispatch_table.update(ps)
+    copy_reg.dispatch_table.clear()
+    copy_reg.dispatch_table.update(ps)
     sys.path_importer_cache.clear()
     sys.path_importer_cache.update(pic)
 
diff --git a/Lib/test/test___all__.py b/Lib/test/test___all__.py
index 3b6d966..466d921 100644
--- a/Lib/test/test___all__.py
+++ b/Lib/test/test___all__.py
@@ -61,7 +61,7 @@ class AllTest(unittest.TestCase):
         self.check_all("commands")
         self.check_all("compileall")
         self.check_all("copy")
-        self.check_all("copyreg")
+        self.check_all("copy_reg")
         self.check_all("csv")
         self.check_all("dbhash")
         self.check_all("decimal")
diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py
index 8645ba1..d2899bd 100644
--- a/Lib/test/test_copy.py
+++ b/Lib/test/test_copy.py
@@ -1,7 +1,7 @@
 """Unit tests for the copy module."""
 
 import copy
-import copyreg
+import copy_reg
 
 import unittest
 from test import test_support
@@ -42,7 +42,7 @@ class TestCopy(unittest.TestCase):
             return (C, (obj.foo,))
         x = C(42)
         self.assertRaises(TypeError, copy.copy, x)
-        copyreg.pickle(C, pickle_C, C)
+        copy_reg.pickle(C, pickle_C, C)
         y = copy.copy(x)
 
     def test_copy_reduce_ex(self):
@@ -215,7 +215,7 @@ class TestCopy(unittest.TestCase):
             return (C, (obj.foo,))
         x = C(42)
         self.assertRaises(TypeError, copy.deepcopy, x)
-        copyreg.pickle(C, pickle_C, C)
+        copy_reg.pickle(C, pickle_C, C)
         y = copy.deepcopy(x)
 
     def test_deepcopy_reduce_ex(self):
diff --git a/Lib/test/test_copyreg.py b/Lib/test/test_copy_reg.py
index 0b42128..c3d3964 100644
--- a/Lib/test/test_copyreg.py
+++ b/Lib/test/test_copy_reg.py
@@ -1,4 +1,4 @@
-import copyreg
+import copy_reg
 import unittest
 
 from test import test_support
@@ -27,15 +27,15 @@ class WithInherited(WithSingleString):
 class CopyRegTestCase(unittest.TestCase):
 
     def test_class(self):
-        self.assertRaises(TypeError, copyreg.pickle,
+        self.assertRaises(TypeError, copy_reg.pickle,
                           C, None, None)
 
     def test_noncallable_reduce(self):
-        self.assertRaises(TypeError, copyreg.pickle,
+        self.assertRaises(TypeError, copy_reg.pickle,
                           type(1), "not a callable")
 
     def test_noncallable_constructor(self):
-        self.assertRaises(TypeError, copyreg.pickle,
+        self.assertRaises(TypeError, copy_reg.pickle,
                           type(1), int, "not a callable")
 
     def test_bool(self):
@@ -47,42 +47,42 @@ class CopyRegTestCase(unittest.TestCase):
         e = ExtensionSaver(code)
         try:
             # Shouldn't be in registry now.
-            self.assertRaises(ValueError, copyreg.remove_extension,
+            self.assertRaises(ValueError, copy_reg.remove_extension,
                               mod, func, code)
-            copyreg.add_extension(mod, func, code)
+            copy_reg.add_extension(mod, func, code)
             # Should be in the registry.
-            self.assert_(copyreg._extension_registry[mod, func] == code)
-            self.assert_(copyreg._inverted_registry[code] == (mod, func))
+            self.assert_(copy_reg._extension_registry[mod, func] == code)
+            self.assert_(copy_reg._inverted_registry[code] == (mod, func))
             # Shouldn't be in the cache.
-            self.assert_(code not in copyreg._extension_cache)
+            self.assert_(code not in copy_reg._extension_cache)
             # Redundant registration should be OK.
-            copyreg.add_extension(mod, func, code)  # shouldn't blow up
+            copy_reg.add_extension(mod, func, code)  # shouldn't blow up
             # Conflicting code.
-            self.assertRaises(ValueError, copyreg.add_extension,
+            self.assertRaises(ValueError, copy_reg.add_extension,
                               mod, func, code + 1)
-            self.assertRaises(ValueError, copyreg.remove_extension,
+            self.assertRaises(ValueError, copy_reg.remove_extension,
                               mod, func, code + 1)
             # Conflicting module name.
-            self.assertRaises(ValueError, copyreg.add_extension,
+            self.assertRaises(ValueError, copy_reg.add_extension,
                               mod[1:], func, code )
-            self.assertRaises(ValueError, copyreg.remove_extension,
+            self.assertRaises(ValueError, copy_reg.remove_extension,
                               mod[1:], func, code )
             # Conflicting function name.
-            self.assertRaises(ValueError, copyreg.add_extension,
+            self.assertRaises(ValueError, copy_reg.add_extension,
                               mod, func[1:], code)
-            self.assertRaises(ValueError, copyreg.remove_extension,
+            self.assertRaises(ValueError, copy_reg.remove_extension,
                               mod, func[1:], code)
             # Can't remove one that isn't registered at all.
-            if code + 1 not in copyreg._inverted_registry:
-                self.assertRaises(ValueError, copyreg.remove_extension,
+            if code + 1 not in copy_reg._inverted_registry:
+                self.assertRaises(ValueError, copy_reg.remove_extension,
                                   mod[1:], func[1:], code + 1)
 
         finally:
             e.restore()
 
         # Shouldn't be there anymore.
-        self.assert_((mod, func) not in copyreg._extension_registry)
-        # The code *may* be in copyreg._extension_registry, though, if
+        self.assert_((mod, func) not in copy_reg._extension_registry)
+        # The code *may* be in copy_reg._extension_registry, though, if
         # we happened to pick on a registered code.  So don't check for
         # that.
 
@@ -90,25 +90,25 @@ class CopyRegTestCase(unittest.TestCase):
         for code in 1, 0x7fffffff:
             e = ExtensionSaver(code)
             try:
-                copyreg.add_extension(mod, func, code)
-                copyreg.remove_extension(mod, func, code)
+                copy_reg.add_extension(mod, func, code)
+                copy_reg.remove_extension(mod, func, code)
             finally:
                 e.restore()
 
         # Ensure invalid codes blow up.
         for code in -1, 0, 0x80000000L:
-            self.assertRaises(ValueError, copyreg.add_extension,
+            self.assertRaises(ValueError, copy_reg.add_extension,
                               mod, func, code)
 
     def test_slotnames(self):
-        self.assertEquals(copyreg._slotnames(WithoutSlots), [])
-        self.assertEquals(copyreg._slotnames(WithWeakref), [])
+        self.assertEquals(copy_reg._slotnames(WithoutSlots), [])
+        self.assertEquals(copy_reg._slotnames(WithWeakref), [])
         expected = ['_WithPrivate__spam']
-        self.assertEquals(copyreg._slotnames(WithPrivate), expected)
-        self.assertEquals(copyreg._slotnames(WithSingleString), ['spam'])
+        self.assertEquals(copy_reg._slotnames(WithPrivate), expected)
+        self.assertEquals(copy_reg._slotnames(WithSingleString), ['spam'])
         expected = ['eggs', 'spam']
         expected.sort()
-        result = copyreg._slotnames(WithInherited)
+        result = copy_reg._slotnames(WithInherited)
         result.sort()
         self.assertEquals(result, expected)
 
diff --git a/Lib/test/test_py3kwarn.py b/Lib/test/test_py3kwarn.py
index 0641f7d..ece38ec 100644
--- a/Lib/test/test_py3kwarn.py
+++ b/Lib/test/test_py3kwarn.py
@@ -215,7 +215,7 @@ class TestStdlibRemovals(unittest.TestCase):
 
 class TestStdlibRenames(unittest.TestCase):
 
-    renames = {'copy_reg': 'copyreg', 'Queue': 'queue',
+    renames = {'Queue': 'queue',
                'SocketServer': 'socketserver',
                'ConfigParser': 'configparser',
                'repr': 'reprlib'}