Revert "PEP 8 (keep to 80 chars)"

This reverts commit 42ce014.

Author: AA-Turner

Tools/jit/.ruff.toml

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

Tools/jit/_llvm.py

@@ -9,9 +9,7 @@
 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")
@@ -35,9 +33,7 @@ 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:
@@ -50,9 +46,7 @@ async def _run(
             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()
 
 
@@ -64,9 +58,7 @@ 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")
 
 
@@ -98,9 +90,7 @@ 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,9 +97,7 @@ 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]]
@@ -112,15 +110,11 @@ 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,18 +199,14 @@ 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:
@@ -295,21 +291,13 @@ 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
             ):
@@ -332,9 +320,7 @@ 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]
@@ -352,9 +338,7 @@ 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,9 +17,7 @@
 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
@@ -29,14 +27,9 @@
 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
 )
 
 
@@ -102,9 +95,7 @@ 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)
@@ -113,9 +104,7 @@ 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(
@@ -171,9 +160,7 @@ 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 = []
@@ -213,9 +200,7 @@ 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"
@@ -279,9 +264,7 @@ 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)
@@ -308,17 +291,13 @@ 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,
@@ -450,12 +429,7 @@ 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
@@ -494,19 +468,13 @@ 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,
@@ -515,19 +483,13 @@ 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,9 +40,7 @@ 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,"
@@ -64,9 +62,7 @@ def _dump_stencil(
             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,22 +17,13 @@
         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: