Restructure the CLI and polygon color formatting

Extract parse_args() from main(), unfold the color-cache conditional
into a plain if/else inside the render loop, wire --cache-colors
through the windowed viewer, and order helpers below their callers
in assets.py and make_assets.py. No behavior change.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: realpython-bot

python315-sampling-profiler/make_assets.py

@@ -28,33 +28,49 @@
 }
 
 
-def trace_trefoil(t: float) -> Vector:
-    return (
-        math.sin(t) + 2.0 * math.sin(2.0 * t),
-        math.cos(t) - 2.0 * math.cos(2.0 * t),
-        -math.sin(3.0 * t) * 1.2,
-    )
-
-
-def subtract(a: Vector, b: Vector) -> Vector:
-    return (a[0] - b[0], a[1] - b[1], a[2] - b[2])
-
-
-def cross(a: Vector, b: Vector) -> Vector:
-    return (
-        a[1] * b[2] - a[2] * b[1],
-        a[2] * b[0] - a[0] * b[2],
-        a[0] * b[1] - a[1] * b[0],
-    )
+def main() -> None:
+    ASSETS_DIR.mkdir(parents=True, exist_ok=True)
+    write_mesh(ASSETS_DIR / "pretzel.mdl")
+    for name, (top, bottom, glow) in WALLPAPERS.items():
+        write_wallpaper(ASSETS_DIR / name, top, bottom, glow)
 
 
-def dot(a: Vector, b: Vector) -> float:
-    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+def write_mesh(path: pathlib.Path) -> None:
+    vertices, faces = sweep_tube()
+    with path.open("w", encoding="utf-8") as file:
+        file.write(f"# Trefoil-knot pretzel: {len(vertices)} vertices,")
+        file.write(f" {len(faces)} faces\n")
+        for x, y, z in vertices:
+            file.write(f"v {x:.6f} {y:.6f} {z:.6f}\n")
+        for a, b, c in faces:
+            file.write(f"f {a + 1} {b + 1} {c + 1}\n")
+    print(f"Wrote {path} ({len(vertices)} vertices, {len(faces)} faces)")
 
 
-def normalize(vector: Vector) -> Vector:
-    length = math.sqrt(dot(vector, vector)) or 1.0
-    return (vector[0] / length, vector[1] / length, vector[2] / length)
+def write_wallpaper(
+    path: pathlib.Path, top: Color, bottom: Color, glow: Color
+) -> None:
+    size = WALLPAPER_SIZE
+    lights = [
+        (size * 0.25, size * 0.3, size * 0.22),
+        (size * 0.7, size * 0.55, size * 0.3),
+        (size * 0.45, size * 0.8, size * 0.18),
+    ]
+    rows = bytearray()
+    for y in range(size):
+        vertical = y / (size - 1)
+        base = blend(top, bottom, vertical)
+        for x in range(size):
+            halo = 0.0
+            for cx, cy, radius in lights:
+                distance = math.hypot(x - cx, y - cy)
+                halo += max(0.0, 1.0 - distance / radius) ** 2
+            color = blend(base, glow, min(1.0, halo))
+            rows.extend(color)
+    with path.open("wb") as file:
+        file.write(b"P6\n%d %d\n255\n" % (size, size))
+        file.write(rows)
+    print(f"Wrote {path} ({size}x{size})")
 
 
 def sweep_tube() -> tuple[list[Vector], list[Face]]:
@@ -101,56 +117,40 @@ def sweep_tube() -> tuple[list[Vector], list[Face]]:
     return vertices, faces
 
 
-def write_mesh(path: pathlib.Path) -> None:
-    vertices, faces = sweep_tube()
-    with path.open("w", encoding="utf-8") as file:
-        file.write(f"# Trefoil-knot pretzel: {len(vertices)} vertices,")
-        file.write(f" {len(faces)} faces\n")
-        for x, y, z in vertices:
-            file.write(f"v {x:.6f} {y:.6f} {z:.6f}\n")
-        for a, b, c in faces:
-            file.write(f"f {a + 1} {b + 1} {c + 1}\n")
-    print(f"Wrote {path} ({len(vertices)} vertices, {len(faces)} faces)")
-
-
 def blend(low: Color, high: Color, amount: float) -> Color:
     return tuple(
         round(low[channel] + (high[channel] - low[channel]) * amount)
         for channel in range(3)
     )
 
 
-def write_wallpaper(
-    path: pathlib.Path, top: Color, bottom: Color, glow: Color
-) -> None:
-    size = WALLPAPER_SIZE
-    lights = [
-        (size * 0.25, size * 0.3, size * 0.22),
-        (size * 0.7, size * 0.55, size * 0.3),
-        (size * 0.45, size * 0.8, size * 0.18),
-    ]
-    rows = bytearray()
-    for y in range(size):
-        vertical = y / (size - 1)
-        base = blend(top, bottom, vertical)
-        for x in range(size):
-            halo = 0.0
-            for cx, cy, radius in lights:
-                distance = math.hypot(x - cx, y - cy)
-                halo += max(0.0, 1.0 - distance / radius) ** 2
-            color = blend(base, glow, min(1.0, halo))
-            rows.extend(color)
-    with path.open("wb") as file:
-        file.write(b"P6\n%d %d\n255\n" % (size, size))
-        file.write(rows)
-    print(f"Wrote {path} ({size}x{size})")
+def trace_trefoil(t: float) -> Vector:
+    return (
+        math.sin(t) + 2.0 * math.sin(2.0 * t),
+        math.cos(t) - 2.0 * math.cos(2.0 * t),
+        -math.sin(3.0 * t) * 1.2,
+    )
 
 
-def main() -> None:
-    ASSETS_DIR.mkdir(parents=True, exist_ok=True)
-    write_mesh(ASSETS_DIR / "pretzel.mdl")
-    for name, (top, bottom, glow) in WALLPAPERS.items():
-        write_wallpaper(ASSETS_DIR / name, top, bottom, glow)
+def subtract(a: Vector, b: Vector) -> Vector:
+    return (a[0] - b[0], a[1] - b[1], a[2] - b[2])
+
+
+def cross(a: Vector, b: Vector) -> Vector:
+    return (
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0],
+    )
+
+
+def dot(a: Vector, b: Vector) -> float:
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+
+
+def normalize(vector: Vector) -> Vector:
+    length = math.sqrt(dot(vector, vector)) or 1.0
+    return (vector[0] / length, vector[1] / length, vector[2] / length)
 
 
 if __name__ == "__main__":

python315-sampling-profiler/src/pretzel/assets.py

@@ -19,10 +19,6 @@ class Background:
     pixels: npt.NDArray[np.float32]
 
 
-def asset_path(name: str) -> str:
-    return str(ASSETS_DIR / name)
-
-
 def load_mesh(name: str) -> Mesh:
     vertices: list[Vertex] = []
     faces: list[Face] = []
@@ -60,10 +56,6 @@ def decode_ppm_pixel_by_pixel(path: str) -> npt.NDArray[np.float32]:
     return np.array(rows, dtype=np.float32)
 
 
-def to_linear(value: int) -> float:
-    return 255.0 * (value / 255.0) ** 2.2
-
-
 def decode_ppm(path: str) -> npt.NDArray[np.float32]:
     with open(path, "rb") as file:
         width, height = read_ppm_header(file)
@@ -80,3 +72,11 @@ def read_ppm_header(file: BinaryIO) -> tuple[int, int]:
     width, height = map(int, file.readline().split())
     file.readline()
     return width, height
+
+
+def to_linear(value: int) -> float:
+    return 255.0 * (value / 255.0) ** 2.2
+
+
+def asset_path(name: str) -> str:
+    return str(ASSETS_DIR / name)

python315-sampling-profiler/src/pretzel/cli.py

@@ -14,33 +14,14 @@
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(prog="pretzel", description=__doc__)
-    parser.add_argument(
-        "--frames",
-        metavar="N",
-        type=int,
-        default=None,
-        help="render N frames headlessly instead of opening a window",
-    )
-    parser.add_argument(
-        "--fast",
-        action="store_true",
-        help="use the optimized asset loader and buffered telemetry",
-    )
-    parser.add_argument(
-        "--cache-colors",
-        action="store_true",
-        help="memoize polygon color formatting in headless mode",
-    )
-    args = parser.parse_args()
-
+    args = parse_args()
     mesh = assets.load_mesh(MODEL)
     streamer = BackgroundStreamer(fast=args.fast)
     streamer.start()
     frame_log = FrameLog("telemetry.csv", durable=not args.fast)
     try:
         if args.frames is None:
-            show_window(mesh, streamer, frame_log)
+            show_window(mesh, streamer, frame_log, args.cache_colors)
         else:
             render_headlessly(
                 mesh, streamer, frame_log, args.frames, args.cache_colors
@@ -50,11 +31,14 @@ def main() -> None:
 
 
 def show_window(
-    mesh: Mesh, streamer: BackgroundStreamer, frame_log: FrameLog
+    mesh: Mesh,
+    streamer: BackgroundStreamer,
+    frame_log: FrameLog,
+    cache_colors: bool = False,
 ) -> None:
     from pretzel.viewer import Viewer
 
-    Viewer(mesh, streamer, frame_log).run()
+    Viewer(mesh, streamer, frame_log, cache_colors).run()
 
 
 def render_headlessly(
@@ -78,3 +62,25 @@ def render_headlessly(
     print(
         f"Rendered {frames} frames in {total:.2f}s ({frames / total:.1f} fps)"
     )
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(prog="pretzel", description=__doc__)
+    parser.add_argument(
+        "--frames",
+        metavar="N",
+        type=int,
+        default=None,
+        help="render N frames headlessly instead of opening a window",
+    )
+    parser.add_argument(
+        "--fast",
+        action="store_true",
+        help="use the optimized asset loader and buffered telemetry",
+    )
+    parser.add_argument(
+        "--cache-colors",
+        action="store_true",
+        help="memoize polygon color formatting",
+    )
+    return parser.parse_args()

python315-sampling-profiler/src/pretzel/render.py

@@ -40,14 +40,11 @@ def compute_frame(
         coordinates: list[float] = []
         for index in face:
             coordinates.extend(projected[index])
-        polygons.append(
-            (
-                coordinates,
-                hex_color(red, green, blue)
-                if cache_colors
-                else f"#{red:02x}{green:02x}{blue:02x}",
-            )
-        )
+        if cache_colors:
+            color = hex_color(red, green, blue)
+        else:
+            color = f"#{red:02x}{green:02x}{blue:02x}"
+        polygons.append((coordinates, color))
     return polygons
 
 

python315-sampling-profiler/src/pretzel/viewer.py

@@ -19,10 +19,12 @@ def __init__(
         mesh: Mesh,
         streamer: BackgroundStreamer,
         frame_log: FrameLog,
+        cache_colors: bool = False,
     ) -> None:
         self.mesh = mesh
         self.streamer = streamer
         self.frame_log = frame_log
+        self.cache_colors = cache_colors
         self.frame = 0
         self.started = time.perf_counter()
         self.window = tk.Tk()
@@ -47,7 +49,9 @@ def render_next_frame(self) -> None:
         if background.path != str(self.wallpaper.cget("file")):
             self.wallpaper.configure(file=background.path)
         tick = frame_started - self.started
-        polygons = compute_frame(self.mesh, background, tick, WIDTH, HEIGHT)
+        polygons = compute_frame(
+            self.mesh, background, tick, WIDTH, HEIGHT, self.cache_colors
+        )
         self.canvas.delete("model")
         for coordinates, color in polygons:
             self.canvas.create_polygon(