Revert copy_reg -> copyreg rename.

6 files changed, 47 insertions, 47 deletions

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'}