diff options
Diffstat (limited to 'Lib')
| -rw-r--r-- | Lib/copy.py | 2 | ||||
| -rw-r--r-- | Lib/copy_reg.py (renamed from Lib/copyreg.py) | 2 | ||||
| -rw-r--r-- | Lib/idlelib/rpc.py | 6 | ||||
| -rw-r--r-- | Lib/lib-old/copy_reg.py | 8 | ||||
| -rw-r--r-- | Lib/os.py | 2 | ||||
| -rw-r--r-- | Lib/pickle.py | 8 | ||||
| -rw-r--r-- | Lib/pickletools.py | 4 | ||||
| -rw-r--r-- | Lib/re.py | 4 | ||||
| -rw-r--r-- | Lib/test/pickletester.py | 18 | ||||
| -rwxr-xr-x | Lib/test/regrtest.py | 10 | ||||
| -rw-r--r-- | Lib/test/test___all__.py | 2 | ||||
| -rw-r--r-- | Lib/test/test_copy.py | 6 | ||||
| -rw-r--r-- | Lib/test/test_copy_reg.py (renamed from Lib/test/test_copyreg.py) | 56 | ||||
| -rw-r--r-- | Lib/test/test_py3kwarn.py | 2 |
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 @@ -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 @@ -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'} |