Lib/pickle.py

   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
   6 Classes:
   7
   8     Pickler
   9     Unpickler
  10
  11 Functions:
  12
  13     dump(object, file)
  14     dumps(object) -> string
  15     load(file) -> object
  16     loads(string) -> object
  17
  18 Misc variables:
  19
  20     __version__
  21     format_version
  22     compatible_formats
  23
  24 """
  25
  26 __version__ = "$Revision$"       # Code version
  27
  28 from types import *
  29 from copy_reg import dispatch_table, safe_constructors
  30 import marshal
  31 import sys
  32 import struct
  33 import re
  34
  35 __all__ = ["PickleError", "PicklingError", "UnpicklingError", "Pickler",
  36            "Unpickler", "dump", "dumps", "load", "loads"]
  37
  38 format_version = "1.3"                     # File format version we write
  39 compatible_formats = ["1.0", "1.1", "1.2"] # Old format versions we can read
  40
  41 mdumps = marshal.dumps
  42 mloads = marshal.loads
  43
  44 class PickleError(Exception): pass
  45 class PicklingError(PickleError): pass
  46 class UnpicklingError(PickleError): pass
  47
  48 class _Stop(Exception):
  49     def __init__(self, value):
  50         self.value = value
  51
  52 try:
  53     from org.python.core import PyStringMap
  54 except ImportError:
  55     PyStringMap = None
  56
  57 try:
  58     UnicodeType
  59 except NameError:
  60     UnicodeType = None
  61
  62
  63 MARK            = '('
  64 STOP            = '.'
  65 POP             = '0'
  66 POP_MARK        = '1'
  67 DUP             = '2'
  68 FLOAT           = 'F'
  69 INT             = 'I'
  70 BININT          = 'J'
  71 BININT1         = 'K'
  72 LONG            = 'L'
  73 BININT2         = 'M'
  74 NONE            = 'N'
  75 PERSID          = 'P'
  76 BINPERSID       = 'Q'
  77 REDUCE          = 'R'
  78 STRING          = 'S'
  79 BINSTRING       = 'T'
  80 SHORT_BINSTRING = 'U'
  81 UNICODE         = 'V'
  82 BINUNICODE      = 'X'
  83 APPEND          = 'a'
  84 BUILD           = 'b'
  85 GLOBAL          = 'c'
  86 DICT            = 'd'
  87 EMPTY_DICT      = '}'
  88 APPENDS         = 'e'
  89 GET             = 'g'
  90 BINGET          = 'h'
  91 INST            = 'i'
  92 LONG_BINGET     = 'j'
  93 LIST            = 'l'
  94 EMPTY_LIST      = ']'
  95 OBJ             = 'o'
  96 PUT             = 'p'
  97 BINPUT          = 'q'
  98 LONG_BINPUT     = 'r'
  99 SETITEM         = 's'
 100 TUPLE           = 't'
 101 EMPTY_TUPLE     = ')'
 102 SETITEMS        = 'u'
 103 BINFLOAT        = 'G'
 104
 105 __all__.extend([x for x in dir() if re.match("[A-Z][A-Z0-9_]+$",x)])
 106
 107 class Pickler:
 108
 109     def __init__(self, file, bin = 0):
 110         self.write = file.write
 111         self.memo = {}
 112         self.bin = bin
 113
 114     def dump(self, object):
 115         self.save(object)
 116         self.write(STOP)
 117
 118     def put(self, i):
 119         if self.bin:
 120             s = mdumps(i)[1:]
 121             if i < 256:
 122                 return BINPUT + s[0]
 123
 124             return LONG_BINPUT + s
 125
 126         return PUT + `i` + '\n'
 127
 128     def get(self, i):
 129         if self.bin:
 130             s = mdumps(i)[1:]
 131
 132             if i < 256:
 133                 return BINGET + s[0]
 134
 135             return LONG_BINGET + s
 136
 137         return GET + `i` + '\n'
 138
 139     def save(self, object, pers_save = 0):
 140         memo = self.memo
 141
 142         if not pers_save:
 143             pid = self.persistent_id(object)
 144             if pid is not None:
 145                 self.save_pers(pid)
 146                 return
 147
 148         d = id(object)
 149
 150         t = type(object)
 151
 152         if (t is TupleType) and (len(object) == 0):
 153             if self.bin:
 154                 self.save_empty_tuple(object)
 155             else:
 156                 self.save_tuple(object)
 157             return
 158
 159         if memo.has_key(d):
 160             self.write(self.get(memo[d][0]))
 161             return
 162
 163         try:
 164             f = self.dispatch[t]
 165         except KeyError:
 166             if issubclass(t, TypeType):
 167                 self.save_global(object)
 168                 return
 169
 170             pid = self.inst_persistent_id(object)
 171             if pid is not None:
 172                 self.save_pers(pid)
 173                 return
 174
 175             try:
 176                 reduce = dispatch_table[t]
 177             except KeyError:
 178                 try:
 179                     reduce = object.__reduce__
 180                 except AttributeError:
 181                     raise PicklingError, \
 182                         "can't pickle %s object: %s" % (`t.__name__`,
 183                                                          `object`)
 184                 else:
 185                     tup = reduce()
 186             else:
 187                 tup = reduce(object)
 188
 189             if type(tup) is StringType:
 190                 self.save_global(object, tup)
 191                 return
 192
 193             if type(tup) is not TupleType:
 194                 raise PicklingError, "Value returned by %s must be a " \
 195                                      "tuple" % reduce
 196
 197             l = len(tup)
 198
 199             if (l != 2) and (l != 3):
 200                 raise PicklingError, "tuple returned by %s must contain " \
 201                                      "only two or three elements" % reduce
 202
 203             callable = tup[0]
 204             arg_tup  = tup[1]
 205
 206             if l > 2:
 207                 state = tup[2]
 208             else:
 209                 state = None
 210
 211             if type(arg_tup) is not TupleType and arg_tup is not None:
 212                 raise PicklingError, "Second element of tuple returned " \
 213                                      "by %s must be a tuple" % reduce
 214
 215             self.save_reduce(callable, arg_tup, state)
 216             memo_len = len(memo)
 217             self.write(self.put(memo_len))
 218             memo[d] = (memo_len, object)
 219             return
 220
 221         f(self, object)
 222
 223     def persistent_id(self, object):
 224         return None
 225
 226     def inst_persistent_id(self, object):
 227         return None
 228
 229     def save_pers(self, pid):
 230         if not self.bin:
 231             self.write(PERSID + str(pid) + '\n')
 232         else:
 233             self.save(pid, 1)
 234             self.write(BINPERSID)
 235
 236     def save_reduce(self, callable, arg_tup, state = None):
 237         write = self.write
 238         save = self.save
 239
 240         save(callable)
 241         save(arg_tup)
 242         write(REDUCE)
 243
 244         if state is not None:
 245             save(state)
 246             write(BUILD)
 247
 248     dispatch = {}
 249
 250     def save_none(self, object):
 251         self.write(NONE)
 252     dispatch[NoneType] = save_none
 253
 254     def save_int(self, object):
 255         if self.bin:
 256             # If the int is small enough to fit in a signed 4-byte 2's-comp
 257             # format, we can store it more efficiently than the general
 258             # case.
 259             high_bits = object >> 31  # note that Python shift sign-extends
 260             if  high_bits == 0 or high_bits == -1:
 261                 # All high bits are copies of bit 2**31, so the value
 262                 # fits in a 4-byte signed int.
 263                 i = mdumps(object)[1:]
 264                 assert len(i) == 4
 265                 if i[-2:] == '\000\000':    # fits in 2-byte unsigned int
 266                     if i[-3] == '\000':     # fits in 1-byte unsigned int
 267                         self.write(BININT1 + i[0])
 268                     else:
 269                         self.write(BININT2 + i[:2])
 270                 else:
 271                     self.write(BININT + i)
 272                 return
 273         # Text pickle, or int too big to fit in signed 4-byte format.
 274         self.write(INT + `object` + '\n')
 275     dispatch[IntType] = save_int
 276
 277     def save_long(self, object):
 278         self.write(LONG + `object` + '\n')
 279     dispatch[LongType] = save_long
 280
 281     def save_float(self, object, pack=struct.pack):
 282         if self.bin:
 283             self.write(BINFLOAT + pack('>d', object))
 284         else:
 285             self.write(FLOAT + `object` + '\n')
 286     dispatch[FloatType] = save_float
 287
 288     def save_string(self, object):
 289         d = id(object)
 290         memo = self.memo
 291
 292         if self.bin:
 293             l = len(object)
 294             s = mdumps(l)[1:]
 295             if l < 256:
 296                 self.write(SHORT_BINSTRING + s[0] + object)
 297             else:
 298                 self.write(BINSTRING + s + object)
 299         else:
 300             self.write(STRING + `object` + '\n')
 301
 302         memo_len = len(memo)
 303         self.write(self.put(memo_len))
 304         memo[d] = (memo_len, object)
 305     dispatch[StringType] = save_string
 306
 307     def save_unicode(self, object):
 308         d = id(object)
 309         memo = self.memo
 310
 311         if self.bin:
 312             encoding = object.encode('utf-8')
 313             l = len(encoding)
 314             s = mdumps(l)[1:]
 315             self.write(BINUNICODE + s + encoding)
 316         else:
 317             object = object.replace("\\", "\\u005c")
 318             object = object.replace("\n", "\\u000a")
 319             self.write(UNICODE + object.encode('raw-unicode-escape') + '\n')
 320
 321         memo_len = len(memo)
 322         self.write(self.put(memo_len))
 323         memo[d] = (memo_len, object)
 324     dispatch[UnicodeType] = save_unicode
 325
 326     if StringType == UnicodeType:
 327         # This is true for Jython
 328         def save_string(self, object):
 329             d = id(object)
 330             memo = self.memo
 331             unicode = object.isunicode()
 332
 333             if self.bin:
 334                 if unicode:
 335                     object = object.encode("utf-8")
 336                 l = len(object)
 337                 s = mdumps(l)[1:]
 338                 if l < 256 and not unicode:
 339                     self.write(SHORT_BINSTRING + s[0] + object)
 340                 else:
 341                     if unicode:
 342                         self.write(BINUNICODE + s + object)
 343                     else:
 344                         self.write(BINSTRING + s + object)
 345             else:
 346                 if unicode:
 347                     object = object.replace("\\", "\\u005c")
 348                     object = object.replace("\n", "\\u000a")
 349                     object = object.encode('raw-unicode-escape')
 350                     self.write(UNICODE + object + '\n')
 351                 else:
 352                     self.write(STRING + `object` + '\n')
 353
 354             memo_len = len(memo)
 355             self.write(self.put(memo_len))
 356             memo[d] = (memo_len, object)
 357         dispatch[StringType] = save_string
 358
 359     def save_tuple(self, object):
 360
 361         write = self.write
 362         save  = self.save
 363         memo  = self.memo
 364
 365         d = id(object)
 366
 367         write(MARK)
 368
 369         for element in object:
 370             save(element)
 371
 372         if len(object) and memo.has_key(d):
 373             if self.bin:
 374                 write(POP_MARK + self.get(memo[d][0]))
 375                 return
 376
 377             write(POP * (len(object) + 1) + self.get(memo[d][0]))
 378             return
 379
 380         memo_len = len(memo)
 381         self.write(TUPLE + self.put(memo_len))
 382         memo[d] = (memo_len, object)
 383     dispatch[TupleType] = save_tuple
 384
 385     def save_empty_tuple(self, object):
 386         self.write(EMPTY_TUPLE)
 387
 388     def save_list(self, object):
 389         d = id(object)
 390
 391         write = self.write
 392         save  = self.save
 393         memo  = self.memo
 394
 395         if self.bin:
 396             write(EMPTY_LIST)
 397         else:
 398             write(MARK + LIST)
 399
 400         memo_len = len(memo)
 401         write(self.put(memo_len))
 402         memo[d] = (memo_len, object)
 403
 404         using_appends = (self.bin and (len(object) > 1))
 405
 406         if using_appends:
 407             write(MARK)
 408
 409         for element in object:
 410             save(element)
 411
 412             if not using_appends:
 413                 write(APPEND)
 414
 415         if using_appends:
 416             write(APPENDS)
 417     dispatch[ListType] = save_list
 418
 419     def save_dict(self, object):
 420         d = id(object)
 421
 422         write = self.write
 423         save  = self.save
 424         memo  = self.memo
 425
 426         if self.bin:
 427             write(EMPTY_DICT)
 428         else:
 429             write(MARK + DICT)
 430
 431         memo_len = len(memo)
 432         self.write(self.put(memo_len))
 433         memo[d] = (memo_len, object)
 434
 435         using_setitems = (self.bin and (len(object) > 1))
 436
 437         if using_setitems:
 438             write(MARK)
 439
 440         items = object.items()
 441         for key, value in items:
 442             save(key)
 443             save(value)
 444
 445             if not using_setitems:
 446                 write(SETITEM)
 447
 448         if using_setitems:
 449             write(SETITEMS)
 450
 451     dispatch[DictionaryType] = save_dict
 452     if not PyStringMap is None:
 453         dispatch[PyStringMap] = save_dict
 454
 455     def save_inst(self, object):
 456         d = id(object)
 457         cls = object.__class__
 458
 459         memo  = self.memo
 460         write = self.write
 461         save  = self.save
 462
 463         if hasattr(object, '__getinitargs__'):
 464             args = object.__getinitargs__()
 465             len(args) # XXX Assert it's a sequence
 466             _keep_alive(args, memo)
 467         else:
 468             args = ()
 469
 470         write(MARK)
 471
 472         if self.bin:
 473             save(cls)
 474
 475         for arg in args:
 476             save(arg)
 477
 478         memo_len = len(memo)
 479         if self.bin:
 480             write(OBJ + self.put(memo_len))
 481         else:
 482             write(INST + cls.__module__ + '\n' + cls.__name__ + '\n' +
 483                 self.put(memo_len))
 484
 485         memo[d] = (memo_len, object)
 486
 487         try:
 488             getstate = object.__getstate__
 489         except AttributeError:
 490             stuff = object.__dict__
 491         else:
 492             stuff = getstate()
 493             _keep_alive(stuff, memo)
 494         save(stuff)
 495         write(BUILD)
 496     dispatch[InstanceType] = save_inst
 497
 498     def save_global(self, object, name = None):
 499         write = self.write
 500         memo = self.memo
 501
 502         if name is None:
 503             name = object.__name__
 504
 505         try:
 506             module = object.__module__
 507         except AttributeError:
 508             module = whichmodule(object, name)
 509
 510         try:
 511             __import__(module)
 512             mod = sys.modules[module]
 513             klass = getattr(mod, name)
 514         except (ImportError, KeyError, AttributeError):
 515             raise PicklingError(
 516                 "Can't pickle %r: it's not found as %s.%s" %
 517                 (object, module, name))
 518         else:
 519             if klass is not object:
 520                 raise PicklingError(
 521                     "Can't pickle %r: it's not the same object as %s.%s" %
 522                     (object, module, name))
 523
 524         memo_len = len(memo)
 525         write(GLOBAL + module + '\n' + name + '\n' +
 526             self.put(memo_len))
 527         memo[id(object)] = (memo_len, object)
 528     dispatch[ClassType] = save_global
 529     dispatch[FunctionType] = save_global
 530     dispatch[BuiltinFunctionType] = save_global
 531     dispatch[TypeType] = save_global
 532
 533
 534 def _keep_alive(x, memo):
 535     """Keeps a reference to the object x in the memo.
 536
 537     Because we remember objects by their id, we have
 538     to assure that possibly temporary objects are kept
 539     alive by referencing them.
 540     We store a reference at the id of the memo, which should
 541     normally not be used unless someone tries to deepcopy
 542     the memo itself...
 543     """
 544     try:
 545         memo[id(memo)].append(x)
 546     except KeyError:
 547         # aha, this is the first one :-)
 548         memo[id(memo)]=[x]
 549
 550
 551 classmap = {}
 552
 553 # This is no longer used to find classes, but still for functions
 554 def whichmodule(cls, clsname):
 555     """Figure out the module in which a class occurs.
 556
 557     Search sys.modules for the module.
 558     Cache in classmap.
 559     Return a module name.
 560     If the class cannot be found, return __main__.
 561     """
 562     if classmap.has_key(cls):
 563         return classmap[cls]
 564
 565     for name, module in sys.modules.items():
 566         if name != '__main__' and \
 567             hasattr(module, clsname) and \
 568             getattr(module, clsname) is cls:
 569             break
 570     else:
 571         name = '__main__'
 572     classmap[cls] = name
 573     return name
 574
 575
 576 class Unpickler:
 577
 578     def __init__(self, file):
 579         self.readline = file.readline
 580         self.read = file.read
 581         self.memo = {}
 582
 583     def load(self):
 584         self.mark = object() # any new unique object
 585         self.stack = []
 586         self.append = self.stack.append
 587         read = self.read
 588         dispatch = self.dispatch
 589         try:
 590             while 1:
 591                 key = read(1)
 592                 dispatch[key](self)
 593         except _Stop, stopinst:
 594             return stopinst.value
 595
 596     def marker(self):
 597         stack = self.stack
 598         mark = self.mark
 599         k = len(stack)-1
 600         while stack[k] is not mark: k = k-1
 601         return k
 602
 603     dispatch = {}
 604
 605     def load_eof(self):
 606         raise EOFError
 607     dispatch[''] = load_eof
 608
 609     def load_persid(self):
 610         pid = self.readline()[:-1]
 611         self.append(self.persistent_load(pid))
 612     dispatch[PERSID] = load_persid
 613
 614     def load_binpersid(self):
 615         stack = self.stack
 616
 617         pid = stack[-1]
 618         del stack[-1]
 619
 620         self.append(self.persistent_load(pid))
 621     dispatch[BINPERSID] = load_binpersid
 622
 623     def load_none(self):
 624         self.append(None)
 625     dispatch[NONE] = load_none
 626
 627     def load_int(self):
 628         data = self.readline()
 629         try:
 630             self.append(int(data))
 631         except ValueError:
 632             self.append(long(data))
 633     dispatch[INT] = load_int
 634
 635     def load_binint(self):
 636         self.append(mloads('i' + self.read(4)))
 637     dispatch[BININT] = load_binint
 638
 639     def load_binint1(self):
 640         self.append(mloads('i' + self.read(1) + '\000\000\000'))
 641     dispatch[BININT1] = load_binint1
 642
 643     def load_binint2(self):
 644         self.append(mloads('i' + self.read(2) + '\000\000'))
 645     dispatch[BININT2] = load_binint2
 646
 647     def load_long(self):
 648         self.append(long(self.readline()[:-1], 0))
 649     dispatch[LONG] = load_long
 650
 651     def load_float(self):
 652         self.append(float(self.readline()[:-1]))
 653     dispatch[FLOAT] = load_float
 654
 655     def load_binfloat(self, unpack=struct.unpack):
 656         self.append(unpack('>d', self.read(8))[0])
 657     dispatch[BINFLOAT] = load_binfloat
 658
 659     def load_string(self):
 660         rep = self.readline()[:-1]
 661         if not self._is_string_secure(rep):
 662             raise ValueError, "insecure string pickle"
 663         self.append(eval(rep,
 664                          {'__builtins__': {}})) # Let's be careful
 665     dispatch[STRING] = load_string
 666
 667     def _is_string_secure(self, s):
 668         """Return true if s contains a string that is safe to eval
 669
 670         The definition of secure string is based on the implementation
 671         in cPickle.  s is secure as long as it only contains a quoted
 672         string and optional trailing whitespace.
 673         """
 674         q = s[0]
 675         if q not in ("'", '"'):
 676             return 0
 677         # find the closing quote
 678         offset = 1
 679         i = None
 680         while 1:
 681             try:
 682                 i = s.index(q, offset)
 683             except ValueError:
 684                 # if there is an error the first time, there is no
 685                 # close quote
 686                 if offset == 1:
 687                     return 0
 688             if s[i-1] != '\\':
 689                 break
 690             # check to see if this one is escaped
 691             nslash = 0
 692             j = i - 1
 693             while j >= offset and s[j] == '\\':
 694                 j = j - 1
 695                 nslash = nslash + 1
 696             if nslash % 2 == 0:
 697                 break
 698             offset = i + 1
 699         for c in s[i+1:]:
 700             if ord(c) > 32:
 701                 return 0
 702         return 1
 703
 704     def load_binstring(self):
 705         len = mloads('i' + self.read(4))
 706         self.append(self.read(len))
 707     dispatch[BINSTRING] = load_binstring
 708
 709     def load_unicode(self):
 710         self.append(unicode(self.readline()[:-1],'raw-unicode-escape'))
 711     dispatch[UNICODE] = load_unicode
 712
 713     def load_binunicode(self):
 714         len = mloads('i' + self.read(4))
 715         self.append(unicode(self.read(len),'utf-8'))
 716     dispatch[BINUNICODE] = load_binunicode
 717
 718     def load_short_binstring(self):
 719         len = mloads('i' + self.read(1) + '\000\000\000')
 720         self.append(self.read(len))
 721     dispatch[SHORT_BINSTRING] = load_short_binstring
 722
 723     def load_tuple(self):
 724         k = self.marker()
 725         self.stack[k:] = [tuple(self.stack[k+1:])]
 726     dispatch[TUPLE] = load_tuple
 727
 728     def load_empty_tuple(self):
 729         self.stack.append(())
 730     dispatch[EMPTY_TUPLE] = load_empty_tuple
 731
 732     def load_empty_list(self):
 733         self.stack.append([])
 734     dispatch[EMPTY_LIST] = load_empty_list
 735
 736     def load_empty_dictionary(self):
 737         self.stack.append({})
 738     dispatch[EMPTY_DICT] = load_empty_dictionary
 739
 740     def load_list(self):
 741         k = self.marker()
 742         self.stack[k:] = [self.stack[k+1:]]
 743     dispatch[LIST] = load_list
 744
 745     def load_dict(self):
 746         k = self.marker()
 747         d = {}
 748         items = self.stack[k+1:]
 749         for i in range(0, len(items), 2):
 750             key = items[i]
 751             value = items[i+1]
 752             d[key] = value
 753         self.stack[k:] = [d]
 754     dispatch[DICT] = load_dict
 755
 756     def load_inst(self):
 757         k = self.marker()
 758         args = tuple(self.stack[k+1:])
 759         del self.stack[k:]
 760         module = self.readline()[:-1]
 761         name = self.readline()[:-1]
 762         klass = self.find_class(module, name)
 763         instantiated = 0
 764         if (not args and type(klass) is ClassType and
 765             not hasattr(klass, "__getinitargs__")):
 766             try:
 767                 value = _EmptyClass()
 768                 value.__class__ = klass
 769                 instantiated = 1
 770             except RuntimeError:
 771                 # In restricted execution, assignment to inst.__class__ is
 772                 # prohibited
 773                 pass
 774         if not instantiated:
 775             try:
 776                 if not hasattr(klass, '__safe_for_unpickling__'):
 777                     raise UnpicklingError('%s is not safe for unpickling' %
 778                                           klass)
 779                 value = apply(klass, args)
 780             except TypeError, err:
 781                 raise TypeError, "in constructor for %s: %s" % (
 782                     klass.__name__, str(err)), sys.exc_info()[2]
 783         self.append(value)
 784     dispatch[INST] = load_inst
 785
 786     def load_obj(self):
 787         stack = self.stack
 788         k = self.marker()
 789         klass = stack[k + 1]
 790         del stack[k + 1]
 791         args = tuple(stack[k + 1:])
 792         del stack[k:]
 793         instantiated = 0
 794         if (not args and type(klass) is ClassType and
 795             not hasattr(klass, "__getinitargs__")):
 796             try:
 797                 value = _EmptyClass()
 798                 value.__class__ = klass
 799                 instantiated = 1
 800             except RuntimeError:
 801                 # In restricted execution, assignment to inst.__class__ is
 802                 # prohibited
 803                 pass
 804         if not instantiated:
 805             value = apply(klass, args)
 806         self.append(value)
 807     dispatch[OBJ] = load_obj
 808
 809     def load_global(self):
 810         module = self.readline()[:-1]
 811         name = self.readline()[:-1]
 812         klass = self.find_class(module, name)
 813         self.append(klass)
 814     dispatch[GLOBAL] = load_global
 815
 816     def find_class(self, module, name):
 817         __import__(module)
 818         mod = sys.modules[module]
 819         klass = getattr(mod, name)
 820         return klass
 821
 822     def load_reduce(self):
 823         stack = self.stack
 824
 825         callable = stack[-2]
 826         arg_tup  = stack[-1]
 827         del stack[-2:]
 828
 829         if type(callable) is not ClassType:
 830             if not safe_constructors.has_key(callable):
 831                 try:
 832                     safe = callable.__safe_for_unpickling__
 833                 except AttributeError:
 834                     safe = None
 835
 836                 if not safe:
 837                     raise UnpicklingError, "%s is not safe for " \
 838                                            "unpickling" % callable
 839
 840         if arg_tup is None:
 841             value = callable.__basicnew__()
 842         else:
 843             value = apply(callable, arg_tup)
 844         self.append(value)
 845     dispatch[REDUCE] = load_reduce
 846
 847     def load_pop(self):
 848         del self.stack[-1]
 849     dispatch[POP] = load_pop
 850
 851     def load_pop_mark(self):
 852         k = self.marker()
 853         del self.stack[k:]
 854     dispatch[POP_MARK] = load_pop_mark
 855
 856     def load_dup(self):
 857         self.append(self.stack[-1])
 858     dispatch[DUP] = load_dup
 859
 860     def load_get(self):
 861         self.append(self.memo[self.readline()[:-1]])
 862     dispatch[GET] = load_get
 863
 864     def load_binget(self):
 865         i = mloads('i' + self.read(1) + '\000\000\000')
 866         self.append(self.memo[`i`])
 867     dispatch[BINGET] = load_binget
 868
 869     def load_long_binget(self):
 870         i = mloads('i' + self.read(4))
 871         self.append(self.memo[`i`])
 872     dispatch[LONG_BINGET] = load_long_binget
 873
 874     def load_put(self):
 875         self.memo[self.readline()[:-1]] = self.stack[-1]
 876     dispatch[PUT] = load_put
 877
 878     def load_binput(self):
 879         i = mloads('i' + self.read(1) + '\000\000\000')
 880         self.memo[`i`] = self.stack[-1]
 881     dispatch[BINPUT] = load_binput
 882
 883     def load_long_binput(self):
 884         i = mloads('i' + self.read(4))
 885         self.memo[`i`] = self.stack[-1]
 886     dispatch[LONG_BINPUT] = load_long_binput
 887
 888     def load_append(self):
 889         stack = self.stack
 890         value = stack[-1]
 891         del stack[-1]
 892         list = stack[-1]
 893         list.append(value)
 894     dispatch[APPEND] = load_append
 895
 896     def load_appends(self):
 897         stack = self.stack
 898         mark = self.marker()
 899         list = stack[mark - 1]
 900         for i in range(mark + 1, len(stack)):
 901             list.append(stack[i])
 902
 903         del stack[mark:]
 904     dispatch[APPENDS] = load_appends
 905
 906     def load_setitem(self):
 907         stack = self.stack
 908         value = stack[-1]
 909         key = stack[-2]
 910         del stack[-2:]
 911         dict = stack[-1]
 912         dict[key] = value
 913     dispatch[SETITEM] = load_setitem
 914
 915     def load_setitems(self):
 916         stack = self.stack
 917         mark = self.marker()
 918         dict = stack[mark - 1]
 919         for i in range(mark + 1, len(stack), 2):
 920             dict[stack[i]] = stack[i + 1]
 921
 922         del stack[mark:]
 923     dispatch[SETITEMS] = load_setitems
 924
 925     def load_build(self):
 926         stack = self.stack
 927         value = stack[-1]
 928         del stack[-1]
 929         inst = stack[-1]
 930         try:
 931             setstate = inst.__setstate__
 932         except AttributeError:
 933             try:
 934                 inst.__dict__.update(value)
 935             except RuntimeError:
 936                 # XXX In restricted execution, the instance's __dict__ is not
 937                 # accessible.  Use the old way of unpickling the instance
 938                 # variables.  This is a semantic different when unpickling in
 939                 # restricted vs. unrestricted modes.
 940                 for k, v in value.items():
 941                     setattr(inst, k, v)
 942         else:
 943             setstate(value)
 944     dispatch[BUILD] = load_build
 945
 946     def load_mark(self):
 947         self.append(self.mark)
 948     dispatch[MARK] = load_mark
 949
 950     def load_stop(self):
 951         value = self.stack[-1]
 952         del self.stack[-1]
 953         raise _Stop(value)
 954     dispatch[STOP] = load_stop
 955
 956 # Helper class for load_inst/load_obj
 957
 958 class _EmptyClass:
 959     pass
 960
 961 # Shorthands
 962
 963 try:
 964     from cStringIO import StringIO
 965 except ImportError:
 966     from StringIO import StringIO
 967
 968 def dump(object, file, bin = 0):
 969     Pickler(file, bin).dump(object)
 970
 971 def dumps(object, bin = 0):
 972     file = StringIO()
 973     Pickler(file, bin).dump(object)
 974     return file.getvalue()
 975
 976 def load(file):
 977     return Unpickler(file).load()
 978
 979 def loads(str):
 980     file = StringIO(str)
 981     return Unpickler(file).load()