1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
import sys
from collections.abc import Callable, Iterator, MutableMapping
from typing import IO, Any
from typing_extensions import TypeAlias
__all__ = ["dis", "genops", "optimize"]
_Reader: TypeAlias = Callable[[IO[bytes]], Any]
bytes_types: tuple[type[Any], ...]
UP_TO_NEWLINE: int
TAKEN_FROM_ARGUMENT1: int
TAKEN_FROM_ARGUMENT4: int
TAKEN_FROM_ARGUMENT4U: int
TAKEN_FROM_ARGUMENT8U: int
class ArgumentDescriptor:
name: str
n: int
reader: _Reader
doc: str
def __init__(self, name: str, n: int, reader: _Reader, doc: str) -> None: ...
def read_uint1(f: IO[bytes]) -> int: ...
uint1: ArgumentDescriptor
def read_uint2(f: IO[bytes]) -> int: ...
uint2: ArgumentDescriptor
def read_int4(f: IO[bytes]) -> int: ...
int4: ArgumentDescriptor
def read_uint4(f: IO[bytes]) -> int: ...
uint4: ArgumentDescriptor
def read_uint8(f: IO[bytes]) -> int: ...
uint8: ArgumentDescriptor
if sys.version_info >= (3, 12):
def read_stringnl(
f: IO[bytes], decode: bool = True, stripquotes: bool = True, *, encoding: str = "latin-1"
) -> bytes | str: ...
else:
def read_stringnl(f: IO[bytes], decode: bool = True, stripquotes: bool = True) -> bytes | str: ...
stringnl: ArgumentDescriptor
def read_stringnl_noescape(f: IO[bytes]) -> str: ...
stringnl_noescape: ArgumentDescriptor
def read_stringnl_noescape_pair(f: IO[bytes]) -> str: ...
stringnl_noescape_pair: ArgumentDescriptor
def read_string1(f: IO[bytes]) -> str: ...
string1: ArgumentDescriptor
def read_string4(f: IO[bytes]) -> str: ...
string4: ArgumentDescriptor
def read_bytes1(f: IO[bytes]) -> bytes: ...
bytes1: ArgumentDescriptor
def read_bytes4(f: IO[bytes]) -> bytes: ...
bytes4: ArgumentDescriptor
def read_bytes8(f: IO[bytes]) -> bytes: ...
bytes8: ArgumentDescriptor
def read_unicodestringnl(f: IO[bytes]) -> str: ...
unicodestringnl: ArgumentDescriptor
def read_unicodestring1(f: IO[bytes]) -> str: ...
unicodestring1: ArgumentDescriptor
def read_unicodestring4(f: IO[bytes]) -> str: ...
unicodestring4: ArgumentDescriptor
def read_unicodestring8(f: IO[bytes]) -> str: ...
unicodestring8: ArgumentDescriptor
def read_decimalnl_short(f: IO[bytes]) -> int: ...
def read_decimalnl_long(f: IO[bytes]) -> int: ...
decimalnl_short: ArgumentDescriptor
decimalnl_long: ArgumentDescriptor
def read_floatnl(f: IO[bytes]) -> float: ...
floatnl: ArgumentDescriptor
def read_float8(f: IO[bytes]) -> float: ...
float8: ArgumentDescriptor
def read_long1(f: IO[bytes]) -> int: ...
long1: ArgumentDescriptor
def read_long4(f: IO[bytes]) -> int: ...
long4: ArgumentDescriptor
class StackObject:
name: str
obtype: type[Any] | tuple[type[Any], ...]
doc: str
def __init__(self, name: str, obtype: type[Any] | tuple[type[Any], ...], doc: str) -> None: ...
pyint: StackObject
pylong: StackObject
pyinteger_or_bool: StackObject
pybool: StackObject
pyfloat: StackObject
pybytes_or_str: StackObject
pystring: StackObject
pybytes: StackObject
pyunicode: StackObject
pynone: StackObject
pytuple: StackObject
pylist: StackObject
pydict: StackObject
pyset: StackObject
pyfrozenset: StackObject
anyobject: StackObject
markobject: StackObject
stackslice: StackObject
class OpcodeInfo:
name: str
code: str
arg: ArgumentDescriptor | None
stack_before: list[StackObject]
stack_after: list[StackObject]
proto: int
doc: str
def __init__(
self,
name: str,
code: str,
arg: ArgumentDescriptor | None,
stack_before: list[StackObject],
stack_after: list[StackObject],
proto: int,
doc: str,
) -> None: ...
opcodes: list[OpcodeInfo]
def genops(pickle: bytes | bytearray | IO[bytes]) -> Iterator[tuple[OpcodeInfo, Any | None, int | None]]: ...
def optimize(p: bytes | bytearray | IO[bytes]) -> bytes: ...
def dis(
pickle: bytes | bytearray | IO[bytes],
out: IO[str] | None = None,
memo: MutableMapping[int, Any] | None = None,
indentlevel: int = 4,
annotate: int = 0,
) -> None: ...
|
