Translate the output of coverage.py and measure-recognition.py

Everything a user reads was already English — README, UI, logs, changelog — but
these two still printed their results in German. Logs were switched for the same
reason in 0.6.13: someone reporting a problem should not have to translate their
own output first. why-no-face.py arriving in English made the two of them the
odd ones out.

Only printed output and --help text; comments and docstrings stay German like
the rest of the codebase. Column widths were re-aligned to the new labels and
both scripts verified against a real gallery.

Author: skycryer

scripts/coverage.py

@@ -157,19 +157,19 @@ def main():
                        "sources": meta.get("sources", {})}
 
     if not gal:
-        print("keine Galerie gefunden", file=sys.stderr)
+        print("no gallery found", file=sys.stderr)
         return 1
 
-    print(f"{'Person':22s} {'Fotos':>5s} {'Vielf.':>6s} {'frontal':>7s} {'halb':>5s} "
-          f"{'Profil':>6s} {'S/W':>4s} {'Selbst':>6s}  Kameras")
+    print(f"{'person':22s} {'photos':>6s} {'divers':>6s} {'front':>6s} {'half':>5s} "
+          f"{'profile':>7s} {'grey':>5s} {'self':>5s}  cameras")
     print("-" * 96)
 
     # Welche Kameras nachts ueberhaupt in Graustufen schalten? Das aus der Galerie
     # abzuleiten waere zirkulaer — fehlt die IR-Aufnahme, faende man die Kamera nie.
     # Also bei Frigate nachsehen, wie die Naechte dort tatsaechlich aussehen.
     ir_cams = ir_cameras(cfg)
     if ir_cams:
-        print(f"Kameras mit IR-Nachtmodus: {', '.join(sorted(ir_cams))}\n")
+        print(f"cameras that switch to IR at night: {', '.join(sorted(ir_cams))}\n")
 
     advice = []
     for slug, g in gal.items():
@@ -209,35 +209,35 @@ def main():
         known = {c: k for c, k in cams.items() if c != "?"}
         cam_s = ", ".join(f"{c} {k}" for c, k in sorted(known.items(), key=lambda x: -x[1]))
         if cams.get("?"):
-            cam_s = (cam_s + ", " if cam_s else "") + f"{cams['?']}x unbekannt"
-        print(f"{g['name'][:22]:22s} {n:5d} {div_s:>6s} {front:>7d} {half:>5d} "
-              f"{prof:>6d} {night:>4d} {rate:>5d}%  {cam_s}")
+            cam_s = (cam_s + ", " if cam_s else "") + f"{cams['?']}x unknown"
+        print(f"{g['name'][:22]:22s} {n:6d} {div_s:>6s} {front:>6d} {half:>5d} "
+              f"{prof:>7d} {night:>5d} {rate:>4d}%  {cam_s}")
 
         missing = []
         if n < 5:
-            missing.append("zu wenige Fotos")
+            missing.append("too few photos")
         if not front:
-            missing.append("keine frontale Aufnahme")
+            missing.append("no frontal shot")
         # S/W nur anmahnen, wo ueberhaupt eine Kamera in den IR-Modus schaltet.
         if ir_cams and not night and (known.keys() & ir_cams):
-            missing.append("keine Aufnahme im IR-Nachtmodus")
+            missing.append("no IR night shot")
         if len(known) == 1 and n >= 3:
-            missing.append(f"nur an einer Kamera ({next(iter(known))})")
+            missing.append(f"only one camera ({next(iter(known))})")
         if n > 1 and diversity > 0.55:
-            missing.append(f"Fotos ähneln sich stark ({diversity:.2f})")
+            missing.append(f"photos look very alike ({diversity:.2f})")
         # Der Selbst-Test ist bei kleinen Sammlungen systematisch pessimistisch —
         # als Mangel nur melden, wenn genug Fotos da sind, dass er aussagt.
         if n >= 8 and rate < 40:
-            missing.append(f"Fotos stuetzen einander kaum (Selbst-Test {rate}%)")
+            missing.append(f"photos barely support each other (self test {rate}%)")
         if missing:
             advice.append((rate, g["name"], missing))
 
     if advice:
-        print("\nWas konkret fehlt (schwächste zuerst):")
+        print("\nWhat is concretely missing (weakest first):")
         for rate, name, missing in sorted(advice):
             print(f"  {name}: {', '.join(missing)}")
     else:
-        print("\nAlle Personen sind breit abgedeckt.")
+        print("\nEvery person is broadly covered.")
     return 0
 
 

scripts/measure-recognition.py

@@ -172,10 +172,10 @@ def load_config(base: Path) -> dict:
 
 def main():
     ap = argparse.ArgumentParser()
-    ap.add_argument("--baseline", help="Pfad zu einer aelteren Galerie (entpacktes Backup)")
-    ap.add_argument("--days", type=float, default=2, help="Zeitraum der Praxisprobe (0 = aus)")
+    ap.add_argument("--baseline", help="path to an older gallery (an unpacked backup)")
+    ap.add_argument("--days", type=float, default=2, help="window for the practical probe (0 = off)")
     ap.add_argument("--data", default=str(BASE / "data"))
-    ap.add_argument("--top-k", type=int, help="match_top_k zum Vergleich uebersteuern")
+    ap.add_argument("--top-k", type=int, help="override match_top_k for comparison")
     args = ap.parse_args()
 
     global TOP_K
@@ -188,69 +188,69 @@ def main():
         TOP_K = max(1, int(cfg["faceid"].get("match_top_k", 3)))
     new = load_gallery(Path(args.data) / "persons")
     if not new:
-        print("keine Galerie gefunden", file=sys.stderr)
+        print("no gallery found", file=sys.stderr)
         return 1
     old = None
     if args.baseline:
         p = Path(args.baseline)
         old = load_gallery(p / "persons" if (p / "persons").is_dir() else p)
 
     def size(g):
-        return f"{len(g)} Personen / {sum(len(e) for _, e in g.values())} Fotos"
+        return f"{len(g)} persons / {sum(len(e) for _, e in g.values())} photos"
 
-    print(f"jetzt:   {size(new)}")
+    print(f"now:      {size(new)}")
     if old:
-        print(f"vorher:  {size(old)}")
-    print(f"Schwelle {thr}, gemittelt ueber {TOP_K} Foto(s)\n")
+        print(f"before:   {size(old)}")
+    print(f"threshold {thr}, averaged over {TOP_K} photo(s)\n")
 
     # 1) Leave-one-out. Testmenge ist die aeltere Galerie, damit keine Seite ihre
     #    eigenen Neuzugaenge benotet.
     test = old or new
     r_new = leave_one_out(test, new, thr)
-    print(f"Leave-one-out ({r_new['n']} Testgesichter)")
-    print(f"{'':22s} {'vorher':>10s} {'jetzt':>10s}" if old else f"{'':22s} {'jetzt':>10s}")
+    print(f"Leave-one-out ({r_new['n']} test faces)")
+    print(f"{'':22s} {'before':>10s} {'now':>10s}" if old else f"{'':22s} {'now':>10s}")
     if old:
         r_old = leave_one_out(test, old, thr)
-        for lbl, k in (("korrekt erkannt", "hit"), ("falsche Person", "wrong"),
-                       ("nicht erkannt", "miss")):
+        for lbl, k in (("recognised correctly", "hit"), ("wrong person", "wrong"),
+                       ("not recognised", "miss")):
             print(f"  {lbl:20s} {r_old[k]:>10d} {r_new[k]:>10d}")
-        print(f"  {'mittlerer Score':20s} {r_old['score']:>10.3f} {r_new['score']:>10.3f}")
+        print(f"  {'mean score':20s} {r_old['score']:>10.3f} {r_new['score']:>10.3f}")
     else:
-        for lbl, k in (("korrekt erkannt", "hit"), ("falsche Person", "wrong"),
-                       ("nicht erkannt", "miss")):
+        for lbl, k in (("recognised correctly", "hit"), ("wrong person", "wrong"),
+                       ("not recognised", "miss")):
             print(f"  {lbl:20s} {r_new[k]:>10d}")
-        print(f"  {'mittlerer Score':20s} {r_new['score']:>10.3f}")
+        print(f"  {'mean score':20s} {r_new['score']:>10.3f}")
 
     if args.days > 0:
         print()
         lp = live_probe(old, new, args.days, thr, cfg)
-        print(f"Praxisprobe ({args.days:g} Tage): {lp['events']} Ereignisse, "
-              f"{lp['faces']} mit verwertbarem Gesicht"
-              + (f" ({lp['selfhits']} Selbsttreffer ausgeschlossen)" if lp["selfhits"] else ""))
+        print(f"Practical probe ({args.days:g} days): {lp['events']} events, "
+              f"{lp['faces']} with a usable face"
+              + (f" ({lp['selfhits']} self-hits excluded)" if lp["selfhits"] else ""))
         f = max(lp["faces"], 1)
         if old:
-            print(f"  erkannt vorher: {lp['old']:3d} ({100*lp['old']//f:3d}%)   "
-                  f"jetzt: {lp['new']:3d} ({100*lp['new']//f:3d}%)")
-            print(f"  beide erkannt, aber anderer Name: {lp['disagree']}")
+            print(f"  recognised before: {lp['old']:3d} ({100*lp['old']//f:3d}%)   "
+                  f"now: {lp['new']:3d} ({100*lp['new']//f:3d}%)")
+            print(f"  recognised by both but under a different name: {lp['disagree']}")
             if lp["gained"]:
-                print(f"  neu erkannt: {dict(lp['gained'])}")
+                print(f"  newly recognised: {dict(lp['gained'])}")
         else:
-            print(f"  erkannt: {lp['new']} ({100*lp['new']//f}%)")
+            print(f"  recognised: {lp['new']} ({100*lp['new']//f}%)")
 
         if lp["per_person"]:
             # Ein Treffer knapp ueber der Schwelle faellt bei schlechterem Licht weg —
             # deshalb zaehlt der Abstand, nicht nur das Ja/Nein.
-            print("\n  Sicherheitsabstand je erkannter Person:")
-            print(f"    {'Person':24s} {'Treffer':>7s} {'Median':>7s} {'min':>6s} {'knapp':>6s}")
+            print("\n  Headroom above the threshold, per recognised person:")
+            print(f"    {'person':24s} {'hits':>7s} {'median':>7s} {'min':>6s} {'tight':>6s}")
             for name, scores in sorted(lp["per_person"].items(),
                                        key=lambda kv: -len(kv[1])):
                 sc = sorted(scores)
-                knapp = sum(1 for v in sc if v < thr + 0.05)
+                tight = sum(1 for v in sc if v < thr + 0.05)
                 mark = " *" if name in FAVORITES else ""
                 print(f"    {(name + mark)[:24]:24s} {len(sc):>7d} "
-                      f"{sc[len(sc)//2]:>7.2f} {sc[0]:>6.2f} {knapp:>6d}")
+                      f"{sc[len(sc)//2]:>7.2f} {sc[0]:>6.2f} {tight:>6d}")
             if FAVORITES:
-                print("    * = Favorit")
+                print("    * = favourite")
     return 0