Thread: [Jython-checkins] SF.net SVN: jython: [2760] trunk/jython/Lib

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 2760
Author:   fwierzbicki
Date:     2006-05-25 19:15:40 -0700 (Thu, 25 May 2006)
ViewCVS:  http://svn.sourceforge.net/jython/?rev=2760&view=rev

Log Message:
-----------
Start of 2.2 level pickle support.

Modified Paths:
--------------
    trunk/jython/Lib/test/test_datetime.py
    trunk/jython/Lib/test/test_subclasses.py
    trunk/jython/src/org/python/core/PyInteger.java
    trunk/jython/src/org/python/core/PyIntegerDerived.java

Added Paths:
-----------
    trunk/jython/Lib/pickle.py
Added: trunk/jython/Lib/pickle.py
===================================================================

--- trunk/jython/Lib/pickle.py	                        (rev 0)
+++ trunk/jython/Lib/pickle.py	2006-05-26 02:15:40 UTC (rev 2760)
@@ -0,0 +1,990 @@
+"""Create portable serialized representations of Python objects.
+
+See module cPickle for a (much) faster implementation.
+See module copy_reg for a mechanism for registering custom picklers.
+
+Classes:
+
+    Pickler
+    Unpickler
+
+Functions:
+
+    dump(object, file)
+    dumps(object) -> string
+    load(file) -> object
+    loads(string) -> object
+
+Misc variables:
+
+    __version__
+    format_version
+    compatible_formats
+
+"""
+
+__version__ = "$Revision: 1.56.4.4 $"       # Code version
+
+from types import *
+from copy_reg import dispatch_table, safe_constructors
+import marshal
+import sys
+import struct
+import re
+
+__all__ = ["PickleError", "PicklingError", "UnpicklingError", "Pickler",
+           "Unpickler", "dump", "dumps", "load", "loads"]
+
+format_version = "1.3"                     # File format version we write
+compatible_formats = ["1.0", "1.1", "1.2"] # Old format versions we can read
+
+mdumps = marshal.dumps
+mloads = marshal.loads
+
+class PickleError(Exception): pass
+class PicklingError(PickleError): pass
+class UnpicklingError(PickleError): pass
+
+class _Stop(Exception):
+    def __init__(self, value):
+        self.value = value
+
+try:
+    from org.python.core import PyStringMap
+except ImportError:
+    PyStringMap = None
+
+try:
+    UnicodeType
+except NameError:
+    UnicodeType = None
+
+
+MARK            = '('
+STOP            = '.'
+POP             = '0'
+POP_MARK        = '1'
+DUP             = '2'
+FLOAT           = 'F'
+INT             = 'I'
+BININT          = 'J'
+BININT1         = 'K'
+LONG            = 'L'
+BININT2         = 'M'
+NONE            = 'N'
+PERSID          = 'P'
+BINPERSID       = 'Q'
+REDUCE          = 'R'
+STRING          = 'S'
+BINSTRING       = 'T'
+SHORT_BINSTRING = 'U'
+UNICODE         = 'V'
+BINUNICODE      = 'X'
+APPEND          = 'a'
+BUILD           = 'b'
+GLOBAL          = 'c'
+DICT            = 'd'
+EMPTY_DICT      = '}'
+APPENDS         = 'e'
+GET             = 'g'
+BINGET          = 'h'
+INST            = 'i'
+LONG_BINGET     = 'j'
+LIST            = 'l'
+EMPTY_LIST      = ']'
+OBJ             = 'o'
+PUT             = 'p'
+BINPUT          = 'q'
+LONG_BINPUT     = 'r'
+SETITEM         = 's'
+TUPLE           = 't'
+EMPTY_TUPLE     = ')'
+SETITEMS        = 'u'
+BINFLOAT        = 'G'
+
+__all__.extend([x for x in dir() if re.match("[A-Z][A-Z0-9_]+$",x)])
+
+class Pickler:
+
+    def __init__(self, file, bin = 0):
+        self.write = file.write
+        self.memo = {}
+        self.bin = bin
+
+    def dump(self, object):
+        self.save(object)
+        self.write(STOP)
+
+    def put(self, i):
+        if self.bin:
+            s = mdumps(i)[1:]
+            if i < 256:
+                return BINPUT + s[0]
+
+            return LONG_BINPUT + s
+
+        return PUT + `i` + '\n'
+
+    def get(self, i):
+        if self.bin:
+            s = mdumps(i)[1:]
+
+            if i < 256:
+                return BINGET + s[0]
+
+            return LONG_BINGET + s
+
+        return GET + `i` + '\n'
+
+    def save(self, object, pers_save = 0):
+        memo = self.memo
+
+        if not pers_save:
+            pid = self.persistent_id(object)
+            if pid is not None:
+                self.save_pers(pid)
+                return
+
+        d = id(object)
+
+        t = type(object)
+
+        if (t is TupleType) and (len(object) == 0):
+            if self.bin:
+                self.save_empty_tuple(object)
+            else:
+                self.save_tuple(object)
+            return
+
+        if memo.has_key(d):
+            self.write(self.get(memo[d][0]))
+            return
+
+        try:
+            f = self.dispatch[t]
+        except KeyError:
+            pid = self.inst_persistent_id(object)
+            if pid is not None:
+                self.save_pers(pid)
+                return
+
+            try:
+                # XXX: TypeType comparison broken in Jython so Kludging around this for now.
+                #issc = issubclass(t, TypeType)
+                issc = str(t) == "<type 'type'>"
+            except TypeError: # t is not a class
+                issc = 0
+            if issc:
+                self.save_global(object)
+                return
+
+            try:
+                reduce = dispatch_table[t]
+            except KeyError:
+                try:
+                    reduce = object.__reduce__
+                except AttributeError:
+                    raise PicklingError, \
+                        "can't pickle %s object: %s" % (`t.__name__`,
+                                                         `object`)
+                else:
+                    tup = reduce()
+            else:
+                tup = reduce(object)
+
+            if type(tup) is StringType:
+                self.save_global(object, tup)
+                return
+
+            if type(tup) is not TupleType:
+                raise PicklingError, "Value returned by %s must be a " \
+                                     "tuple" % reduce
+
+            l = len(tup)
+
+            if (l != 2) and (l != 3):
+                raise PicklingError, "tuple returned by %s must contain " \
+                                     "only two or three elements" % reduce
+
+            callable = tup[0]
+            arg_tup  = tup[1]
+
+            if l > 2:
+                state = tup[2]
+            else:
+                state = None
+
+            if type(arg_tup) is not TupleType and arg_tup is not None:
+                raise PicklingError, "Second element of tuple returned " \
+                                     "by %s must be a tuple" % reduce
+
+            self.save_reduce(callable, arg_tup, state)
+            memo_len = len(memo)
+            self.write(self.put(memo_len))
+            memo[d] = (memo_len, object)
+            return
+
+        f(self, object)
+
+    def persistent_id(self, object):
+        return None
+
+    def inst_persistent_id(self, object):
+        return None
+
+    def save_pers(self, pid):
+        if not self.bin:
+            self.write(PERSID + str(pid) + '\n')
+        else:
+            self.save(pid, 1)
+            self.write(BINPERSID)
+
+    def save_reduce(self, callable, arg_tup, state = None):
+        write = self.write
+        save = self.save
+
+        save(callable)
+        save(arg_tup)
+        write(REDUCE)
+
+        if state is not None:
+            save(state)
+            write(BUILD)
+
+    dispatch = {}
+
+    def save_none(self, object):
+        self.write(NONE)
+    dispatch[NoneType] = save_none
+
+    def save_int(self, object):
+        if self.bin:
+            # If the int is small enough to fit in a signed 4-byte 2's-comp
+            # format, we can store it more efficiently than the general
+            # case.
+            high_bits = object >> 31  # note that Python shift sign-extends
+            if  high_bits == 0 or high_bits == -1:
+                # All high bits are copies of bit 2**31, so the value
+                # fits in a 4-byte signed int.
+                i = mdumps(object)[1:]
+                assert len(i) == 4
+                if i[-2:] == '\000\000':    # fits in 2-byte unsigned int
+                    if i[-3] == '\000':     # fits in 1-byte unsigned int
+                        self.write(BININT1 + i[0])
+                    else:
+                        self.write(BININT2 + i[:2])
+                else:
+                    self.write(BININT + i)
+                return
+        # Text pickle, or int too big to fit in signed 4-byte format.
+        self.write(INT + `object` + '\n')
+    dispatch[IntType] = save_int
+
+    def save_long(self, object):
+        self.write(LONG + `object` + '\n')
+    dispatch[LongType] = save_long
+
+    def save_float(self, object, pack=struct.pack):
+        if self.bin:
+            self.write(BINFLOAT + pack('>d', object))
+        else:
+            self.write(FLOAT + `object` + '\n')
+    dispatch[FloatType] = save_float
+
+    def save_string(self, object):
+        d = id(object)
+        memo = self.memo
+
+        if self.bin:
+            l = len(object)
+            s = mdumps(l)[1:]
+            if l < 256:
+                self.write(SHORT_BINSTRING + s[0] + object)
+            else:
+                self.write(BINSTRING + s + object)
+        else:
+            self.write(STRING + `object` + '\n')
+
+        memo_len = len(memo)
+        self.write(self.put(memo_len))
+        memo[d] = (memo_len, object)
+    dispatch[StringType] = save_string
+
+    def save_unicode(self, object):
+        d = id(object)
+        memo = self.memo
+
+        if self.bin:
+            encoding = object.encode('utf-8')
+            l = len(encoding)
+            s = mdumps(l)[1:]
+            self.write(BINUNICODE + s + encoding)
+        else:
+            object = object.replace("\\", "\\u005c")
+            object = object.replace("\n", "\\u000a")
+            self.write(UNICODE + object.encode('raw-unicode-escape') + '\n')
+
+        memo_len = len(memo)
+        self.write(self.put(memo_len))
+        memo[d] = (memo_len, object)
+    dispatch[UnicodeType] = save_unicode
+
+    if StringType == UnicodeType:
+        # This is true for Jython
+        def save_string(self, object):
+            d = id(object)
+            memo = self.memo
+            unicode = object.isunicode()
+
+            if self.bin:
+                if unicode:
+                    object = object.encode("utf-8")
+                l = len(object)
+                s = mdumps(l)[1:]
+                if l < 256 and not unicode:
+                    self.write(SHORT_BINSTRING + s[0] + object)
+                else:
+                    if unicode:
+                        self.write(BINUNICODE + s + object)
+                    else:
+                        self.write(BINSTRING + s + object)
+            else:
+                if unicode:
+                    object = object.replace("\\", "\\u005c")
+                    object = object.replace("\n", "\\u000a")
+                    object = object.encode('raw-unicode-escape')
+                    self.write(UNICODE + object + '\n')
+                else:
+                    self.write(STRING + `object` + '\n')
+
+            memo_len = len(memo)
+            self.write(self.put(memo_len))
+            memo[d] = (memo_len, object)
+        dispatch[StringType] = save_string
+
+    def save_tuple(self, object):
+
+        write = self.write
+        save  = self.save
+        memo  = self.memo
+
+        d = id(object)
+
+        write(MARK)
+
+        for element in object:
+            save(element)
+
+        if len(object) and memo.has_key(d):
+            if self.bin:
+                write(POP_MARK + self.get(memo[d][0]))
+                return
+
+            write(POP * (len(object) + 1) + self.get(memo[d][0]))
+            return
+
+        memo_len = len(memo)
+        self.write(TUPLE + self.put(memo_len))
+        memo[d] = (memo_len, object)
+    dispatch[TupleType] = save_tuple
+
+    def save_empty_tuple(self, object):
+        self.write(EMPTY_TUPLE)
+
+    def save_list(self, object):
+        d = id(object)
+
+        write = self.write
+        save  = self.save
+        memo  = self.memo
+
+        if self.bin:
+            write(EMPTY_LIST)
+        else:
+            write(MARK + LIST)
+
+        memo_len = len(memo)
+        write(self.put(memo_len))
+        memo[d] = (memo_len, object)
+
+        using_appends = (self.bin and (len(object) > 1))
+
+        if using_appends:
+            write(MARK)
+
+        for element in object:
+            save(element)
+
+            if not using_appends:
+                write(APPEND)
+
+        if using_appends:
+            write(APPENDS)
+    dispatch[ListType] = save_list
+
+    def save_dict(self, object):
+        d = id(object)
+
+        write = self.write
+        save  = self.save
+        memo  = self.memo
+
+        if self.bin:
+            write(EMPTY_DICT)
+        else:
+            write(MARK + DICT)
+
+        memo_len = len(memo)
+        self.write(self.put(memo_len))
+        memo[d] = (memo_len, object)
+
+        using_setitems = (self.bin and (len(object) > 1))
+
+        if using_setitems:
+            write(MARK)
+
+        items = object.items()
+        for key, value in items:
+            save(key)
+            save(value)
+
+            if not using_setitems:
+                write(SETITEM)
+
+        if using_setitems:
+            write(SETITEMS)
+
+    dispatch[DictionaryType] = save_dict
+    if not PyStringMap is None:
+        dispatch[PyStringMap] = save_dict
+
+    def save_inst(self, object):
+        d = id(object)
+        cls = object.__class__
+
+        memo  = self.memo
+        write = self.write
+        save  = self.save
+
+        if hasattr(object, '__getinitargs__'):
+            args = object.__getinitargs__()
+            len(args) # XXX Assert it's a sequence
+            _keep_alive(args, memo)
+        else:
+            args = ()
+
+        write(MARK)
+
+        if self.bin:
+            save(cls)
+
+        for arg in args:
+            save(arg)
+
+        memo_len = len(memo)
+        if self.bin:
+            write(OBJ + self.put(memo_len))
+        else:
+            write(INST + cls.__module__ + '\n' + cls.__name__ + '\n' +
+                self.put(memo_len))
+
+        memo[d] = (memo_len, object)
+
+        try:
+            getstate = object.__getstate__
+        except AttributeError:
+            stuff = object.__dict__
+        else:
+            stuff = getstate()
+            _keep_alive(stuff, memo)
+        save(stuff)
+        write(BUILD)
+    dispatch[InstanceType] = save_inst
+
+    def save_global(self, object, name = None):
+        write = self.write
+        memo = self.memo
+
+        if name is None:
+            name = object.__name__
+
+        try:
+            module = object.__module__
+        except AttributeError:
+            module = whichmodule(object, name)
+
+        try:
+            __import__(module)
+            mod = sys.modules[module]
+            klass = getattr(mod, name)
+        except (ImportError, KeyError, AttributeError):
+            raise PicklingError(
+                "Can't pickle %r: it's not found as %s.%s" %
+                (object, module, name))
+        else:
+            if klass is not object:
+                raise PicklingError(
+                    "Can't pickle %r: it's not the same object as %s.%s" %
+                    (object, module, name))
+
+        memo_len = len(memo)
+        write(GLOBAL + module + '\n' + name + '\n' +
+            self.put(memo_len))
+        memo[id(object)] = (memo_len, object)
+    dispatch[ClassType] = save_global
+    dispatch[FunctionType] = save_global
+    dispatch[BuiltinFunctionType] = save_global
+    dispatch[TypeType] = save_global
+
+
+def _keep_alive(x, memo):
+    """Keeps a reference to the object x in the memo.
+
+    Because we remember objects by their id, we have
+    to assure that possibly temporary objects are kept
+    alive by referencing them.
+    We store a reference at the id of the memo, which should
+    normally not be used unless someone tries to deepcopy
+    the memo itself...
+    """
+    try:
+        memo[id(memo)].append(x)
+    except KeyError:
+        # aha, this is the first one :-)
+        memo[id(memo)]=[x]
+
+
+classmap = {} # called classmap for backwards compatibility
+
+def whichmodule(func, funcname):
+    """Figure out the module in which a function occurs.
+
+    Search sys.modules for the module.
+    Cache in classmap.
+    Return a module name.
+    If the function cannot be found, return __main__.
+    """
+    if classmap.has_key(func):
+        return classmap[func]
+
+    for name, module in sys.modules.items():
+        if module is None:
+            continue # skip dummy package entries
+        if name != '__main__' and \
+            hasattr(module, funcname) and \
+            getattr(module, funcname) is func:
+            break
+    else:
+        name = '__main__'
+    classmap[func] = name
+    return name
+
+
+class Unpickler:
+
+    def __init__(self, file):
+        self.readline = file.readline
+        self.read = file.read
+        self.memo = {}
+
+    def load(self):
+        self.mark = object() # any new unique object
+        self.stack = []
+        self.append = self.stack.append
+        read = self.read
+        dispatch = self.dispatch
+        try:
+            while 1:
+                key = read(1)
+                dispatch[key](self)
+        except _Stop, stopinst:
+            return stopinst.value
+
+    def marker(self):
+        stack = self.stack
+        mark = self.mark
+        k = len(stack)-1
+        while stack[k] is not mark: k = k-1
+        return k
+
+    dispatch = {}
+
+    def load_eof(self):
+        raise EOFError
+    dispatch[''] = load_eof
+
+    def load_persid(self):
+        pid = self.readline()[:-1]
+        self.append(self.persistent_load(pid))
+    dispatch[PERSID] = load_persid
+
+    def load_binpersid(self):
+        stack = self.stack
+
+        pid = stack[-1]
+        del stack[-1]
+
+        self.append(self.persistent_load(pid))
+    dispatch[BINPERSID] = load_binpersid
+
+    def load_none(self):
+        self.append(None)
+    dispatch[NONE] = load_none
+
+    def load_int(self):
+        data = self.readline()
+        try:
+            self.append(int(data))
+        except ValueError:
+            self.append(long(data))
+    dispatch[INT] = load_int
+
+    def load_binint(self):
+        self.append(mloads('i' + self.read(4)))
+    dispatch[BININT] = load_binint
+
+    def load_binint1(self):
+        self.append(mloads('i' + self.read(1) + '\000\000\000'))
+    dispatch[BININT1] = load_binint1
+
+    def load_binint2(self):
+        self.append(mloads('i' + self.read(2) + '\000\000'))
+    dispatch[BININT2] = load_binint2
+
+    def load_long(self):
+        self.append(long(self.readline()[:-1], 0))
+    dispatch[LONG] = load_long
+
+    def load_float(self):
+        self.append(float(self.readline()[:-1]))
+    dispatch[FLOAT] = load_float
+
+    def load_binfloat(self, unpack=struct.unpack):
+        self.append(unpack('>d', self.read(8))[0])
+    dispatch[BINFLOAT] = load_binfloat
+
+    def load_string(self):
+        rep = self.readline()[:-1]
+        if not self._is_string_secure(rep):
+            raise ValueError, "insecure string pickle"
+        self.append(eval(rep,
+                         {'__builtins__': {}})) # Let's be careful
+    dispatch[STRING] = load_string
+
+    def _is_string_secure(self, s):
+        """Return true if s contains a string that is safe to eval
+
+        The definition of secure string is based on the implementation
+        in cPickle.  s is secure as long as it only contains a quoted
+        string and optional trailing whitespace.
+        """
+        q = s[0]
+        if q not in ("'", '"'):
+            return 0
+        # find the closing quote
+        offset = 1
+        i = None
+        while 1:
+            try:
+                i = s.index(q, offset)
+            except ValueError:
+                # if there is an error the first time, there is no
+                # close quote
+                if offset == 1:
+                    return 0
+            if s[i-1] != '\\':
+                break
+            # check to see if this one is escaped
+            nslash = 0
+            j = i - 1
+            while j >= offset and s[j] == '\\':
+                j = j - 1
+                nslash = nslash + 1
+            if nslash % 2 == 0:
+                break
+            offset = i + 1
+        for c in s[i+1:]:
+            if ord(c) > 32:
+                return 0
+        return 1
+
+    def load_binstring(self):
+        len = mloads('i' + self.read(4))
+        self.append(self.read(len))
+    dispatch[BINSTRING] = load_binstring
+
+    def load_unicode(self):
+        self.append(unicode(self.readline()[:-1],'raw-unicode-escape'))
+    dispatch[UNICODE] = load_unicode
+
+    def load_binunicode(self):
+        len = mloads('i' + self.read(4))
+        self.append(unicode(self.read(len),'utf-8'))
+    dispatch[BINUNICODE] = load_binunicode
+
+    def load_short_binstring(self):
+        len = mloads('i' + self.read(1) + '\000\000\000')
+        self.append(self.read(len))
+    dispatch[SHORT_BINSTRING] = load_short_binstring
+
+    def load_tuple(self):
+        k = self.marker()
+        self.stack[k:] = [tuple(self.stack[k+1:])]
+    dispatch[TUPLE] = load_tuple
+
+    def load_empty_tuple(self):
+        self.stack.append(())
+    dispatch[EMPTY_TUPLE] = load_empty_tuple
+
+    def load_empty_list(self):
+        self.stack.append([])
+    dispatch[EMPTY_LIST] = load_empty_list
+
+    def load_empty_dictionary(self):
+        self.stack.append({})
+    dispatch[EMPTY_DICT] = load_empty_dictionary
+
+    def load_list(self):
+        k = self.marker()
+        self.stack[k:] = [self.stack[k+1:]]
+    dispatch[LIST] = load_list
+
+    def load_dict(self):
+        k = self.marker()
+        d = {}
+        items = self.stack[k+1:]
+        for i in range(0, len(items), 2):
+            key = items[i]
+            value = items[i+1]
+            d[key] = value
+        self.stack[k:] = [d]
+    dispatch[DICT] = load_dict
+
+    def load_inst(self):
+        k = self.marker()
+        args = tuple(self.stack[k+1:])
+        del self.stack[k:]
+        module = self.readline()[:-1]
+        name = self.readline()[:-1]
+        klass = self.find_class(module, name)
+        instantiated = 0
+        if (not args and type(klass) is ClassType and
+            not hasattr(klass, "__getinitargs__")):
+            try:
+                value = _EmptyClass()
+                value.__class__ = klass
+                instantiated = 1
+            except RuntimeError:
+                # In restricted execution, assignment to inst.__class__ is
+                # prohibited
+                pass
+        if not instantiated:
+            try:
+                #XXX: This test is deprecated in 2.3, so commenting out.
+                #if not hasattr(klass, '__safe_for_unpickling__'):
+                #    raise UnpicklingError('%s is not safe for unpickling' %
+                #                          klass)
+                value = apply(klass, args)
+            except TypeError, err:
+                raise TypeError, "in constructor for %s: %s" % (
+                    klass.__name__, str(err)), sys.exc_info()[2]
+        self.append(value)
+    dispatch[INST] = load_inst
+
+    def load_obj(self):
+        stack = self.stack
+        k = self.marker()
+        klass = stack[k + 1]
+        del stack[k + 1]
+        args = tuple(stack[k + 1:])
+        del stack[k:]
+        instantiated = 0
+        if (not args and type(klass) is ClassType and
+            not hasattr(klass, "__getinitargs__")):
+            try:
+                value = _EmptyClass()
+                value.__class__ = klass
+                instantiated = 1
+            except RuntimeError:
+                # In restricted execution, assignment to inst.__class__ is
+                # prohibited
+                pass
+        if not instantiated:
+            value = apply(klass, args)
+        self.append(value)
+    dispatch[OBJ] = load_obj
+
+    def load_global(self):
+        module = self.readline()[:-1]
+        name = self.readline()[:-1]
+        klass = self.find_class(module, name)
+        self.append(klass)
+    dispatch[GLOBAL] = load_global
+
+    def find_class(self, module, name):
+        __import__(module)
+        mod = sys.modules[module]
+        klass = getattr(mod, name)
+        return klass
+
+    def load_reduce(self):
+        stack = self.stack
+
+        callable = stack[-2]
+        arg_tup  = stack[-1]
+        del stack[-2:]
+
+        #XXX: The __safe_for_unpickling__ test is deprecated in 2.3, so commenting out.
+        #if type(callable) is not ClassType:
+            #if not safe_constructors.has_key(callable):
+                #try:
+                #    safe = callable.__safe_for_unpickling__
+                #except AttributeError:
+                #    safe = None
+                #
+                #if not safe:
+                #    raise UnpicklingError, "%s is not safe for " \
+                #                           "unpickling" % callable
+
+        if arg_tup is None:
+            value = callable.__basicnew__()
+        else:
+            value = apply(callable, arg_tup)
+        self.append(value)
+    dispatch[REDUCE] = load_reduce
+
+    def load_pop(self):
+        del self.stack[-1]
+    dispatch[POP] = load_pop
+
+    def load_pop_mark(self):
+        k = self.marker()
+        del self.stack[k:]
+    dispatch[POP_MARK] = load_pop_mark
+
+    def load_dup(self):
+        self.append(self.stack[-1])
+    dispatch[DUP] = load_dup
+
+    def load_get(self):
+        self.append(self.memo[self.readline()[:-1]])
+    dispatch[GET] = load_get
+
+    def load_binget(self):
+        i = mloads('i' + self.read(1) + '\000\000\000')
+        self.append(self.memo[`i`])
+    dispatch[BINGET] = load_binget
+
+    def load_long_binget(self):
+        i = mloads('i' + self.read(4))
+        self.append(self.memo[`i`])
+    dispatch[LONG_BINGET] = load_long_binget
+
+    def load_put(self):
+        self.memo[self.readline()[:-1]] = self.stack[-1]
+    dispatch[PUT] = load_put
+
+    def load_binput(self):
+        i = mloads('i' + self.read(1) + '\000\000\000')
+        self.memo[`i`] = self.stack[-1]
+    dispatch[BINPUT] = load_binput
+
+    def load_long_binput(self):
+        i = mloads('i' + self.read(4))
+        self.memo[`i`] = self.stack[-1]
+    dispatch[LONG_BINPUT] = load_long_binput
+
+    def load_append(self):
+        stack = self.stack
+        value = stack[-1]
+        del stack[-1]
+        list = stack[-1]
+        list.append(value)
+    dispatch[APPEND] = load_append
+
+    def load_appends(self):
+        stack = self.stack
+        mark = self.marker()
+        list = stack[mark - 1]
+        for i in range(mark + 1, len(stack)):
+            list.append(stack[i])
+
+        del stack[mark:]
+    dispatch[APPENDS] = load_appends
+
+    def load_setitem(self):
+        stack = self.stack
+        value = stack[-1]
+        key = stack[-2]
+        del stack[-2:]
+        dict = stack[-1]
+        dict[key] = value
+    dispatch[SETITEM] = load_setitem
+
+    def load_setitems(self):
+        stack = self.stack
+        mark = self.marker()
+        dict = stack[mark - 1]
+        for i in range(mark + 1, len(stack), 2):
+            dict[stack[i]] = stack[i + 1]
+
+        del stack[mark:]
+    dispatch[SETITEMS] = load_setitems
+
+    def load_build(self):
+        stack = self.stack
+        value = stack[-1]
+        del stack[-1]
+        inst = stack[-1]
+        try:
+            setstate = inst.__setstate__
+        except AttributeError:
+            try:
+                inst.__dict__.update(value)
+            except RuntimeError:
+                # XXX In restricted execution, the instance's __dict__ is not
+                # accessible.  Use the old way of unpickling the instance
+                # variables.  This is a semantic different when unpickling in
+                # restricted vs. unrestricted modes.
+                for k, v in value.items():
+                    setattr(inst, k, v)
+        else:
+            setstate(value)
+    dispatch[BUILD] = load_build
+
+    def load_mark(self):
+        self.append(self.mark)
+    dispatch[MARK] = load_mark
+
+    def load_stop(self):
+        value = self.stack[-1]
+        del self.stack[-1]
+        raise _Stop(value)
+    dispatch[STOP] = load_stop
+
+# Helper class for load_inst/load_obj
+
+class _EmptyClass:
+    pass
+
+# Shorthands
+
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from StringIO import StringIO
+
+def dump(object, file, bin = 0):
+    Pickler(file, bin).dump(object)
+
+def dumps(object, bin = 0):
+    file = StringIO()
+    Pickler(file, bin).dump(object)
+    return file.getvalue()
+
+def load(file):
+    return Unpickler(file).load()
+
+def loads(str):
+    file = StringIO(str)
+    return Unpickler(file).load()

Modified: trunk/jython/Lib/test/test_datetime.py
===================================================================
--- trunk/jython/Lib/test/test_datetime.py	2006-05-24 17:16:28 UTC (rev 2759)
+++ trunk/jython/Lib/test/test_datetime.py	2006-05-26 02:15:40 UTC (rev 2760)
@@ -15,11 +15,12 @@
 from datetime import date, datetime
 
 # Before Python 2.3, proto=2 was taken as a synonym for proto=1.
+# cPickle not updated in Jython so commenting out.
 pickle_choices = [(pickler, unpickler, proto)
-                  for pickler in pickle, cPickle
-                  for unpickler in pickle, cPickle
+                  for pickler in pickle, #cPickle
+                  for unpickler in pickle, #cPickle
                   for proto in range(3)]
-assert len(pickle_choices) == 2*2*3
+#assert len(pickle_choices) == 2*2*3
 
 # An arbitrary collection of objects of non-datetime types, for testing
 # mixed-type comparisons.
@@ -96,7 +97,7 @@
             self.assertEqual(fo.dst(dt), timedelta(minutes=42))
 
     #XXX: pickling not working for jython yet.
-    def _test_pickling_base(self):
+    def test_pickling_base(self):
         # There's no point to pickling tzinfo objects on their own (they
         # carry no data), but they need to be picklable anyway else
         # concrete subclasses can't be pickled.
@@ -108,7 +109,7 @@
                 self.failUnless(type(derived) is tzinfo)
 
     #XXX: pickling not working for jython yet.
-    def _test_pickling_subclass(self):
+    def test_pickling_subclass(self):
         # Make sure we can pickle/unpickle an instance of a subclass.
         offset = timedelta(minutes=-300)
         orig = PicklableFixedOffset(offset, 'cookie')
@@ -298,7 +299,7 @@
         self.assertEqual(d[t1], 2)
 
     #XXX: pickling not working for jython yet.
-    def _test_pickling(self):
+    def test_pickling(self):
         args = 12, 34, 56
         orig = timedelta(*args)
         for pickler, unpickler, proto in pickle_choices:
@@ -852,7 +853,7 @@
             self.assertEqual(t.tm_isdst, -1)
 
     #XXX: pickling not working for jython yet.
-    def _test_pickling(self):
+    def test_pickling(self):
         args = 6, 7, 23
         orig = self.theclass(*args)
         for pickler, unpickler, proto in pickle_choices:
@@ -1205,7 +1206,7 @@
         self.assertRaises(TypeError, lambda: a + a)
 
     #XXX: pickling not working for jython yet.
-    def _test_pickling(self):
+    def test_pickling(self):
         args = 6, 7, 23, 20, 59, 1, 64**2
         orig = self.theclass(*args)
         for pickler, unpickler, proto in pickle_choices:
@@ -1214,7 +1215,7 @@
             self.assertEqual(orig, derived)
 
     #XXX: pickling not working for jython yet.
-    def _test_more_pickling(self):
+    def test_more_pickling(self):
         a = self.theclass(2003, 2, 7, 16, 48, 37, 444116)
         s = pickle.dumps(a)
         b = pickle.loads(s)
@@ -1592,7 +1593,7 @@
         self.assert_(self.theclass.max > self.theclass.min)
 
     #XXX: pickling not working for jython yet.
-    def _test_pickling(self):
+    def test_pickling(self):
         args = 20, 59, 16, 64**2
         orig = self.theclass(*args)
         for pickler, unpickler, proto in pickle_choices:
@@ -1900,7 +1901,7 @@
         self.assertEqual(hash(t1), hash(t2))
 
     #XXX: pickling not working for jython yet.
-    def _test_pickling(self):
+    def test_pickling(self):
         # Try one without a tzinfo.
         args = 20, 59, 16, 64**2
         orig = self.theclass(*args)
@@ -2101,7 +2102,7 @@
         self.assertRaises(ValueError, lambda: t1 == t2)
 
     #XXX: pickling not working for jython yet.
-    def _test_pickling(self):
+    def test_pickling(self):
         # Try one without a tzinfo.
         args = 6, 7, 23, 20, 59, 1, 64**2
         orig = self.theclass(*args)

Modified: trunk/jython/Lib/test/test_subclasses.py
===================================================================
--- trunk/jython/Lib/test/test_subclasses.py	2006-05-24 17:16:28 UTC (rev 2759)
+++ trunk/jython/Lib/test/test_subclasses.py	2006-05-26 02:15:40 UTC (rev 2760)
@@ -128,7 +128,12 @@
         self.assertEqual(SubSubStrSpam().eggs(), "I am eggs.")
         self.assertEqual(SubSubStrSpam2().eggs(), "I am eggs.")
 
+    def test_pickle_builtins(self):
+       class myint(int):
+            def __init__(self, x):
+                self.str = str(x)
 
+ 
 def test_suite():
     allsuites = [unittest.makeSuite(klass, 'test')
                  for klass in (TestSubclasses,

Modified: trunk/jython/src/org/python/core/PyInteger.java
===================================================================
--- trunk/jython/src/org/python/core/PyInteger.java	2006-05-24 17:16:28 UTC (rev 2759)
+++ trunk/jython/src/org/python/core/PyInteger.java	2006-05-26 02:15:40 UTC (rev 2760)
@@ -1058,6 +1058,34 @@
 
         }
         dict.__setitem__("__nonzero__",new PyMethodDescr("__nonzero__",PyInteger.class,0,0,new exposed___nonzero__(null,null)));
+        class exposed___reduce__ extends PyBuiltinFunctionNarrow {
+
+            private PyInteger self;
+
+            public PyObject getSelf() {
+                return self;
+            }
+
+            exposed___reduce__(PyInteger self,PyBuiltinFunction.Info info) {
+                super(info);
+                this.self=self;
+            }
+
+            public PyBuiltinFunction makeBound(PyObject self) {
+                return new exposed___reduce__((PyInteger)self,info);
+            }
+
+            public PyObject __call__() {
+                return self.int___reduce__();
+            }
+
+            public PyObject inst_call(PyObject gself) {
+                PyInteger self=(PyInteger)gself;
+                return self.int___reduce__();
+            }
+
+        }
+        dict.__setitem__("__reduce__",new PyMethodDescr("__reduce__",PyInteger.class,0,0,new exposed___reduce__(null,null)));
         class exposed___repr__ extends PyBuiltinFunctionNarrow {
 
             private PyInteger self;
@@ -1782,4 +1810,22 @@
     public int asInt(int index) throws PyObject.ConversionException {
         return getValue();
     }
+
+    /**
+     * Used for pickling.
+     *
+     * @return a tuple of (class, (Integer))
+     */
+    public PyObject __reduce__() {
+        return int___reduce__();
+    }
+
+    public PyObject int___reduce__() {
+        return new PyTuple(new PyObject[]{
+            getType(),
+            new PyTuple(new PyObject[]{
+                new PyString(int_toString())
+            })
+        });
+    }
 }

Modified: trunk/jython/src/org/python/core/PyIntegerDerived.java
===================================================================
--- trunk/jython/src/org/python/core/PyIntegerDerived.java	2006-05-24 17:16:28 UTC (rev 2759)
+++ trunk/jython/src/org/python/core/PyIntegerDerived.java	2006-05-26 02:15:40 UTC (rev 2760)
@@ -12,9 +12,8 @@
         return dict;
     }
 
-    //XXX: hand modified to pass v into super
-    public PyIntegerDerived(PyType subtype, int v) {
-        super(subtype, v);
+    public PyIntegerDerived(PyType subtype,int v) {
+        super(subtype,v);
         dict=subtype.instDict();
     }
 
@@ -42,6 +41,18 @@
         return super.__repr__();
     }
 
+    public PyUnicode __unicode__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__unicode__");
+        if (impl!=null) {
+            PyObject res=impl.__get__(this,self_type).__call__();
+            if (res instanceof PyUnicode)
+                return(PyUnicode)res;
+            throw Py.TypeError("__unicode__"+" should return a "+"unicode");
+        }
+        return super.__unicode__();
+    }
+
     public PyString __hex__() {
         PyType self_type=getType();
         PyObject impl=self_type.lookup("__hex__");
@@ -146,6 +157,19 @@
         return super.__invert__();
     }
 
+    public PyObject __reduce__() {
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__reduce__");
+        if (impl!=null)
+            return impl.__get__(this,self_type).__call__();
+        return new PyTuple(new PyObject[]{
+            getType(),
+            new PyTuple(new PyObject[]{
+                new PyString("x")
+            })
+        });
+    }
+
     public PyObject __add__(PyObject other) {
         PyType self_type=getType();
         PyObject impl=self_type.lookup("__add__");
@@ -779,6 +803,35 @@
         super.__setitem__(key,value);
     }
 
+    public PyObject __getitem__(PyObject key) { // ???
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__getitem__");
+        if (impl!=null) {
+            try {
+                return impl.__get__(this,self_type).__call__(key);
+            } catch (PyException exc) {
+                if (Py.matchException(exc,Py.LookupError))
+                    return null;
+                throw exc;
+            }
+        }
+        return super.__getitem__(key);
+    }
+
+    public PyObject __getslice__(PyObject start,PyObject stop,PyObject step) { // ???
+        PyType self_type=getType();
+        PyObject impl=self_type.lookup("__getslice__");
+        if (impl!=null)
+            try {
+                return impl.__get__(this,self_type).__call__(start,stop);
+            } catch (PyException exc) {
+                if (Py.matchException(exc,Py.LookupError))
+                    return null;
+                throw exc;
+            }
+        return super.__getslice__(start,stop,step);
+    }
+
     public void __delitem__(PyObject key) { // ???
         PyType self_type=getType();
         PyObject impl=self_type.lookup("__delitem__");


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.





Thread: [Jython-checkins] SF.net SVN: jython: [2760] trunk/jython/Lib

jython-checkins