qa-agent-kit 0.6.0__py3-none-any.whl

qakit/tools/screenshot_contrast.swift

@@ -0,0 +1,42 @@
+// Measure the real contrast of text in a screenshot: the WCAG ratio between the darkest and the lightest pixels in a box.
+// XCUITest's accessibility audit reports "Contrast failed" on text drawn over glass, materials and shadows because it samples
+// what lies under them; a reviewed exception needs the number the user actually sees.
+//
+//   DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer swift tools/screenshot_contrast.swift <shot.png> <x0> <y0> <x1> <y1>
+//   -> "text 0.000  background 0.811  contrast 17.2:1"
+//
+// The box is in fractions of the image (0.25 0.79 0.75 0.825 = the middle half, 79-82.5% down). Put it around one line of
+// text and a little of what is behind it. The 1st and 99th percentile luminances stand for the text and the background, so
+// a few anti-aliased edge pixels do not decide it. Light text on a dark fill works the same way. Elsewhen 2026-10-28: the
+// type-a-time read-back on the Liquid Glass sheet, reported "Contrast failed", measured 17.2:1.
+import AppKit
+
+let args = CommandLine.arguments
+let fractions = args.count == 6 ? args[2...5].compactMap(Double.init) : []
+guard fractions.count == 4 else {
+    print("usage: screenshot_contrast.swift <shot.png> <x0> <y0> <x1> <y1>   (fractions of width and height)"); exit(2)
+}
+guard let image = NSImage(contentsOfFile: args[1])?.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
+    print("unreadable: \(args[1])"); exit(1)
+}
+let bitmap = NSBitmapImageRep(cgImage: image)
+let width = Double(bitmap.pixelsWide), height = Double(bitmap.pixelsHigh)
+let x0 = Int(fractions[0] * width), y0 = Int(fractions[1] * height), x1 = Int(fractions[2] * width), y1 = Int(fractions[3] * height)
+guard x0 < x1, y0 < y1 else { print("empty box"); exit(2) }
+
+/// WCAG relative luminance of one sRGB channel.
+func linear(_ channel: CGFloat) -> Double {
+    let v = Double(channel)
+    return v <= 0.04045 ? v / 12.92 : pow((v + 0.055) / 1.055, 2.4)
+}
+
+var luminances: [Double] = []
+for y in y0..<y1 {
+    for x in x0..<x1 {
+        guard let color = bitmap.colorAt(x: x, y: y)?.usingColorSpace(.sRGB) else { continue }
+        luminances.append(0.2126 * linear(color.redComponent) + 0.7152 * linear(color.greenComponent) + 0.0722 * linear(color.blueComponent))
+    }
+}
+luminances.sort()
+let dark = luminances[luminances.count / 100], light = luminances[luminances.count * 99 / 100]
+print(String(format: "text %.3f  background %.3f  contrast %.1f:1", dark, light, (light + 0.05) / (dark + 0.05)))

qakit/tools/shots_gif.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Turn a run's screenshots into one animated GIF: the demo, the PR comment, the bug report.
+
+  python3 tools/shots_gif.py <shots-dir> --out walk.gif                 # every PNG in index.md order
+  python3 tools/shots_gif.py <shots-dir> --out walk.gif --match "settings" --width 360 --ms 700 --max 40
+  python3 tools/shots_gif.py a.png b.png c.png --out variants.gif --ms 1200   # explicit frames (dark, large text, ...)
+
+Reads the `index.md` that `device_qa.py shots` writes (one section per test, attachments in order) and keeps the PNGs
+whose name matches `--match` (a regular expression against the attachment's name, case-insensitive). Needs Pillow
+(`pip install pillow`); the kit's other tools do not. Frames are scaled to `--width`, padded to the tallest frame so a
+rotated or shorter screenshot does not jump, and each frame shows for `--ms` milliseconds (the last one twice as long).
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+ENTRY = re.compile(r"^- (?P<name>.*?): `(?P<file>[^`]+)`", re.M)
+
+
+def ordered_frames(shots_dir: Path, match: str | None = None, limit: int = 0) -> list[Path]:
+    """PNG paths in index.md order (fallback: sorted directory listing), filtered by `match` against the attachment name."""
+    index = shots_dir / "index.md"
+    pattern = re.compile(match, re.I) if match else None
+    frames: list[Path] = []
+    if index.is_file():
+        for m in ENTRY.finditer(index.read_text(encoding="utf-8")):
+            path = shots_dir / m.group("file")
+            if path.suffix.lower() == ".png" and path.is_file() and (pattern is None or pattern.search(m.group("name"))):
+                frames.append(path)
+    else:
+        frames = [p for p in sorted(shots_dir.glob("*.png")) if pattern is None or pattern.search(p.stem)]
+    return frames[:limit] if limit else frames
+
+
+def write_gif(frames: list[Path], out: Path, width: int = 360, ms: int = 700) -> int:
+    try:
+        from PIL import Image
+    except ImportError:
+        raise SystemExit("shots_gif.py needs Pillow: pip install pillow")
+    images = []
+    for path in frames:
+        im = Image.open(path).convert("RGB")
+        scale = width / im.width
+        images.append(im.resize((width, max(1, round(im.height * scale)))))
+    if not images:
+        raise SystemExit("no frames")
+    height = max(im.height for im in images)
+    canvas = []
+    for im in images:
+        page = Image.new("RGB", (width, height), (16, 23, 42))
+        page.paste(im, (0, (height - im.height) // 2))
+        canvas.append(page.quantize(colors=128))
+    durations = [ms] * len(canvas)
+    durations[-1] = ms * 2
+    out.parent.mkdir(parents=True, exist_ok=True)
+    canvas[0].save(out, save_all=True, append_images=canvas[1:], duration=durations, loop=0, optimize=True)
+    return len(canvas)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("inputs", nargs="+", help="a shots folder (with index.md) or PNG files")
+    parser.add_argument("--out", required=True)
+    parser.add_argument("--match", help="keep attachments whose name matches this regex (folder input only)")
+    parser.add_argument("--width", type=int, default=360)
+    parser.add_argument("--ms", type=int, default=700)
+    parser.add_argument("--max", type=int, default=0, help="at most this many frames (0 = all)")
+    args = parser.parse_args(argv)
+    paths = [Path(p) for p in args.inputs]
+    frames = ordered_frames(paths[0], args.match, args.max) if len(paths) == 1 and paths[0].is_dir() else [p for p in paths if p.is_file()]
+    n = write_gif(frames, Path(args.out), args.width, args.ms)
+    print(f"{n} frames -> {args.out}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())   # mutation-ok: entry point, pytest calls main() directly