PEP 8 (keep to 80 chars)

Author: AA-Turner

Tools/jit/.ruff.toml

@@ -1,7 +1,5 @@
 extend = "../../.ruff.toml"  # Inherit the project-wide settings
 
-line-length = 88
-
 [format]
 preview = true
 docstring-code-format = true

Tools/jit/_llvm.py

@@ -9,7 +9,9 @@
 import typing
 
 _LLVM_VERSION = 19
-_LLVM_VERSION_PATTERN = re.compile(rf"version\s+{_LLVM_VERSION}\.\d+\.\d+\S*\s+")
+_LLVM_VERSION_PATTERN = re.compile(
+    rf"version\s+{_LLVM_VERSION}\.\d+\.\d+\S*\s+"
+)
 
 _P = typing.ParamSpec("_P")
 _R = typing.TypeVar("_R")
@@ -33,7 +35,9 @@ async def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R:
 _CORES = asyncio.BoundedSemaphore(os.cpu_count() or 1)
 
 
-async def _run(tool: str, args: typing.Iterable[str], echo: bool = False) -> str | None:
+async def _run(
+    tool: str, args: typing.Iterable[str], echo: bool = False
+) -> str | None:
     command = [tool, *args]
     async with _CORES:
         if echo:
@@ -46,7 +50,9 @@ async def _run(tool: str, args: typing.Iterable[str], echo: bool = False) -> str
             return None
         out, _ = await process.communicate()
     if process.returncode:
-        raise RuntimeError(f"{tool} exited with return code {process.returncode}")
+        raise RuntimeError(
+            f"{tool} exited with return code {process.returncode}"
+        )
     return out.decode()
 
 
@@ -58,7 +64,9 @@ async def _check_tool_version(name: str, *, echo: bool = False) -> bool:
 
 @_async_cache
 async def _get_brew_llvm_prefix(*, echo: bool = False) -> str | None:
-    output = await _run("brew", ["--prefix", f"llvm@{_LLVM_VERSION}"], echo=echo)
+    output = await _run(
+        "brew", ["--prefix", f"llvm@{_LLVM_VERSION}"], echo=echo
+    )
     return output and output.removesuffix("\n")
 
 
@@ -90,7 +98,9 @@ async def maybe_run(
     return path and await _run(path, args, echo=echo)
 
 
-async def run(tool: str, args: typing.Iterable[str], echo: bool = False) -> str:
+async def run(
+    tool: str, args: typing.Iterable[str], echo: bool = False
+) -> str:
     """Run an LLVM tool if it can be found. Otherwise, raise RuntimeError."""
     output = await maybe_run(tool, args, echo=echo)
     if output is None:

Tools/jit/_schema.py

@@ -97,7 +97,9 @@ class COFFSection(typing.TypedDict):
 class ELFSection(typing.TypedDict):
     """An ELF object file section."""
 
-    Flags: dict[typing.Literal["Flags"], list[dict[typing.Literal["Name"], str]]]
+    Flags: dict[
+        typing.Literal["Flags"], list[dict[typing.Literal["Name"], str]]
+    ]
     Index: int
     Info: int
     Relocations: list[dict[typing.Literal["Relocation"], ELFRelocation]]
@@ -110,11 +112,15 @@ class MachOSection(typing.TypedDict):
     """A Mach-O object file section."""
 
     Address: int
-    Attributes: dict[typing.Literal["Flags"], list[dict[typing.Literal["Name"], str]]]
+    Attributes: dict[
+        typing.Literal["Flags"], list[dict[typing.Literal["Name"], str]]
+    ]
     Index: int
     Name: dict[typing.Literal["Value"], str]
     Relocations: typing.NotRequired[
         list[dict[typing.Literal["Relocation"], MachORelocation]]
     ]
     SectionData: typing.NotRequired[dict[typing.Literal["Bytes"], list[int]]]
-    Symbols: typing.NotRequired[list[dict[typing.Literal["Symbol"], _MachOSymbol]]]
+    Symbols: typing.NotRequired[
+        list[dict[typing.Literal["Symbol"], _MachOSymbol]]
+    ]

Tools/jit/_stencils.py

@@ -199,14 +199,18 @@ class Stencil:
 
     body: bytearray = dataclasses.field(default_factory=bytearray, init=False)
     holes: list[Hole] = dataclasses.field(default_factory=list, init=False)
-    disassembly: list[str] = dataclasses.field(default_factory=list, init=False)
+    disassembly: list[str] = dataclasses.field(
+        default_factory=list, init=False
+    )
 
     def pad(self, alignment: int) -> None:
         """Pad the stencil to the given alignment."""
         offset = len(self.body)
         padding = -offset % alignment
         if padding:
-            self.disassembly.append(f"{offset:x}: {' '.join(['00'] * padding)}")
+            self.disassembly.append(
+                f"{offset:x}: {' '.join(['00'] * padding)}"
+            )
         self.body.extend([0] * padding)
 
     def add_nops(self, nop: bytes, alignment: int) -> None:
@@ -291,13 +295,21 @@ class StencilGroup:
     _trampolines: set[int] = dataclasses.field(default_factory=set, init=False)
 
     def process_relocations(
-        self, known_symbols: dict[str, int], *, alignment: int = 1, nop: bytes = b""
+        self,
+        known_symbols: dict[str, int],
+        *,
+        alignment: int = 1,
+        nop: bytes = b"",
     ) -> None:
         """Fix up all GOT and internal relocations for this stencil group."""
         for hole in self.code.holes.copy():
             if (
                 hole.kind
-                in {"R_AARCH64_CALL26", "R_AARCH64_JUMP26", "ARM64_RELOC_BRANCH26"}
+                in {
+                    "R_AARCH64_CALL26",
+                    "R_AARCH64_JUMP26",
+                    "ARM64_RELOC_BRANCH26",
+                }
                 and hole.value is HoleValue.ZERO
                 and hole.symbol not in self.symbols
             ):
@@ -320,7 +332,9 @@ def process_relocations(
                 if hole.value is HoleValue.GOT:
                     assert hole.symbol is not None
                     hole.value = HoleValue.DATA
-                    hole.addend += self._global_offset_table_lookup(hole.symbol)
+                    hole.addend += self._global_offset_table_lookup(
+                        hole.symbol
+                    )
                     hole.symbol = None
                 elif hole.symbol in self.symbols:
                     hole.value, addend = self.symbols[hole.symbol]
@@ -338,7 +352,9 @@ def process_relocations(
         self.data.holes.sort(key=lambda hole: hole.offset)
 
     def _global_offset_table_lookup(self, symbol: str) -> int:
-        return len(self.data.body) + self._got.setdefault(symbol, 8 * len(self._got))
+        return len(self.data.body) + self._got.setdefault(
+            symbol, 8 * len(self._got)
+        )
 
     def _emit_global_offset_table(self) -> None:
         got = len(self.data.body)

Tools/jit/_targets.py

@@ -17,7 +17,9 @@
 import _writer
 
 if sys.version_info < (3, 11):
-    raise RuntimeError("Building the JIT compiler requires Python 3.11 or newer!")
+    raise RuntimeError(
+        "Building the JIT compiler requires Python 3.11 or newer!"
+    )
 
 TOOLS_JIT_BUILD = pathlib.Path(__file__).resolve()
 TOOLS_JIT = TOOLS_JIT_BUILD.parent
@@ -27,9 +29,14 @@
 TOOLS_JIT_TEMPLATE_C = TOOLS_JIT / "template.c"
 ASYNCIO_RUNNER = asyncio.Runner()
 
-_S = typing.TypeVar("_S", _schema.COFFSection, _schema.ELFSection, _schema.MachOSection)
+_S = typing.TypeVar(
+    "_S", _schema.COFFSection, _schema.ELFSection, _schema.MachOSection
+)
 _R = typing.TypeVar(
-    "_R", _schema.COFFRelocation, _schema.ELFRelocation, _schema.MachORelocation
+    "_R",
+    _schema.COFFRelocation,
+    _schema.ELFRelocation,
+    _schema.MachORelocation,
 )
 
 
@@ -95,7 +102,9 @@ async def _parse(self, path: pathlib.Path) -> _stencils.StencilGroup:
         # ...and also COFF:
         output = output[output.index("[", 1, None) :]
         output = output[: output.rindex("]", None, -1) + 1]
-        sections: list[dict[typing.Literal["Section"], _S]] = json.loads(output)
+        sections: list[dict[typing.Literal["Section"], _S]] = json.loads(
+            output
+        )
         for wrapped_section in sections:
             self._handle_section(wrapped_section["Section"], group)
         assert group.symbols["_JIT_ENTRY"] == (_stencils.HoleValue.CODE, 0)
@@ -104,7 +113,9 @@ async def _parse(self, path: pathlib.Path) -> _stencils.StencilGroup:
             group.data.disassembly.append(line)
         return group
 
-    def _handle_section(self, section: _S, group: _stencils.StencilGroup) -> None:
+    def _handle_section(
+        self, section: _S, group: _stencils.StencilGroup
+    ) -> None:
         raise NotImplementedError(type(self))
 
     def _handle_relocation(
@@ -160,7 +171,9 @@ async def _build_stencils(self) -> dict[str, _stencils.StencilGroup]:
         generated_cases = PYTHON_EXECUTOR_CASES_C_H.read_text()
         cases_and_opnames = sorted(
             re.findall(
-                r"\n {8}(case (\w+): \{\n.*?\n {8}\})", generated_cases, flags=re.DOTALL
+                r"\n {8}(case (\w+): \{\n.*?\n {8}\})",
+                generated_cases,
+                flags=re.DOTALL,
             )
         )
         tasks = []
@@ -200,7 +213,9 @@ def build(
         """Build jit_stencils.h in the given directory."""
         if not self.stable:
             warning = f"JIT support for {self.triple} is still experimental!"
-            request = "Please report any issues you encounter.".center(len(warning))
+            request = "Please report any issues you encounter.".center(
+                len(warning)
+            )
             outline = "=" * len(warning)
             print("\n".join(["", outline, warning, request, outline, ""]))
         digest = f"// {self._compute_digest(out)}\n"
@@ -264,7 +279,9 @@ def _handle_section(
             hole = self._handle_relocation(base, relocation, stencil.body)
             stencil.holes.append(hole)
 
-    def _unwrap_dllimport(self, name: str) -> tuple[_stencils.HoleValue, str | None]:
+    def _unwrap_dllimport(
+        self, name: str
+    ) -> tuple[_stencils.HoleValue, str | None]:
         if name.startswith("__imp_"):
             name = name.removeprefix("__imp_")
             name = name.removeprefix(self.prefix)
@@ -291,13 +308,17 @@ def _handle_relocation(
                 "Offset": offset,
                 "Symbol": s,
                 "Type": {
-                    "Name": "IMAGE_REL_AMD64_REL32" | "IMAGE_REL_I386_REL32" as kind
+                    "Name": "IMAGE_REL_AMD64_REL32"
+                    | "IMAGE_REL_I386_REL32" as kind
                 },
             }:
                 offset += base
                 value, symbol = self._unwrap_dllimport(s)
                 addend = (
-                    int.from_bytes(raw[offset : offset + 4], "little", signed=True) - 4
+                    int.from_bytes(
+                        raw[offset : offset + 4], "little", signed=True
+                    )
+                    - 4
                 )
             case {
                 "Offset": offset,
@@ -429,7 +450,12 @@ def _handle_section(
         base = section["Address"] - start_address
         group.symbols[section["Index"]] = value, base
         stencil.body.extend(
-            [0] * (section["Address"] - len(group.code.body) - len(group.data.body))
+            [0]
+            * (
+                section["Address"]
+                - len(group.code.body)
+                - len(group.data.body)
+            )
         )
         stencil.body.extend(section["SectionData"]["Bytes"])
         assert "Symbols" in section
@@ -468,13 +494,19 @@ def _handle_relocation(
             case {
                 "Offset": offset,
                 "Symbol": {"Name": s},
-                "Type": {"Name": "X86_64_RELOC_GOT" | "X86_64_RELOC_GOT_LOAD" as kind},
+                "Type": {
+                    "Name": "X86_64_RELOC_GOT"
+                    | "X86_64_RELOC_GOT_LOAD" as kind
+                },
             }:
                 offset += base
                 s = s.removeprefix(self.prefix)
                 value, symbol = _stencils.HoleValue.GOT, s
                 addend = (
-                    int.from_bytes(raw[offset : offset + 4], "little", signed=True) - 4
+                    int.from_bytes(
+                        raw[offset : offset + 4], "little", signed=True
+                    )
+                    - 4
                 )
             case {
                 "Offset": offset,
@@ -483,13 +515,19 @@ def _handle_relocation(
             } | {
                 "Offset": offset,
                 "Symbol": {"Name": s},
-                "Type": {"Name": "X86_64_RELOC_BRANCH" | "X86_64_RELOC_SIGNED" as kind},
+                "Type": {
+                    "Name": "X86_64_RELOC_BRANCH"
+                    | "X86_64_RELOC_SIGNED" as kind
+                },
             }:
                 offset += base
                 s = s.removeprefix(self.prefix)
                 value, symbol = _stencils.symbol_to_value(s)
                 addend = (
-                    int.from_bytes(raw[offset : offset + 4], "little", signed=True) - 4
+                    int.from_bytes(
+                        raw[offset : offset + 4], "little", signed=True
+                    )
+                    - 4
                 )
             case {
                 "Offset": offset,

Tools/jit/_writer.py

@@ -40,7 +40,9 @@ def _dump_footer(
     yield "};"
 
 
-def _dump_stencil(opname: str, group: _stencils.StencilGroup) -> typing.Iterator[str]:
+def _dump_stencil(
+    opname: str, group: _stencils.StencilGroup
+) -> typing.Iterator[str]:
     yield "void"
     yield f"emit_{opname}("
     yield "    unsigned char *code, unsigned char *data, _PyExecutorObject *executor,"
@@ -62,7 +64,9 @@ def _dump_stencil(opname: str, group: _stencils.StencilGroup) -> typing.Iterator
             yield f"    memcpy({part}, {part}_body, sizeof({part}_body));"
         skip = False
         stencil.holes.sort(key=lambda hole: hole.offset)
-        for hole, pair in itertools.zip_longest(stencil.holes, stencil.holes[1:]):
+        for hole, pair in itertools.zip_longest(
+            stencil.holes, stencil.holes[1:]
+        ):
             if skip:
                 skip = False
                 continue

Tools/jit/build.py

@@ -17,13 +17,22 @@
         help="a PEP 11 target triple to compile for",
     )
     parser.add_argument(
-        "-d", "--debug", action="store_true", help="compile for a debug build of Python"
+        "-d",
+        "--debug",
+        action="store_true",
+        help="compile for a debug build of Python",
     )
     parser.add_argument(
-        "-f", "--force", action="store_true", help="force the entire JIT to be rebuilt"
+        "-f",
+        "--force",
+        action="store_true",
+        help="force the entire JIT to be rebuilt",
     )
     parser.add_argument(
-        "-v", "--verbose", action="store_true", help="echo commands as they are run"
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="echo commands as they are run",
     )
     args = parser.parse_args()
     for target in args.target: