1 """Create portable serialized representations of Python objects.
2
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.
6
7 Classes:
8
9 Pickler
10 Unpickler
11
12 Functions:
13
14 dump(object, file)
15 dumps(object) -> string
16 load(file) -> object
17 loads(string) -> object
18
19 Misc variables:
20
21 __version__
22 format_version
23 compatible_formats
24
25 """
26
27 __version__ = "$Revision: 72223 $"
28
29 from types import *
30 from copy_reg import dispatch_table
31 from copy_reg import _extension_registry, _inverted_registry, _extension_cache
32 import marshal
33 import sys
34 import struct
35 import re
36
37 __all__ = ["PickleError", "PicklingError", "UnpicklingError", "Pickler",
38 "Unpickler", "dump", "dumps", "load", "loads"]
39
40
41 format_version = "2.0"
42 compatible_formats = ["1.0",
43 "1.1",
44 "1.2",
45 "1.3",
46 "2.0",
47 ]
48
49
50
51 HIGHEST_PROTOCOL = 2
52
53
54
55
56 mloads = marshal.loads
57
59 """A common base class for the other pickling exceptions."""
60 pass
61
63 """This exception is raised when an unpicklable object is passed to the
64 dump() method.
65
66 """
67 pass
68
70 """This exception is raised when there is a problem unpickling an object,
71 such as a security violation.
72
73 Note that other exceptions may also be raised during unpickling, including
74 (but not necessarily limited to) AttributeError, EOFError, ImportError,
75 and IndexError.
76
77 """
78 pass
79
80
81
85
86
87 try:
88 from org.python.core import PyStringMap
89 except ImportError:
90 PyStringMap = None
91
92
93 try:
94 UnicodeType
95 except NameError:
96 UnicodeType = None
97
98
99
100
101
102 MARK = '('
103 STOP = '.'
104 POP = '0'
105 POP_MARK = '1'
106 DUP = '2'
107 FLOAT = 'F'
108 INT = 'I'
109 BININT = 'J'
110 BININT1 = 'K'
111 LONG = 'L'
112 BININT2 = 'M'
113 NONE = 'N'
114 PERSID = 'P'
115 BINPERSID = 'Q'
116 REDUCE = 'R'
117 STRING = 'S'
118 BINSTRING = 'T'
119 SHORT_BINSTRING = 'U'
120 UNICODE = 'V'
121 BINUNICODE = 'X'
122 APPEND = 'a'
123 BUILD = 'b'
124 GLOBAL = 'c'
125 DICT = 'd'
126 EMPTY_DICT = '}'
127 APPENDS = 'e'
128 GET = 'g'
129 BINGET = 'h'
130 INST = 'i'
131 LONG_BINGET = 'j'
132 LIST = 'l'
133 EMPTY_LIST = ']'
134 OBJ = 'o'
135 PUT = 'p'
136 BINPUT = 'q'
137 LONG_BINPUT = 'r'
138 SETITEM = 's'
139 TUPLE = 't'
140 EMPTY_TUPLE = ')'
141 SETITEMS = 'u'
142 BINFLOAT = 'G'
143
144 TRUE = 'I01\n'
145 FALSE = 'I00\n'
146
147
148
149 PROTO = '\x80'
150 NEWOBJ = '\x81'
151 EXT1 = '\x82'
152 EXT2 = '\x83'
153 EXT4 = '\x84'
154 TUPLE1 = '\x85'
155 TUPLE2 = '\x86'
156 TUPLE3 = '\x87'
157 NEWTRUE = '\x88'
158 NEWFALSE = '\x89'
159 LONG1 = '\x8a'
160 LONG4 = '\x8b'
161
162 _tuplesize2code = [EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3]
163
164
165 __all__.extend([x for x in dir() if re.match("[A-Z][A-Z0-9_]+$",x)])
166 del x
167
168
169
170
172
173 - def __init__(self, file, protocol=None):
174 """This takes a file-like object for writing a pickle data stream.
175
176 The optional protocol argument tells the pickler to use the
177 given protocol; supported protocols are 0, 1, 2. The default
178 protocol is 0, to be backwards compatible. (Protocol 0 is the
179 only protocol that can be written to a file opened in text
180 mode and read back successfully. When using a protocol higher
181 than 0, make sure the file is opened in binary mode, both when
182 pickling and unpickling.)
183
184 Protocol 1 is more efficient than protocol 0; protocol 2 is
185 more efficient than protocol 1.
186
187 Specifying a negative protocol version selects the highest
188 protocol version supported. The higher the protocol used, the
189 more recent the version of Python needed to read the pickle
190 produced.
191
192 The file parameter must have a write() method that accepts a single
193 string argument. It can thus be an open file object, a StringIO
194 object, or any other custom object that meets this interface.
195
196 """
197 if protocol is None:
198 protocol = 0
199 if protocol < 0:
200 protocol = HIGHEST_PROTOCOL
201 elif not 0 <= protocol <= HIGHEST_PROTOCOL:
202 raise ValueError("pickle protocol must be <= %d" % HIGHEST_PROTOCOL)
203 self.write = file.write
204 self.memo = {}
205 self.proto = int(protocol)
206 self.bin = protocol >= 1
207 self.fast = 0
208
210 """Clears the pickler's "memo".
211
212 The memo is the data structure that remembers which objects the
213 pickler has already seen, so that shared or recursive objects are
214 pickled by reference and not by value. This method is useful when
215 re-using picklers.
216
217 """
218 self.memo.clear()
219
220 - def dump(self, obj):
221 """Write a pickled representation of obj to the open file."""
222 if self.proto >= 2:
223 self.write(PROTO + chr(self.proto))
224 self.save(obj)
225 self.write(STOP)
226
228 """Store an object in the memo."""
229
230
231
232
233
234
235
236
237
238
239
240
241
242 if self.fast:
243 return
244 assert id(obj) not in self.memo
245 memo_len = len(self.memo)
246 self.write(self.put(memo_len))
247 self.memo[id(obj)] = memo_len, obj
248
249
250 - def put(self, i, pack=struct.pack):
251 if self.bin:
252 if i < 256:
253 return BINPUT + chr(i)
254 else:
255 return LONG_BINPUT + pack("<i", i)
256
257 return PUT + repr(i) + '\n'
258
259
260 - def get(self, i, pack=struct.pack):
261 if self.bin:
262 if i < 256:
263 return BINGET + chr(i)
264 else:
265 return LONG_BINGET + pack("<i", i)
266
267 return GET + repr(i) + '\n'
268
269 - def save(self, obj):
270
271 pid = self.persistent_id(obj)
272 if pid is not None:
273 self.save_pers(pid)
274 return
275
276
277 x = self.memo.get(id(obj))
278 if x:
279 self.write(self.get(x[0]))
280 return
281
282
283 t = type(obj)
284 f = self.dispatch.get(t)
285 if f:
286 f(self, obj)
287 return
288
289
290 reduce = dispatch_table.get(t)
291 if reduce:
292 rv = reduce(obj)
293 else:
294
295 try:
296 issc = issubclass(t, TypeType)
297 except TypeError:
298 issc = 0
299 if issc:
300 self.save_global(obj)
301 return
302
303
304 reduce = getattr(obj, "__reduce_ex__", None)
305 if reduce:
306 rv = reduce(self.proto)
307 else:
308 reduce = getattr(obj, "__reduce__", None)
309 if reduce:
310 rv = reduce()
311 else:
312 raise PicklingError("Can't pickle %r object: %r" %
313 (t.__name__, obj))
314
315
316 if type(rv) is StringType:
317 self.save_global(obj, rv)
318 return
319
320
321 if type(rv) is not TupleType:
322 raise PicklingError("%s must return string or tuple" % reduce)
323
324
325 l = len(rv)
326 if not (2 <= l <= 5):
327 raise PicklingError("Tuple returned by %s must have "
328 "two to five elements" % reduce)
329
330
331 self.save_reduce(obj=obj, *rv)
332
336
338
339 if self.bin:
340 self.save(pid)
341 self.write(BINPERSID)
342 else:
343 self.write(PERSID + str(pid) + '\n')
344
345 - def save_reduce(self, func, args, state=None,
346 listitems=None, dictitems=None, obj=None):
347
348
349
350 if not isinstance(args, TupleType):
351 raise PicklingError("args from reduce() should be a tuple")
352
353
354 if not hasattr(func, '__call__'):
355 raise PicklingError("func from reduce should be callable")
356
357 save = self.save
358 write = self.write
359
360
361 if self.proto >= 2 and getattr(func, "__name__", "") == "__newobj__":
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388 cls = args[0]
389 if not hasattr(cls, "__new__"):
390 raise PicklingError(
391 "args[0] from __newobj__ args has no __new__")
392 if obj is not None and cls is not obj.__class__:
393 raise PicklingError(
394 "args[0] from __newobj__ args has the wrong class")
395 args = args[1:]
396 save(cls)
397 save(args)
398 write(NEWOBJ)
399 else:
400 save(func)
401 save(args)
402 write(REDUCE)
403
404 if obj is not None:
405
406
407
408 if id(obj) in self.memo:
409 write(POP + self.get(self.memo[id(obj)][0]))
410 else:
411 self.memoize(obj)
412
413
414
415
416
417
418 if listitems is not None:
419 self._batch_appends(listitems)
420
421 if dictitems is not None:
422 self._batch_setitems(dictitems)
423
424 if state is not None:
425 save(state)
426 write(BUILD)
427
428
429
430 dispatch = {}
431
434 dispatch[NoneType] = save_none
435
441 dispatch[bool] = save_bool
442
443 - def save_int(self, obj, pack=struct.pack):
444 if self.bin:
445
446
447
448
449 if obj >= 0:
450 if obj <= 0xff:
451 self.write(BININT1 + chr(obj))
452 return
453 if obj <= 0xffff:
454 self.write("%c%c%c" % (BININT2, obj&0xff, obj>>8))
455 return
456
457 high_bits = obj >> 31
458 if high_bits == 0 or high_bits == -1:
459
460
461 self.write(BININT + pack("<i", obj))
462 return
463
464 self.write(INT + repr(obj) + '\n')
465 dispatch[IntType] = save_int
466
468 if self.proto >= 2:
469 bytes = encode_long(obj)
470 n = len(bytes)
471 if n < 256:
472 self.write(LONG1 + chr(n) + bytes)
473 else:
474 self.write(LONG4 + pack("<i", n) + bytes)
475 return
476 self.write(LONG + repr(obj) + '\n')
477 dispatch[LongType] = save_long
478
480 if self.bin:
481 self.write(BINFLOAT + pack('>d', obj))
482 else:
483 self.write(FLOAT + repr(obj) + '\n')
484 dispatch[FloatType] = save_float
485
487 if self.bin:
488 n = len(obj)
489 if n < 256:
490 self.write(SHORT_BINSTRING + chr(n) + obj)
491 else:
492 self.write(BINSTRING + pack("<i", n) + obj)
493 else:
494 self.write(STRING + repr(obj) + '\n')
495 self.memoize(obj)
496 dispatch[StringType] = save_string
497
499 if self.bin:
500 encoding = obj.encode('utf-8')
501 n = len(encoding)
502 self.write(BINUNICODE + pack("<i", n) + encoding)
503 else:
504 obj = obj.replace("\\", "\\u005c")
505 obj = obj.replace("\n", "\\u000a")
506 self.write(UNICODE + obj.encode('raw-unicode-escape') + '\n')
507 self.memoize(obj)
508 dispatch[UnicodeType] = save_unicode
509
510 if StringType is UnicodeType:
511
513 unicode = obj.isunicode()
514
515 if self.bin:
516 if unicode:
517 obj = obj.encode("utf-8")
518 l = len(obj)
519 if l < 256 and not unicode:
520 self.write(SHORT_BINSTRING + chr(l) + obj)
521 else:
522 s = pack("<i", l)
523 if unicode:
524 self.write(BINUNICODE + s + obj)
525 else:
526 self.write(BINSTRING + s + obj)
527 else:
528 if unicode:
529 obj = obj.replace("\\", "\\u005c")
530 obj = obj.replace("\n", "\\u000a")
531 obj = obj.encode('raw-unicode-escape')
532 self.write(UNICODE + obj + '\n')
533 else:
534 self.write(STRING + repr(obj) + '\n')
535 self.memoize(obj)
536 dispatch[StringType] = save_string
537
539 write = self.write
540 proto = self.proto
541
542 n = len(obj)
543 if n == 0:
544 if proto:
545 write(EMPTY_TUPLE)
546 else:
547 write(MARK + TUPLE)
548 return
549
550 save = self.save
551 memo = self.memo
552 if n <= 3 and proto >= 2:
553 for element in obj:
554 save(element)
555
556 if id(obj) in memo:
557 get = self.get(memo[id(obj)][0])
558 write(POP * n + get)
559 else:
560 write(_tuplesize2code[n])
561 self.memoize(obj)
562 return
563
564
565
566 write(MARK)
567 for element in obj:
568 save(element)
569
570 if id(obj) in memo:
571
572
573
574
575
576
577
578 get = self.get(memo[id(obj)][0])
579 if proto:
580 write(POP_MARK + get)
581 else:
582 write(POP * (n+1) + get)
583 return
584
585
586 self.write(TUPLE)
587 self.memoize(obj)
588
589 dispatch[TupleType] = save_tuple
590
591
592
593
596
598 write = self.write
599
600 if self.bin:
601 write(EMPTY_LIST)
602 else:
603 write(MARK + LIST)
604
605 self.memoize(obj)
606 self._batch_appends(iter(obj))
607
608 dispatch[ListType] = save_list
609
610
611
612 _BATCHSIZE = 1000
613
615
616 save = self.save
617 write = self.write
618
619 if not self.bin:
620 for x in items:
621 save(x)
622 write(APPEND)
623 return
624
625 r = xrange(self._BATCHSIZE)
626 while items is not None:
627 tmp = []
628 for i in r:
629 try:
630 x = items.next()
631 tmp.append(x)
632 except StopIteration:
633 items = None
634 break
635 n = len(tmp)
636 if n > 1:
637 write(MARK)
638 for x in tmp:
639 save(x)
640 write(APPENDS)
641 elif n:
642 save(tmp[0])
643 write(APPEND)
644
645
647 write = self.write
648
649 if self.bin:
650 write(EMPTY_DICT)
651 else:
652 write(MARK + DICT)
653
654 self.memoize(obj)
655 self._batch_setitems(obj.iteritems())
656
657 dispatch[DictionaryType] = save_dict
658 if not PyStringMap is None:
659 dispatch[PyStringMap] = save_dict
660
662
663 save = self.save
664 write = self.write
665
666 if not self.bin:
667 for k, v in items:
668 save(k)
669 save(v)
670 write(SETITEM)
671 return
672
673 r = xrange(self._BATCHSIZE)
674 while items is not None:
675 tmp = []
676 for i in r:
677 try:
678 tmp.append(items.next())
679 except StopIteration:
680 items = None
681 break
682 n = len(tmp)
683 if n > 1:
684 write(MARK)
685 for k, v in tmp:
686 save(k)
687 save(v)
688 write(SETITEMS)
689 elif n:
690 k, v = tmp[0]
691 save(k)
692 save(v)
693 write(SETITEM)
694
695
697 cls = obj.__class__
698
699 memo = self.memo
700 write = self.write
701 save = self.save
702
703 if hasattr(obj, '__getinitargs__'):
704 args = obj.__getinitargs__()
705 len(args)
706 _keep_alive(args, memo)
707 else:
708 args = ()
709
710 write(MARK)
711
712 if self.bin:
713 save(cls)
714 for arg in args:
715 save(arg)
716 write(OBJ)
717 else:
718 for arg in args:
719 save(arg)
720 write(INST + cls.__module__ + '\n' + cls.__name__ + '\n')
721
722 self.memoize(obj)
723
724 try:
725 getstate = obj.__getstate__
726 except AttributeError:
727 stuff = obj.__dict__
728 else:
729 stuff = getstate()
730 _keep_alive(stuff, memo)
731 save(stuff)
732 write(BUILD)
733
734 dispatch[InstanceType] = save_inst
735
736 - def save_global(self, obj, name=None, pack=struct.pack):
737 write = self.write
738 memo = self.memo
739
740 if name is None:
741 name = obj.__name__
742
743 module = getattr(obj, "__module__", None)
744 if module is None:
745 module = whichmodule(obj, name)
746
747 try:
748 __import__(module)
749 mod = sys.modules[module]
750 klass = getattr(mod, name)
751 except (ImportError, KeyError, AttributeError):
752 raise PicklingError(
753 "Can't pickle %r: it's not found as %s.%s" %
754 (obj, module, name))
755 else:
756 if klass is not obj:
757 raise PicklingError(
758 "Can't pickle %r: it's not the same object as %s.%s" %
759 (obj, module, name))
760
761 if self.proto >= 2:
762 code = _extension_registry.get((module, name))
763 if code:
764 assert code > 0
765 if code <= 0xff:
766 write(EXT1 + chr(code))
767 elif code <= 0xffff:
768 write("%c%c%c" % (EXT2, code&0xff, code>>8))
769 else:
770 write(EXT4 + pack("<i", code))
771 return
772
773 write(GLOBAL + module + '\n' + name + '\n')
774 self.memoize(obj)
775
776 dispatch[ClassType] = save_global
777 dispatch[FunctionType] = save_global
778 dispatch[BuiltinFunctionType] = save_global
779 dispatch[TypeType] = save_global
780
781
782
784 """Keeps a reference to the object x in the memo.
785
786 Because we remember objects by their id, we have
787 to assure that possibly temporary objects are kept
788 alive by referencing them.
789 We store a reference at the id of the memo, which should
790 normally not be used unless someone tries to deepcopy
791 the memo itself...
792 """
793 try:
794 memo[id(memo)].append(x)
795 except KeyError:
796
797 memo[id(memo)]=[x]
798
799
800
801
802
803 classmap = {}
804
806 """Figure out the module in which a function occurs.
807
808 Search sys.modules for the module.
809 Cache in classmap.
810 Return a module name.
811 If the function cannot be found, return "__main__".
812 """
813
814 mod = getattr(func, "__module__", None)
815 if mod is not None:
816 return mod
817 if func in classmap:
818 return classmap[func]
819
820 for name, module in sys.modules.items():
821 if module is None:
822 continue
823 if name != '__main__' and getattr(module, funcname, None) is func:
824 break
825 else:
826 name = '__main__'
827 classmap[func] = name
828 return name
829
830
831
832
834
836 """This takes a file-like object for reading a pickle data stream.
837
838 The protocol version of the pickle is detected automatically, so no
839 proto argument is needed.
840
841 The file-like object must have two methods, a read() method that
842 takes an integer argument, and a readline() method that requires no
843 arguments. Both methods should return a string. Thus file-like
844 object can be a file object opened for reading, a StringIO object,
845 or any other custom object that meets this interface.
846 """
847 self.readline = file.readline
848 self.read = file.read
849 self.memo = {}
850
852 """Read a pickled object representation from the open file.
853
854 Return the reconstituted object hierarchy specified in the file.
855 """
856 self.mark = object()
857 self.stack = []
858 self.append = self.stack.append
859 read = self.read
860 dispatch = self.dispatch
861 try:
862 while 1:
863 key = read(1)
864 dispatch[key](self)
865 except _Stop, stopinst:
866 return stopinst.value
867
868
869
870
871
872
873
874
875
877 stack = self.stack
878 mark = self.mark
879 k = len(stack)-1
880 while stack[k] is not mark: k = k-1
881 return k
882
883 dispatch = {}
884
887 dispatch[''] = load_eof
888
890 proto = ord(self.read(1))
891 if not 0 <= proto <= 2:
892 raise ValueError, "unsupported pickle protocol: %d" % proto
893 dispatch[PROTO] = load_proto
894
896 pid = self.readline()[:-1]
897 self.append(self.persistent_load(pid))
898 dispatch[PERSID] = load_persid
899
901 pid = self.stack.pop()
902 self.append(self.persistent_load(pid))
903 dispatch[BINPERSID] = load_binpersid
904
907 dispatch[NONE] = load_none
908
911 dispatch[NEWFALSE] = load_false
912
915 dispatch[NEWTRUE] = load_true
916
918 data = self.readline()
919 if data == FALSE[1:]:
920 val = False
921 elif data == TRUE[1:]:
922 val = True
923 else:
924 try:
925 val = int(data)
926 except ValueError:
927 val = long(data)
928 self.append(val)
929 dispatch[INT] = load_int
930
932 self.append(mloads('i' + self.read(4)))
933 dispatch[BININT] = load_binint
934
936 self.append(ord(self.read(1)))
937 dispatch[BININT1] = load_binint1
938
940 self.append(mloads('i' + self.read(2) + '\000\000'))
941 dispatch[BININT2] = load_binint2
942
944 self.append(long(self.readline()[:-1], 0))
945 dispatch[LONG] = load_long
946
948 n = ord(self.read(1))
949 bytes = self.read(n)
950 self.append(decode_long(bytes))
951 dispatch[LONG1] = load_long1
952
954 n = mloads('i' + self.read(4))
955 bytes = self.read(n)
956 self.append(decode_long(bytes))
957 dispatch[LONG4] = load_long4
958
960 self.append(float(self.readline()[:-1]))
961 dispatch[FLOAT] = load_float
962
964 self.append(unpack('>d', self.read(8))[0])
965 dispatch[BINFLOAT] = load_binfloat
966
968 rep = self.readline()[:-1]
969 for q in "\"'":
970 if rep.startswith(q):
971 if len(rep) < 2 or not rep.endswith(q):
972 raise ValueError, "insecure string pickle"
973 rep = rep[len(q):-len(q)]
974 break
975 else:
976 raise ValueError, "insecure string pickle"
977 self.append(rep.decode("string-escape"))
978 dispatch[STRING] = load_string
979
981 len = mloads('i' + self.read(4))
982 self.append(self.read(len))
983 dispatch[BINSTRING] = load_binstring
984
986 self.append(unicode(self.readline()[:-1],'raw-unicode-escape'))
987 dispatch[UNICODE] = load_unicode
988
990 len = mloads('i' + self.read(4))
991 self.append(unicode(self.read(len),'utf-8'))
992 dispatch[BINUNICODE] = load_binunicode
993
995 len = ord(self.read(1))
996 self.append(self.read(len))
997 dispatch[SHORT_BINSTRING] = load_short_binstring
998
1000 k = self.marker()
1001 self.stack[k:] = [tuple(self.stack[k+1:])]
1002 dispatch[TUPLE] = load_tuple
1003
1005 self.stack.append(())
1006 dispatch[EMPTY_TUPLE] = load_empty_tuple
1007
1009 self.stack[-1] = (self.stack[-1],)
1010 dispatch[TUPLE1] = load_tuple1
1011
1013 self.stack[-2:] = [(self.stack[-2], self.stack[-1])]
1014 dispatch[TUPLE2] = load_tuple2
1015
1017 self.stack[-3:] = [(self.stack[-3], self.stack[-2], self.stack[-1])]
1018 dispatch[TUPLE3] = load_tuple3
1019
1021 self.stack.append([])
1022 dispatch[EMPTY_LIST] = load_empty_list
1023
1025 self.stack.append({})
1026 dispatch[EMPTY_DICT] = load_empty_dictionary
1027
1029 k = self.marker()
1030 self.stack[k:] = [self.stack[k+1:]]
1031 dispatch[LIST] = load_list
1032
1034 k = self.marker()
1035 d = {}
1036 items = self.stack[k+1:]
1037 for i in range(0, len(items), 2):
1038 key = items[i]
1039 value = items[i+1]
1040 d[key] = value
1041 self.stack[k:] = [d]
1042 dispatch[DICT] = load_dict
1043
1044
1045
1046
1047
1048
1050 args = tuple(self.stack[k+1:])
1051 del self.stack[k:]
1052 instantiated = 0
1053 if (not args and
1054 type(klass) is ClassType and
1055 not hasattr(klass, "__getinitargs__")):
1056 try:
1057 value = _EmptyClass()
1058 value.__class__ = klass
1059 instantiated = 1
1060 except RuntimeError:
1061
1062
1063 pass
1064 if not instantiated:
1065 try:
1066 value = klass(*args)
1067 except TypeError, err:
1068 raise TypeError, "in constructor for %s: %s" % (
1069 klass.__name__, str(err)), sys.exc_info()[2]
1070 self.append(value)
1071
1073 module = self.readline()[:-1]
1074 name = self.readline()[:-1]
1075 klass = self.find_class(module, name)
1076 self._instantiate(klass, self.marker())
1077 dispatch[INST] = load_inst
1078
1080
1081 k = self.marker()
1082 klass = self.stack.pop(k+1)
1083 self._instantiate(klass, k)
1084 dispatch[OBJ] = load_obj
1085
1087 args = self.stack.pop()
1088 cls = self.stack[-1]
1089 obj = cls.__new__(cls, *args)
1090 self.stack[-1] = obj
1091 dispatch[NEWOBJ] = load_newobj
1092
1094 module = self.readline()[:-1]
1095 name = self.readline()[:-1]
1096 klass = self.find_class(module, name)
1097 self.append(klass)
1098 dispatch[GLOBAL] = load_global
1099
1101 code = ord(self.read(1))
1102 self.get_extension(code)
1103 dispatch[EXT1] = load_ext1
1104
1106 code = mloads('i' + self.read(2) + '\000\000')
1107 self.get_extension(code)
1108 dispatch[EXT2] = load_ext2
1109
1111 code = mloads('i' + self.read(4))
1112 self.get_extension(code)
1113 dispatch[EXT4] = load_ext4
1114
1116 nil = []
1117 obj = _extension_cache.get(code, nil)
1118 if obj is not nil:
1119 self.append(obj)
1120 return
1121 key = _inverted_registry.get(code)
1122 if not key:
1123 raise ValueError("unregistered extension code %d" % code)
1124 obj = self.find_class(*key)
1125 _extension_cache[code] = obj
1126 self.append(obj)
1127
1129
1130 __import__(module)
1131 mod = sys.modules[module]
1132 klass = getattr(mod, name)
1133 return klass
1134
1136 stack = self.stack
1137 args = stack.pop()
1138 func = stack[-1]
1139 value = func(*args)
1140 stack[-1] = value
1141 dispatch[REDUCE] = load_reduce
1142
1145 dispatch[POP] = load_pop
1146
1148 k = self.marker()
1149 del self.stack[k:]
1150 dispatch[POP_MARK] = load_pop_mark
1151
1153 self.append(self.stack[-1])
1154 dispatch[DUP] = load_dup
1155
1157 self.append(self.memo[self.readline()[:-1]])
1158 dispatch[GET] = load_get
1159
1161 i = ord(self.read(1))
1162 self.append(self.memo[repr(i)])
1163 dispatch[BINGET] = load_binget
1164
1166 i = mloads('i' + self.read(4))
1167 self.append(self.memo[repr(i)])
1168 dispatch[LONG_BINGET] = load_long_binget
1169
1171 self.memo[self.readline()[:-1]] = self.stack[-1]
1172 dispatch[PUT] = load_put
1173
1177 dispatch[BINPUT] = load_binput
1178
1182 dispatch[LONG_BINPUT] = load_long_binput
1183
1185 stack = self.stack
1186 value = stack.pop()
1187 list = stack[-1]
1188 list.append(value)
1189 dispatch[APPEND] = load_append
1190
1192 stack = self.stack
1193 mark = self.marker()
1194 list = stack[mark - 1]
1195 list.extend(stack[mark + 1:])
1196 del stack[mark:]
1197 dispatch[APPENDS] = load_appends
1198
1200 stack = self.stack
1201 value = stack.pop()
1202 key = stack.pop()
1203 dict = stack[-1]
1204 dict[key] = value
1205 dispatch[SETITEM] = load_setitem
1206
1208 stack = self.stack
1209 mark = self.marker()
1210 dict = stack[mark - 1]
1211 for i in range(mark + 1, len(stack), 2):
1212 dict[stack[i]] = stack[i + 1]
1213
1214 del stack[mark:]
1215 dispatch[SETITEMS] = load_setitems
1216
1218 stack = self.stack
1219 state = stack.pop()
1220 inst = stack[-1]
1221 setstate = getattr(inst, "__setstate__", None)
1222 if setstate:
1223 setstate(state)
1224 return
1225 slotstate = None
1226 if isinstance(state, tuple) and len(state) == 2:
1227 state, slotstate = state
1228 if state:
1229 try:
1230 d = inst.__dict__
1231 try:
1232 for k, v in state.iteritems():
1233 d[intern(k)] = v
1234
1235
1236 except TypeError:
1237 d.update(state)
1238
1239 except RuntimeError:
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249 for k, v in state.items():
1250 setattr(inst, k, v)
1251 if slotstate:
1252 for k, v in slotstate.items():
1253 setattr(inst, k, v)
1254 dispatch[BUILD] = load_build
1255
1257 self.append(self.mark)
1258 dispatch[MARK] = load_mark
1259
1261 value = self.stack.pop()
1262 raise _Stop(value)
1263 dispatch[STOP] = load_stop
1264
1265
1266
1269
1270
1271
1272 import binascii as _binascii
1273
1275 r"""Encode a long to a two's complement little-endian binary string.
1276 Note that 0L is a special case, returning an empty string, to save a
1277 byte in the LONG1 pickling context.
1278
1279 >>> encode_long(0L)
1280 ''
1281 >>> encode_long(255L)
1282 '\xff\x00'
1283 >>> encode_long(32767L)
1284 '\xff\x7f'
1285 >>> encode_long(-256L)
1286 '\x00\xff'
1287 >>> encode_long(-32768L)
1288 '\x00\x80'
1289 >>> encode_long(-128L)
1290 '\x80'
1291 >>> encode_long(127L)
1292 '\x7f'
1293 >>>
1294 """
1295
1296 if x == 0:
1297 return ''
1298 if x > 0:
1299 ashex = hex(x)
1300 assert ashex.startswith("0x")
1301 njunkchars = 2 + ashex.endswith('L')
1302 nibbles = len(ashex) - njunkchars
1303 if nibbles & 1:
1304
1305 ashex = "0x0" + ashex[2:]
1306 elif int(ashex[2], 16) >= 8:
1307
1308 ashex = "0x00" + ashex[2:]
1309 else:
1310
1311
1312
1313 ashex = hex(-x)
1314 assert ashex.startswith("0x")
1315 njunkchars = 2 + ashex.endswith('L')
1316 nibbles = len(ashex) - njunkchars
1317 if nibbles & 1:
1318
1319 nibbles += 1
1320 nbits = nibbles * 4
1321 x += 1L << nbits
1322 assert x > 0
1323 ashex = hex(x)
1324 njunkchars = 2 + ashex.endswith('L')
1325 newnibbles = len(ashex) - njunkchars
1326 if newnibbles < nibbles:
1327 ashex = "0x" + "0" * (nibbles - newnibbles) + ashex[2:]
1328 if int(ashex[2], 16) < 8:
1329
1330 ashex = "0xff" + ashex[2:]
1331
1332 if ashex.endswith('L'):
1333 ashex = ashex[2:-1]
1334 else:
1335 ashex = ashex[2:]
1336 assert len(ashex) & 1 == 0, (x, ashex)
1337 binary = _binascii.unhexlify(ashex)
1338 return binary[::-1]
1339
1341 r"""Decode a long from a two's complement little-endian binary string.
1342
1343 >>> decode_long('')
1344 0L
1345 >>> decode_long("\xff\x00")
1346 255L
1347 >>> decode_long("\xff\x7f")
1348 32767L
1349 >>> decode_long("\x00\xff")
1350 -256L
1351 >>> decode_long("\x00\x80")
1352 -32768L
1353 >>> decode_long("\x80")
1354 -128L
1355 >>> decode_long("\x7f")
1356 127L
1357 """
1358
1359 nbytes = len(data)
1360 if nbytes == 0:
1361 return 0L
1362 ashex = _binascii.hexlify(data[::-1])
1363 n = long(ashex, 16)
1364 if data[-1] >= '\x80':
1365 n -= 1L << (nbytes * 8)
1366 return n
1367
1368
1369
1370 try:
1371 from cStringIO import StringIO
1372 except ImportError:
1373 from StringIO import StringIO
1374
1375 -def dump(obj, file, protocol=None):
1376 Pickler(file, protocol).dump(obj)
1377
1378 -def dumps(obj, protocol=None):
1379 file = StringIO()
1380 Pickler(file, protocol).dump(obj)
1381 return file.getvalue()
1382
1385
1387 file = StringIO(str)
1388 return Unpickler(file).load()
1389
1390
1391
1393 import doctest
1394 return doctest.testmod()
1395
1396 if __name__ == "__main__":
1397 _test()
1398