When instantiating a class with no arguments and where the class does
not define __getinitargs__, bypass the __init__ constructor
completely. This uses the trick of instantiating an empty dummy class
and then changing inst.__class__ to the real class. This is done in
two places: once for the INST and once for the OBJ format code.
Also replaced the much outdated long doc string with a short summary
of the module; the information of that doc string is already
incorporated in the library reference manual.
diff --git a/Lib/pickle.py b/Lib/pickle.py
index a38f4f6..3068b41 100644
--- a/Lib/pickle.py
+++ b/Lib/pickle.py
@@ -1,134 +1,29 @@
-"""\
-Pickling Algorithm
-------------------
+"""create portable serialized representations of Python objects.
-This module implements a basic but powerful algorithm for "pickling" (a.k.a.
-serializing, marshalling or flattening) nearly arbitrary Python objects.
-This is a more primitive notion than persistency -- although pickle
-reads and writes file objects, it does not handle the issue of naming
-persistent objects, nor the (even more complicated) area of concurrent
-access to persistent objects. The pickle module can transform a complex
-object into a byte stream and it can transform the byte stream into
-an object with the same internal structure. The most obvious thing to
-do with these byte streams is to write them onto a file, but it is also
-conceivable to send them across a network or store them in a database.
+See module cPickle for a (much) faster implementation.
+See module copy_reg for a mechanism for registering custom picklers.
-Unlike the built-in marshal module, pickle handles the following correctly:
+Classes:
-- recursive objects
-- pointer sharing
-- classes and class instances
+ Pickler
+ Unpickler
-Pickle is Python-specific. This has the advantage that there are no
-restrictions imposed by external standards such as CORBA (which probably
-can't represent pointer sharing or recursive objects); however it means
-that non-Python programs may not be able to reconstruct pickled Python
-objects.
+Functions:
-Pickle uses a printable ASCII representation. This is slightly more
-voluminous than a binary representation. However, small integers actually
-take *less* space when represented as minimal-size decimal strings than
-when represented as 32-bit binary numbers, and strings are only much longer
-if they contain control characters or 8-bit characters. The big advantage
-of using printable ASCII (and of some other characteristics of pickle's
-representation) is that for debugging or recovery purposes it is possible
-for a human to read the pickled file with a standard text editor. (I could
-have gone a step further and used a notation like S-expressions, but the
-parser would have been considerably more complicated and slower, and the
-files would probably have become much larger.)
+ dump(object, file)
+ dumps(object) -> string
+ load(file) -> object
+ loads(string) -> object
-Pickle doesn't handle code objects, which marshal does.
-I suppose pickle could, and maybe it should, but there's probably no
-great need for it right now (as long as marshal continues to be used
-for reading and writing code objects), and at least this avoids
-the possibility of smuggling Trojan horses into a program.
+Misc variables:
-For the benefit of persistency modules written using pickle, it supports
-the notion of a reference to an object outside the pickled data stream.
-Such objects are referenced by a name, which is an arbitrary string of
-printable ASCII characters. The resolution of such names is not defined
-by the pickle module -- the persistent object module will have to implement
-a method "persistent_load". To write references to persistent objects,
-the persistent module must define a method "persistent_id" which returns
-either None or the persistent ID of the object.
+ __ version__
+ format_version
+ compatible_formats
-There are some restrictions on the pickling of class instances.
-
-First of all, the class must be defined at the top level in a module.
-
-Next, it must normally be possible to create class instances by
-calling the class without arguments. Usually, this is best
-accomplished by providing default values for all arguments to its
-__init__ method (if it has one). If this is undesirable, the
-class can define a method __getinitargs__, which should return a
-*tuple* containing the arguments to be passed to the class
-constructor.
-
-Classes can influence how their instances are pickled -- if the class defines
-the method __getstate__, it is called and the return state is pickled
-as the contents for the instance, and if the class defines the
-method __setstate__, it is called with the unpickled state. (Note
-that these methods can also be used to implement copying class instances.)
-If there is no __getstate__ method, the instance's __dict__
-is pickled. If there is no __setstate__ method, the pickled object
-must be a dictionary and its items are assigned to the new instance's
-dictionary. (If a class defines both __getstate__ and __setstate__,
-the state object needn't be a dictionary -- these methods can do what they
-want.)
-
-Note that when class instances are pickled, their class's code and data
-is not pickled along with them. Only the instance data is pickled.
-This is done on purpose, so you can fix bugs in a class or add methods and
-still load objects that were created with an earlier version of the
-class. If you plan to have long-lived objects that will see many versions
-of a class, it may be worth to put a version number in the objects so
-that suitable conversions can be made by the class's __setstate__ method.
-
-The interface is as follows:
-
-To pickle an object x onto a file f, open for writing:
-
- p = pickle.Pickler(f)
- p.dump(x)
-
-To unpickle an object x from a file f, open for reading:
-
- u = pickle.Unpickler(f)
- x = u.load()
-
-The Pickler class only calls the method f.write with a string argument
-(XXX possibly the interface should pass f.write instead of f).
-The Unpickler calls the methods f.read(with an integer argument)
-and f.readline(without argument), both returning a string.
-It is explicitly allowed to pass non-file objects here, as long as they
-have the right methods.
-
-The following types can be pickled:
-
-- None
-- integers, long integers, floating point numbers
-- strings
-- tuples, lists and dictionaries containing only picklable objects
-- class instances whose __dict__ or __setstate__() is picklable
-- classes
-
-Attempts to pickle unpicklable objects will raise an exception
-after having written an unspecified number of bytes to the file argument.
-
-It is possible to make multiple calls to Pickler.dump() or to
-Unpickler.load(), as long as there is a one-to-one correspondence
-between pickler and Unpickler objects and between dump and load calls
-for any pair of corresponding Pickler and Unpicklers. WARNING: this
-is intended for pickleing multiple objects without intervening modifications
-to the objects or their parts. If you modify an object and then pickle
-it again using the same Pickler instance, the object is not pickled
-again -- a reference to it is pickled and the Unpickler will return
-the old value, not the modified one. (XXX There are two problems here:
-(a) detecting changes, and (b) marshalling a minimal set of changes.
-I have no answers. Garbage Collection may also become a problem here.)
"""
-__version__ = "1.8" # Code version
+__version__ = "1.9" # Code version
from types import *
from copy_reg import dispatch_table, safe_constructors
@@ -702,11 +597,12 @@
module = self.readline()[:-1]
name = self.readline()[:-1]
klass = self.find_class(module, name)
-## if (type(klass) is not ClassType):
-## raise SystemError, "Imported object %s from module %s is " \
-## "not a class" % (name, module)
-
- value = apply(klass, args)
+ if (not args and type(klass) is ClassType and
+ not hasattr(klass, "__getinitargs__")):
+ value = _EmptyClass()
+ value.__class__ = klass
+ else:
+ value = apply(klass, args)
self.append(value)
dispatch[INST] = load_inst
@@ -717,7 +613,12 @@
del stack[k + 1]
args = tuple(stack[k + 1:])
del stack[k:]
- value = apply(klass, args)
+ if (not args and type(klass) is ClassType and
+ not hasattr(klass, "__getinitargs__")):
+ value = _EmptyClass()
+ value.__class__ = klass
+ else:
+ value = apply(klass, args)
self.append(value)
dispatch[OBJ] = load_obj
@@ -863,6 +764,10 @@
raise STOP, value
dispatch[STOP] = load_stop
+# Helper class for load_inst/load_obj
+
+class _EmptyClass:
+ pass
# Shorthands