1
"""Create portable serialized representations of Python objects.
3
See module cPickle for a (much) faster implementation.
4
See module copy_reg for a mechanism for registering custom picklers.
5
See module pickletools source for extensive comments.
15
dumps(object) -> string
17
loads(string) -> object
27
__version__ = "$Revision: 1.158 $" # Code version
30
from copy_reg import dispatch_table
31
from copy_reg import _extension_registry, _inverted_registry, _extension_cache
38
__all__ = ["PickleError", "PicklingError", "UnpicklingError", "Pickler",
39
"Unpickler", "dump", "dumps", "load", "loads"]
41
# These are purely informational; no code uses these.
42
format_version = "2.0" # File format version we write
43
compatible_formats = ["1.0", # Original protocol 0
44
"1.1", # Protocol 0 with INST added
45
"1.2", # Original protocol 1
46
"1.3", # Protocol 1 with BINFLOAT added
48
] # Old format versions we can read
50
# Keep in synch with cPickle. This is the highest protocol number we
54
# Why use struct.pack() for pickling but marshal.loads() for
55
# unpickling? struct.pack() is 40% faster than marshal.dumps(), but
56
# marshal.loads() is twice as fast as struct.unpack()!
57
mloads = marshal.loads
59
class PickleError(Exception):
60
"""A common base class for the other pickling exceptions."""
63
class PicklingError(PickleError):
64
"""This exception is raised when an unpicklable object is passed to the
70
class UnpicklingError(PickleError):
71
"""This exception is raised when there is a problem unpickling an object,
72
such as a security violation.
74
Note that other exceptions may also be raised during unpickling, including
75
(but not necessarily limited to) AttributeError, EOFError, ImportError,
81
# An instance of _Stop is raised by Unpickler.load_stop() in response to
82
# the STOP opcode, passing the object that is the result of unpickling.
83
class _Stop(Exception):
84
def __init__(self, value):
87
# Jython has PyStringMap; it's a dict subclass with string keys
89
from org.python.core import PyStringMap
93
# UnicodeType may or may not be exported (normally imported from types)
99
# Pickle opcodes. See pickletools.py for extensive docs. The listing
100
# here is in kind-of alphabetical order of 1-character pickle code.
101
# pickletools groups them by purpose.
103
MARK = '(' # push special markobject on stack
104
STOP = '.' # every pickle ends with STOP
105
POP = '0' # discard topmost stack item
106
POP_MARK = '1' # discard stack top through topmost markobject
107
DUP = '2' # duplicate top stack item
108
FLOAT = 'F' # push float object; decimal string argument
109
INT = 'I' # push integer or bool; decimal string argument
110
BININT = 'J' # push four-byte signed int
111
BININT1 = 'K' # push 1-byte unsigned int
112
LONG = 'L' # push long; decimal string argument
113
BININT2 = 'M' # push 2-byte unsigned int
114
NONE = 'N' # push None
115
PERSID = 'P' # push persistent object; id is taken from string arg
116
BINPERSID = 'Q' # " " " ; " " " " stack
117
REDUCE = 'R' # apply callable to argtuple, both on stack
118
STRING = 'S' # push string; NL-terminated string argument
119
BINSTRING = 'T' # push string; counted binary string argument
120
SHORT_BINSTRING = 'U' # " " ; " " " " < 256 bytes
121
UNICODE = 'V' # push Unicode string; raw-unicode-escaped'd argument
122
BINUNICODE = 'X' # " " " ; counted UTF-8 string argument
123
APPEND = 'a' # append stack top to list below it
124
BUILD = 'b' # call __setstate__ or __dict__.update()
125
GLOBAL = 'c' # push self.find_class(modname, name); 2 string args
126
DICT = 'd' # build a dict from stack items
127
EMPTY_DICT = '}' # push empty dict
128
APPENDS = 'e' # extend list on stack by topmost stack slice
129
GET = 'g' # push item from memo on stack; index is string arg
130
BINGET = 'h' # " " " " " " ; " " 1-byte arg
131
INST = 'i' # build & push class instance
132
LONG_BINGET = 'j' # push item from memo on stack; index is 4-byte arg
133
LIST = 'l' # build list from topmost stack items
134
EMPTY_LIST = ']' # push empty list
135
OBJ = 'o' # build & push class instance
136
PUT = 'p' # store stack top in memo; index is string arg
137
BINPUT = 'q' # " " " " " ; " " 1-byte arg
138
LONG_BINPUT = 'r' # " " " " " ; " " 4-byte arg
139
SETITEM = 's' # add key+value pair to dict
140
TUPLE = 't' # build tuple from topmost stack items
141
EMPTY_TUPLE = ')' # push empty tuple
142
SETITEMS = 'u' # modify dict by adding topmost key+value pairs
143
BINFLOAT = 'G' # push float; arg is 8-byte float encoding
145
TRUE = 'I01\n' # not an opcode; see INT docs in pickletools.py
146
FALSE = 'I00\n' # not an opcode; see INT docs in pickletools.py
150
PROTO = '\x80' # identify pickle protocol
151
NEWOBJ = '\x81' # build object by applying cls.__new__ to argtuple
152
EXT1 = '\x82' # push object from extension registry; 1-byte index
153
EXT2 = '\x83' # ditto, but 2-byte index
154
EXT4 = '\x84' # ditto, but 4-byte index
155
TUPLE1 = '\x85' # build 1-tuple from stack top
156
TUPLE2 = '\x86' # build 2-tuple from two topmost stack items
157
TUPLE3 = '\x87' # build 3-tuple from three topmost stack items
158
NEWTRUE = '\x88' # push True
159
NEWFALSE = '\x89' # push False
160
LONG1 = '\x8a' # push long from < 256 bytes
161
LONG4 = '\x8b' # push really big long
163
_tuplesize2code = [EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3]
166
__all__.extend([x for x in dir() if re.match("[A-Z][A-Z0-9_]+$",x)])
174
def __init__(self, file, protocol=None, bin=None):
175
"""This takes a file-like object for writing a pickle data stream.
177
The optional protocol argument tells the pickler to use the
178
given protocol; supported protocols are 0, 1, 2. The default
179
protocol is 0, to be backwards compatible. (Protocol 0 is the
180
only protocol that can be written to a file opened in text
181
mode and read back successfully. When using a protocol higher
182
than 0, make sure the file is opened in binary mode, both when
183
pickling and unpickling.)
185
Protocol 1 is more efficient than protocol 0; protocol 2 is
186
more efficient than protocol 1.
188
Specifying a negative protocol version selects the highest
189
protocol version supported. The higher the protocol used, the
190
more recent the version of Python needed to read the pickle
193
The file parameter must have a write() method that accepts a single
194
string argument. It can thus be an open file object, a StringIO
195
object, or any other custom object that meets this interface.
198
if protocol is not None and bin is not None:
199
raise ValueError, "can't specify both 'protocol' and 'bin'"
201
warnings.warn("The 'bin' argument to Pickler() is deprecated",
207
protocol = HIGHEST_PROTOCOL
208
elif not 0 <= protocol <= HIGHEST_PROTOCOL:
209
raise ValueError("pickle protocol must be <= %d" % HIGHEST_PROTOCOL)
210
self.write = file.write
212
self.proto = int(protocol)
213
self.bin = protocol >= 1
216
def clear_memo(self):
217
"""Clears the pickler's "memo".
219
The memo is the data structure that remembers which objects the
220
pickler has already seen, so that shared or recursive objects are
221
pickled by reference and not by value. This method is useful when
228
"""Write a pickled representation of obj to the open file."""
230
self.write(PROTO + chr(self.proto))
234
def memoize(self, obj):
235
"""Store an object in the memo."""
237
# The Pickler memo is a dictionary mapping object ids to 2-tuples
238
# that contain the Unpickler memo key and the object being memoized.
239
# The memo key is written to the pickle and will become
240
# the key in the Unpickler's memo. The object is stored in the
241
# Pickler memo so that transient objects are kept alive during
244
# The use of the Unpickler memo length as the memo key is just a
245
# convention. The only requirement is that the memo values be unique.
246
# But there appears no advantage to any other scheme, and this
247
# scheme allows the Unpickler memo to be implemented as a plain (but
248
# growable) array, indexed by memo key.
251
assert id(obj) not in self.memo
252
memo_len = len(self.memo)
253
self.write(self.put(memo_len))
254
self.memo[id(obj)] = memo_len, obj
256
# Return a PUT (BINPUT, LONG_BINPUT) opcode string, with argument i.
257
def put(self, i, pack=struct.pack):
260
return BINPUT + chr(i)
262
return LONG_BINPUT + pack("<i", i)
264
return PUT + repr(i) + '\n'
266
# Return a GET (BINGET, LONG_BINGET) opcode string, with argument i.
267
def get(self, i, pack=struct.pack):
270
return BINGET + chr(i)
272
return LONG_BINGET + pack("<i", i)
274
return GET + repr(i) + '\n'
277
# Check for persistent id (defined by a subclass)
278
pid = self.persistent_id(obj)
284
x = self.memo.get(id(obj))
286
self.write(self.get(x[0]))
289
# Check the type dispatch table
291
f = self.dispatch.get(t)
293
f(self, obj) # Call unbound method with explicit self
296
# Check for a class with a custom metaclass; treat as regular class
298
issc = issubclass(t, TypeType)
299
except TypeError: # t is not a class (old Boost; see SF #502085)
302
self.save_global(obj)
305
# Check copy_reg.dispatch_table
306
reduce = dispatch_table.get(t)
310
# Check for a __reduce_ex__ method, fall back to __reduce__
311
reduce = getattr(obj, "__reduce_ex__", None)
313
rv = reduce(self.proto)
315
reduce = getattr(obj, "__reduce__", None)
319
raise PicklingError("Can't pickle %r object: %r" %
322
# Check for string returned by reduce(), meaning "save as global"
323
if type(rv) is StringType:
324
self.save_global(obj, rv)
327
# Assert that reduce() returned a tuple
328
if type(rv) is not TupleType:
329
raise PicklingError("%s must return string or tuple" % reduce)
331
# Assert that it returned an appropriately sized tuple
333
if not (2 <= l <= 5):
334
raise PicklingError("Tuple returned by %s must have "
335
"two to five elements" % reduce)
337
# Save the reduce() output and finally memoize the object
338
self.save_reduce(obj=obj, *rv)
340
def persistent_id(self, obj):
341
# This exists so a subclass can override it
344
def save_pers(self, pid):
345
# Save a persistent id reference
348
self.write(BINPERSID)
350
self.write(PERSID + str(pid) + '\n')
352
def save_reduce(self, func, args, state=None,
353
listitems=None, dictitems=None, obj=None):
354
# This API is called by some subclasses
356
# Assert that args is a tuple or None
357
if not isinstance(args, TupleType):
359
# A hack for Jim Fulton's ExtensionClass, now deprecated.
361
warnings.warn("__basicnew__ special case is deprecated",
365
"args from reduce() should be a tuple")
367
# Assert that func is callable
368
if not callable(func):
369
raise PicklingError("func from reduce should be callable")
374
# Protocol 2 special case: if func's name is __newobj__, use NEWOBJ
375
if self.proto >= 2 and getattr(func, "__name__", "") == "__newobj__":
376
# A __reduce__ implementation can direct protocol 2 to
377
# use the more efficient NEWOBJ opcode, while still
378
# allowing protocol 0 and 1 to work normally. For this to
379
# work, the function returned by __reduce__ should be
380
# called __newobj__, and its first argument should be a
381
# new-style class. The implementation for __newobj__
382
# should be as follows, although pickle has no way to
385
# def __newobj__(cls, *args):
386
# return cls.__new__(cls, *args)
388
# Protocols 0 and 1 will pickle a reference to __newobj__,
389
# while protocol 2 (and above) will pickle a reference to
390
# cls, the remaining args tuple, and the NEWOBJ code,
391
# which calls cls.__new__(cls, *args) at unpickling time
392
# (see load_newobj below). If __reduce__ returns a
393
# three-tuple, the state from the third tuple item will be
394
# pickled regardless of the protocol, calling __setstate__
395
# at unpickling time (see load_build below).
397
# Note that no standard __newobj__ implementation exists;
398
# you have to provide your own. This is to enforce
399
# compatibility with Python 2.2 (pickles written using
400
# protocol 0 or 1 in Python 2.3 should be unpicklable by
403
if not hasattr(cls, "__new__"):
405
"args[0] from __newobj__ args has no __new__")
406
if obj is not None and cls is not obj.__class__:
408
"args[0] from __newobj__ args has the wrong class")
421
# More new special cases (that work with older protocols as
422
# well): when __reduce__ returns a tuple with 4 or 5 items,
423
# the 4th and 5th item should be iterators that provide list
424
# items and dict items (as (key, value) tuples), or None.
426
if listitems is not None:
427
self._batch_appends(listitems)
429
if dictitems is not None:
430
self._batch_setitems(dictitems)
432
if state is not None:
436
# Methods below this point are dispatched through the dispatch table
440
def save_none(self, obj):
442
dispatch[NoneType] = save_none
444
def save_bool(self, obj):
446
self.write(obj and NEWTRUE or NEWFALSE)
448
self.write(obj and TRUE or FALSE)
449
dispatch[bool] = save_bool
451
def save_int(self, obj, pack=struct.pack):
453
# If the int is small enough to fit in a signed 4-byte 2's-comp
454
# format, we can store it more efficiently than the general
456
# First one- and two-byte unsigned ints:
459
self.write(BININT1 + chr(obj))
462
self.write("%c%c%c" % (BININT2, obj&0xff, obj>>8))
464
# Next check for 4-byte signed ints:
465
high_bits = obj >> 31 # note that Python shift sign-extends
466
if high_bits == 0 or high_bits == -1:
467
# All high bits are copies of bit 2**31, so the value
468
# fits in a 4-byte signed int.
469
self.write(BININT + pack("<i", obj))
471
# Text pickle, or int too big to fit in signed 4-byte format.
472
self.write(INT + repr(obj) + '\n')
473
dispatch[IntType] = save_int
475
def save_long(self, obj, pack=struct.pack):
477
bytes = encode_long(obj)
480
self.write(LONG1 + chr(n) + bytes)
482
self.write(LONG4 + pack("<i", n) + bytes)
484
self.write(LONG + repr(obj) + '\n')
485
dispatch[LongType] = save_long
487
def save_float(self, obj, pack=struct.pack):
489
self.write(BINFLOAT + pack('>d', obj))
491
self.write(FLOAT + repr(obj) + '\n')
492
dispatch[FloatType] = save_float
494
def save_string(self, obj, pack=struct.pack):
498
self.write(SHORT_BINSTRING + chr(n) + obj)
500
self.write(BINSTRING + pack("<i", n) + obj)
502
self.write(STRING + repr(obj) + '\n')
504
dispatch[StringType] = save_string
506
def save_unicode(self, obj, pack=struct.pack):
508
encoding = obj.encode('utf-8')
510
self.write(BINUNICODE + pack("<i", n) + encoding)
512
obj = obj.replace("\\", "\\u005c")
513
obj = obj.replace("\n", "\\u000a")
514
self.write(UNICODE + obj.encode('raw-unicode-escape') + '\n')
516
dispatch[UnicodeType] = save_unicode
518
if StringType == UnicodeType:
519
# This is true for Jython
520
def save_string(self, obj, pack=struct.pack):
521
unicode = obj.isunicode()
525
obj = obj.encode("utf-8")
527
if l < 256 and not unicode:
528
self.write(SHORT_BINSTRING + chr(l) + obj)
532
self.write(BINUNICODE + s + obj)
534
self.write(BINSTRING + s + obj)
537
obj = obj.replace("\\", "\\u005c")
538
obj = obj.replace("\n", "\\u000a")
539
obj = obj.encode('raw-unicode-escape')
540
self.write(UNICODE + obj + '\n')
542
self.write(STRING + repr(obj) + '\n')
544
dispatch[StringType] = save_string
546
def save_tuple(self, obj):
560
if n <= 3 and proto >= 2:
563
# Subtle. Same as in the big comment below.
565
get = self.get(memo[id(obj)][0])
568
write(_tuplesize2code[n])
572
# proto 0 or proto 1 and tuple isn't empty, or proto > 1 and tuple
573
# has more than 3 elements.
579
# Subtle. d was not in memo when we entered save_tuple(), so
580
# the process of saving the tuple's elements must have saved
581
# the tuple itself: the tuple is recursive. The proper action
582
# now is to throw away everything we put on the stack, and
583
# simply GET the tuple (it's already constructed). This check
584
# could have been done in the "for element" loop instead, but
585
# recursive tuples are a rare thing.
586
get = self.get(memo[id(obj)][0])
588
write(POP_MARK + get)
589
else: # proto 0 -- POP_MARK not available
590
write(POP * (n+1) + get)
597
dispatch[TupleType] = save_tuple
599
# save_empty_tuple() isn't used by anything in Python 2.3. However, I
600
# found a Pickler subclass in Zope3 that calls it, so it's not harmless
602
def save_empty_tuple(self, obj):
603
self.write(EMPTY_TUPLE)
605
def save_list(self, obj):
610
else: # proto 0 -- can't use EMPTY_LIST
614
self._batch_appends(iter(obj))
616
dispatch[ListType] = save_list
618
# Keep in synch with cPickle's BATCHSIZE. Nothing will break if it gets
619
# out of synch, though.
622
def _batch_appends(self, items):
623
# Helper to batch up APPENDS sequences
633
r = xrange(self._BATCHSIZE)
634
while items is not None:
640
except StopIteration:
652
# else tmp is empty, and we're done
654
def save_dict(self, obj):
659
else: # proto 0 -- can't use EMPTY_DICT
663
self._batch_setitems(obj.iteritems())
665
dispatch[DictionaryType] = save_dict
666
if not PyStringMap is None:
667
dispatch[PyStringMap] = save_dict
669
def _batch_setitems(self, items):
670
# Helper to batch up SETITEMS sequences; proto >= 1 only
681
r = xrange(self._BATCHSIZE)
682
while items is not None:
686
tmp.append(items.next())
687
except StopIteration:
702
# else tmp is empty, and we're done
704
def save_inst(self, obj):
711
if hasattr(obj, '__getinitargs__'):
712
args = obj.__getinitargs__()
713
len(args) # XXX Assert it's a sequence
714
_keep_alive(args, memo)
728
write(INST + cls.__module__ + '\n' + cls.__name__ + '\n')
733
getstate = obj.__getstate__
734
except AttributeError:
738
_keep_alive(stuff, memo)
742
dispatch[InstanceType] = save_inst
744
def save_global(self, obj, name=None, pack=struct.pack):
751
module = getattr(obj, "__module__", None)
753
module = whichmodule(obj, name)
757
mod = sys.modules[module]
758
klass = getattr(mod, name)
759
except (ImportError, KeyError, AttributeError):
761
"Can't pickle %r: it's not found as %s.%s" %
766
"Can't pickle %r: it's not the same object as %s.%s" %
770
code = _extension_registry.get((module, name))
774
write(EXT1 + chr(code))
776
write("%c%c%c" % (EXT2, code&0xff, code>>8))
778
write(EXT4 + pack("<i", code))
781
write(GLOBAL + module + '\n' + name + '\n')
784
dispatch[ClassType] = save_global
785
dispatch[FunctionType] = save_global
786
dispatch[BuiltinFunctionType] = save_global
787
dispatch[TypeType] = save_global
791
def _keep_alive(x, memo):
792
"""Keeps a reference to the object x in the memo.
794
Because we remember objects by their id, we have
795
to assure that possibly temporary objects are kept
796
alive by referencing them.
797
We store a reference at the id of the memo, which should
798
normally not be used unless someone tries to deepcopy
802
memo[id(memo)].append(x)
804
# aha, this is the first one :-)
808
# A cache for whichmodule(), mapping a function object to the name of
809
# the module in which the function was found.
811
classmap = {} # called classmap for backwards compatibility
813
def whichmodule(func, funcname):
814
"""Figure out the module in which a function occurs.
816
Search sys.modules for the module.
818
Return a module name.
819
If the function cannot be found, return "__main__".
821
# Python functions should always get an __module__ from their globals.
822
mod = getattr(func, "__module__", None)
826
return classmap[func]
828
for name, module in sys.modules.items():
830
continue # skip dummy package entries
831
if name != '__main__' and getattr(module, funcname, None) is func:
835
classmap[func] = name
839
# Unpickling machinery
843
def __init__(self, file):
844
"""This takes a file-like object for reading a pickle data stream.
846
The protocol version of the pickle is detected automatically, so no
847
proto argument is needed.
849
The file-like object must have two methods, a read() method that
850
takes an integer argument, and a readline() method that requires no
851
arguments. Both methods should return a string. Thus file-like
852
object can be a file object opened for reading, a StringIO object,
853
or any other custom object that meets this interface.
855
self.readline = file.readline
856
self.read = file.read
860
"""Read a pickled object representation from the open file.
862
Return the reconstituted object hierarchy specified in the file.
864
self.mark = object() # any new unique object
866
self.append = self.stack.append
868
dispatch = self.dispatch
873
except _Stop, stopinst:
874
return stopinst.value
876
# Return largest index k such that self.stack[k] is self.mark.
877
# If the stack doesn't contain a mark, eventually raises IndexError.
878
# This could be sped by maintaining another stack, of indices at which
879
# the mark appears. For that matter, the latter stack would suffice,
880
# and we wouldn't need to push mark objects on self.stack at all.
881
# Doing so is probably a good thing, though, since if the pickle is
882
# corrupt (or hostile) we may get a clue from finding self.mark embedded
883
# in unpickled objects.
888
while stack[k] is not mark: k = k-1
895
dispatch[''] = load_eof
897
def load_proto(self):
898
proto = ord(self.read(1))
899
if not 0 <= proto <= 2:
900
raise ValueError, "unsupported pickle protocol: %d" % proto
901
dispatch[PROTO] = load_proto
903
def load_persid(self):
904
pid = self.readline()[:-1]
905
self.append(self.persistent_load(pid))
906
dispatch[PERSID] = load_persid
908
def load_binpersid(self):
909
pid = self.stack.pop()
910
self.append(self.persistent_load(pid))
911
dispatch[BINPERSID] = load_binpersid
915
dispatch[NONE] = load_none
917
def load_false(self):
919
dispatch[NEWFALSE] = load_false
923
dispatch[NEWTRUE] = load_true
926
data = self.readline()
927
if data == FALSE[1:]:
929
elif data == TRUE[1:]:
937
dispatch[INT] = load_int
939
def load_binint(self):
940
self.append(mloads('i' + self.read(4)))
941
dispatch[BININT] = load_binint
943
def load_binint1(self):
944
self.append(ord(self.read(1)))
945
dispatch[BININT1] = load_binint1
947
def load_binint2(self):
948
self.append(mloads('i' + self.read(2) + '\000\000'))
949
dispatch[BININT2] = load_binint2
952
self.append(long(self.readline()[:-1], 0))
953
dispatch[LONG] = load_long
955
def load_long1(self):
956
n = ord(self.read(1))
958
self.append(decode_long(bytes))
959
dispatch[LONG1] = load_long1
961
def load_long4(self):
962
n = mloads('i' + self.read(4))
964
self.append(decode_long(bytes))
965
dispatch[LONG4] = load_long4
967
def load_float(self):
968
self.append(float(self.readline()[:-1]))
969
dispatch[FLOAT] = load_float
971
def load_binfloat(self, unpack=struct.unpack):
972
self.append(unpack('>d', self.read(8))[0])
973
dispatch[BINFLOAT] = load_binfloat
975
def load_string(self):
976
rep = self.readline()[:-1]
977
for q in "\"'": # double or single quote
978
if rep.startswith(q):
979
if not rep.endswith(q):
980
raise ValueError, "insecure string pickle"
981
rep = rep[len(q):-len(q)]
984
raise ValueError, "insecure string pickle"
985
self.append(rep.decode("string-escape"))
986
dispatch[STRING] = load_string
988
def load_binstring(self):
989
len = mloads('i' + self.read(4))
990
self.append(self.read(len))
991
dispatch[BINSTRING] = load_binstring
993
def load_unicode(self):
994
self.append(unicode(self.readline()[:-1],'raw-unicode-escape'))
995
dispatch[UNICODE] = load_unicode
997
def load_binunicode(self):
998
len = mloads('i' + self.read(4))
999
self.append(unicode(self.read(len),'utf-8'))
1000
dispatch[BINUNICODE] = load_binunicode
1002
def load_short_binstring(self):
1003
len = ord(self.read(1))
1004
self.append(self.read(len))
1005
dispatch[SHORT_BINSTRING] = load_short_binstring
1007
def load_tuple(self):
1009
self.stack[k:] = [tuple(self.stack[k+1:])]
1010
dispatch[TUPLE] = load_tuple
1012
def load_empty_tuple(self):
1013
self.stack.append(())
1014
dispatch[EMPTY_TUPLE] = load_empty_tuple
1016
def load_tuple1(self):
1017
self.stack[-1] = (self.stack[-1],)
1018
dispatch[TUPLE1] = load_tuple1
1020
def load_tuple2(self):
1021
self.stack[-2:] = [(self.stack[-2], self.stack[-1])]
1022
dispatch[TUPLE2] = load_tuple2
1024
def load_tuple3(self):
1025
self.stack[-3:] = [(self.stack[-3], self.stack[-2], self.stack[-1])]
1026
dispatch[TUPLE3] = load_tuple3
1028
def load_empty_list(self):
1029
self.stack.append([])
1030
dispatch[EMPTY_LIST] = load_empty_list
1032
def load_empty_dictionary(self):
1033
self.stack.append({})
1034
dispatch[EMPTY_DICT] = load_empty_dictionary
1036
def load_list(self):
1038
self.stack[k:] = [self.stack[k+1:]]
1039
dispatch[LIST] = load_list
1041
def load_dict(self):
1044
items = self.stack[k+1:]
1045
for i in range(0, len(items), 2):
1049
self.stack[k:] = [d]
1050
dispatch[DICT] = load_dict
1052
# INST and OBJ differ only in how they get a class object. It's not
1053
# only sensible to do the rest in a common routine, the two routines
1054
# previously diverged and grew different bugs.
1055
# klass is the class to instantiate, and k points to the topmost mark
1056
# object, following which are the arguments for klass.__init__.
1057
def _instantiate(self, klass, k):
1058
args = tuple(self.stack[k+1:])
1062
type(klass) is ClassType and
1063
not hasattr(klass, "__getinitargs__")):
1065
value = _EmptyClass()
1066
value.__class__ = klass
1068
except RuntimeError:
1069
# In restricted execution, assignment to inst.__class__ is
1072
if not instantiated:
1074
value = klass(*args)
1075
except TypeError, err:
1076
raise TypeError, "in constructor for %s: %s" % (
1077
klass.__name__, str(err)), sys.exc_info()[2]
1080
def load_inst(self):
1081
module = self.readline()[:-1]
1082
name = self.readline()[:-1]
1083
klass = self.find_class(module, name)
1084
self._instantiate(klass, self.marker())
1085
dispatch[INST] = load_inst
1088
# Stack is ... markobject classobject arg1 arg2 ...
1090
klass = self.stack.pop(k+1)
1091
self._instantiate(klass, k)
1092
dispatch[OBJ] = load_obj
1094
def load_newobj(self):
1095
args = self.stack.pop()
1096
cls = self.stack[-1]
1097
obj = cls.__new__(cls, *args)
1098
self.stack[-1] = obj
1099
dispatch[NEWOBJ] = load_newobj
1101
def load_global(self):
1102
module = self.readline()[:-1]
1103
name = self.readline()[:-1]
1104
klass = self.find_class(module, name)
1106
dispatch[GLOBAL] = load_global
1108
def load_ext1(self):
1109
code = ord(self.read(1))
1110
self.get_extension(code)
1111
dispatch[EXT1] = load_ext1
1113
def load_ext2(self):
1114
code = mloads('i' + self.read(2) + '\000\000')
1115
self.get_extension(code)
1116
dispatch[EXT2] = load_ext2
1118
def load_ext4(self):
1119
code = mloads('i' + self.read(4))
1120
self.get_extension(code)
1121
dispatch[EXT4] = load_ext4
1123
def get_extension(self, code):
1125
obj = _extension_cache.get(code, nil)
1129
key = _inverted_registry.get(code)
1131
raise ValueError("unregistered extension code %d" % code)
1132
obj = self.find_class(*key)
1133
_extension_cache[code] = obj
1136
def find_class(self, module, name):
1137
# Subclasses may override this
1139
mod = sys.modules[module]
1140
klass = getattr(mod, name)
1143
def load_reduce(self):
1148
# A hack for Jim Fulton's ExtensionClass, now deprecated
1149
warnings.warn("__basicnew__ special case is deprecated",
1151
value = func.__basicnew__()
1155
dispatch[REDUCE] = load_reduce
1159
dispatch[POP] = load_pop
1161
def load_pop_mark(self):
1164
dispatch[POP_MARK] = load_pop_mark
1167
self.append(self.stack[-1])
1168
dispatch[DUP] = load_dup
1171
self.append(self.memo[self.readline()[:-1]])
1172
dispatch[GET] = load_get
1174
def load_binget(self):
1175
i = ord(self.read(1))
1176
self.append(self.memo[repr(i)])
1177
dispatch[BINGET] = load_binget
1179
def load_long_binget(self):
1180
i = mloads('i' + self.read(4))
1181
self.append(self.memo[repr(i)])
1182
dispatch[LONG_BINGET] = load_long_binget
1185
self.memo[self.readline()[:-1]] = self.stack[-1]
1186
dispatch[PUT] = load_put
1188
def load_binput(self):
1189
i = ord(self.read(1))
1190
self.memo[repr(i)] = self.stack[-1]
1191
dispatch[BINPUT] = load_binput
1193
def load_long_binput(self):
1194
i = mloads('i' + self.read(4))
1195
self.memo[repr(i)] = self.stack[-1]
1196
dispatch[LONG_BINPUT] = load_long_binput
1198
def load_append(self):
1203
dispatch[APPEND] = load_append
1205
def load_appends(self):
1207
mark = self.marker()
1208
list = stack[mark - 1]
1209
list.extend(stack[mark + 1:])
1211
dispatch[APPENDS] = load_appends
1213
def load_setitem(self):
1219
dispatch[SETITEM] = load_setitem
1221
def load_setitems(self):
1223
mark = self.marker()
1224
dict = stack[mark - 1]
1225
for i in range(mark + 1, len(stack), 2):
1226
dict[stack[i]] = stack[i + 1]
1229
dispatch[SETITEMS] = load_setitems
1231
def load_build(self):
1235
setstate = getattr(inst, "__setstate__", None)
1240
if isinstance(state, tuple) and len(state) == 2:
1241
state, slotstate = state
1244
inst.__dict__.update(state)
1245
except RuntimeError:
1246
# XXX In restricted execution, the instance's __dict__
1247
# is not accessible. Use the old way of unpickling
1248
# the instance variables. This is a semantic
1249
# difference when unpickling in restricted
1250
# vs. unrestricted modes.
1251
# Note, however, that cPickle has never tried to do the
1252
# .update() business, and always uses
1253
# PyObject_SetItem(inst.__dict__, key, value) in a
1254
# loop over state.items().
1255
for k, v in state.items():
1258
for k, v in slotstate.items():
1260
dispatch[BUILD] = load_build
1262
def load_mark(self):
1263
self.append(self.mark)
1264
dispatch[MARK] = load_mark
1266
def load_stop(self):
1267
value = self.stack.pop()
1269
dispatch[STOP] = load_stop
1271
# Helper class for load_inst/load_obj
1276
# Encode/decode longs in linear time.
1278
import binascii as _binascii
1281
r"""Encode a long to a two's complement little-endian binary string.
1282
Note that 0L is a special case, returning an empty string, to save a
1283
byte in the LONG1 pickling context.
1287
>>> encode_long(255L)
1289
>>> encode_long(32767L)
1291
>>> encode_long(-256L)
1293
>>> encode_long(-32768L)
1295
>>> encode_long(-128L)
1297
>>> encode_long(127L)
1306
assert ashex.startswith("0x")
1307
njunkchars = 2 + ashex.endswith('L')
1308
nibbles = len(ashex) - njunkchars
1310
# need an even # of nibbles for unhexlify
1311
ashex = "0x0" + ashex[2:]
1312
elif int(ashex[2], 16) >= 8:
1313
# "looks negative", so need a byte of sign bits
1314
ashex = "0x00" + ashex[2:]
1316
# Build the 256's-complement: (1L << nbytes) + x. The trick is
1317
# to find the number of bytes in linear time (although that should
1318
# really be a constant-time task).
1320
assert ashex.startswith("0x")
1321
njunkchars = 2 + ashex.endswith('L')
1322
nibbles = len(ashex) - njunkchars
1324
# Extend to a full byte.
1330
njunkchars = 2 + ashex.endswith('L')
1331
newnibbles = len(ashex) - njunkchars
1332
if newnibbles < nibbles:
1333
ashex = "0x" + "0" * (nibbles - newnibbles) + ashex[2:]
1334
if int(ashex[2], 16) < 8:
1335
# "looks positive", so need a byte of sign bits
1336
ashex = "0xff" + ashex[2:]
1338
if ashex.endswith('L'):
1342
assert len(ashex) & 1 == 0, (x, ashex)
1343
binary = _binascii.unhexlify(ashex)
1346
def decode_long(data):
1347
r"""Decode a long from a two's complement little-endian binary string.
1351
>>> decode_long("\xff\x00")
1353
>>> decode_long("\xff\x7f")
1355
>>> decode_long("\x00\xff")
1357
>>> decode_long("\x00\x80")
1359
>>> decode_long("\x80")
1361
>>> decode_long("\x7f")
1368
ashex = _binascii.hexlify(data[::-1])
1369
n = long(ashex, 16) # quadratic time before Python 2.3; linear now
1370
if data[-1] >= '\x80':
1371
n -= 1L << (nbytes * 8)
1377
from cStringIO import StringIO
1379
from StringIO import StringIO
1381
def dump(obj, file, protocol=None, bin=None):
1382
Pickler(file, protocol, bin).dump(obj)
1384
def dumps(obj, protocol=None, bin=None):
1386
Pickler(file, protocol, bin).dump(obj)
1387
return file.getvalue()
1390
return Unpickler(file).load()
1393
file = StringIO(str)
1394
return Unpickler(file).load()
1400
return doctest.testmod()
1402
if __name__ == "__main__":
added
removed
lib-python/2.4.1/pickle.py
