Lines Matching refs:self
98 def __init__(self, value):
99 self.value = value
133 GLOBAL = b'c' # push self.find_class(modname, name); 2 string args
205 def __init__(self, file_write):
206 self.file_write = file_write
207 self.current_frame = None
209 def start_framing(self):
210 self.current_frame = io.BytesIO()
212 def end_framing(self):
213 if self.current_frame and self.current_frame.tell() > 0:
214 self.commit_frame(force=True)
215 self.current_frame = None
217 def commit_frame(self, force=False):
218 if self.current_frame:
219 f = self.current_frame
220 if f.tell() >= self._FRAME_SIZE_TARGET or force:
222 write = self.file_write
223 if len(data) >= self._FRAME_SIZE_MIN:
239 self.current_frame = io.BytesIO()
241 def write(self, data):
242 if self.current_frame:
243 return self.current_frame.write(data)
245 return self.file_write(data)
247 def write_large_bytes(self, header, payload):
248 write = self.file_write
249 if self.current_frame:
251 self.commit_frame(force=True)
265 def __init__(self, file_read, file_readline, file_tell=None):
266 self.file_read = file_read
267 self.file_readline = file_readline
268 self.current_frame = None
270 def readinto(self, buf):
271 if self.current_frame:
272 n = self.current_frame.readinto(buf)
274 self.current_frame = None
276 buf[:] = self.file_read(n)
284 buf[:] = self.file_read(n)
287 def read(self, n):
288 if self.current_frame:
289 data = self.current_frame.read(n)
291 self.current_frame = None
292 return self.file_read(n)
298 return self.file_read(n)
300 def readline(self):
301 if self.current_frame:
302 data = self.current_frame.readline()
304 self.current_frame = None
305 return self.file_readline()
311 return self.file_readline()
313 def load_frame(self, frame_size):
314 if self.current_frame and self.current_frame.read() != b'':
317 self.current_frame = io.BytesIO(self.file_read(frame_size))
409 def __init__(self, file, protocol=None, *, fix_imports=True,
452 self._buffer_callback = buffer_callback
454 self._file_write = file.write
457 self.framer = _Framer(self._file_write)
458 self.write = self.framer.write
459 self._write_large_bytes = self.framer.write_large_bytes
460 self.memo = {}
461 self.proto = int(protocol)
462 self.bin = protocol >= 1
463 self.fast = 0
464 self.fix_imports = fix_imports and protocol < 3
466 def clear_memo(self):
474 self.memo.clear()
476 def dump(self, obj):
480 if not hasattr(self, "_file_write"):
482 "%s.__init__()" % (self.__class__.__name__,))
483 if self.proto >= 2:
484 self.write(PROTO + pack("<B", self.proto))
485 if self.proto >= 4:
486 self.framer.start_framing()
487 self.save(obj)
488 self.write(STOP)
489 self.framer.end_framing()
491 def memoize(self, obj):
506 if self.fast:
508 assert id(obj) not in self.memo
509 idx = len(self.memo)
510 self.write(self.put(idx))
511 self.memo[id(obj)] = idx, obj
514 def put(self, idx):
515 if self.proto >= 4:
517 elif self.bin:
526 def get(self, i):
527 if self.bin:
535 def save(self, obj, save_persistent_id=True):
536 self.framer.commit_frame()
539 pid = self.persistent_id(obj)
541 self.save_pers(pid)
545 x = self.memo.get(id(obj))
547 self.write(self.get(x[0]))
551 reduce = getattr(self, "reducer_override", None)
558 f = self.dispatch.get(t)
560 f(self, obj) # Call unbound method with explicit self
565 reduce = getattr(self, 'dispatch_table', dispatch_table).get(t)
572 self.save_global(obj)
578 rv = reduce(self.proto)
589 self.save_global(obj, rv)
603 self.save_reduce(obj=obj, *rv)
605 def persistent_id(self, obj):
609 def save_pers(self, pid):
611 if self.bin:
612 self.save(pid, save_persistent_id=False)
613 self.write(BINPERSID)
616 self.write(PERSID + str(pid).encode("ascii") + b'\n')
621 def save_reduce(self, func, args, state=None, listitems=None,
630 save = self.save
631 write = self.write
634 if self.proto >= 2 and func_name == "__newobj_ex__":
642 if self.proto >= 4:
652 elif self.proto >= 2 and func_name == "__newobj__":
699 if id(obj) in self.memo:
700 write(POP + self.get(self.memo[id(obj)][0]))
702 self.memoize(obj)
710 self._batch_appends(listitems)
713 self._batch_setitems(dictitems)
740 def save_none(self, obj):
741 self.write(NONE)
744 def save_bool(self, obj):
745 if self.proto >= 2:
746 self.write(NEWTRUE if obj else NEWFALSE)
748 self.write(TRUE if obj else FALSE)
751 def save_long(self, obj):
752 if self.bin:
759 self.write(BININT1 + pack("<B", obj))
762 self.write(BININT2 + pack("<H", obj))
766 self.write(BININT + pack("<i", obj))
768 if self.proto >= 2:
772 self.write(LONG1 + pack("<B", n) + encoded)
774 self.write(LONG4 + pack("<i", n) + encoded)
777 self.write(INT + repr(obj).encode("ascii") + b'\n')
779 self.write(LONG + repr(obj).encode("ascii") + b'L\n')
782 def save_float(self, obj):
783 if self.bin:
784 self.write(BINFLOAT + pack('>d', obj))
786 self.write(FLOAT + repr(obj).encode("ascii") + b'\n')
789 def save_bytes(self, obj):
790 if self.proto < 3:
792 self.save_reduce(bytes, (), obj=obj)
794 self.save_reduce(codecs.encode,
799 self.write(SHORT_BINBYTES + pack("<B", n) + obj)
800 elif n > 0xffffffff and self.proto >= 4:
801 self._write_large_bytes(BINBYTES8 + pack("<Q", n), obj)
802 elif n >= self.framer._FRAME_SIZE_TARGET:
803 self._write_large_bytes(BINBYTES + pack("<I", n), obj)
805 self.write(BINBYTES + pack("<I", n) + obj)
806 self.memoize(obj)
809 def save_bytearray(self, obj):
810 if self.proto < 5:
812 self.save_reduce(bytearray, (), obj=obj)
814 self.save_reduce(bytearray, (bytes(obj),), obj=obj)
817 if n >= self.framer._FRAME_SIZE_TARGET:
818 self._write_large_bytes(BYTEARRAY8 + pack("<Q", n), obj)
820 self.write(BYTEARRAY8 + pack("<Q", n) + obj)
821 self.memoize(obj)
825 def save_picklebuffer(self, obj):
826 if self.proto < 5:
834 if self._buffer_callback is not None:
835 in_band = bool(self._buffer_callback(obj))
840 self.save_bytes(m.tobytes())
842 self.save_bytearray(m.tobytes())
845 self.write(NEXT_BUFFER)
847 self.write(READONLY_BUFFER)
851 def save_str(self, obj):
852 if self.bin:
855 if n <= 0xff and self.proto >= 4:
856 self.write(SHORT_BINUNICODE + pack("<B", n) + encoded)
857 elif n > 0xffffffff and self.proto >= 4:
858 self._write_large_bytes(BINUNICODE8 + pack("<Q", n), encoded)
859 elif n >= self.framer._FRAME_SIZE_TARGET:
860 self._write_large_bytes(BINUNICODE + pack("<I", n), encoded)
862 self.write(BINUNICODE + pack("<I", n) + encoded)
869 self.write(UNICODE + obj.encode('raw-unicode-escape') +
871 self.memoize(obj)
874 def save_tuple(self, obj):
876 if self.bin:
877 self.write(EMPTY_TUPLE)
879 self.write(MARK + TUPLE)
883 save = self.save
884 memo = self.memo
885 if n <= 3 and self.proto >= 2:
890 get = self.get(memo[id(obj)][0])
891 self.write(POP * n + get)
893 self.write(_tuplesize2code[n])
894 self.memoize(obj)
899 write = self.write
912 get = self.get(memo[id(obj)][0])
913 if self.bin:
921 self.memoize(obj)
925 def save_list(self, obj):
926 if self.bin:
927 self.write(EMPTY_LIST)
929 self.write(MARK + LIST)
931 self.memoize(obj)
932 self._batch_appends(obj)
938 def _batch_appends(self, items):
940 save = self.save
941 write = self.write
943 if not self.bin:
951 tmp = list(islice(it, self._BATCHSIZE))
962 if n < self._BATCHSIZE:
965 def save_dict(self, obj):
966 if self.bin:
967 self.write(EMPTY_DICT)
969 self.write(MARK + DICT)
971 self.memoize(obj)
972 self._batch_setitems(obj.items())
978 def _batch_setitems(self, items):
980 save = self.save
981 write = self.write
983 if not self.bin:
992 tmp = list(islice(it, self._BATCHSIZE))
1006 if n < self._BATCHSIZE:
1009 def save_set(self, obj):
1010 save = self.save
1011 write = self.write
1013 if self.proto < 4:
1014 self.save_reduce(set, (list(obj),), obj=obj)
1018 self.memoize(obj)
1022 batch = list(islice(it, self._BATCHSIZE))
1029 if n < self._BATCHSIZE:
1033 def save_frozenset(self, obj):
1034 save = self.save
1035 write = self.write
1037 if self.proto < 4:
1038 self.save_reduce(frozenset, (list(obj),), obj=obj)
1045 if id(obj) in self.memo:
1049 write(POP_MARK + self.get(self.memo[id(obj)][0]))
1053 self.memoize(obj)
1056 def save_global(self, obj, name=None):
1057 write = self.write
1058 memo = self.memo
1080 if self.proto >= 2:
1095 if self.proto >= 4:
1096 self.save(module_name)
1097 self.save(name)
1100 self.save_reduce(getattr, (parent, lastname))
1101 elif self.proto >= 3:
1105 if self.fix_imports:
1118 "pickle protocol %i" % (module, name, self.proto)) from None
1120 self.memoize(obj)
1122 def save_type(self, obj):
1124 return self.save_reduce(type, (None,), obj=obj)
1126 return self.save_reduce(type, (NotImplemented,), obj=obj)
1128 return self.save_reduce(type, (...,), obj=obj)
1129 return self.save_global(obj)
1139 def __init__(self, file, *, fix_imports=True,
1178 self._buffers = iter(buffers) if buffers is not None else None
1179 self._file_readline = file.readline
1180 self._file_read = file.read
1181 self.memo = {}
1182 self.encoding = encoding
1183 self.errors = errors
1184 self.proto = 0
1185 self.fix_imports = fix_imports
1187 def load(self):
1194 if not hasattr(self, "_file_read"):
1196 "%s.__init__()" % (self.__class__.__name__,))
1197 self._unframer = _Unframer(self._file_read, self._file_readline)
1198 self.read = self._unframer.read
1199 self.readinto = self._unframer.readinto
1200 self.readline = self._unframer.readline
1201 self.metastack = []
1202 self.stack = []
1203 self.append = self.stack.append
1204 self.proto = 0
1205 read = self.read
1206 dispatch = self.dispatch
1213 dispatch[key[0]](self)
1218 def pop_mark(self):
1219 items = self.stack
1220 self.stack = self.metastack.pop()
1221 self.append = self.stack.append
1224 def persistent_load(self, pid):
1229 def load_proto(self):
1230 proto = self.read(1)[0]
1233 self.proto = proto
1236 def load_frame(self):
1237 frame_size, = unpack('<Q', self.read(8))
1240 self._unframer.load_frame(frame_size)
1243 def load_persid(self):
1245 pid = self.readline()[:-1].decode("ascii")
1249 self.append(self.persistent_load(pid))
1252 def load_binpersid(self):
1253 pid = self.stack.pop()
1254 self.append(self.persistent_load(pid))
1257 def load_none(self):
1258 self.append(None)
1261 def load_false(self):
1262 self.append(False)
1265 def load_true(self):
1266 self.append(True)
1269 def load_int(self):
1270 data = self.readline()
1277 self.append(val)
1280 def load_binint(self):
1281 self.append(unpack('<i', self.read(4))[0])
1284 def load_binint1(self):
1285 self.append(self.read(1)[0])
1288 def load_binint2(self):
1289 self.append(unpack('<H', self.read(2))[0])
1292 def load_long(self):
1293 val = self.readline()[:-1]
1296 self.append(int(val, 0))
1299 def load_long1(self):
1300 n = self.read(1)[0]
1301 data = self.read(n)
1302 self.append(decode_long(data))
1305 def load_long4(self):
1306 n, = unpack('<i', self.read(4))
1310 data = self.read(n)
1311 self.append(decode_long(data))
1314 def load_float(self):
1315 self.append(float(self.readline()[:-1]))
1318 def load_binfloat(self):
1319 self.append(unpack('>d', self.read(8))[0])
1322 def _decode_string(self, value):
1326 if self.encoding == "bytes":
1329 return value.decode(self.encoding, self.errors)
1331 def load_string(self):
1332 data = self.readline()[:-1]
1338 self.append(self._decode_string(codecs.escape_decode(data)[0]))
1341 def load_binstring(self):
1343 len, = unpack('<i', self.read(4))
1346 data = self.read(len)
1347 self.append(self._decode_string(data))
1350 def load_binbytes(self):
1351 len, = unpack('<I', self.read(4))
1355 self.append(self.read(len))
1358 def load_unicode(self):
1359 self.append(str(self.readline()[:-1], 'raw-unicode-escape'))
1362 def load_binunicode(self):
1363 len, = unpack('<I', self.read(4))
1367 self.append(str(self.read(len), 'utf-8', 'surrogatepass'))
1370 def load_binunicode8(self):
1371 len, = unpack('<Q', self.read(8))
1375 self.append(str(self.read(len), 'utf-8', 'surrogatepass'))
1378 def load_binbytes8(self):
1379 len, = unpack('<Q', self.read(8))
1383 self.append(self.read(len))
1386 def load_bytearray8(self):
1387 len, = unpack('<Q', self.read(8))
1392 self.readinto(b)
1393 self.append(b)
1396 def load_next_buffer(self):
1397 if self._buffers is None:
1401 buf = next(self._buffers)
1404 self.append(buf)
1407 def load_readonly_buffer(self):
1408 buf = self.stack[-1]
1411 self.stack[-1] = m.toreadonly()
1414 def load_short_binstring(self):
1415 len = self.read(1)[0]
1416 data = self.read(len)
1417 self.append(self._decode_string(data))
1420 def load_short_binbytes(self):
1421 len = self.read(1)[0]
1422 self.append(self.read(len))
1425 def load_short_binunicode(self):
1426 len = self.read(1)[0]
1427 self.append(str(self.read(len), 'utf-8', 'surrogatepass'))
1430 def load_tuple(self):
1431 items = self.pop_mark()
1432 self.append(tuple(items))
1435 def load_empty_tuple(self):
1436 self.append(())
1439 def load_tuple1(self):
1440 self.stack[-1] = (self.stack[-1],)
1443 def load_tuple2(self):
1444 self.stack[-2:] = [(self.stack[-2], self.stack[-1])]
1447 def load_tuple3(self):
1448 self.stack[-3:] = [(self.stack[-3], self.stack[-2], self.stack[-1])]
1451 def load_empty_list(self):
1452 self.append([])
1455 def load_empty_dictionary(self):
1456 self.append({})
1459 def load_empty_set(self):
1460 self.append(set())
1463 def load_frozenset(self):
1464 items = self.pop_mark()
1465 self.append(frozenset(items))
1468 def load_list(self):
1469 items = self.pop_mark()
1470 self.append(items)
1473 def load_dict(self):
1474 items = self.pop_mark()
1477 self.append(d)
1485 def _instantiate(self, klass, args):
1495 self.append(value)
1497 def load_inst(self):
1498 module = self.readline()[:-1].decode("ascii")
1499 name = self.readline()[:-1].decode("ascii")
1500 klass = self.find_class(module, name)
1501 self._instantiate(klass, self.pop_mark())
1504 def load_obj(self):
1506 args = self.pop_mark()
1508 self._instantiate(cls, args)
1511 def load_newobj(self):
1512 args = self.stack.pop()
1513 cls = self.stack.pop()
1515 self.append(obj)
1518 def load_newobj_ex(self):
1519 kwargs = self.stack.pop()
1520 args = self.stack.pop()
1521 cls = self.stack.pop()
1523 self.append(obj)
1526 def load_global(self):
1527 module = self.readline()[:-1].decode("utf-8")
1528 name = self.readline()[:-1].decode("utf-8")
1529 klass = self.find_class(module, name)
1530 self.append(klass)
1533 def load_stack_global(self):
1534 name = self.stack.pop()
1535 module = self.stack.pop()
1538 self.append(self.find_class(module, name))
1541 def load_ext1(self):
1542 code = self.read(1)[0]
1543 self.get_extension(code)
1546 def load_ext2(self):
1547 code, = unpack('<H', self.read(2))
1548 self.get_extension(code)
1551 def load_ext4(self):
1552 code, = unpack('<i', self.read(4))
1553 self.get_extension(code)
1556 def get_extension(self, code):
1560 self.append(obj)
1568 obj = self.find_class(*key)
1570 self.append(obj)
1572 def find_class(self, module, name):
1575 if self.proto < 3 and self.fix_imports:
1581 if self.proto >= 4:
1586 def load_reduce(self):
1587 stack = self.stack
1593 def load_pop(self):
1594 if self.stack:
1595 del self.stack[-1]
1597 self.pop_mark()
1600 def load_pop_mark(self):
1601 self.pop_mark()
1604 def load_dup(self):
1605 self.append(self.stack[-1])
1608 def load_get(self):
1609 i = int(self.readline()[:-1])
1611 self.append(self.memo[i])
1617 def load_binget(self):
1618 i = self.read(1)[0]
1620 self.append(self.memo[i])
1626 def load_long_binget(self):
1627 i, = unpack('<I', self.read(4))
1629 self.append(self.memo[i])
1635 def load_put(self):
1636 i = int(self.readline()[:-1])
1639 self.memo[i] = self.stack[-1]
1642 def load_binput(self):
1643 i = self.read(1)[0]
1646 self.memo[i] = self.stack[-1]
1649 def load_long_binput(self):
1650 i, = unpack('<I', self.read(4))
1653 self.memo[i] = self.stack[-1]
1656 def load_memoize(self):
1657 memo = self.memo
1658 memo[len(memo)] = self.stack[-1]
1661 def load_append(self):
1662 stack = self.stack
1668 def load_appends(self):
1669 items = self.pop_mark()
1670 list_obj = self.stack[-1]
1686 def load_setitem(self):
1687 stack = self.stack
1694 def load_setitems(self):
1695 items = self.pop_mark()
1696 dict = self.stack[-1]
1701 def load_additems(self):
1702 items = self.pop_mark()
1703 set_obj = self.stack[-1]
1712 def load_build(self):
1713 stack = self.stack
1736 def load_mark(self):
1737 self.metastack.append(self.stack)
1738 self.stack = []
1739 self.append = self.stack.append
1742 def load_stop(self):
1743 value = self.stack.pop()
1806 help='run self-test suite')
1809 help='run verbosely; only affects self-test run')