pickletools

"Executable documentation" for the pickle module.

Extensive comments about the pickle protocols and pickle-machine opcodes
can be found here.  Some functions meant for external use:

genops(pickle)
   Generate all the opcodes in a pickle, as (opcode, arg, position) triples.

dis(pickle, out=None, memo=None, indentlevel=4)
   Print a symbolic disassembly of a pickle.

Classes

ArgumentDescriptor

doc = <member 'doc' of 'ArgumentDescriptor' objects>

n = <member 'n' of 'ArgumentDescriptor' objects>

name = <member 'name' of 'ArgumentDescriptor' objects>

reader = <member 'reader' of 'ArgumentDescriptor' objects>

OpcodeInfo

arg = <member 'arg' of 'OpcodeInfo' objects>

code = <member 'code' of 'OpcodeInfo' objects>

doc = <member 'doc' of 'OpcodeInfo' objects>

name = <member 'name' of 'OpcodeInfo' objects>

proto = <member 'proto' of 'OpcodeInfo' objects>

stack_after = <member 'stack_after' of 'OpcodeInfo' objects>

stack_before = <member 'stack_before' of 'OpcodeInfo' objects>

StackObject

doc = <member 'doc' of 'StackObject' objects>

name = <member 'name' of 'StackObject' objects>

obtype = <member 'obtype' of 'StackObject' objects>

Functions

decode_long

decode_long(data)

  Decode a long from a two's complement little-endian binary string.

      >>> decode_long(b'')
      0
      >>> decode_long(b"\xff\x00")
      255
      >>> decode_long(b"\xff\x7f")
      32767
      >>> decode_long(b"\x00\xff")
      -256
      >>> decode_long(b"\x00\x80")
      -32768
      >>> decode_long(b"\x80")
      -128
      >>> decode_long(b"\x7f")
      127

dis

dis(pickle, out=None, memo=None, indentlevel=4, annotate=0)

  Produce a symbolic disassembly of a pickle.

      'pickle' is a file-like object, or string, containing a (at least one)
      pickle.  The pickle is disassembled from the current position, through
      the first STOP opcode encountered.

      Optional arg 'out' is a file-like object to which the disassembly is
      printed.  It defaults to sys.stdout.

      Optional arg 'memo' is a Python dict, used as the pickle's memo.  It
      may be mutated by dis(), if the pickle contains PUT or BINPUT opcodes.
      Passing the same memo object to another dis() call then allows disassembly
      to proceed across multiple pickles that were all created by the same
      pickler with the same memo.  Ordinarily you don't need to worry about this.

      Optional arg 'indentlevel' is the number of blanks by which to indent
      a new MARK level.  It defaults to 4.

      Optional arg 'annotate' if nonzero instructs dis() to add short
      description of the opcode on each line of disassembled output.
      The value given to 'annotate' must be an integer and is used as a
      hint for the column where annotation should start.  The default
      value is 0, meaning no annotations.

      In addition to printing the disassembly, some sanity checks are made:

      + All embedded opcode arguments "make sense".

      + Explicit and implicit pop operations have enough items on the stack.

      + When an opcode implicitly refers to a markobject, a markobject is
        actually on the stack.

      + A memo entry isn't referenced before it's defined.

      + The markobject isn't stored in the memo.

      + A memo entry isn't redefined.

genops

genops(pickle)

  Generate all the opcodes in a pickle.

      'pickle' is a file-like object, or string, containing the pickle.

      Each opcode in the pickle is generated, from the current pickle position,
      stopping after a STOP opcode is delivered.  A triple is generated for
      each opcode:

          opcode, arg, pos

      opcode is an OpcodeInfo record, describing the current opcode.

      If the opcode has an argument embedded in the pickle, arg is its decoded
      value, as a Python object.  If the opcode doesn't have an argument, arg
      is None.

      If the pickle has a tell() method, pos was the value of pickle.tell()
      before reading the current opcode.  If the pickle is a bytes object,
      it's wrapped in a BytesIO object, and the latter's tell() result is
      used.  Else (the pickle doesn't have a tell(), and it's not obvious how
      to query its current position) pos is None.

optimize

optimize(p)

  Optimize a pickle string by removing unused PUT opcodes

read_bytearray8

read_bytearray8(f)


      >>> import io, struct, sys
      >>> read_bytearray8(io.BytesIO(b"\x00\x00\x00\x00\x00\x00\x00\x00abc"))
      bytearray(b'')
      >>> read_bytearray8(io.BytesIO(b"\x03\x00\x00\x00\x00\x00\x00\x00abcdef"))
      bytearray(b'abc')
      >>> bigsize8 = struct.pack("<Q", sys.maxsize//3)
      >>> read_bytearray8(io.BytesIO(bigsize8 + b"abcdef"))  #doctest: +ELLIPSIS
      Traceback (most recent call last):
      ...
      ValueError: expected ... bytes in a bytearray8, but only 6 remain

read_bytes1

read_bytes1(f)


      >>> import io
      >>> read_bytes1(io.BytesIO(b"\x00"))
      b''
      >>> read_bytes1(io.BytesIO(b"\x03abcdef"))
      b'abc'

read_bytes4

read_bytes4(f)


      >>> import io
      >>> read_bytes4(io.BytesIO(b"\x00\x00\x00\x00abc"))
      b''
      >>> read_bytes4(io.BytesIO(b"\x03\x00\x00\x00abcdef"))
      b'abc'
      >>> read_bytes4(io.BytesIO(b"\x00\x00\x00\x03abcdef"))
      Traceback (most recent call last):
      ...
      ValueError: expected 50331648 bytes in a bytes4, but only 6 remain

read_bytes8

read_bytes8(f)


      >>> import io, struct, sys
      >>> read_bytes8(io.BytesIO(b"\x00\x00\x00\x00\x00\x00\x00\x00abc"))
      b''
      >>> read_bytes8(io.BytesIO(b"\x03\x00\x00\x00\x00\x00\x00\x00abcdef"))
      b'abc'
      >>> bigsize8 = struct.pack("<Q", sys.maxsize//3)
      >>> read_bytes8(io.BytesIO(bigsize8 + b"abcdef"))  #doctest: +ELLIPSIS
      Traceback (most recent call last):
      ...
      ValueError: expected ... bytes in a bytes8, but only 6 remain

read_decimalnl_long

read_decimalnl_long(f)


      >>> import io

      >>> read_decimalnl_long(io.BytesIO(b"1234L\n56"))
      1234

      >>> read_decimalnl_long(io.BytesIO(b"123456789012345678901234L\n6"))
      123456789012345678901234

read_decimalnl_short

read_decimalnl_short(f)


      >>> import io
      >>> read_decimalnl_short(io.BytesIO(b"1234\n56"))
      1234

      >>> read_decimalnl_short(io.BytesIO(b"1234L\n56"))
      Traceback (most recent call last):
      ...
      ValueError: invalid literal for int() with base 10: b'1234L'

read_float8

read_float8(f)


      >>> import io, struct
      >>> raw = struct.pack(">d", -1.25)
      >>> raw
      b'\xbf\xf4\x00\x00\x00\x00\x00\x00'
      >>> read_float8(io.BytesIO(raw + b"\n"))
      -1.25

read_floatnl

read_floatnl(f)


      >>> import io
      >>> read_floatnl(io.BytesIO(b"-1.25\n6"))
      -1.25

read_int4

read_int4(f)


      >>> import io
      >>> read_int4(io.BytesIO(b'\xff\x00\x00\x00'))
      255
      >>> read_int4(io.BytesIO(b'\x00\x00\x00\x80')) == -(2**31)
      True

read_long1

read_long1(f)


      >>> import io
      >>> read_long1(io.BytesIO(b"\x00"))
      0
      >>> read_long1(io.BytesIO(b"\x02\xff\x00"))
      255
      >>> read_long1(io.BytesIO(b"\x02\xff\x7f"))
      32767
      >>> read_long1(io.BytesIO(b"\x02\x00\xff"))
      -256
      >>> read_long1(io.BytesIO(b"\x02\x00\x80"))
      -32768

read_long4

read_long4(f)


      >>> import io
      >>> read_long4(io.BytesIO(b"\x02\x00\x00\x00\xff\x00"))
      255
      >>> read_long4(io.BytesIO(b"\x02\x00\x00\x00\xff\x7f"))
      32767
      >>> read_long4(io.BytesIO(b"\x02\x00\x00\x00\x00\xff"))
      -256
      >>> read_long4(io.BytesIO(b"\x02\x00\x00\x00\x00\x80"))
      -32768
      >>> read_long1(io.BytesIO(b"\x00\x00\x00\x00"))
      0

read_string1

read_string1(f)


      >>> import io
      >>> read_string1(io.BytesIO(b"\x00"))
      ''
      >>> read_string1(io.BytesIO(b"\x03abcdef"))
      'abc'

read_string4

read_string4(f)


      >>> import io
      >>> read_string4(io.BytesIO(b"\x00\x00\x00\x00abc"))
      ''
      >>> read_string4(io.BytesIO(b"\x03\x00\x00\x00abcdef"))
      'abc'
      >>> read_string4(io.BytesIO(b"\x00\x00\x00\x03abcdef"))
      Traceback (most recent call last):
      ...
      ValueError: expected 50331648 bytes in a string4, but only 6 remain

read_stringnl

read_stringnl(f, decode=True, stripquotes=True)


      >>> import io
      >>> read_stringnl(io.BytesIO(b"'abcd'\nefg\n"))
      'abcd'

      >>> read_stringnl(io.BytesIO(b"\n"))
      Traceback (most recent call last):
      ...
      ValueError: no string quotes around b''

      >>> read_stringnl(io.BytesIO(b"\n"), stripquotes=False)
      ''

      >>> read_stringnl(io.BytesIO(b"''\n"))
      ''

      >>> read_stringnl(io.BytesIO(b'"abcd"'))
      Traceback (most recent call last):
      ...
      ValueError: no newline found when trying to read stringnl

      Embedded escapes are undone in the result.
      >>> read_stringnl(io.BytesIO(br"'a\n\\b\x00c\td'" + b"\n'e'"))
      'a\n\\b\x00c\td'

read_stringnl_noescape

read_stringnl_noescape(f)

read_stringnl_noescape_pair

read_stringnl_noescape_pair(f)


      >>> import io
      >>> read_stringnl_noescape_pair(io.BytesIO(b"Queue\nEmpty\njunk"))
      'Queue Empty'

read_uint1

read_uint1(f)


      >>> import io
      >>> read_uint1(io.BytesIO(b'\xff'))
      255

read_uint2

read_uint2(f)


      >>> import io
      >>> read_uint2(io.BytesIO(b'\xff\x00'))
      255
      >>> read_uint2(io.BytesIO(b'\xff\xff'))
      65535

read_uint4

read_uint4(f)


      >>> import io
      >>> read_uint4(io.BytesIO(b'\xff\x00\x00\x00'))
      255
      >>> read_uint4(io.BytesIO(b'\x00\x00\x00\x80')) == 2**31
      True

read_uint8

read_uint8(f)


      >>> import io
      >>> read_uint8(io.BytesIO(b'\xff\x00\x00\x00\x00\x00\x00\x00'))
      255
      >>> read_uint8(io.BytesIO(b'\xff' * 8)) == 2**64-1
      True

read_unicodestring1

read_unicodestring1(f)


      >>> import io
      >>> s = 'abcd\uabcd'
      >>> enc = s.encode('utf-8')
      >>> enc
      b'abcd\xea\xaf\x8d'
      >>> n = bytes([len(enc)])  # little-endian 1-byte length
      >>> t = read_unicodestring1(io.BytesIO(n + enc + b'junk'))
      >>> s == t
      True

      >>> read_unicodestring1(io.BytesIO(n + enc[:-1]))
      Traceback (most recent call last):
      ...
      ValueError: expected 7 bytes in a unicodestring1, but only 6 remain

read_unicodestring4

read_unicodestring4(f)


      >>> import io
      >>> s = 'abcd\uabcd'
      >>> enc = s.encode('utf-8')
      >>> enc
      b'abcd\xea\xaf\x8d'
      >>> n = bytes([len(enc), 0, 0, 0])  # little-endian 4-byte length
      >>> t = read_unicodestring4(io.BytesIO(n + enc + b'junk'))
      >>> s == t
      True

      >>> read_unicodestring4(io.BytesIO(n + enc[:-1]))
      Traceback (most recent call last):
      ...
      ValueError: expected 7 bytes in a unicodestring4, but only 6 remain

read_unicodestring8

read_unicodestring8(f)


      >>> import io
      >>> s = 'abcd\uabcd'
      >>> enc = s.encode('utf-8')
      >>> enc
      b'abcd\xea\xaf\x8d'
      >>> n = bytes([len(enc)]) + b'\0' * 7  # little-endian 8-byte length
      >>> t = read_unicodestring8(io.BytesIO(n + enc + b'junk'))
      >>> s == t
      True

      >>> read_unicodestring8(io.BytesIO(n + enc[:-1]))
      Traceback (most recent call last):
      ...
      ValueError: expected 7 bytes in a unicodestring8, but only 6 remain

read_unicodestringnl

read_unicodestringnl(f)


      >>> import io
      >>> read_unicodestringnl(io.BytesIO(b"abc\\uabcd\njunk")) == 'abc\uabcd'
      True

Other members

TAKEN_FROM_ARGUMENT1 = -2

TAKEN_FROM_ARGUMENT4 = -3

TAKEN_FROM_ARGUMENT4U = -4

TAKEN_FROM_ARGUMENT8U = -5

UP_TO_NEWLINE = -1

anyobject = any

bytearray8 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f940>

bytes1 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f880>

bytes4 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f8c0>

bytes8 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f900>

bytes_types = (<class 'bytes'>, <class 'bytearray'>)

code2op = {'I': <pickletools.OpcodeInfo object at 0x7f75e0b84640>, 'J': <pickletools.OpcodeInfo object at 0x7f75e0b84700>, 'K': <pickletools.OpcodeInfo object at 0x7f75e0b84760>, 'M': <pickletools.OpcodeInfo object at 0x7f75e0b847c0>, 'L': <pickletools.OpcodeInfo object at 0x7f75e0b84820>, '\x8a': <pickletools.OpcodeInfo object at 0x7f75e0b84880>, '\x8b': <pickletools.OpcodeInfo object at 0x7f75e0b848e0>, 'S': <pickletools.OpcodeInfo object at 0x7f75e0b84940>, 'T': <pickletools.OpcodeInfo object at 0x7f75e0b849a0>, 'U': <pickletools.OpcodeInfo object at 0x7f75e0b84a00>, 'B': <pickletools.OpcodeInfo object at 0x7f75e0b84a60>, 'C': <pickletools.OpcodeInfo object at 0x7f75e0b84ac0>, '\x8e': <pickletools.OpcodeInfo object at 0x7f75e0b84b20>, '\x96': <pickletools.OpcodeInfo object at 0x7f75e0b84b80>, '\x97': <pickletools.OpcodeInfo object at 0x7f75e0b84be0>, '\x98': <pickletools.OpcodeInfo object at 0x7f75e0b84c40>, 'N': <pickletools.OpcodeInfo object at 0x7f75e0b84ca0>, '\x88': <pickletools.OpcodeInfo object at 0x7f75e0b84d00>, '\x89': <pickletools.OpcodeInfo object at 0x7f75e0b84d60>, 'V': <pickletools.OpcodeInfo object at 0x7f75e0b84dc0>, '\x8c': <pickletools.OpcodeInfo object at 0x7f75e0b84e20>, 'X': <pickletools.OpcodeInfo object at 0x7f75e0b84e80>, '\x8d': <pickletools.OpcodeInfo object at 0x7f75e0b84ee0>, 'F': <pickletools.OpcodeInfo object at 0x7f75e0b84f40>, 'G': <pickletools.OpcodeInfo object at 0x7f75e0b84fa0>, ']': <pickletools.OpcodeInfo object at 0x7f75e0b85000>, 'a': <pickletools.OpcodeInfo object at 0x7f75e0b85060>, 'e': <pickletools.OpcodeInfo object at 0x7f75e0b850c0>, 'l': <pickletools.OpcodeInfo object at 0x7f75e0b85120>, ')': <pickletools.OpcodeInfo object at 0x7f75e0b85180>, 't': <pickletools.OpcodeInfo object at 0x7f75e0b851e0>, '\x85': <pickletools.OpcodeInfo object at 0x7f75e0b85240>, '\x86': <pickletools.OpcodeInfo object at 0x7f75e0b852a0>, '\x87': <pickletools.OpcodeInfo object at 0x7f75e0b85300>, '}': <pickletools.OpcodeInfo object at 0x7f75e0b85360>, 'd': <pickletools.OpcodeInfo object at 0x7f75e0b853c0>, 's': <pickletools.OpcodeInfo object at 0x7f75e0b85420>, 'u': <pickletools.OpcodeInfo object at 0x7f75e0b85480>, '\x8f': <pickletools.OpcodeInfo object at 0x7f75e0b854e0>, '\x90': <pickletools.OpcodeInfo object at 0x7f75e0b85540>, '\x91': <pickletools.OpcodeInfo object at 0x7f75e0b855a0>, '0': <pickletools.OpcodeInfo object at 0x7f75e0b85600>, '2': <pickletools.OpcodeInfo object at 0x7f75e0b85660>, '(': <pickletools.OpcodeInfo object at 0x7f75e0b856c0>, '1': <pickletools.OpcodeInfo object at 0x7f75e0b85720>, 'g': <pickletools.OpcodeInfo object at 0x7f75e0b85780>, 'h': <pickletools.OpcodeInfo object at 0x7f75e0b857e0>, 'j': <pickletools.OpcodeInfo object at 0x7f75e0b85840>, 'p': <pickletools.OpcodeInfo object at 0x7f75e0b858a0>, 'q': <pickletools.OpcodeInfo object at 0x7f75e0b85900>, 'r': <pickletools.OpcodeInfo object at 0x7f75e0b85960>, '\x94': <pickletools.OpcodeInfo object at 0x7f75e0b859c0>, '\x82': <pickletools.OpcodeInfo object at 0x7f75e0b85a20>, '\x83': <pickletools.OpcodeInfo object at 0x7f75e0b85a80>, '\x84': <pickletools.OpcodeInfo object at 0x7f75e0b85ae0>, 'c': <pickletools.OpcodeInfo object at 0x7f75e0b85b40>, '\x93': <pickletools.OpcodeInfo object at 0x7f75e0b85ba0>, 'R': <pickletools.OpcodeInfo object at 0x7f75e0b85c00>, 'b': <pickletools.OpcodeInfo object at 0x7f75e0b85c60>, 'i': <pickletools.OpcodeInfo object at 0x7f75e0b85cc0>, 'o': <pickletools.OpcodeInfo object at 0x7f75e0b85d20>, '\x81': <pickletools.OpcodeInfo object at 0x7f75e0b85d80>, '\x92': <pickletools.OpcodeInfo object at 0x7f75e0b85de0>, '\x80': <pickletools.OpcodeInfo object at 0x7f75e0b85e40>, '.': <pickletools.OpcodeInfo object at 0x7f75e0b85ea0>, '\x95': <pickletools.OpcodeInfo object at 0x7f75e0b85f00>, 'P': <pickletools.OpcodeInfo object at 0x7f75e0b85f60>, 'Q': <pickletools.OpcodeInfo object at 0x7f75e0b85fc0>}

decimalnl_long = <pickletools.ArgumentDescriptor object at 0x7f75e0b7fac0>

decimalnl_short = <pickletools.ArgumentDescriptor object at 0x7f75e0b7fa80>

float8 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7fb40>

floatnl = <pickletools.ArgumentDescriptor object at 0x7f75e0b7fb00>

int4 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f680>

long1 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7fb80>

long4 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7fbc0>

markobject = mark

opcodes = [<pickletools.OpcodeInfo object at 0x7f75e0b84640>, <pickletools.OpcodeInfo object at 0x7f75e0b84700>, <pickletools.OpcodeInfo object at 0x7f75e0b84760>, <pickletools.OpcodeInfo object at 0x7f75e0b847c0>, <pickletools.OpcodeInfo object at 0x7f75e0b84820>, <pickletools.OpcodeInfo object at 0x7f75e0b84880>, <pickletools.OpcodeInfo object at 0x7f75e0b848e0>, <pickletools.OpcodeInfo object at 0x7f75e0b84940>, <pickletools.OpcodeInfo object at 0x7f75e0b849a0>, <pickletools.OpcodeInfo object at 0x7f75e0b84a00>, <pickletools.OpcodeInfo object at 0x7f75e0b84a60>, <pickletools.OpcodeInfo object at 0x7f75e0b84ac0>, <pickletools.OpcodeInfo object at 0x7f75e0b84b20>, <pickletools.OpcodeInfo object at 0x7f75e0b84b80>, <pickletools.OpcodeInfo object at 0x7f75e0b84be0>, <pickletools.OpcodeInfo object at 0x7f75e0b84c40>, <pickletools.OpcodeInfo object at 0x7f75e0b84ca0>, <pickletools.OpcodeInfo object at 0x7f75e0b84d00>, <pickletools.OpcodeInfo object at 0x7f75e0b84d60>, <pickletools.OpcodeInfo object at 0x7f75e0b84dc0>, <pickletools.OpcodeInfo object at 0x7f75e0b84e20>, <pickletools.OpcodeInfo object at 0x7f75e0b84e80>, <pickletools.OpcodeInfo object at 0x7f75e0b84ee0>, <pickletools.OpcodeInfo object at 0x7f75e0b84f40>, <pickletools.OpcodeInfo object at 0x7f75e0b84fa0>, <pickletools.OpcodeInfo object at 0x7f75e0b85000>, <pickletools.OpcodeInfo object at 0x7f75e0b85060>, <pickletools.OpcodeInfo object at 0x7f75e0b850c0>, <pickletools.OpcodeInfo object at 0x7f75e0b85120>, <pickletools.OpcodeInfo object at 0x7f75e0b85180>, <pickletools.OpcodeInfo object at 0x7f75e0b851e0>, <pickletools.OpcodeInfo object at 0x7f75e0b85240>, <pickletools.OpcodeInfo object at 0x7f75e0b852a0>, <pickletools.OpcodeInfo object at 0x7f75e0b85300>, <pickletools.OpcodeInfo object at 0x7f75e0b85360>, <pickletools.OpcodeInfo object at 0x7f75e0b853c0>, <pickletools.OpcodeInfo object at 0x7f75e0b85420>, <pickletools.OpcodeInfo object at 0x7f75e0b85480>, <pickletools.OpcodeInfo object at 0x7f75e0b854e0>, <pickletools.OpcodeInfo object at 0x7f75e0b85540>, <pickletools.OpcodeInfo object at 0x7f75e0b855a0>, <pickletools.OpcodeInfo object at 0x7f75e0b85600>, <pickletools.OpcodeInfo object at 0x7f75e0b85660>, <pickletools.OpcodeInfo object at 0x7f75e0b856c0>, <pickletools.OpcodeInfo object at 0x7f75e0b85720>, <pickletools.OpcodeInfo object at 0x7f75e0b85780>, <pickletools.OpcodeInfo object at 0x7f75e0b857e0>, <pickletools.OpcodeInfo object at 0x7f75e0b85840>, <pickletools.OpcodeInfo object at 0x7f75e0b858a0>, <pickletools.OpcodeInfo object at 0x7f75e0b85900>, <pickletools.OpcodeInfo object at 0x7f75e0b85960>, <pickletools.OpcodeInfo object at 0x7f75e0b859c0>, <pickletools.OpcodeInfo object at 0x7f75e0b85a20>, <pickletools.OpcodeInfo object at 0x7f75e0b85a80>, <pickletools.OpcodeInfo object at 0x7f75e0b85ae0>, <pickletools.OpcodeInfo object at 0x7f75e0b85b40>, <pickletools.OpcodeInfo object at 0x7f75e0b85ba0>, <pickletools.OpcodeInfo object at 0x7f75e0b85c00>, <pickletools.OpcodeInfo object at 0x7f75e0b85c60>, <pickletools.OpcodeInfo object at 0x7f75e0b85cc0>, <pickletools.OpcodeInfo object at 0x7f75e0b85d20>, <pickletools.OpcodeInfo object at 0x7f75e0b85d80>, <pickletools.OpcodeInfo object at 0x7f75e0b85de0>, <pickletools.OpcodeInfo object at 0x7f75e0b85e40>, <pickletools.OpcodeInfo object at 0x7f75e0b85ea0>, <pickletools.OpcodeInfo object at 0x7f75e0b85f00>, <pickletools.OpcodeInfo object at 0x7f75e0b85f60>, <pickletools.OpcodeInfo object at 0x7f75e0b85fc0>]

pybool = bool

pybuffer = buffer

pybytearray = bytearray

pybytes = bytes

pybytes_or_str = bytes_or_str

pydict = dict

pyfloat = float

pyfrozenset = frozenset

pyint = int

pyinteger_or_bool = int_or_bool

pylist = list

pylong = int

pynone = None

pyset = set

pystring = bytes_or_str

pytuple = tuple

pyunicode = str

stackslice = stackslice

string1 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f800>

string4 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f840>

stringnl = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f740>

stringnl_noescape = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f780>

stringnl_noescape_pair = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f7c0>

uint1 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f640>

uint2 = <pickletools.ArgumentDescriptor object at 0x7f75e0d49c40>

uint4 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f6c0>

uint8 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f700>

unicodestring1 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f9c0>

unicodestring4 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7fa00>

unicodestring8 = <pickletools.ArgumentDescriptor object at 0x7f75e0b7fa40>

unicodestringnl = <pickletools.ArgumentDescriptor object at 0x7f75e0b7f980>

Modules

codecs

pickle

sys