coverage 7.6.7__cp311-cp311-win_amd64.whl → 7.11.1__cp311-cp311-win_amd64.whl

coverage/sqlitedb.py

@@ -8,9 +8,8 @@ from __future__ import annotations
 import contextlib
 import re
 import sqlite3
-
-from typing import cast, Any
 from collections.abc import Iterable, Iterator
+from typing import Any, cast
 
 from coverage.debug import auto_repr, clipped_repr, exc_one_line
 from coverage.exceptions import DataError
@@ -29,9 +28,11 @@ class SqliteDb:
                     etc(a, b)
 
     """
-    def __init__(self, filename: str, debug: TDebugCtl) -> None:
+
+    def __init__(self, filename: str, debug: TDebugCtl, no_disk: bool = False) -> None:
         self.debug = debug
         self.filename = filename
+        self.no_disk = no_disk
         self.nest = 0
         self.con: sqlite3.Connection | None = None
 
@@ -50,7 +51,11 @@ class SqliteDb:
         if self.debug.should("sql"):
             self.debug.write(f"Connecting to {self.filename!r}")
         try:
-            self.con = sqlite3.connect(self.filename, check_same_thread=False)
+            # Use uri=True when connecting to memory URIs
+            if self.filename.startswith("file:"):
+                self.con = sqlite3.connect(self.filename, check_same_thread=False, uri=True)
+            else:
+                self.con = sqlite3.connect(self.filename, check_same_thread=False)
         except sqlite3.Error as exc:
             raise DataError(f"Couldn't use data file {self.filename!r}: {exc}") from exc
 
@@ -64,8 +69,9 @@ class SqliteDb:
         # In Python 3.12+, we can change the config to allow journal_mode=off.
         if hasattr(sqlite3, "SQLITE_DBCONFIG_DEFENSIVE"):
             # Turn off defensive mode, so that journal_mode=off can succeed.
-            self.con.setconfig(                     # type: ignore[attr-defined, unused-ignore]
-                sqlite3.SQLITE_DBCONFIG_DEFENSIVE, False,
+            self.con.setconfig(  # type: ignore[attr-defined, unused-ignore]
+                sqlite3.SQLITE_DBCONFIG_DEFENSIVE,
+                False,
             )
 
         # This pragma makes writing faster. It disables rollbacks, but we never need them.
@@ -76,13 +82,14 @@ class SqliteDb:
         # to keep things going.
         self.execute_void("pragma synchronous=off", fail_ok=True)
 
-    def close(self) -> None:
+    def close(self, force: bool = False) -> None:
         """If needed, close the connection."""
-        if self.con is not None and self.filename != ":memory:":
-            if self.debug.should("sql"):
-                self.debug.write(f"Closing {self.con!r} on {self.filename!r}")
-            self.con.close()
-            self.con = None
+        if self.con is not None:
+            if force or not self.no_disk:
+                if self.debug.should("sql"):
+                    self.debug.write(f"Closing {self.con!r} on {self.filename!r}")
+                self.con.close()
+                self.con = None
 
     def __enter__(self) -> SqliteDb:
         if self.nest == 0:
@@ -92,7 +99,7 @@ class SqliteDb:
         self.nest += 1
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback) -> None:     # type: ignore[no-untyped-def]
+    def __exit__(self, exc_type, exc_value, traceback) -> None:  # type: ignore[no-untyped-def]
         self.nest -= 1
         if self.nest == 0:
             try:
@@ -112,15 +119,15 @@ class SqliteDb:
         try:
             assert self.con is not None
             try:
-                return self.con.execute(sql, parameters)    # type: ignore[arg-type]
+                return self.con.execute(sql, parameters)  # type: ignore[arg-type]
             except Exception:
                 # In some cases, an error might happen that isn't really an
                 # error.  Try again immediately.
                 # https://github.com/nedbat/coveragepy/issues/1010
-                return self.con.execute(sql, parameters)    # type: ignore[arg-type]
+                return self.con.execute(sql, parameters)  # type: ignore[arg-type]
         except sqlite3.Error as exc:
             msg = str(exc)
-            if self.filename != ":memory:":
+            if not self.no_disk:
                 try:
                     # `execute` is the first thing we do with the database, so try
                     # hard to provide useful hints if something goes wrong now.
@@ -128,8 +135,8 @@ class SqliteDb:
                         cov4_sig = b"!coverage.py: This is a private format"
                         if bad_file.read(len(cov4_sig)) == cov4_sig:
                             msg = (
-                                "Looks like a coverage 4.x data file. " +
-                                "Are you mixing versions of coverage?"
+                                "Looks like a coverage 4.x data file. "
+                                + "Are you mixing versions of coverage?"
                             )
                 except Exception:
                     pass
@@ -210,18 +217,19 @@ class SqliteDb:
             # https://github.com/nedbat/coveragepy/issues/1010
             return self.con.executemany(sql, data)
 
-    def executemany_void(self, sql: str, data: Iterable[Any]) -> None:
+    def executemany_void(self, sql: str, data: list[Any]) -> None:
         """Same as :meth:`python:sqlite3.Connection.executemany` when you don't need the cursor."""
-        data = list(data)
-        if data:
-            self._executemany(sql, data).close()
+        self._executemany(sql, data).close()
 
     def executescript(self, script: str) -> None:
         """Same as :meth:`python:sqlite3.Connection.executescript`."""
         if self.debug.should("sql"):
-            self.debug.write("Executing script with {} chars: {}".format(
-                len(script), clipped_repr(script, 100),
-            ))
+            self.debug.write(
+                "Executing script with {} chars: {}".format(
+                    len(script),
+                    clipped_repr(script, 100),
+                )
+            )
         assert self.con is not None
         self.con.executescript(script).close()
 

coverage/sysmon.py

@@ -12,46 +12,48 @@ import os.path
 import sys
 import threading
 import traceback
-
 from dataclasses import dataclass
-from types import CodeType, FrameType
-from typing import (
-    Any,
-    Callable,
-    TYPE_CHECKING,
-    cast,
-)
+from types import CodeType
+from typing import Any, Callable, NewType, Optional, cast
 
+from coverage import env
+from coverage.bytecode import TBranchTrails, always_jumps, branch_trails
 from coverage.debug import short_filename, short_stack
 from coverage.misc import isolate_module
+from coverage.parser import PythonParser
 from coverage.types import (
     AnyCallable,
-    TArc,
     TFileDisposition,
     TLineNo,
+    TOffset,
+    Tracer,
     TShouldStartContextFn,
     TShouldTraceFn,
     TTraceData,
     TTraceFileData,
-    Tracer,
     TWarnFn,
 )
 
+# Only needed for some of the commented-out logging:
+# from coverage.debug import ppformat
+
 os = isolate_module(os)
 
 # pylint: disable=unused-argument
 
-LOG = False
+# $set_env.py: COVERAGE_SYSMON_LOG - Log sys.monitoring activity
+LOG = bool(int(os.getenv("COVERAGE_SYSMON_LOG", 0)))
+
+# $set_env.py: COVERAGE_SYSMON_STATS - Collect sys.monitoring stats
+COLLECT_STATS = bool(int(os.getenv("COVERAGE_SYSMON_STATS", 0)))
 
 # This module will be imported in all versions of Python, but only used in 3.12+
 # It will be type-checked for 3.12, but not for earlier versions.
 sys_monitoring = getattr(sys, "monitoring", None)
 
-if TYPE_CHECKING:
-    assert sys_monitoring is not None
-    # I want to say this but it's not allowed:
-    #   MonitorReturn = Literal[sys.monitoring.DISABLE] | None
-    MonitorReturn = Any
+DISABLE_TYPE = NewType("DISABLE_TYPE", object)
+MonitorReturn = Optional[DISABLE_TYPE]
+DISABLE = cast(MonitorReturn, getattr(sys_monitoring, "DISABLE", None))
 
 
 if LOG:  # pragma: debugging
@@ -74,7 +76,10 @@ if LOG:  # pragma: debugging
     assert sys_monitoring is not None
 
     short_stack = functools.partial(
-        short_stack, full=True, short_filenames=True, frame_ids=True,
+        short_stack,
+        full=True,
+        short_filenames=True,
+        frame_ids=True,
     )
     seen_threads: set[int] = set()
 
@@ -96,8 +101,11 @@ if LOG:  # pragma: debugging
             # f"{root}-{pid}.out",
             # f"{root}-{pid}-{tslug}.out",
         ]:
-            with open(filename, "a") as f:
-                print(f"{pid}:{tslug}: {msg}", file=f, flush=True)
+            with open(filename, "a", encoding="utf-8") as f:
+                try:
+                    print(f"{pid}:{tslug}: {msg}", file=f, flush=True)
+                except UnicodeError:
+                    print(f"{pid}:{tslug}: {ascii(msg)}", file=f, flush=True)
 
     def arg_repr(arg: Any) -> str:
         """Make a customized repr for logged values."""
@@ -128,7 +136,8 @@ if LOG:  # pragma: debugging
                     return ret
                 except Exception as exc:
                     log(f"!!{exc.__class__.__name__}: {exc}")
-                    log("".join(traceback.format_exception(exc))) # pylint: disable=[no-value-for-parameter]
+                    if 1:
+                        log("".join(traceback.format_exception(exc)))
                     try:
                         assert sys_monitoring is not None
                         sys_monitoring.set_events(sys.monitoring.COVERAGE_ID, 0)
@@ -161,11 +170,22 @@ class CodeInfo:
 
     tracing: bool
     file_data: TTraceFileData | None
-    # TODO: what is byte_to_line for?
-    byte_to_line: dict[int, int] | None
+    byte_to_line: dict[TOffset, TLineNo] | None
+
+    # Keys are start instruction offsets for branches.
+    # Values are dicts:
+    #   {
+    #       (from_line, to_line): {offset, offset, ...},
+    #       (from_line, to_line): {offset, offset, ...},
+    #   }
+    branch_trails: TBranchTrails
 
+    # Always-jumps are bytecode offsets that do no work but move
+    # to another offset.
+    always_jumps: dict[TOffset, TOffset]
 
-def bytes_to_lines(code: CodeType) -> dict[int, int]:
+
+def bytes_to_lines(code: CodeType) -> dict[TOffset, TLineNo]:
     """Make a dict mapping byte code offsets to line numbers."""
     b2l = {}
     for bstart, bend, lineno in code.co_lines():
@@ -202,17 +222,16 @@ class SysMonitor(Tracer):
         # A list of code_objects, just to keep them alive so that id's are
         # useful as identity.
         self.code_objects: list[CodeType] = []
-        self.last_lines: dict[FrameType, int] = {}
-        # Map id(code_object) -> code_object
-        self.local_event_codes: dict[int, CodeType] = {}
         self.sysmon_on = False
         self.lock = threading.Lock()
 
-        self.stats = {
-            "starts": 0,
-        }
+        self.stats: dict[str, int] | None = None
+        if COLLECT_STATS:
+            self.stats = dict.fromkeys(
+                "starts start_tracing returns line_lines line_arcs branches branch_trails".split(),
+                0,
+            )
 
-        self.stopped = False
         self._activity = False
 
     def __repr__(self) -> str:
@@ -223,44 +242,43 @@ class SysMonitor(Tracer):
     @panopticon()
     def start(self) -> None:
         """Start this Tracer."""
-        self.stopped = False
-
-        assert sys_monitoring is not None
-        sys_monitoring.use_tool_id(self.myid, "coverage.py")
-        register = functools.partial(sys_monitoring.register_callback, self.myid)
-        events = sys_monitoring.events
-        if self.trace_arcs:
-            sys_monitoring.set_events(
-                self.myid,
-                events.PY_START | events.PY_UNWIND,
-            )
-            register(events.PY_START, self.sysmon_py_start)
-            register(events.PY_RESUME, self.sysmon_py_resume_arcs)
-            register(events.PY_RETURN, self.sysmon_py_return_arcs)
-            register(events.PY_UNWIND, self.sysmon_py_unwind_arcs)
-            register(events.LINE, self.sysmon_line_arcs)
-        else:
+        with self.lock:
+            assert sys_monitoring is not None
+            sys_monitoring.use_tool_id(self.myid, "coverage.py")
+            register = functools.partial(sys_monitoring.register_callback, self.myid)
+            events = sys.monitoring.events
+
             sys_monitoring.set_events(self.myid, events.PY_START)
             register(events.PY_START, self.sysmon_py_start)
-            register(events.LINE, self.sysmon_line_lines)
-        sys_monitoring.restart_events()
-        self.sysmon_on = True
+            if self.trace_arcs:
+                register(events.PY_RETURN, self.sysmon_py_return)
+                register(events.LINE, self.sysmon_line_arcs)
+                if env.PYBEHAVIOR.branch_right_left:
+                    register(
+                        events.BRANCH_RIGHT,  # type:ignore[attr-defined]
+                        self.sysmon_branch_either,
+                    )
+                    register(
+                        events.BRANCH_LEFT,  # type:ignore[attr-defined]
+                        self.sysmon_branch_either,
+                    )
+            else:
+                register(events.LINE, self.sysmon_line_lines)
+            sys_monitoring.restart_events()
+            self.sysmon_on = True
 
     @panopticon()
     def stop(self) -> None:
         """Stop this Tracer."""
-        if not self.sysmon_on:
-            # In forking situations, we might try to stop when we are not
-            # started.  Do nothing in that case.
-            return
-        assert sys_monitoring is not None
-        sys_monitoring.set_events(self.myid, 0)
         with self.lock:
+            if not self.sysmon_on:
+                # In forking situations, we might try to stop when we are not
+                # started.  Do nothing in that case.
+                return
+            assert sys_monitoring is not None
+            sys_monitoring.set_events(self.myid, 0)
             self.sysmon_on = False
-            for code in self.local_event_codes.values():
-                sys_monitoring.set_local_events(self.myid, code, 0)
-            self.local_event_codes = {}
-        sys_monitoring.free_tool_id(self.myid)
+            sys_monitoring.free_tool_id(self.myid)
 
     @panopticon()
     def post_fork(self) -> None:
@@ -277,29 +295,15 @@ class SysMonitor(Tracer):
 
     def get_stats(self) -> dict[str, int] | None:
         """Return a dictionary of statistics, or None."""
-        return None
-
-    # The number of frames in callers_frame takes @panopticon into account.
-    if LOG:
-
-        def callers_frame(self) -> FrameType:
-            """Get the frame of the Python code we're monitoring."""
-            return (
-                inspect.currentframe().f_back.f_back.f_back  # type: ignore[union-attr,return-value]
-            )
-
-    else:
-
-        def callers_frame(self) -> FrameType:
-            """Get the frame of the Python code we're monitoring."""
-            return inspect.currentframe().f_back.f_back  # type: ignore[union-attr,return-value]
+        return self.stats
 
     @panopticon("code", "@")
-    def sysmon_py_start(self, code: CodeType, instruction_offset: int) -> MonitorReturn:
+    def sysmon_py_start(self, code: CodeType, instruction_offset: TOffset) -> MonitorReturn:
         """Handle sys.monitoring.events.PY_START events."""
         # Entering a new frame.  Decide if we should trace in this file.
         self._activity = True
-        self.stats["starts"] += 1
+        if self.stats is not None:
+            self.stats["starts"] += 1
 
         code_info = self.code_infos.get(id(code))
         tracing_code: bool | None = None
@@ -312,10 +316,12 @@ class SysMonitor(Tracer):
             filename = code.co_filename
             disp = self.should_trace_cache.get(filename)
             if disp is None:
-                frame = inspect.currentframe().f_back  # type: ignore[union-attr]
-                if LOG:
-                    # @panopticon adds a frame.
-                    frame = frame.f_back  # type: ignore[union-attr]
+                frame = inspect.currentframe()
+                if frame is not None:
+                    frame = inspect.currentframe().f_back  # type: ignore[union-attr]
+                    if LOG:
+                        # @panopticon adds a frame.
+                        frame = frame.f_back  # type: ignore[union-attr]
                 disp = self.should_trace(filename, frame)  # type: ignore[arg-type]
                 self.should_trace_cache[filename] = disp
 
@@ -335,102 +341,134 @@ class SysMonitor(Tracer):
                 file_data = None
                 b2l = None
 
-            self.code_infos[id(code)] = CodeInfo(
+            code_info = CodeInfo(
                 tracing=tracing_code,
                 file_data=file_data,
                 byte_to_line=b2l,
+                branch_trails={},
+                always_jumps={},
             )
+            self.code_infos[id(code)] = code_info
             self.code_objects.append(code)
 
             if tracing_code:
+                if self.stats is not None:
+                    self.stats["start_tracing"] += 1
                 events = sys.monitoring.events
                 with self.lock:
                     if self.sysmon_on:
                         assert sys_monitoring is not None
-                        sys_monitoring.set_local_events(
-                            self.myid,
-                            code,
-                            events.PY_RETURN
-                            #
-                            | events.PY_RESUME
-                            # | events.PY_YIELD
-                            | events.LINE,
-                            # | events.BRANCH
-                            # | events.JUMP
-                        )
-                        self.local_event_codes[id(code)] = code
-
-        if tracing_code and self.trace_arcs:
-            frame = self.callers_frame()
-            self.last_lines[frame] = -code.co_firstlineno
-            return None
-        else:
-            return sys.monitoring.DISABLE
+                        local_events = events.PY_RETURN | events.PY_RESUME | events.LINE
+                        if self.trace_arcs:
+                            assert env.PYBEHAVIOR.branch_right_left
+                            local_events |= (
+                                events.BRANCH_RIGHT  # type:ignore[attr-defined]
+                                | events.BRANCH_LEFT  # type:ignore[attr-defined]
+                            )
+                        sys_monitoring.set_local_events(self.myid, code, local_events)
 
-    @panopticon("code", "@")
-    def sysmon_py_resume_arcs(
-        self, code: CodeType, instruction_offset: int,
-    ) -> MonitorReturn:
-        """Handle sys.monitoring.events.PY_RESUME events for branch coverage."""
-        frame = self.callers_frame()
-        self.last_lines[frame] = frame.f_lineno
+        return DISABLE
 
     @panopticon("code", "@", None)
-    def sysmon_py_return_arcs(
-        self, code: CodeType, instruction_offset: int, retval: object,
+    def sysmon_py_return(
+        self,
+        code: CodeType,
+        instruction_offset: TOffset,
+        retval: object,
     ) -> MonitorReturn:
         """Handle sys.monitoring.events.PY_RETURN events for branch coverage."""
-        frame = self.callers_frame()
-        code_info = self.code_infos.get(id(code))
-        if code_info is not None and code_info.file_data is not None:
-            last_line = self.last_lines.get(frame)
-            if last_line is not None:
-                arc = (last_line, -code.co_firstlineno)
-                # log(f"adding {arc=}")
-                cast(set[TArc], code_info.file_data).add(arc)
-
-        # Leaving this function, no need for the frame any more.
-        self.last_lines.pop(frame, None)
-
-    @panopticon("code", "@", "exc")
-    def sysmon_py_unwind_arcs(
-        self, code: CodeType, instruction_offset: int, exception: BaseException,
-    ) -> MonitorReturn:
-        """Handle sys.monitoring.events.PY_UNWIND events for branch coverage."""
-        frame = self.callers_frame()
-        # Leaving this function.
-        last_line = self.last_lines.pop(frame, None)
-        if isinstance(exception, GeneratorExit):
-            # We don't want to count generator exits as arcs.
-            return
+        if self.stats is not None:
+            self.stats["returns"] += 1
         code_info = self.code_infos.get(id(code))
-        if code_info is not None and code_info.file_data is not None:
-            if last_line is not None:
-                arc = (last_line, -code.co_firstlineno)
-                # log(f"adding {arc=}")
-                cast(set[TArc], code_info.file_data).add(arc)
-
+        # code_info is not None and code_info.file_data is not None, since we
+        # wouldn't have enabled this event if they were.
+        last_line = code_info.byte_to_line[instruction_offset]  # type: ignore
+        if last_line is not None:
+            arc = (last_line, -code.co_firstlineno)
+            code_info.file_data.add(arc)  # type: ignore
+            # log(f"adding {arc=}")
+        return DISABLE
 
     @panopticon("code", "line")
-    def sysmon_line_lines(self, code: CodeType, line_number: int) -> MonitorReturn:
+    def sysmon_line_lines(self, code: CodeType, line_number: TLineNo) -> MonitorReturn:
         """Handle sys.monitoring.events.LINE events for line coverage."""
-        code_info = self.code_infos[id(code)]
-        if code_info.file_data is not None:
-            cast(set[TLineNo], code_info.file_data).add(line_number)
-            # log(f"adding {line_number=}")
-        return sys.monitoring.DISABLE
+        if self.stats is not None:
+            self.stats["line_lines"] += 1
+        code_info = self.code_infos.get(id(code))
+        # It should be true that code_info is not None and code_info.file_data
+        # is not None, since we wouldn't have enabled this event if they were.
+        # But somehow code_info can be None here, so we have to check.
+        if code_info is not None and code_info.file_data is not None:
+            code_info.file_data.add(line_number)  # type: ignore
+        # log(f"adding {line_number=}")
+        return DISABLE
 
     @panopticon("code", "line")
-    def sysmon_line_arcs(self, code: CodeType, line_number: int) -> MonitorReturn:
+    def sysmon_line_arcs(self, code: CodeType, line_number: TLineNo) -> MonitorReturn:
         """Handle sys.monitoring.events.LINE events for branch coverage."""
+        if self.stats is not None:
+            self.stats["line_arcs"] += 1
         code_info = self.code_infos[id(code)]
-        ret = None
-        if code_info.file_data is not None:
-            frame = self.callers_frame()
-            last_line = self.last_lines.get(frame)
-            if last_line is not None:
-                arc = (last_line, line_number)
-                cast(set[TArc], code_info.file_data).add(arc)
-            # log(f"adding {arc=}")
-            self.last_lines[frame] = line_number
-        return ret
+        # code_info is not None and code_info.file_data is not None, since we
+        # wouldn't have enabled this event if they were.
+        arc = (line_number, line_number)
+        code_info.file_data.add(arc)  # type: ignore
+        # log(f"adding {arc=}")
+        return DISABLE
+
+    @panopticon("code", "@", "@")
+    def sysmon_branch_either(
+        self, code: CodeType, instruction_offset: TOffset, destination_offset: TOffset
+    ) -> MonitorReturn:
+        """Handle BRANCH_RIGHT and BRANCH_LEFT events."""
+        if self.stats is not None:
+            self.stats["branches"] += 1
+        code_info = self.code_infos[id(code)]
+        # code_info is not None and code_info.file_data is not None, since we
+        # wouldn't have enabled this event if they were.
+        if not code_info.branch_trails:
+            if self.stats is not None:
+                self.stats["branch_trails"] += 1
+            multiline_map = get_multiline_map(code.co_filename)
+            code_info.branch_trails = branch_trails(code, multiline_map=multiline_map)
+            code_info.always_jumps = always_jumps(code)
+            # log(f"branch_trails for {code}:\n{ppformat(code_info.branch_trails)}")
+        added_arc = False
+        dest_info = code_info.branch_trails.get(instruction_offset)
+
+        # Re-map the destination offset through always-jumps to deal with NOP etc.
+        dests = {destination_offset}
+        while (dest := code_info.always_jumps.get(destination_offset)) is not None:
+            destination_offset = dest
+            dests.add(destination_offset)
+
+        # log(f"dest_info = {ppformat(dest_info)}")
+        if dest_info is not None:
+            for arc, offsets in dest_info.items():
+                if arc is None:
+                    continue
+                if dests & offsets:
+                    code_info.file_data.add(arc)  # type: ignore
+                    # log(f"adding {arc=}")
+                    added_arc = True
+                    break
+
+        if not added_arc:
+            # This could be an exception jumping from line to line.
+            assert code_info.byte_to_line is not None
+            l1 = code_info.byte_to_line[instruction_offset]
+            l2 = code_info.byte_to_line.get(destination_offset)
+            if l2 is not None and l1 != l2:
+                arc = (l1, l2)
+                code_info.file_data.add(arc)  # type: ignore
+                # log(f"adding unforeseen {arc=}")
+
+        return DISABLE
+
+
+@functools.lru_cache(maxsize=5)
+def get_multiline_map(filename: str) -> dict[TLineNo, TLineNo]:
+    """Get a PythonParser for the given filename, cached."""
+    parser = PythonParser(filename=filename)
+    parser.parse_source()
+    return parser.multiline_map

coverage/templite.py

@@ -13,19 +13,18 @@ http://aosabook.org/en/500L/a-template-engine.html
 from __future__ import annotations
 
 import re
-
-from typing import (
-    Any, Callable, NoReturn, cast,
-)
+from typing import Any, Callable, NoReturn, cast
 
 
 class TempliteSyntaxError(ValueError):
     """Raised when a template has a syntax error."""
+
     pass
 
 
 class TempliteValueError(ValueError):
     """Raised when an expression won't evaluate in a template."""
+
     pass
 
 
@@ -53,7 +52,7 @@ class CodeBuilder:
         self.code.append(section)
         return section
 
-    INDENT_STEP = 4      # PEP8 says so!
+    INDENT_STEP = 4  # PEP8 says so!
 
     def indent(self) -> None:
         """Increase the current indent for following lines."""
@@ -117,6 +116,7 @@ class Templite:
         })
 
     """
+
     def __init__(self, text: str, *contexts: dict[str, Any]) -> None:
         """Construct a Templite with the given `text`.
 
@@ -163,7 +163,7 @@ class Templite:
         for token in tokens:
             if token.startswith("{"):
                 start, end = 2, -2
-                squash = (token[-3] == "-")
+                squash = (token[-3] == "-")  # fmt: skip
                 if squash:
                     end = -3