Revert copy_reg -> copyreg rename.

git-svn-id: http://svn.python.org/projects/python/trunk@63493 6015fed2-1504-0410-9fe1-9d1591cc4771

Author: georg.brandl

Doc/library/copy.rst

@@ -63,7 +63,7 @@ of lists by assigning a slice of the entire list, for example,
 
 Classes can use the same interfaces to control copying that they use to control
 pickling.  See the description of module :mod:`pickle` for information on these
-methods.  The :mod:`copy` module does not use the :mod:`copyreg` registration
+methods.  The :mod:`copy` module does not use the :mod:`copy_reg` registration
 module.
 
 .. index::

Doc/library/copyreg.rst Doc/library/copy_reg.rst

@@ -1,23 +1,20 @@
-:mod:`copyreg` --- Register :mod:`pickle` support functions
-===========================================================
+:mod:`copy_reg` --- Register :mod:`pickle` support functions
+============================================================
 
 .. module:: copy_reg
-   :synopsis: Old name for the copyreg module.
-
-.. module:: copyreg
    :synopsis: Register pickle support functions.
 
 .. note::
    The :mod:`copy_reg` module has been renamed to :mod:`copyreg` in Python 3.0.
-   It is importable under both names in Python 2.6 and the rest of the 2.x
-   series.
+   The :term:`2to3` tool will automatically adapt imports when converting your
+   sources to 3.0.
 
 .. index::
    module: pickle
    module: cPickle
    module: copy
 
-The :mod:`copyreg` module provides support for the :mod:`pickle` and
+The :mod:`copy_reg` module provides support for the :mod:`pickle` and
 :mod:`cPickle` modules.  The :mod:`copy` module is likely to use this in the
 future as well.  It provides configuration information about object constructors
 which are not classes.  Such constructors may be factory functions or class

Doc/library/modulefinder.rst

@@ -97,7 +97,7 @@ Sample output (may vary depending on the architecture)::
 
     Loaded modules:
     _types:
-    copyreg:  _inverted_registry,_slotnames,__all__
+    copy_reg:  _inverted_registry,_slotnames,__all__
     sre_compile:  isstring,_sre,_optimize_unicode
     _sre:
     sre_constants:  REPEAT_ONE,makedict,AT_END_LINE

Doc/library/persistence.rst

@@ -19,7 +19,7 @@ The list of modules described in this chapter is:
 .. toctree::
 
    pickle.rst
-   copyreg.rst
+   copy_reg.rst
    shelve.rst
    marshal.rst
    anydbm.rst

Doc/library/pickle.rst

@@ -535,7 +535,7 @@ not :meth:`__reduce_ex__`, the :meth:`__reduce_ex__` implementation detects this
 and calls :meth:`__reduce__`.
 
 An alternative to implementing a :meth:`__reduce__` method on the object to be
-pickled, is to register the callable with the :mod:`copyreg` module.  This
+pickled, is to register the callable with the :mod:`copy_reg` module.  This
 module provides a way for programs to register "reduction functions" and
 constructors for user-defined types.   Reduction functions have the same
 semantics and interface as the :meth:`__reduce__` method described above, except
@@ -786,7 +786,7 @@ the same process or a new process. ::
 
 .. seealso::
 
-   Module :mod:`copyreg`
+   Module :mod:`copy_reg`
       Pickle interface constructor registration for extension types.
 
    Module :mod:`shelve`

Lib/copy.py

@@ -49,7 +49,7 @@ class instances).
 """
 
 import types
-from copyreg import dispatch_table
+from copy_reg import dispatch_table
 
 class Error(Exception):
     pass

Lib/copyreg.py Lib/copy_reg.py

@@ -13,7 +13,7 @@
 
 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")

Lib/idlelib/rpc.py

@@ -37,7 +37,7 @@
 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'

Lib/lib-old/copy_reg.py

@@ -715,7 +715,7 @@ def popen4(cmd, mode="t", bufsize=-1):
             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)

Lib/os.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 @@
 __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 @@ def save(self, obj):
             self.save_global(obj)
             return
 
-        # Check copyreg.dispatch_table
+        # Check copy_reg.dispatch_table
         reduce = dispatch_table.get(t)
         if reduce:
             rv = reduce(obj)

Lib/pickle.py

@@ -136,7 +136,7 @@
 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 @@ def __init__(self, name, code, arg,
       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

Lib/pickletools.py

@@ -278,12 +278,12 @@ def filter(match, template=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)

Lib/re.py

@@ -2,7 +2,7 @@
 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 @@ def test_newobj_generic(self):
                 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"

Lib/test/pickletester.py

@@ -629,15 +629,15 @@ 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 "
                         "of Python")
 
     # 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 run_the_test():
         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)
 

Lib/test/regrtest.py

@@ -61,7 +61,7 @@ def test_all(self):
         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")

Lib/test/test___all__.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 @@ def pickle_C(obj):
             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 @@ def pickle_C(obj):
             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):