Adminisitrivia

Makefile: add ChangeLog-without-correction to facilitate diff changes
black, 25.12.0 xdis/bytecode.py

Author: rocky

Makefile

@@ -127,12 +127,17 @@ verbose-install:
 install:
 	$(PYTHON) ./setup.py install >/dev/null
 
+#: Remove ChangeLog
 rmChangeLog:
 	rm ChangeLog || true
 
+#: Create ChangeLog from version control without corrections
+ChangeLog-without-corrections:
+	git log --pretty --numstat --summary | $(GIT2CL) >ChangeLog
+
 #: Create a ChangeLog from git via git log and git2cl
 ChangeLog: rmChangeLog
-	git log --pretty --numstat --summary | $(GIT2CL) >$@
+	ChangeLog-without-corrections
 	patch ChangeLog < ChangeLog-spell-corrected.diff
 
 .PHONY: $(PHONY)

xdis/bytecode.py

@@ -70,12 +70,18 @@ def get_const_info(const_index, const_list):
     if const_list is not None:
         arg_val = const_list[const_index]
 
-    arg_repr = prefer_double_quote(repr(arg_val)) if isinstance(arg_val, str) else repr(arg_val)
+    arg_repr = (
+        prefer_double_quote(repr(arg_val))
+        if isinstance(arg_val, str)
+        else repr(arg_val)
+    )
 
     # Float values "nan" and "inf" are not directly representable in Python at least
     # before 3.5 and even there it is via a library constant.
     # So we will canonicalize their representation as float('nan') and float('inf')
-    if isinstance(arg_val, float) and str(arg_val) in frozenset(["nan", "-nan", "inf", "-inf"]):
+    if isinstance(arg_val, float) and str(arg_val) in frozenset(
+        ["nan", "-nan", "inf", "-inf"]
+    ):
         return arg_val, f"float('{arg_val}')"
     return arg_val, arg_repr
 
@@ -172,7 +178,9 @@ def _parse_varint(iterator: Iterator[int]) -> int:
     return val
 
 
-_ExceptionTableEntry = collections.namedtuple("_ExceptionTableEntry", "start end target depth lasti")
+_ExceptionTableEntry = collections.namedtuple(
+    "_ExceptionTableEntry", "start end target depth lasti"
+)
 
 
 def parse_exception_table(exception_table: bytes) -> list:
@@ -272,7 +280,9 @@ def get_logical_instruction_at_offset(
     i = offset
 
     # create a localsplusnames table that resolves duplicates.
-    localsplusnames = (varnames or tuple()) + tuple(name for name in (cells or tuple()) if name not in varnames)
+    localsplusnames = (varnames or tuple()) + tuple(
+        name for name in (cells or tuple()) if name not in varnames
+    )
 
     while i < n and last_op_was_extended_arg:
         op = code2num(bytecode, i)
@@ -299,7 +309,11 @@ def get_logical_instruction_at_offset(
                 # FIXME: Python 3.6.0a1 is 2, for 3.6.a3 we have 1
                 i += 1
             else:
-                arg = code2num(bytecode, i) + code2num(bytecode, i + 1) * 0x100 + extended_arg
+                arg = (
+                    code2num(bytecode, i)
+                    + code2num(bytecode, i + 1) * 0x100
+                    + extended_arg
+                )
                 i += 2
                 extended_arg = arg * 0x10000 if opname == "EXTENDED_ARG" else 0
 
@@ -400,7 +414,10 @@ def get_logical_instruction_at_offset(
                         assert opname == "CALL_FUNCTION_EX"
                         argrepr = format_CALL_FUNCTION_EX(code2num(bytecode, i - 1))
                 else:
-                    if not (fixed_length_instructions or opname in ("RAISE_VARARGS", "DUP_TOPX", "MAKE_FUNCTION")):
+                    if not (
+                        fixed_length_instructions
+                        or opname in ("RAISE_VARARGS", "DUP_TOPX", "MAKE_FUNCTION")
+                    ):
                         argrepr = "%d positional, %d named" % (
                             code2num(bytecode, i - 2),
                             code2num(bytecode, i - 1),
@@ -465,9 +482,17 @@ def get_instructions_bytes(
     constants: tuple = code_object.co_consts
     names: tuple = code_object.co_names
     varnames: tuple = code_object.co_varnames
-    cellvars: tuple = code_object.co_cellvars if hasattr(code_object, "co_cellvars") else tuple()
-    exception_entries = code_object.exception_entries if hasattr(code_object, "exception_entries") else tuple()
-    freevars: tuple = code_object.co_freevars if hasattr(code_object, "co_freevars") else tuple()
+    cellvars: tuple = (
+        code_object.co_cellvars if hasattr(code_object, "co_cellvars") else tuple()
+    )
+    exception_entries = (
+        code_object.exception_entries
+        if hasattr(code_object, "exception_entries")
+        else tuple()
+    )
+    freevars: tuple = (
+        code_object.co_freevars if hasattr(code_object, "co_freevars") else tuple()
+    )
 
     cells = cellvars + freevars
 
@@ -521,7 +546,9 @@ class Bytecode:
     Iterating over these yields the bytecode operations as Instruction instances.
     """
 
-    def __init__(self, x, opc, first_line=None, current_offset=None, dup_lines: bool = True) -> None:
+    def __init__(
+        self, x, opc, first_line=None, current_offset=None, dup_lines: bool = True
+    ) -> None:
         self.codeobj = co = get_code_object(x)
         self._line_offset = 0
         self._cell_names = tuple()
@@ -542,7 +569,11 @@ def __init__(self, x, opc, first_line=None, current_offset=None, dup_lines: bool
         self.opnames = opc.opname
         self.current_offset = current_offset
 
-        if opc.version_tuple >= (3, 11) and not opc.is_pypy and hasattr(co, "co_exceptiontable"):
+        if (
+            opc.version_tuple >= (3, 11)
+            and not opc.is_pypy
+            and hasattr(co, "co_exceptiontable")
+        ):
             self.exception_entries = parse_exception_table(co.co_exceptiontable)
         else:
             self.exception_entries = None
@@ -561,7 +592,9 @@ def from_traceback(cls, tb, opc=None):
             opc = get_opcode_module(sys.version_info, PYTHON_IMPLEMENTATION)
         while tb.tb_next:
             tb = tb.tb_next
-        return cls(tb.tb_frame.f_code, opc=opc, first_line=None, current_offset=tb.tb_lasti)
+        return cls(
+            tb.tb_frame.f_code, opc=opc, first_line=None, current_offset=tb.tb_lasti
+        )
 
     def info(self) -> str:
         """Return formatted information about the code object."""
@@ -647,7 +680,9 @@ def show_source_text(line_number: Optional[int]) -> None:
             if show_source and filename and line_number:
                 source_text = getline(filename, line_number).lstrip()
                 if source_text.startswith('"""'):
-                    source_text = get_docstring(filename, line_number + 1, source_text.rstrip())
+                    source_text = get_docstring(
+                        filename, line_number + 1, source_text.rstrip()
+                    )
                 if source_text:
                     file.write(" " * 13 + "# " + source_text)
 
@@ -743,10 +778,18 @@ def show_source_text(line_number: Optional[int]) -> None:
                 extended_arg_jump_target_offset = None
 
             instructions.append(instr)
-            new_source_line = show_lineno and (extended_arg_starts_line or instr.starts_line is not None and instr.offset >= 0)
+            new_source_line = show_lineno and (
+                extended_arg_starts_line
+                or instr.starts_line is not None
+                and instr.offset >= 0
+            )
             if new_source_line:
                 file.write("\n")
-                show_source_text(extended_arg_starts_line if extended_arg_starts_line else instr.starts_line)
+                show_source_text(
+                    extended_arg_starts_line
+                    if extended_arg_starts_line
+                    else instr.starts_line
+                )
 
             is_current_instr = instr.offset == lasti
 
@@ -775,7 +818,9 @@ def show_source_text(line_number: Optional[int]) -> None:
             # currently we can't track names in this area, but instead use
             # locals and hope the two are the same.
             if instr.opname == "RESERVE_FAST":
-                file.write("# Warning: subsequent LOAD_FAST and STORE_FAST after RESERVE_FAST are inaccurate here in Python before 1.5\n")
+                file.write(
+                    "# Warning: subsequent LOAD_FAST and STORE_FAST after RESERVE_FAST are inaccurate here in Python before 1.5\n"
+                )
             pass
         return instructions
 
@@ -794,7 +839,9 @@ def get_instructions(self, x):
         return get_instructions_bytes(co, self.opc)
 
 
-def list2bytecode(inst_list: Iterable, opc, varnames: str, consts: Tuple[None, int]) -> bytes:
+def list2bytecode(
+    inst_list: Iterable, opc, varnames: str, consts: Tuple[None, int]
+) -> bytes:
     """Convert list/tuple of list/tuples to bytecode
     _names_ contains a list of name objects
     """
@@ -803,15 +850,19 @@ def list2bytecode(inst_list: Iterable, opc, varnames: str, consts: Tuple[None, i
         opname = opcodes[0]
         operands = opcodes[1:]
         if opname not in opc.opname:
-            raise TypeError("error at item %d [%s, %s], opcode not valid" % (i, opname, operands))
+            raise TypeError(
+                "error at item %d [%s, %s], opcode not valid" % (i, opname, operands)
+            )
         opcode = opc.opmap[opname]
         bc.append(opcode)
         print(opname, operands)
         gen = (j for j in operands if operands)
         for j in gen:
             k = (consts if opcode in opc.CONST_OPS else varnames).index(j)
             if k == -1:
-                raise TypeError(f"operand {i} [{opname}, {operands}], not found in names")
+                raise TypeError(
+                    f"operand {i} [{opname}, {operands}], not found in names"
+                )
             else:
                 bc += num2code(k)
                 pass