From: Georg Brandl Date: Tue, 20 May 2008 07:49:57 +0000 (+0000) Subject: Revert copy_reg -> copyreg rename. X-Git-Tag: v2.6b1~315 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=dffbf5f5421cbeb20237280c0bd70f989269f844;p=python Revert copy_reg -> copyreg rename. --- diff --git a/Doc/library/copy.rst b/Doc/library/copy.rst index ce127a3633..89b668d5f9 100644 --- a/Doc/library/copy.rst +++ b/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:: diff --git a/Doc/library/copyreg.rst b/Doc/library/copy_reg.rst similarity index 81% rename from Doc/library/copyreg.rst rename to Doc/library/copy_reg.rst index 3a3f815de8..609ded045e 100644 --- a/Doc/library/copyreg.rst +++ b/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 diff --git a/Doc/library/modulefinder.rst b/Doc/library/modulefinder.rst index 402f5db48e..a086206df7 100644 --- a/Doc/library/modulefinder.rst +++ b/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 diff --git a/Doc/library/persistence.rst b/Doc/library/persistence.rst index 3708d17fb8..78e40f6446 100644 --- a/Doc/library/persistence.rst +++ b/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 diff --git a/Doc/library/pickle.rst b/Doc/library/pickle.rst index eefa4d33b8..f19726159f 100644 --- a/Doc/library/pickle.rst +++ b/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` diff --git a/Lib/copy.py b/Lib/copy.py index 26ab366ec6..f3871e5cb9 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 similarity index 98% rename from Lib/copyreg.py rename to Lib/copy_reg.py index bf8827e3c0..db1715092c 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 a8c6afb02f..e0bcf2ca5d 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 700698c5fa..0000000000 --- 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 f9389623db..def448f472 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 ddb2c81490..02a1b1d1ae 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 623dd16bf4..ae02a36103 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 3f4f02ce12..1d9c987c1c 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 ed3b626593..e1bc078154 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 85df78e11d..7aa22ed814 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 3b6d966f0b..466d921c92 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 8645ba1b8a..d2899bd4ea 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 similarity index 58% rename from Lib/test/test_copyreg.py rename to Lib/test/test_copy_reg.py index 0b4212832e..c3d3964b38 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 0641f7d5ce..ece38ec46c 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'} diff --git a/Misc/cheatsheet b/Misc/cheatsheet index 1ce19964c7..e69935979a 100644 --- a/Misc/cheatsheet +++ b/Misc/cheatsheet @@ -1864,7 +1864,7 @@ commands Tools for executing UNIX commands . compileall Force "compilation" of all .py files in a directory. configparser Configuration file parser (much like windows .ini files) copy Generic shallow and deep copying operations. -copyreg Helper to provide extensibility for pickle/cPickle. +copy_reg Helper to provide extensibility for pickle/cPickle. csv Read and write files with comma separated values. dbhash (g)dbm-compatible interface to bsdhash.hashopen. dircache Sorted list of files in a dir, using a cache. diff --git a/Modules/cPickle.c b/Modules/cPickle.c index 06726eed9c..f13008783e 100644 --- a/Modules/cPickle.c +++ b/Modules/cPickle.c @@ -105,18 +105,18 @@ static PyObject *BadPickleGet; /* As the name says, an empty tuple. */ static PyObject *empty_tuple; -/* copyreg.dispatch_table, {type_object: pickling_function} */ +/* copy_reg.dispatch_table, {type_object: pickling_function} */ static PyObject *dispatch_table; /* For EXT[124] opcodes. */ -/* copyreg._extension_registry, {(module_name, function_name): code} */ +/* copy_reg._extension_registry, {(module_name, function_name): code} */ static PyObject *extension_registry; -/* copyreg._inverted_registry, {code: (module_name, function_name)} */ +/* copy_reg._inverted_registry, {code: (module_name, function_name)} */ static PyObject *inverted_registry; -/* copyreg._extension_cache, {code: object} */ +/* copy_reg._extension_cache, {code: object} */ static PyObject *extension_cache; -/* For looking up name pairs in copyreg._extension_registry. */ +/* For looking up name pairs in copy_reg._extension_registry. */ static PyObject *two_tuple; static PyObject *__class___str, *__getinitargs___str, *__dict___str, @@ -2477,7 +2477,7 @@ save(Picklerobject *self, PyObject *args, int pers_save) } /* Get a reduction callable, and call it. This may come from - * copyreg.dispatch_table, the object's __reduce_ex__ method, + * copy_reg.dispatch_table, the object's __reduce_ex__ method, * or the object's __reduce__ method. */ __reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type); @@ -5591,7 +5591,7 @@ init_stuff(PyObject *module_dict) INIT_STR(copyreg); INIT_STR(dispatch_table); - if (!( copyreg = PyImport_ImportModule("copyreg"))) + if (!( copyreg = PyImport_ImportModule("copy_reg"))) return -1; /* This is special because we want to use a different diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c index 02a1e481b2..6e52343e0d 100644 --- a/Modules/parsermodule.c +++ b/Modules/parsermodule.c @@ -3284,7 +3284,7 @@ initparser(void) * If this fails, the import of this module will fail because an * exception will be raised here; should we clear the exception? */ - copyreg = PyImport_ImportModuleNoBlock("copyreg"); + copyreg = PyImport_ImportModuleNoBlock("copy_reg"); if (copyreg != NULL) { PyObject *func, *pickler; diff --git a/Objects/typeobject.c b/Objects/typeobject.c index 113829109c..c3aa090585 100644 --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -3058,7 +3058,7 @@ static PyGetSetDef object_getsets[] = { /* Stuff to implement __reduce_ex__ for pickle protocols >= 2. - We fall back to helpers in copyreg for: + We fall back to helpers in copy_reg for: - pickle protocols < 2 - calculating the list of slot names (done only once per class) - the __newobj__ function (which is used as a token but never called) @@ -3070,7 +3070,7 @@ import_copyreg(void) static PyObject *copyreg_str; if (!copyreg_str) { - copyreg_str = PyString_InternFromString("copyreg"); + copyreg_str = PyString_InternFromString("copy_reg"); if (copyreg_str == NULL) return NULL; } @@ -3108,7 +3108,7 @@ slotnames(PyObject *cls) !PyList_Check(slotnames)) { PyErr_SetString(PyExc_TypeError, - "copyreg._slotnames didn't return a list or None"); + "copy_reg._slotnames didn't return a list or None"); Py_DECREF(slotnames); slotnames = NULL; }