def save_global(self, obj, name=None, pack=struct.pack): write = self.write memo = self.memo if name is None: name = obj.__name__ module = getattr(obj, '__module__', None) if module is None: module = whichmodule(obj, 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" % (obj, module, name)) else: if klass is not obj: raise PicklingError( "Can't pickle %r: it's not the same object as %s.%s" % (obj, module, name)) if self.proto >= 2: code = _extension_registry.get((module, name)) if code: if code <= 255: write(EXT1 + chr(code)) elif code <= 65535: write('%c%c%c' % (EXT2, code & 255, code >> 8)) else: write(EXT4 + pack('<i', code)) return write(GLOBAL + module + '\n' + name + '\n') self.memoize(obj) return
def save_global(self, obj, name = None, pack = struct.pack): write = self.write memo = self.memo if name is None: name = obj.__name__ module = getattr(obj, '__module__', None) if module is None: module = whichmodule(obj, 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" % (obj, module, name)) else: if klass is not obj: raise PicklingError("Can't pickle %r: it's not the same object as %s.%s" % (obj, module, name)) code = self.proto >= 2 and _extension_registry.get((module, name)) if code: if not code > 0: raise AssertionError if code <= 255: write(EXT1 + chr(code)) elif code <= 65535: write('%c%c%c' % (EXT2, code & 255, code >> 8)) else: write(EXT4 + pack('<i', code)) return write(GLOBAL + module + '\n' + name + '\n') self.memoize(obj) return
def save_global(self, obj, name=None, pack=struct.pack): write = self.write memo = self.memo if name is None: name = obj.__name__ module = getattr(obj, "__module__", None) if module is None: module = whichmodule(obj, 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" % (obj, module, name)) else: if klass is not obj: raise PicklingError("Can't pickle %r: it's not the same object as %s.%s" % (obj, module, name)) if self.proto >= 2: code = _extension_registry.get((module, name)) if code: assert code > 0 if code <= 0xFF: write(EXT1 + chr(code)) elif code <= 0xFFFF: write("%c%c%c" % (EXT2, code & 0xFF, code >> 8)) else: write(EXT4 + pack("<i", code)) return write(GLOBAL + module + "\n" + name + "\n") self.memoize(obj)
def save_global(self, obj, name=None, pack=struct.pack): write = self.write memo = self.memo if name is None: name = obj.__name__ module = getattr(obj, "__module__", None) if module is None: module = whichmodule(obj, 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" % (obj, module, name)) else: if klass is not obj: raise PicklingError( "Can't pickle %r: it's not the same object as %s.%s" % (obj, module, name)) if self.proto >= 2: code = _extension_registry.get((module, name)) if code: assert code > 0 if code <= 0xff: write(EXT1 + chr(code)) elif code <= 0xffff: write("%c%c%c" % (EXT2, code & 0xff, code >> 8)) else: write(EXT4 + pack("<i", code)) return raise PicklingError( "Can't pickle %r: %s.%s isn't in the extension registry" % (obj, module, name), )
def _save_global(self, path, obj, name=None, pack=struct.pack): if name is None: name = obj.__name__ module = getattr(obj, "__module__", None) if module is None: module = whichmodule(obj, 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" % (obj, module, name)) else: if klass is not obj: raise PicklingError( "Can't pickle %r: it's not the same object as %s.%s" % (obj, module, name)) pickletype = None code = _extension_registry.get((module, name)) if code: assert code > 0 pickletype = EXT4 stuff = pack("<i", code) if not pickletype: stuff = module + '\n' + name pickletype = GLOBAL array = self.file.save_array(path, str(stuff)) self.file.set_attr(array, 'pickletype', pickletype)
def save_global(self, obj, name=None, pack=struct.pack): write = self.write memo = self.memo if name is None: name = obj.__name__ modname = getattr(obj, "__module__", None) if modname is None: modname = pickle.whichmodule(obj, name) try: __import__(modname) themodule = sys.modules[modname] except (ImportError, KeyError, AttributeError): #should never occur raise pickle.PicklingError( "Can't pickle %r: Module %s cannot be found" % (obj, modname)) if modname == '__main__': themodule = None if themodule: self.modules.add(themodule) sendRef = True typ = type(obj) #print 'saving', obj, typ try: try: #Deal with case when getattribute fails with exceptions klass = getattr(themodule, name) except (AttributeError): if modname == '__builtin__': #new.* are misrepeported modname = 'new' __import__(modname) themodule = sys.modules[modname] try: klass = getattr(themodule, name) except AttributeError, a: # print themodule, name, obj, type(obj) raise pickle.PicklingError("Can't pickle builtin %s" % obj) else: raise except (ImportError, KeyError, AttributeError): if typ == types.TypeType or typ == types.ClassType: sendRef = False else: #we can't deal with this raise else: if klass is not obj and (typ == types.TypeType or typ == types.ClassType): sendRef = False if not sendRef: #note: Third party types might crash this - add better checks! d = dict(obj.__dict__) #copy dict proxy to a dict if not isinstance( d.get('__dict__', None), property): # don't extract dict that are properties d.pop('__dict__', None) d.pop('__weakref__', None) # hack as __new__ is stored differently in the __dict__ new_override = d.get('__new__', None) if new_override: d['__new__'] = obj.__new__ self.save_reduce(type(obj), (obj.__name__, obj.__bases__, d), obj=obj) #print 'internal reduce dask %s %s' % (obj, d) return if self.proto >= 2: code = _extension_registry.get((modname, name)) if code: assert code > 0 if code <= 0xff: write(pickle.EXT1 + chr(code)) elif code <= 0xffff: write("%c%c%c" % (pickle.EXT2, code & 0xff, code >> 8)) else: write(pickle.EXT4 + pack("<i", code)) return write(pickle.GLOBAL + modname + '\n' + name + '\n') self.memoize(obj)
def save_global(self, obj, name=None, pack=struct.pack): write = self.write memo = self.memo if name is None: name = obj.__name__ modname = getattr(obj, "__module__", None) if modname is None: modname = whichmodule(obj, name) try: __import__(modname) themodule = sys.modules[modname] except (ImportError, KeyError, AttributeError): # should never occur raise pickle.PicklingError( "Can't pickle %r: Module %s cannot be found" % (obj, modname)) if modname == '__main__': themodule = None if themodule: self.modules.add(themodule) sendRef = True typ = type(obj) #print 'saving', obj, typ try: try: # Deal with case when getattribute fails with exceptions klass = getattr(themodule, name) except (AttributeError): if modname == '__builtin__': # new.* are misrepeported modname = 'new' __import__(modname) themodule = sys.modules[modname] try: klass = getattr(themodule, name) except AttributeError, a: #print themodule, name, obj, type(obj) raise pickle.PicklingError("Can't pickle builtin %s" % obj) else: raise except (ImportError, KeyError, AttributeError): if isinstance(obj, types.TypeType) or \ isinstance(obj, types.ClassType): sendRef = False else: # we can't deal with this raise else: if klass is not obj and (isinstance(type, types.TypeType) or isinstance(type, types.ClassType)): sendRef = False if not sendRef: #note: Third party types might crash this - add better checks! d = dict(obj.__dict__) # copy dict proxy to a dict d.pop('__dict__', None) d.pop('__weakref__', None) self.save_reduce(type(obj), (obj.__name__, obj.__bases__, d), obj=obj) return if self.proto >= 2: code = _extension_registry.get((modname, name)) if code: assert code > 0 if code <= 0xff: write(pickle.EXT1 + chr(code)) elif code <= 0xffff: write("%c%c%c" % (pickle.EXT2, code & 0xff, code >> 8)) else: write(pickle.EXT4 + pack("<i", code)) return write(pickle.GLOBAL + modname + '\n' + name + '\n') self.memoize(obj)
def save_global(self, obj, name=None, pack=struct.pack): write = self.write memo = self.memo if name is None: name = obj.__name__ modname = getattr(obj, "__module__", None) if modname is None: modname = pickle.whichmodule(obj, name) try: __import__(modname) themodule = sys.modules[modname] except (ImportError, KeyError, AttributeError): #should never occur raise pickle.PicklingError( "Can't pickle %r: Module %s cannot be found" % (obj, modname)) if modname == '__main__': themodule = None if themodule: self.modules.add(themodule) sendRef = True typ = type(obj) #print 'saving', obj, typ try: try: #Deal with case when getattribute fails with exceptions klass = getattr(themodule, name) except (AttributeError): if modname == '__builtin__': #new.* are misrepeported modname = 'new' __import__(modname) themodule = sys.modules[modname] try: klass = getattr(themodule, name) except AttributeError, a: #print themodule, name, obj, type(obj) raise pickle.PicklingError("Can't pickle builtin %s" % obj) else: raise except (ImportError, KeyError, AttributeError): if typ == types.TypeType or typ == types.ClassType: sendRef = False else: #we can't deal with this raise else: if klass is not obj and (typ == types.TypeType or typ == types.ClassType): sendRef = False if not sendRef: self.save_class_obj(obj, name, pack) return if self.proto >= 2: code = _extension_registry.get((modname, name)) if code: assert code > 0 if code <= 0xff: write(pickle.EXT1 + chr(code)) elif code <= 0xffff: write("%c%c%c" % (pickle.EXT2, code & 0xff, code >> 8)) else: write(pickle.EXT4 + pack("<i", code)) return write(pickle.GLOBAL + modname + '\n' + name + '\n') self.memoize(obj)
def save_global(self, obj, name=None, pack=struct.pack): write = self.write memo = self.memo if name is None: name = obj.__name__ modname = getattr(obj, "__module__", None) if modname is None: modname = pickle.whichmodule(obj, name) try: __import__(modname) themodule = sys.modules[modname] except (ImportError, KeyError, AttributeError): # should never occur raise pickle.PicklingError("Can't pickle %r: Module %s cannot be found" % (obj, modname)) if modname == "__main__": themodule = None if themodule: self.modules.add(themodule) sendRef = True typ = type(obj) # print 'saving', obj, typ try: try: # Deal with case when getattribute fails with exceptions klass = getattr(themodule, name) except (AttributeError): if modname == "__builtin__": # new.* are misrepeported modname = "new" __import__(modname) themodule = sys.modules[modname] try: klass = getattr(themodule, name) except AttributeError, a: # print themodule, name, obj, type(obj) raise pickle.PicklingError("Can't pickle builtin %s" % obj) else: raise except (ImportError, KeyError, AttributeError): if typ == types.TypeType or typ == types.ClassType: sendRef = False else: # we can't deal with this raise else: if klass is not obj and (typ == types.TypeType or typ == types.ClassType): sendRef = False if not sendRef: # note: Third party types might crash this - add better checks! d = dict(obj.__dict__) # copy dict proxy to a dict if not isinstance(d.get("__dict__", None), property): # don't extract dict that are properties d.pop("__dict__", None) d.pop("__weakref__", None) # hack as __new__ is stored differently in the __dict__ new_override = d.get("__new__", None) if new_override: d["__new__"] = obj.__new__ self.save_reduce(type(obj), (obj.__name__, obj.__bases__, d), obj=obj) # print 'internal reduce dask %s %s' % (obj, d) return if self.proto >= 2: code = _extension_registry.get((modname, name)) if code: assert code > 0 if code <= 0xFF: write(pickle.EXT1 + chr(code)) elif code <= 0xFFFF: write("%c%c%c" % (pickle.EXT2, code & 0xFF, code >> 8)) else: write(pickle.EXT4 + pack("<i", code)) return write(pickle.GLOBAL + modname + "\n" + name + "\n") self.memoize(obj)