def load_binbytes8(self):
len, = unpack('<Q', self.read(8))
if len > maxsize:
raise UnpicklingError(
"BINBYTES8 exceeds system's maximum size of %d bytes" %
maxsize)
self.append(self.read(len))
def load_persid(self):
try:
pid = self.readline()[:-1].decode('ascii')
except UnicodeDecodeError:
raise UnpicklingError('persistent IDs in protocol 0 must be ASCII strings')
self.append(self.persistent_load(pid))
def load(self):
"""Read a pickled object representation from the open file.
Return the reconstituted object hierarchy specified in the file.
"""
if not hasattr(self, '_file_read'):
raise UnpicklingError('Unpickler.__init__() was not called by %s.__init__()' % (
self.__class__.__name__,))
self._unframer = _Unframer(self._file_read, self._file_readline)
self.read = self._unframer.read
self.readline = self._unframer.readline
self.metastack = []
self.stack = []
self.append = self.stack.append
self.proto = 0
read = self.read
dispatch = self.dispatch
try:
while True:
key = read(1)
if not key:
raise EOFError
if not isinstance(key, bytes_types):
raise AssertionError
dispatch[key[0]](self)
except _Stop as stopinst:
try:
return stopinst.value
finally:
stopinst = None
del stopinst
def load_binunicode8(self):
len, = unpack('<Q', self.read(8))
if len > maxsize:
raise UnpicklingError(
"BINUNICODE8 exceeds system's maximum size of %d bytes" %
maxsize)
self.append(str(self.read(len), 'utf-8', 'surrogatepass'))
def load_string(self):
data = self.readline()[:-1]
if len(data) >= 2 and data[0] == data[-1] and data[0] in b'"\'':
data = data[1:-1]
else:
raise UnpicklingError('the STRING opcode argument must be quoted')
self.append(self._decode_string(codecs.escape_decode(data)[0]))
def readline(self):
if self.current_frame:
data = self.current_frame.readline()
if not data:
self.current_frame = None
return self.file_readline()
if data[(-1)] != 10:
raise UnpicklingError('pickle exhausted before end of frame')
return data
else:
return self.file_readline()
def read(self, n):
if self.current_frame:
data = self.current_frame.read(n)
if not data and n != 0:
self.current_frame = None
return self.file_read(n)
if len(data) < n:
raise UnpicklingError('pickle exhausted before end of frame')
return data
else:
return self.file_read(n)
def get_extension(self, code):
nil = []
obj = _extension_cache.get(code, nil)
if obj is not nil:
self.append(obj)
return
key = _inverted_registry.get(code)
if not key:
if code <= 0:
raise UnpicklingError('EXT specifies code <= 0')
raise ValueError('unregistered extension code %d' % code)
obj = (self.find_class)(*key)
_extension_cache[code] = obj
self.append(obj)
def persistent_load(self, pid):
raise UnpicklingError('unsupported persistent id encountered')
def load_frame(self, frame_size):
if self.current_frame:
if self.current_frame.read() != '':
raise UnpicklingError('beginning of a new frame before end of current frame')
self.current_frame = io.BytesIO(self.file_read(frame_size))
def load_stack_global(self):
name = self.stack.pop()
module = self.stack.pop()
if type(name) is not str or type(module) is not str:
raise UnpicklingError('STACK_GLOBAL requires str')
self.append(self.find_class(module, name))
def load_binstring(self):
len, = unpack('<i', self.read(4))
if len < 0:
raise UnpicklingError('BINSTRING pickle has negative byte count')
data = self.read(len)
self.append(self._decode_string(data))
def load_long4(self):
n, = unpack('<i', self.read(4))
if n < 0:
raise UnpicklingError('LONG pickle has negative byte count')
data = self.read(n)
self.append(decode_long(data))