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): objNumber = obj[tags.ID] try: objRef = self._objs[objNumber] except IndexError: raise IndexError( 'Cannot find objRef %d in self._objs of len(%d), looking for obj %r' % (objNumber, len(self._objs), obj)) poppedValue = self._pop(objRef) return poppedValue 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)
import base64 import collections.abc import io import operator import time import types import inspect from music21.ext.jsonpickle import tags from music21.ext.jsonpickle.compat import set, unicode, long, bytes, PY3 if not PY3: import __builtin__ # @UnresolvedImport 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
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 music21.ext.jsonpickle.compat import set 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' # All reserved tag names RESERVED = set([OBJECT, TYPE, REPR, REF, TUPLE, SET, SEQ, STATE])
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): objNumber = obj[tags.ID] try: objRef = self._objs[objNumber] except IndexError: raise IndexError('Cannot find objRef %d in self._objs of len(%d), looking for obj %r' % (objNumber, len(self._objs), obj)) poppedValue = self._pop(objRef) return poppedValue 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)
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([ BYTES, FUNCTION, ID, INITARGS, ITERATOR, NEWARGS, NEWARGSEX, NEWOBJ, OBJECT, REDUCE, REF, REPR, SEQ, SET, STATE, TUPLE, TYPE, ])