def restore(self, obj):
"""Restores a flattened object to its original python state.
Simply returns any of the basic builtin types
>>> u = Unpickler()
>>> u.restore('hello world')
'hello world'
>>> u.restore({'key': 'value'})
{'key': 'value'}
"""
self._push()
if has_tag(obj, tags.ID):
return self._pop(self._objs[obj[tags.ID]])
if has_tag(obj, tags.REF):
return self._pop(self._namedict.get(obj[tags.REF]))
if has_tag(obj, tags.TYPE):
typeref = loadclass(obj[tags.TYPE])
if not typeref:
return self._pop(obj)
return self._pop(typeref)
if has_tag(obj, tags.REPR):
return self._pop(loadrepr(obj[tags.REPR]))
if has_tag(obj, tags.OBJECT):
cls = loadclass(obj[tags.OBJECT])
if not cls:
return self._pop(obj)
# check custom handlers
HandlerClass = handlers.registry.get(cls)
if HandlerClass:
handler = HandlerClass(self)
return self._pop(handler.restore(obj))
try:
if hasattr(cls, '__new__'):
instance = cls.__new__(cls)
else:
instance = object.__new__(cls)
except TypeError:
# old-style classes
try:
instance = cls()
except TypeError:
# fail gracefully if the constructor requires arguments
self._mkref(obj)
return self._pop(obj)
# keep a obj->name mapping for use in the _isobjref() case
self._mkref(instance)
if hasattr(instance, '__setstate__') and has_tag(obj, tags.STATE):
state = self.restore(obj[tags.STATE])
instance.__setstate__(state)
return self._pop(instance)
for k, v in sorted(obj.iteritems(), key=operator.itemgetter(0)):
# ignore the reserved attribute
if k in tags.RESERVED:
continue
self._namestack.append(k)
# step into the namespace
value = self.restore(v)
if (util.is_noncomplex(instance) or
util.is_dictionary_subclass(instance)):
instance[k] = value
else:
setattr(instance, k, value)
# step out
self._namestack.pop()
# Handle list and set subclasses
if has_tag(obj, tags.SEQ):
if hasattr(instance, 'append'):
for v in obj[tags.SEQ]:
instance.append(self.restore(v))
if hasattr(instance, 'add'):
for v in obj[tags.SEQ]:
instance.add(self.restore(v))
return self._pop(instance)
if util.is_list(obj):
return self._pop([self.restore(v) for v in obj])
if has_tag(obj, tags.TUPLE):
return self._pop(tuple([self.restore(v) for v in obj[tags.TUPLE]]))
if has_tag(obj, tags.SET):
return self._pop(set([self.restore(v) for v in obj[tags.SET]]))
if util.is_dictionary(obj):
data = {}
for k, v in sorted(obj.iteritems(), key=operator.itemgetter(0)):
self._namestack.append(k)
data[k] = self.restore(v)
self._namestack.pop()
return self._pop(data)
return self._pop(obj)
"""The jsonpickle.tags module provides the custom tags used for pickling and unpickling Python objects. These tags are keys into the flattened dictionaries created by the Pickler class. The Unpickler uses these custom key names to identify dictionaries that need to be specially handled. """ from jsonpickle.compat import set # @UnresolvedImport ID = 'py/id' OBJECT = 'py/object' TYPE = 'py/type' REPR = 'py/repr' REF = 'py/ref' TUPLE = 'py/tuple' SET = 'py/set' SEQ = 'py/seq' STATE = 'py/state' JSON_KEY = 'json://' # All reserved tag names RESERVED = set([OBJECT, TYPE, REPR, REF, TUPLE, SET, SEQ, STATE])
NEWOBJ = 'py/newobj'
OBJECT = 'py/object'
REDUCE = 'py/reduce'
REF = 'py/ref'
REPR = 'py/repr'
SEQ = 'py/seq'
SET = 'py/set'
STATE = 'py/state'
TUPLE = 'py/tuple'
TYPE = 'py/type'
# All reserved tag names
RESERVED = set([
FUNCTION,
ID,
INITARGS,
ITERATOR,
NEWARGS,
NEWARGSEX,
NEWOBJ,
OBJECT,
REDUCE,
REF,
REPR,
SEQ,
SET,
STATE,
TUPLE,
TYPE,
])
import operator
import time
import types
import inspect
from jsonpickle import tags
from jsonpickle.compat import set
from jsonpickle.compat import unicode
from jsonpickle.compat import long
from jsonpickle.compat import PY3
if not PY3:
import __builtin__
SEQUENCES = (list, set, tuple)
SEQUENCES_SET = set(SEQUENCES)
PRIMITIVES = set((str, unicode, bool, float, int, long))
def is_type(obj):
"""Returns True is obj is a reference to a type.
>>> is_type(1)
False
>>> is_type(object)
True
>>> class Klass: pass
>>> is_type(Klass)
True
import base64
import collections
import io
import operator
import time
import types
import inspect
from jsonpickle import tags
from jsonpickle.compat import set, unicode, long, bytes, PY3
if not PY3:
import __builtin__
SEQUENCES = (list, set, tuple)
SEQUENCES_SET = set(SEQUENCES)
PRIMITIVES = set((unicode, bool, float, int, long))
def is_type(obj):
"""Returns True is obj is a reference to a type.
>>> is_type(1)
False
>>> is_type(object)
True
>>> class Klass: pass
>>> is_type(Klass)
True
NEWOBJ = 'py/newobj'
OBJECT = 'py/object'
REDUCE = 'py/reduce'
REF = 'py/ref'
REPR = 'py/repr'
SEQ = 'py/seq'
SET = 'py/set'
STATE = 'py/state'
TUPLE = 'py/tuple'
TYPE = 'py/type'
# All reserved tag names
RESERVED = set([
FUNCTION,
ID,
INITARGS,
ITERATOR,
NEWARGS,
NEWARGSEX,
NEWOBJ,
OBJECT,
REDUCE,
REF,
REPR,
SEQ,
SET,
STATE,
TUPLE,
TYPE,
])
def _restore_set(self, obj):
return set([self._restore(v) for v in obj[tags.SET]])
"""The jsonpickle.tags module provides the custom tags used for pickling and unpickling Python objects. These tags are keys into the flattened dictionaries created by the Pickler class. The Unpickler uses these custom key names to identify dictionaries that need to be specially handled. """ from jsonpickle.compat import set # @UnresolvedImport ID = 'py/id' OBJECT = 'py/object' TYPE = 'py/type' REPR = 'py/repr' REF = 'py/ref' TUPLE = 'py/tuple' SET = 'py/set' SEQ = 'py/seq' STATE = 'py/state' JSON_KEY = 'json://' # All reserved tag names RESERVED = set([OBJECT, TYPE, REPR, REF, TUPLE, SET, SEQ, STATE])
def _restore_set(self, obj):
return set([self._restore(v) for v in obj[tags.SET]])
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
"""Helper functions for pickling and unpickling. Most functions assist in
determining the type of an object.
"""
import time
import types
from jsonpickle import tags
from jsonpickle.compat import set
from jsonpickle.compat import str, int
COLLECTIONS = (list, set, tuple)
COLLECTIONS_SET = set(COLLECTIONS)
PRIMITIVES = set((str, str, bool, float, int, int))
def is_type(obj):
"""Returns True is obj is a reference to a type.
>>> is_type(1)
False
>>> is_type(object)
True
>>> class Klass: pass
>>> is_type(Klass)
True
def restore(self, obj):
"""Restores a flattened object to its original python state.
Simply returns any of the basic builtin types
>>> u = Unpickler()
>>> u.restore('hello world')
'hello world'
>>> u.restore({'key': 'value'})
{'key': 'value'}
"""
self._push()
if has_tag(obj, tags.ID):
return self._pop(self._objs[obj[tags.ID]])
# Backwards compatibility
if has_tag(obj, tags.REF):
return self._pop(self._namedict.get(obj[tags.REF]))
if has_tag(obj, tags.TYPE):
typeref = loadclass(obj[tags.TYPE])
if not typeref:
return self._pop(obj)
return self._pop(typeref)
# Backwards compatibility
if has_tag(obj, tags.REPR):
obj = loadrepr(obj[tags.REPR])
return self._pop(self._mkref(obj))
if has_tag(obj, tags.OBJECT):
cls = loadclass(obj[tags.OBJECT])
if not cls:
return self._pop(self._mkref(obj))
# check custom handlers
HandlerClass = handlers.registry.get(cls)
if HandlerClass:
handler = HandlerClass(self)
instance = handler.restore(obj)
return self._pop(self._mkref(instance))
factory = loadfactory(obj)
args = getargs(obj)
if args:
args = self.restore(args)
try:
if hasattr(cls, '__new__'):
# new style classes
if factory:
instance = cls.__new__(cls, factory, *args)
instance.default_factory = factory
else:
instance = cls.__new__(cls, *args)
else:
instance = object.__new__(cls)
except TypeError:
# old-style classes
try:
instance = cls()
except TypeError:
# fail gracefully if the constructor requires arguments
return self._pop(self._mkref(obj))
# Add to the instance table to allow being referenced by a
# downstream object
self._mkref(instance)
if hasattr(instance, '__setstate__') and has_tag(obj, tags.STATE):
state = self.restore(obj[tags.STATE])
instance.__setstate__(state)
return self._pop(instance)
for k, v in sorted(obj.items(), key=operator.itemgetter(0)):
# ignore the reserved attribute
if k in tags.RESERVED:
continue
self._namestack.append(k)
# step into the namespace
value = self.restore(v)
if (util.is_noncomplex(instance) or
util.is_dictionary_subclass(instance)):
instance[k] = value
else:
setattr(instance, k, value)
# step out
self._namestack.pop()
# Handle list and set subclasses
if has_tag(obj, tags.SEQ):
if hasattr(instance, 'append'):
for v in obj[tags.SEQ]:
instance.append(self.restore(v))
if hasattr(instance, 'add'):
for v in obj[tags.SEQ]:
instance.add(self.restore(v))
return self._pop(instance)
if util.is_list(obj):
parent = []
self._mkref(parent)
children = [self.restore(v) for v in obj]
parent.extend(children)
return self._pop(parent)
if has_tag(obj, tags.TUPLE):
return self._pop(tuple([self.restore(v)
for v in obj[tags.TUPLE]]))
if has_tag(obj, tags.SET):
return self._pop(set([self.restore(v)
for v in obj[tags.SET]]))
if util.is_dictionary(obj):
data = {}
for k, v in sorted(obj.items(), key=operator.itemgetter(0)):
self._namestack.append(k)
data[k] = self.restore(v)
self._namestack.pop()
return self._pop(data)
return self._pop(obj)
def restore(self, obj):
"""Restores a flattened object to its original python state.
Simply returns any of the basic builtin types
>>> u = Unpickler()
>>> u.restore('hello world')
'hello world'
>>> u.restore({'key': 'value'})
{'key': 'value'}
"""
self._push()
if has_tag(obj, tags.ID):
return self._pop(self._objs[obj[tags.ID]])
# Backwards compatibility
if has_tag(obj, tags.REF):
return self._pop(self._namedict.get(obj[tags.REF]))
if has_tag(obj, tags.TYPE):
typeref = loadclass(obj[tags.TYPE])
if not typeref:
return self._pop(obj)
return self._pop(typeref)
# Backwards compatibility
if has_tag(obj, tags.REPR):
obj = loadrepr(obj[tags.REPR])
return self._pop(self._mkref(obj))
if has_tag(obj, tags.OBJECT):
cls = loadclass(obj[tags.OBJECT])
if not cls:
return self._pop(self._mkref(obj))
# check custom handlers
HandlerClass = handlers.BaseHandler._registry.get(cls)
if HandlerClass:
handler = HandlerClass(self)
instance = handler.restore(obj)
return self._pop(self._mkref(instance))
factory = loadfactory(obj)
args = getargs(obj)
if args:
args = self.restore(args)
try:
if hasattr(cls, '__new__'):
# new style classes
if factory:
instance = cls.__new__(cls, factory, *args)
instance.default_factory = factory
else:
instance = cls.__new__(cls, *args)
else:
instance = object.__new__(cls)
except TypeError:
# old-style classes
try:
instance = cls()
except TypeError:
# fail gracefully if the constructor requires arguments
return self._pop(self._mkref(obj))
# Add to the instance table to allow being referenced by a
# downstream object
self._mkref(instance)
if isinstance(instance, tuple):
return self._pop(instance)
if hasattr(instance, '__setstate__') and has_tag(obj, tags.STATE):
state = self.restore(obj[tags.STATE])
instance.__setstate__(state)
return self._pop(instance)
for k, v in sorted(obj.items(), key=operator.itemgetter(0)):
# ignore the reserved attribute
if k in tags.RESERVED:
continue
self._namestack.append(k)
# step into the namespace
value = self.restore(v)
if (util.is_noncomplex(instance)
or util.is_dictionary_subclass(instance)):
instance[k] = value
else:
setattr(instance, k, value)
# step out
self._namestack.pop()
# Handle list and set subclasses
if has_tag(obj, tags.SEQ):
if hasattr(instance, 'append'):
for v in obj[tags.SEQ]:
instance.append(self.restore(v))
if hasattr(instance, 'add'):
for v in obj[tags.SEQ]:
instance.add(self.restore(v))
return self._pop(instance)
if util.is_list(obj):
parent = []
self._mkref(parent)
children = [self.restore(v) for v in obj]
parent.extend(children)
return self._pop(parent)
if has_tag(obj, tags.TUPLE):
return self._pop(tuple([self.restore(v) for v in obj[tags.TUPLE]]))
if has_tag(obj, tags.SET):
return self._pop(set([self.restore(v) for v in obj[tags.SET]]))
if util.is_dictionary(obj):
data = {}
for k, v in sorted(obj.items(), key=operator.itemgetter(0)):
self._namestack.append(k)
data[k] = self.restore(v)
self._namestack.pop()
return self._pop(data)
return self._pop(obj)
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
"""Helper functions for pickling and unpickling. Most functions assist in
determining the type of an object.
"""
import time
import types
from jsonpickle import tags
from jsonpickle.compat import set
from jsonpickle.compat import unicode, long
COLLECTIONS = (list, set, tuple)
COLLECTIONS_SET = set(COLLECTIONS)
PRIMITIVES = set((str, unicode, bool, float, int, long))
def is_type(obj):
"""Returns True is obj is a reference to a type.
>>> is_type(1)
False
>>> is_type(object)
True
>>> class Klass: pass
>>> is_type(Klass)
True
