我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用pickle.PicklingError()。
def putmessage(self, message): self.debug("putmessage:%d:" % message[0]) try: s = pickle.dumps(message) except pickle.PicklingError: print("Cannot pickle:", repr(message), file=sys.__stderr__) raise s = struct.pack("<i", len(s)) + s while len(s) > 0: try: r, w, x = select.select([], [self.sock], []) n = self.sock.send(s[:BUFSIZE]) except (AttributeError, TypeError): raise IOError("socket no longer exists") except socket.error: raise else: s = s[n:]
def GetPeerList(self, request, context): """?? RadioStation ? ??? Peer ??? ???. :param request: CommonRequest :param context: :return: PeerList """ channel_name = conf.LOOPCHAIN_DEFAULT_CHANNEL if not request.channel else request.channel try: peer_list_dump = ObjectManager().rs_service.channel_manager.get_peer_manager(channel_name).dump() except pickle.PicklingError as e: logging.warning("fail peer_list dump") peer_list_dump = b'' return loopchain_pb2.PeerList( peer_list=peer_list_dump )
def on_connected(self, f): """Callback fired /on_connection/ established. Once the connection to the websocket has been established, all the currenct namespace is pickled and written to the corresponding web_socket connection. """ try: ws_conn = f.result() self.ws_conn = ws_conn data = {'connection_id': self.connection_id, 'nb_code_to_run_async': self.cell_source,} msg = json.dumps(data) ws_conn.write_message(message=msg) white_ns = self._pack_namespace() ws_conn.write_message(message=pickle_dumps(white_ns), binary=True) except PicklingError as e: print(str(e))
def _pack_namespace(self): """Collect all the /pickable/ objects from the namespace so to pass them to the async execution environment.""" white_ns = dict() white_ns.setdefault('import_modules', list()) for k, v in self.shell.user_ns.items(): if not k in DEFAULT_BLACKLIST: try: if inspect_ismodule(v): white_ns['import_modules'].append((k, v.__name__)) else: _ = pickle_dumps({k: v}) white_ns[k] = v except PicklingError: continue except Exception: continue white_ns['connection_id'] = self.connection_id return white_ns
def test_reduce_bad_iterator(self): # Issue4176: crash when 4th and 5th items of __reduce__() # are not iterators class C(object): def __reduce__(self): # 4th item is not an iterator return list, (), None, [], None class D(object): def __reduce__(self): # 5th item is not an iterator return dict, (), None, None, [] # Protocol 0 in Python implementation is less strict and also accepts # iterables. for proto in protocols: try: self.dumps(C(), proto) except (AttributeError, pickle.PicklingError, cPickle.PicklingError): pass try: self.dumps(D(), proto) except (AttributeError, pickle.PicklingError, cPickle.PicklingError): pass
def save_global(self, obj, name=None, pack=struct.pack): # We have to override this method in order to deal with objects # defined interactively in IPython that are not injected in # __main__ kwargs = dict(name=name, pack=pack) if sys.version_info >= (3, 4): del kwargs['pack'] try: Pickler.save_global(self, obj, **kwargs) except pickle.PicklingError: Pickler.save_global(self, obj, **kwargs) module = getattr(obj, "__module__", None) if module == '__main__': my_name = name if my_name is None: my_name = obj.__name__ mod = sys.modules[module] if not hasattr(mod, my_name): # IPython doesn't inject the variables define # interactively in __main__ setattr(mod, my_name, obj)
def pickleRoundTrip(self, obj, name, dumper, loader): save_m = sys.modules[name] try: sys.modules[name] = dumper temp = pickle.dumps(obj) sys.modules[name] = loader result = pickle.loads(temp) except pickle.PicklingError as pe: # pyET must be second, because pyET may be (equal to) ET. human = dict([(ET, "cET"), (pyET, "pyET")]) raise support.TestFailed("Failed to round-trip %r from %r to %r" % (obj, human.get(dumper, dumper), human.get(loader, loader))) from pe finally: sys.modules[name] = save_m return result
def pickleRoundTrip(self, obj, name, dumper, loader, proto): save_m = sys.modules[name] try: sys.modules[name] = dumper temp = pickle.dumps(obj, proto) sys.modules[name] = loader result = pickle.loads(temp) except pickle.PicklingError as pe: # pyET must be second, because pyET may be (equal to) ET. human = dict([(ET, "cET"), (pyET, "pyET")]) raise support.TestFailed("Failed to round-trip %r from %r to %r" % (obj, human.get(dumper, dumper), human.get(loader, loader))) from pe finally: sys.modules[name] = save_m return result
def save_func(self, obj): try: self.save_global(obj) return except pickle.PicklingError: pass assert type(obj) is types.FunctionType self.save(types.FunctionType) self.save(( obj.func_code, obj.func_globals, obj.func_name, obj.func_defaults, obj.func_closure, )) self.write(pickle.REDUCE) if id(obj) not in self.memo: # Could be if we recursively landed here. See also pickle.save_tuple(). self.memoize(obj)
def set_to_cache(self): """ Add widget object to Django's cache. You may need to overwrite this method, to pickle all information that is required to serve your JSON response view. """ try: cache.set(self._get_cache_key(), { 'widget': self, 'url': self.get_url(), }) except (PicklingError, cPicklingError, AttributeError): msg = "You need to overwrite \"set_to_cache\" or ensure that %s is serialisable." raise NotImplementedError(msg % self.__class__.__name__)
def put(self, o): """Encode object ``o`` and write it to the pipe. Block gevent-cooperatively until all data is written. The default encoder is ``pickle.dumps``. :arg o: a Python object that is encodable with the encoder of choice. Raises: - :exc:`GIPCError` - :exc:`GIPCClosed` - :exc:`pickle.PicklingError` """ self._validate() with self._lock: bindata = self._encoder(o) self._write(struct.pack("!i", len(bindata)) + bindata)
def dump(self, obj): self.inject_addons() try: return Pickler.dump(self, obj) except RuntimeError as e: if 'recursion' in e.args[0]: msg = """Could not pickle object as excessively deep recursion required.""" raise pickle.PicklingError(msg) except pickle.PickleError: raise except Exception as e: if "'i' format requires" in e.message: msg = "Object too large to serialize: " + e.message else: msg = "Could not serialize object: " + e.__class__.__name__ + ": " + e.message print_exec(sys.stderr) raise pickle.PicklingError(msg)
def save_unsupported(self, obj): raise pickle.PicklingError("Cannot pickle objects of type %s" % type(obj))
def save_ufunc(self, obj): """Hack function for saving numpy ufunc objects""" name = obj.__name__ numpy_tst_mods = ['numpy', 'scipy.special'] for tst_mod_name in numpy_tst_mods: tst_mod = sys.modules.get(tst_mod_name, None) if tst_mod and name in tst_mod.__dict__: return self.save_reduce(_getobject, (tst_mod_name, name)) raise pickle.PicklingError('cannot save %s. Cannot resolve what module it is defined in' % str(obj))
def save(self, filename=None): self.check_filename(filename) fh = None try: data = (self.title, self.year, self.duration, self.director_id) fh = open(self.filename, 'wb') pickle.dump(data, fh) except (EnvironmentError, pickle.PicklingError) as err: raise SaveError(str(err)) finally: if fh is not None: fh.close()
def load(self, filename=None): self.check_filename(filename) fh = None try: fh = open(self.filename, 'rb') data = pickle.load(fh) (self.title, self.year, self.duration, self.director_id) = data except (EnvironmentError, pickle.PicklingError) as err: raise LoadError(str(err)) finally: if fh is not None: fh.close()
def save(self, filename=None): self.check_filename(filename) fh = None try: # todo.. except (EnvironmentError, pickle.PicklingError) as err: raise SaveError(str(err)) finally: if fh is not None: fh.close()
def load(self, filename=None): self.check_filename(filename) fh = None try: # todo.. except (EnvironmentError, pickle.PicklingError) as err: raise LoadError(str(err)) finally: if fh is not None: fh.close()
def save(self, filename=None): self.check_filename(filename) fh = None try: data = (self.title, self.year, self.duration, self.director_id) with open(self.filename, 'wb') as fh: pickle.dump(data, fh) except (EnvironmentError, pickle.PicklingError) as err: raise SaveError(str(err))
def __getstate__(self): raise PicklingError('no access to the daemon')
def test_class_nested_enum_and_pickle_protocol_four(self): # would normally just have this directly in the class namespace class NestedEnum(Enum): twigs = 'common' shiny = 'rare' self.__class__.NestedEnum = NestedEnum self.NestedEnum.__qualname__ = '%s.NestedEnum' % self.__class__.__name__ test_pickle_exception( self.assertRaises, PicklingError, self.NestedEnum.twigs, protocol=(0, 3)) test_pickle_dump_load(self.assertTrue, self.NestedEnum.twigs, protocol=(4, HIGHEST_PROTOCOL))
def test_exploding_pickle(self): BadPickle = Enum('BadPickle', 'dill sweet bread-n-butter') enum._make_class_unpicklable(BadPickle) globals()['BadPickle'] = BadPickle test_pickle_exception(self.assertRaises, TypeError, BadPickle.dill) test_pickle_exception(self.assertRaises, PicklingError, BadPickle)
def __getstate__(self): raise pickle.PicklingError( 'Pickling of datastore_query.PropertyFilter is unsupported.')
def __getstate__(self): raise pickle.PicklingError( 'Pickling of %r is unsupported.' % self)
def __getstate__(self): raise pickle.PicklingError( 'Pickling of datastore_query.PropertyOrder is unsupported.')
def __getstate__(self): raise pickle.PicklingError( 'Pickling of datastore_query.Batch is unsupported.')
def __getstate__(self): raise pickle.PicklingError( 'Pickling of datastore_query.Batcher is unsupported.')
def hash(self, obj, return_digest=True): try: self.dump(obj) except pickle.PicklingError as e: e.args += ('PicklingError while hashing %r: %r' % (obj, e),) raise dumps = self.stream.getvalue() self._hash.update(dumps) if return_digest: return self._hash.hexdigest()
def __init__(self, infile, cache=False, cfg_options=None, debugangr=False): self.infile = infile self.error = False self._stack_patch_data = [] self.stack_increases = {} if cfg_options is None: cfg_options = {} cachename = infile + '.fcfg' l.info("Loading %s", infile) try: if not cache: raise IOError('fuck off') fh = open(cachename, 'rb') self.project, self.cfg = pickle.load(fh) self.cfg.project = self.project fh.close() except (IOError, OSError, pickle.UnpicklingError): if debugangr: import ipdb; ipdb.set_trace() self.project = Project(infile, load_options={'auto_load_libs': False}) self.cfg = self.project.analyses.CFGFast(**cfg_options) try: fh = open(cachename, 'wb') pickle.dump((self.project, self.cfg), fh, -1) fh.close() except (IOError, OSError, pickle.PicklingError): l.exception('Error pickling CFG')
