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