Tag 15: Wettkampf – Tool-Challenges auf Zeit
Ziel: Sieben kleine Ops-Tools unter Zeitdruck von null bauen – nur mit Spezifikation und Testdatei – und damit beweisen, dass die Muster aus 14 Tagen sitzen · Dauer: ca. 150 min · Voraussetzung: Tag 14
Briefing
- Jede Runde: Spezifikation lesen,
Testdatei anlegen, Stoppuhr starten, Modul schreiben,
bis
pytestgrün ist. Erst dann die Uhr anhalten. - Die Musterlösung steht direkt darunter. Decke sie ab und lies sie erst nach Ablauf der Zeit.
- Erlaubt: Anhang A,
--help, docs.python.org. Nicht erlaubt: KI-Assistenten und Kopieren aus früheren Tagen. - Wertung: alle Tests grün in der Zeit = volle Punkte, bis zur
doppelten Zeit = halbe Punkte, danach 0. Dazu müssen
ruff checkundmypysauber sein. - Alle Tools leben in einem uv-Projekt, jedes als eigenes Modul mit eigenem Kommando.
tag15-wettkampf/
├── pyproject.toml 7 Kommandos in [project.scripts]
├── src/wettkampf/ dupfind.py portwait.py jsonq.py envdiff.py
│ cronnext.py secretscan.py summarize.py
├── tests/test_<tool>.py vorgegeben – nicht ändern
└── lab/ Übungsdaten pro Runde
Aufwärmen: Das Wettkampfgelände
Das Gelände baust du vor dem Start – es zählt nicht zur Zeit.
cd ~/py-lab
uv init -q -p 3.14 --package --name wettkampf tag15-wettkampf
cd tag15-wettkampf
cat > pyproject.toml <<'EOF'
[project]
name = "wettkampf"
version = "0.1.0"
description = "Tag 15: kleine Tools auf Zeit"
readme = "README.md"
authors = [{ name = "Thomas Zachmann", email = "[email protected]" }]
requires-python = ">=3.14"
dependencies = []
[project.scripts]
dupfind = "wettkampf.dupfind:app"
portwait = "wettkampf.portwait:app"
jsonq = "wettkampf.jsonq:app"
envdiff = "wettkampf.envdiff:app"
cronnext = "wettkampf.cronnext:app"
secretscan = "wettkampf.secretscan:app"
llm-summarize = "wettkampf.summarize:app"
[build-system]
requires = ["uv_build>=0.9.26,<0.10.0"]
build-backend = "uv_build"
[tool.ruff.lint]
extend-select = ["E501", "B", "UP", "SIM", "I"]
[tool.mypy]
strict = true
files = ["src"]
[tool.pytest.ini_options]
testpaths = ["tests"]
EOF
uv add -q typer openai pydantic httpx
uv add -q --dev pytest ruff mypy
: > src/wettkampf/__init__.py
mkdir -p tests lab
uv run pytest -q; echo "exit=$?"Erwartet:
no tests ran in 0.00s
exit=5
-p 3.14pinnt die Python-Version, auch wenn uv sonst eine ältere als Standard wählen würde.- Ein Konsolenskript darf auf ein
typer.Typer-Objekt zeigen (wettkampf.dupfind:app); typer-Apps sind aufrufbar. Kommandos zu Modulen, die es noch nicht gibt, stören erst beim Aufruf. : > dateileert das von uv erzeugte__init__.py; das Paket braucht keinemain().httpxsteht explizit drin, weil dasopenai-SDK es nicht mehr zwingend mitbringt (Tag 10).- pytest-Exit 5 heißt „keine Tests gefunden“ – gleich ändert sich das.
Stoppuhr im Terminal, falls keine zur Hand ist:
start=$(date +%s) # vor jeder Runde
echo "$(( ($(date +%s) - start) / 60 )) min" # wenn pytest grün istRunde 1: dupfind – doppelte Dateien
Zeitlimit: 15 min · Punkte: 10
Spezifikation
dupfind DIR...durchsucht die Verzeichnisse rekursiv und findet Dateien mit identischem Inhalt (SHA-256).- Leere Dateien und Symlinks werden ignoriert. Erst nach Größe gruppieren, nur gleich große Dateien hashen.
find_duplicates(roots) -> list[list[Path]]: Gruppen mit mindestens zwei Pfaden, Pfade sortiert, größte Dateien zuerst.- Ausgabe pro Gruppe:
<Größe> Bytes x <Anzahl>, darunter eingerückt die Pfade. - Exit 0: keine Duplikate, Exit 1: Duplikate gefunden, Exit 2: Verzeichnis fehlt.
Tests
cat > tests/test_dupfind.py <<'EOF'
from pathlib import Path
from typer.testing import CliRunner
from wettkampf.dupfind import app, find_duplicates
runner = CliRunner()
def make(base: Path, files: dict[str, str]) -> None:
for name, content in files.items():
path = base / name
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(content, encoding="utf-8")
def test_findet_gruppen(tmp_path):
make(tmp_path, {"a.txt": "x" * 10, "sub/b.txt": "x" * 10, "c.txt": "y" * 10})
groups = find_duplicates([tmp_path])
assert groups == [[tmp_path / "a.txt", tmp_path / "sub/b.txt"]]
def test_gleiche_groesse_anderer_inhalt(tmp_path):
make(tmp_path, {"a": "abc", "b": "abd"})
assert find_duplicates([tmp_path]) == []
def test_leere_dateien_und_symlinks_ignoriert(tmp_path):
make(tmp_path, {"a": "", "b": "", "c": "inhalt"})
(tmp_path / "link").symlink_to(tmp_path / "c")
assert find_duplicates([tmp_path]) == []
def test_groesste_gruppe_zuerst(tmp_path):
make(tmp_path, {"k1": "kurz", "k2": "kurz", "l1": "lang" * 50, "l2": "lang" * 50})
groups = find_duplicates([tmp_path])
assert [g[0].name for g in groups] == ["l1", "k1"]
def test_cli_exit_codes(tmp_path):
make(tmp_path, {"a": "1", "b": "2"})
assert runner.invoke(app, [str(tmp_path)]).exit_code == 0
make(tmp_path, {"c": "1"})
result = runner.invoke(app, [str(tmp_path)])
assert result.exit_code == 1
assert "1 Bytes x 2" in result.output
EOFMusterlösung
cat > src/wettkampf/dupfind.py <<'EOF'
"""dupfind – doppelte Dateien per SHA-256 finden."""
import hashlib
from collections import defaultdict
from pathlib import Path
from typing import Annotated
import typer
app = typer.Typer(add_completion=False)
def sha256(path: Path) -> str:
with path.open("rb") as f:
return hashlib.file_digest(f, "sha256").hexdigest()
def find_duplicates(roots: list[Path]) -> list[list[Path]]:
"""Gruppen gleicher Dateien; größte Dateien zuerst, Pfade sortiert."""
by_size: defaultdict[int, list[Path]] = defaultdict(list)
for root in roots:
for path in root.rglob("*"):
if path.is_file() and not path.is_symlink():
size = path.stat().st_size
if size:
by_size[size].append(path)
groups: list[tuple[int, list[Path]]] = []
for size, paths in by_size.items():
if len(paths) < 2:
continue # einzigartige Größe: kein Hash nötig
by_hash: defaultdict[str, list[Path]] = defaultdict(list)
for path in paths:
by_hash[sha256(path)].append(path)
groups += [(size, sorted(g)) for g in by_hash.values() if len(g) > 1]
groups.sort(key=lambda g: (-g[0], g[1]))
return [paths for _, paths in groups]
@app.command()
def main(
roots: Annotated[list[Path], typer.Argument(exists=True, file_okay=False)],
) -> None:
"""Listet Duplikate. Exit 0: keine, Exit 1: Duplikate gefunden."""
groups = find_duplicates(roots)
for paths in groups:
typer.echo(f"{paths[0].stat().st_size} Bytes x {len(paths)}")
for path in paths:
typer.echo(f" {path}")
if groups:
raise typer.Exit(1)
EOFhashlib.file_digest(seit 3.11) liest die Datei blockweise – auch 10 GB passen nicht auf einmal in den Speicher, das müssen sie hier nicht.- Die Größe ist ein kostenloser Vorfilter: Dateien mit einzigartiger Größe können keine Duplikate haben und werden nie gelesen.
defaultdict(list)spart dasif key not in d; der Sortierschlüssel(-size, paths)liefert große Gruppen zuerst und stabile Reihenfolge.
Prüfen
uv run pytest -q tests/test_dupfind.py
mkdir -p lab/dup/a lab/dup/b
printf 'runbook v1\n' > lab/dup/a/runbook.md
cp lab/dup/a/runbook.md lab/dup/b/runbook-kopie.md
head -c 4096 /dev/zero > lab/dup/a/null.bin && cp lab/dup/a/null.bin lab/dup/b/null2.bin
printf 'anders\n' > lab/dup/b/notiz.txt
uv run dupfind lab/dup; echo "exit=$?"Erwartet:
..... [100%]
5 passed in 0.05s
4096 Bytes x 2
lab/dup/a/null.bin
lab/dup/b/null2.bin
11 Bytes x 2
lab/dup/a/runbook.md
lab/dup/b/runbook-kopie.md
exit=1
Fortschritt speichern? Kostenlos registrieren
Runde 2: portwait – auf einen Port warten
Zeitlimit: 15 min · Punkte: 10
Spezifikation
portwait HOST:PORT [--timeout 30] [--interval 0.2]versucht so lange eine TCP-Verbindung, bis sie klappt oder der Timeout abläuft. Klassiker für Init-Container und CI („warte, bis die Datenbank da ist”).parse_target("db:5432") -> ("db", 5432), auch[::1]:8200. Fehlender oder ungültiger Port (nicht 1–65535):typer.BadParameter(Exit 2).wait_for(host, port, timeout, interval=0.2) -> float | None: Sekunden bis zum Erfolg oderNone. JederOSError(abgelehnt, DNS, Timeout) heißt: später nochmal.- Erfolg:
HOST:PORT offen nach 1.4s, Exit 0. Timeout: Meldung auf stderr, Exit 1.
Tests
cat > tests/test_portwait.py <<'EOF'
import socket
import pytest
import typer
from typer.testing import CliRunner
from wettkampf.portwait import app, parse_target, wait_for
runner = CliRunner()
@pytest.fixture
def open_port():
with socket.create_server(("127.0.0.1", 0)) as server:
yield server.getsockname()[1]
@pytest.fixture
def closed_port():
with socket.create_server(("127.0.0.1", 0)) as server:
port = server.getsockname()[1]
return port # Server ist zu: Verbindungen werden abgelehnt
def test_offener_port(open_port):
waited = wait_for("127.0.0.1", open_port, timeout=2)
assert waited is not None
assert waited < 1
def test_timeout(closed_port):
assert wait_for("127.0.0.1", closed_port, timeout=0.3, interval=0.05) is None
@pytest.mark.parametrize(
("target", "expected"),
[("db:5432", ("db", 5432)), ("[::1]:8200", ("::1", 8200))],
)
def test_parse_target(target, expected):
assert parse_target(target) == expected
@pytest.mark.parametrize("target", ["db", "db:http", "db:70000"])
def test_parse_target_fehler(target):
with pytest.raises(typer.BadParameter):
parse_target(target)
def test_cli(open_port, closed_port):
ok = runner.invoke(app, [f"127.0.0.1:{open_port}"])
assert ok.exit_code == 0
assert "offen nach" in ok.output
args = [f"127.0.0.1:{closed_port}", "--timeout", "0.2"]
assert runner.invoke(app, args).exit_code == 1
assert runner.invoke(app, ["kaputt"]).exit_code == 2
EOFMusterlösung
cat > src/wettkampf/portwait.py <<'EOF'
"""portwait – warten, bis ein TCP-Port Verbindungen annimmt."""
import socket
import time
from typing import Annotated
import typer
app = typer.Typer(add_completion=False)
def parse_target(target: str) -> tuple[str, int]:
"""'host:port' oder '[ipv6]:port' -> (host, port)."""
host, sep, port = target.rpartition(":")
if not sep or not port.isdigit() or not 0 < int(port) < 65536:
raise typer.BadParameter(f"erwartet host:port, nicht {target!r}")
return host.strip("[]"), int(port)
def wait_for(
host: str, port: int, timeout: float, interval: float = 0.2
) -> float | None:
"""Sekunden bis zur ersten erfolgreichen Verbindung, None bei Timeout."""
start = time.monotonic()
deadline = start + timeout
while True:
left = deadline - time.monotonic()
try:
with socket.create_connection((host, port), timeout=max(left, 0.01)):
return time.monotonic() - start
except OSError:
pass # abgelehnt, DNS noch nicht da, Timeout: nochmal
if time.monotonic() + interval > deadline:
return None
time.sleep(interval)
@app.command()
def main(
target: Annotated[str, typer.Argument(help="host:port")],
timeout: Annotated[float, typer.Option(help="Sekunden insgesamt")] = 30.0,
interval: Annotated[float, typer.Option(help="Pause zwischen Versuchen")] = 0.2,
) -> None:
"""Exit 0, sobald der Port offen ist; Exit 1 nach Ablauf des Timeouts."""
host, port = parse_target(target)
waited = wait_for(host, port, timeout, interval)
if waited is None:
typer.echo(f"{host}:{port} nach {timeout}s nicht erreichbar", err=True)
raise typer.Exit(1)
typer.echo(f"{host}:{port} offen nach {waited:.1f}s")
EOFtime.monotonic()statttime.time(): Die monotone Uhr springt nie, auch nicht bei NTP-Korrekturen.- Der Verbindungs-Timeout ist die Restzeit – ein hängender SYN kann den Gesamt-Timeout nicht überschreiten.
- Die Test-Fixtures binden Port 0: Das Betriebssystem vergibt einen freien Port, Kollisionen mit laufenden Diensten sind ausgeschlossen.
Prüfen
uv run pytest -q tests/test_portwait.py
(sleep 1.5; uv run python -m http.server 8799 --bind 127.0.0.1 >/dev/null 2>&1) &
uv run portwait 127.0.0.1:8799 --timeout 10; echo "exit=$?"
pkill -f 'http.server 8799'
uv run portwait 127.0.0.1:8799 --timeout 1; echo "exit=$?"Erwartet:
........ [100%]
8 passed in 0.42s
127.0.0.1:8799 offen nach 1.4s
exit=0
127.0.0.1:8799 nach 1.0s nicht erreichbar
exit=1
Fortschritt speichern? Kostenlos registrieren
Runde 3: jsonq – ein Mini-jq
Zeitlimit: 25 min · Punkte: 20
Spezifikation
jsonq EXPR [FILE]wendet einen Pfadausdruck auf JSON aus FILE oder stdin an und gibt jedes Ergebnis als JSON-Zeile aus; mit-rStrings ohne Anführungszeichen.- Ausdrücke:
.(alles),.key,."key.mit.punkten",[n](auch negativ),[](über Liste oder Dict-Werte iterieren). Beliebig kombinierbar:.items[].ports[]. - Fehlende Schlüssel und Indizes ergeben
null(wie jq)..keyauf etwas anderem als Dict/null,[n]auf Nicht-Liste und kaputte Ausdrücke:QueryError. query(data, expr) -> list[Any]. Kaputtes JSON oderQueryError: Meldung auf stderr, Exit 2.
Tests
cat > tests/test_jsonq.py <<'EOF'
import json
import pytest
from typer.testing import CliRunner
from wettkampf.jsonq import QueryError, app, query
runner = CliRunner()
DATA = {
"kind": "List",
"items": [
{"name": "web", "ports": [80, 443], "labels": {"app.kubernetes.io/name": "w"}},
{"name": "db", "ports": [5432]},
],
}
@pytest.mark.parametrize(
("expr", "expected"),
[
(".", [DATA]),
(".kind", ["List"]),
(".items[1].name", ["db"]),
(".items[-1].ports[0]", [5432]),
(".items[].name", ["web", "db"]),
(".items[].ports[]", [80, 443, 5432]),
(".items[1].labels", [None]),
('.items[0].labels."app.kubernetes.io/name"', ["w"]),
(".fehlt.auch", [None]),
],
)
def test_query(expr, expected):
assert query(DATA, expr) == expected
@pytest.mark.parametrize("expr", ["kind", ".items[x]", ".items[0", ".kind[0]"])
def test_query_fehler(expr):
with pytest.raises(QueryError):
query(DATA, expr)
def test_cli_stdin_und_raw():
data = json.dumps(DATA)
result = runner.invoke(app, [".items[].name"], input=data)
assert result.output.splitlines() == ['"web"', '"db"']
result = runner.invoke(app, ["-r", ".items[].name"], input=data)
assert result.output.splitlines() == ["web", "db"]
def test_cli_fehler(tmp_path):
bad = tmp_path / "bad.json"
bad.write_text("{kaputt", encoding="utf-8")
assert runner.invoke(app, [".", str(bad)]).exit_code == 2
assert runner.invoke(app, ["kind"], input="{}").exit_code == 2
EOFMusterlösung
cat > src/wettkampf/jsonq.py <<'EOF'
"""jsonq – ein Mini-jq: .key, ."key.mit.punkt", [n], [] auf JSON anwenden."""
import json
import re
import sys
from pathlib import Path
from typing import Annotated, Any
import typer
app = typer.Typer(add_completion=False)
TOKEN = re.compile(r'\.(?:([A-Za-z_][\w-]*)|"([^"]+)")|\[(-?\d+)\]|\[\]|\.')
class QueryError(ValueError):
"""Ausdruck ungültig oder passt nicht zu den Daten."""
def step(value: Any, m: re.Match[str]) -> list[Any]:
key = m[1] or m[2]
if key is not None:
if value is not None and not isinstance(value, dict):
raise QueryError(f"kann {type(value).__name__} nicht mit .{key} lesen")
return [None if value is None else value.get(key)]
if m[3] is not None:
if value is None:
return [None]
if not isinstance(value, list):
raise QueryError(f"kann {type(value).__name__} nicht indizieren")
i = int(m[3])
return [value[i] if -len(value) <= i < len(value) else None]
if m[0] == "[]":
if not isinstance(value, list | dict):
raise QueryError(f"kann {type(value).__name__} nicht iterieren")
return list(value.values() if isinstance(value, dict) else value)
return [value] # "." allein
def query(data: Any, expr: str) -> list[Any]:
if not expr.startswith("."):
raise QueryError(f"Ausdruck muss mit '.' beginnen: {expr!r}")
results, pos = [data], 0
while pos < len(expr):
m = TOKEN.match(expr, pos)
if m is None:
raise QueryError(f"unerwartet bei Position {pos}: {expr[pos:]!r}")
results = [out for value in results for out in step(value, m)]
pos = m.end()
return results
@app.command()
def main(
expr: str,
file: Annotated[Path | None, typer.Argument(exists=True, dir_okay=False)] = None,
raw: Annotated[
bool, typer.Option("--raw", "-r", help="Strings ohne Quotes")
] = False,
) -> None:
"""Wendet EXPR auf FILE oder stdin an. Exit 2 bei kaputtem JSON/Ausdruck."""
try:
text = file.read_text(encoding="utf-8") if file else sys.stdin.read()
results = query(json.loads(text), expr)
except (json.JSONDecodeError, QueryError) as err:
typer.echo(f"jsonq: {err}", err=True)
raise typer.Exit(2) from err
for value in results:
if raw and isinstance(value, str):
typer.echo(value)
else:
typer.echo(json.dumps(value, ensure_ascii=False))
EOF- Ein Regex mit Alternativen ist ein vollwertiger Tokenizer:
TOKEN.match(expr, pos)liest genau ein Token ab Positionpos, die Gruppen sagen, welches. - Die Ergebnisliste wächst durch
[]und wird von jedem weiteren Schritt komplett verarbeitet – die verschachtelte Comprehension ist der ganze „Interpreter”. isinstance(value, list | dict): Seit 3.10 nimmtisinstanceauch Union-Typen.
Prüfen
uv run pytest -q tests/test_jsonq.py
cat > lab/pods.json <<'EOF'
{"kind": "List", "items": [
{"metadata": {"name": "web-1", "labels": {"app.kubernetes.io/name": "web"}},
"status": {"phase": "Running", "containerStatuses": [{"restartCount": 0}]}},
{"metadata": {"name": "db-0", "labels": {"app.kubernetes.io/name": "db"}},
"status": {"phase": "CrashLoopBackOff", "containerStatuses": [{"restartCount": 7}]}}
]}
EOF
uv run jsonq '.items[].metadata.name' lab/pods.json
uv run jsonq -r '.items[1].status.phase' lab/pods.json
cat lab/pods.json | uv run jsonq '.items[].status.containerStatuses[].restartCount'
uv run jsonq '.items[0].metadata.labels."app.kubernetes.io/name"' lab/pods.json
uv run jsonq '.items[0].metadata.name[0]' lab/pods.json; echo "exit=$?"Erwartet:
............... [100%]
15 passed in 0.02s
"web-1"
"db-0"
CrashLoopBackOff
0
7
"web"
jsonq: kann str nicht indizieren
exit=2
Fortschritt speichern? Kostenlos registrieren
Runde 4: envdiff – .env-Dateien vergleichen
Zeitlimit: 15 min · Punkte: 10
Spezifikation
envdiff A B [--show-values]vergleicht zwei.env-Dateien und gibt pro Schlüssel eine Zeile aus:- KEYnur in A,+ KEYnur in B,~ KEYWert verschieden; sortiert nach Schlüssel.- Werte erscheinen nur mit
--show-values(~ KEY: alt -> neu, fehlend als<fehlt>)..env-Dateien enthalten Secrets; ein Diff landet schnell in einem Ticket. parse_env(text) -> dict[str, str]:KEY=VALUE, optionalexport, Leerzeichen um=, Werte in'…'oder"…"(Inhalt bleibt wörtlich, auch#), sonst#als Kommentarbeginn. Kommentarzeilen, Leerzeilen und kaputte Zeilen ignorieren.- Exit 0: gleich, Exit 1: Unterschiede.
Tests
cat > tests/test_envdiff.py <<'EOF'
from typer.testing import CliRunner
from wettkampf.envdiff import app, diff, parse_env
runner = CliRunner()
A = """# Lab-Werte
DB_HOST=db.lab
DB_PASS='lab-geheim-1'
export API_URL="https://api.lab"
DEBUG=true
"""
B = """DB_HOST=db.lab
DB_PASS=lab-geheim-2
API_URL=https://api.lab # Kommentar am Ende
TIMEOUT=30
"""
def test_parse_env():
env = parse_env(A)
assert env == {
"DB_HOST": "db.lab",
"DB_PASS": "lab-geheim-1",
"API_URL": "https://api.lab",
"DEBUG": "true",
}
def test_parse_env_sonderfaelle():
env = parse_env("X='a # b'\nY=\nkaputt\n Z = 1 \n")
assert env == {"X": "a # b", "Y": "", "Z": "1"}
def test_diff():
assert diff(parse_env(A), parse_env(B)) == [
("~", "DB_PASS"),
("-", "DEBUG"),
("+", "TIMEOUT"),
]
def test_cli_maskiert_werte(tmp_path):
a, b = tmp_path / "a.env", tmp_path / "b.env"
a.write_text(A, encoding="utf-8")
b.write_text(B, encoding="utf-8")
result = runner.invoke(app, [str(a), str(b)])
assert result.exit_code == 1
assert "~ DB_PASS" in result.output
assert "geheim" not in result.output
shown = runner.invoke(app, [str(a), str(b), "--show-values"])
assert "lab-geheim-1 -> lab-geheim-2" in shown.output
assert runner.invoke(app, [str(a), str(a)]).exit_code == 0
EOFMusterlösung
cat > src/wettkampf/envdiff.py <<'EOF'
"""envdiff – zwei .env-Dateien vergleichen, ohne Werte zu verraten."""
import re
from pathlib import Path
from typing import Annotated
import typer
app = typer.Typer(add_completion=False)
LINE = re.compile(r"^\s*(?:export\s+)?([A-Za-z_]\w*)\s*=\s*(.*?)\s*$")
EnvFile = Annotated[Path, typer.Argument(exists=True, dir_okay=False)]
def parse_value(raw: str) -> str:
if raw[:1] in ("'", '"'):
quote = raw[0]
end = raw.find(quote, 1)
return raw[1:end] if end > 0 else raw[1:]
return raw.split(" #", 1)[0].strip()
def parse_env(text: str) -> dict[str, str]:
"""KEY=VALUE pro Zeile; Kommentare, Leerzeilen und Kaputtes ignorieren."""
env = {}
for line in text.splitlines():
if line.lstrip().startswith("#"):
continue
m = LINE.match(line)
if m:
env[m[1]] = parse_value(m[2])
return env
def diff(a: dict[str, str], b: dict[str, str]) -> list[tuple[str, str]]:
"""(-, KEY) nur in a, (+, KEY) nur in b, (~, KEY) verschieden – nach KEY."""
out = [("-", k) for k in a.keys() - b.keys()]
out += [("+", k) for k in b.keys() - a.keys()]
out += [("~", k) for k in a.keys() & b.keys() if a[k] != b[k]]
return sorted(out, key=lambda item: item[1])
@app.command()
def main(
a: EnvFile,
b: EnvFile,
show_values: Annotated[bool, typer.Option(help="Werte anzeigen")] = False,
) -> None:
"""Exit 0: gleich, Exit 1: Unterschiede. Werte nur mit --show-values."""
env_a = parse_env(a.read_text(encoding="utf-8"))
env_b = parse_env(b.read_text(encoding="utf-8"))
changes = diff(env_a, env_b)
for sign, key in changes:
line = f"{sign} {key}"
if show_values:
old, new = env_a.get(key, "<fehlt>"), env_b.get(key, "<fehlt>")
line += f": {old} -> {new}"
typer.echo(line)
if changes:
raise typer.Exit(1)
EOF- Dict-Views verhalten sich wie Mengen:
a.keys() - b.keys(),a.keys() & b.keys()– ohneset()-Umweg. sorted(..., key=lambda item: item[1])sortiert nur nach dem Schlüssel; die Reihenfolge-/+/~spielt keine Rolle.- Ein Typ-Alias mit
Annotated(EnvFile) hält zwei gleichartige Argumente schlank (Tag 3).
Prüfen
uv run pytest -q tests/test_envdiff.py
cat > lab/staging.env <<'EOF'
# Lab-Werte
DB_HOST=db.lab
DB_PASS=lab-pw-alt
export API_URL="https://api.lab"
DEBUG=true
EOF
cat > lab/prod.env <<'EOF'
DB_HOST=db.lab
DB_PASS=lab-pw-neu
API_URL=https://api.lab # gleich
TIMEOUT=30
EOF
uv run envdiff lab/staging.env lab/prod.env; echo "exit=$?"
uv run envdiff lab/staging.env lab/prod.env --show-valuesErwartet:
.... [100%]
4 passed in 0.01s
~ DB_PASS
- DEBUG
+ TIMEOUT
exit=1
~ DB_PASS: lab-pw-alt -> lab-pw-neu
- DEBUG: true -> <fehlt>
+ TIMEOUT: <fehlt> -> 30
Fortschritt speichern? Kostenlos registrieren
Runde 5: cronnext – wann läuft der Job?
Zeitlimit: 25 min · Punkte: 20
Spezifikation
cronnext EXPR [-n 5] [--from 2026-10-10T08:07]gibt die nächsten N Zeitpunkte nach--from(Default: jetzt) aus:2026-10-12 09:00 Mo.- Fünf Felder: Minute (0–59), Stunde (0–23), Tag (1–31), Monat (1–12),
Wochentag (0–7, 0 und 7 = Sonntag). Pro Feld:
*,5, Listen1,3, Bereiche1-5, Schritte*/15und10-20/5. parse_field(field, lo, hi) -> set[int]; Werte außerhalb, umgedrehte Bereiche, Schritt 0 oder Unsinn:CronError(im CLI Exit 2).- Klassische cron-Regel: Sind Tag und Wochentag
eingeschränkt, reicht es, wenn eins passt
(
0 0 13 * 5= jeden 13. und jeden Freitag). next_runs(expr, start, count) -> list[datetime], naive lokale Zeit, Sekunden 0, strikt nachstart.
Tests
cat > tests/test_cronnext.py <<'EOF'
from datetime import datetime
import pytest
from typer.testing import CliRunner
from wettkampf.cronnext import CronError, app, next_runs, parse_field
runner = CliRunner()
START = datetime(2026, 10, 10, 8, 7) # Samstag
@pytest.mark.parametrize(
("field", "lo", "hi", "expected"),
[
("*", 0, 6, set(range(7))),
("5", 0, 59, {5}),
("1,3-5", 0, 59, {1, 3, 4, 5}),
("*/15", 0, 59, {0, 15, 30, 45}),
("10-20/5", 0, 59, {10, 15, 20}),
],
)
def test_parse_field(field, lo, hi, expected):
assert parse_field(field, lo, hi) == expected
@pytest.mark.parametrize("field", ["60", "5-1", "*/0", "x", ""])
def test_parse_field_fehler(field):
with pytest.raises(CronError):
parse_field(field, 0, 59)
def test_alle_15_minuten():
runs = next_runs("*/15 * * * *", START, 3)
assert [r.strftime("%H:%M") for r in runs] == ["08:15", "08:30", "08:45"]
def test_werktags_9_uhr_ueberspringt_wochenende():
assert next_runs("0 9 * * 1-5", START, 1) == [datetime(2026, 10, 12, 9, 0)]
def test_sonntag_als_0_und_7():
sunday = [datetime(2026, 10, 11, 0, 0)]
assert next_runs("0 0 * * 0", START, 1) == sunday
assert next_runs("0 0 * * 7", START, 1) == sunday
def test_tag_oder_wochentag():
# Beide eingeschränkt: der 13. ODER ein Montag (klassische cron-Regel)
runs = next_runs("0 0 13 * 1", START, 2)
assert runs == [datetime(2026, 10, 12), datetime(2026, 10, 13)]
def test_29_februar():
assert next_runs("0 0 29 2 *", START, 1) == [datetime(2028, 2, 29)]
def test_cli():
args = ["*/15 9-17 * * 1-5", "-n", "2", "--from", "2026-10-10T08:07"]
result = runner.invoke(app, args)
assert result.output.splitlines() == ["2026-10-12 09:00 Mo", "2026-10-12 09:15 Mo"]
assert runner.invoke(app, ["* * *"]).exit_code == 2
EOFMusterlösung
cat > src/wettkampf/cronnext.py <<'EOF'
"""cronnext – die nächsten Läufe eines cron-Ausdrucks berechnen."""
from datetime import datetime, timedelta
from typing import Annotated
import typer
app = typer.Typer(add_completion=False)
FIELDS = [(0, 59), (0, 23), (1, 31), (1, 12), (0, 7)] # min std tag monat wtag
DAYS = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
class CronError(ValueError):
"""Ungültiger cron-Ausdruck."""
def parse_field(field: str, lo: int, hi: int) -> set[int]:
"""'*', '5', '1,3-5', '*/15', '10-20/5' -> Menge erlaubter Werte."""
values: set[int] = set()
for part in field.split(","):
rng, _, step_s = part.partition("/")
try:
step = int(step_s) if step_s else 1
if rng == "*":
start, end = lo, hi
else:
a, _, b = rng.partition("-")
start, end = int(a), int(b or a)
except ValueError as err:
raise CronError(f"ungültig: {part!r}") from err
if step < 1 or not lo <= start <= end <= hi:
raise CronError(f"außerhalb {lo}-{hi} oder Schritt < 1: {part!r}")
values |= set(range(start, end + 1, step))
return values
def next_runs(expr: str, start: datetime, count: int) -> list[datetime]:
fields = expr.split()
if len(fields) != 5:
raise CronError(f"5 Felder erwartet, {len(fields)} bekommen")
minute, hour, dom, month, dow = (
parse_field(f, lo, hi) for f, (lo, hi) in zip(fields, FIELDS, strict=True)
)
dow = {d % 7 for d in dow} # 7 ist auch Sonntag
dom_any, dow_any = fields[2] == "*", fields[4] == "*"
t = start.replace(second=0, microsecond=0) + timedelta(minutes=1)
runs: list[datetime] = []
limit = start + timedelta(days=366 * 5)
while len(runs) < count and t < limit:
cron_dow = (t.weekday() + 1) % 7 # Python: Mo=0, cron: So=0
day_ok = (t.day in dom) if dow_any else (cron_dow in dow)
if not dom_any and not dow_any:
day_ok = t.day in dom or cron_dow in dow
if t.month not in month or not day_ok:
t = t.replace(hour=0, minute=0) + timedelta(days=1)
elif t.hour not in hour:
t = t.replace(minute=0) + timedelta(hours=1)
elif t.minute not in minute:
t += timedelta(minutes=1)
else:
runs.append(t)
t += timedelta(minutes=1)
return runs
@app.command()
def main(
expr: Annotated[str, typer.Argument(help='z. B. "*/15 9-17 * * 1-5"')],
n: Annotated[int, typer.Option("-n", help="Anzahl Läufe")] = 5,
start: Annotated[
datetime | None,
typer.Option("--from", formats=["%Y-%m-%dT%H:%M"], help="Default: jetzt"),
] = None,
) -> None:
"""Gibt die nächsten N Zeitpunkte aus (lokale Zeit, ohne Zeitzone)."""
try:
runs = next_runs(expr, start or datetime.now(), n)
except CronError as err:
raise typer.BadParameter(str(err)) from err
for run in runs:
typer.echo(f"{run:%Y-%m-%d %H:%M} {DAYS[run.weekday()]}")
EOF- Minutenweise über ein Jahr zu laufen wären 525 600 Schritte pro Treffer. Die Schleife springt deshalb: passt der Tag nicht, zum nächsten Tag; passt die Stunde nicht, zur nächsten Stunde.
(t.weekday() + 1) % 7übersetzt Pythons Montag=0 in cron-Sonntag=0 – die häufigste Fehlerquelle dieser Runde.limit(fünf Jahre) beendet unmögliche Ausdrücke wie0 0 31 2 *mit einer leeren Liste statt einer Endlosschleife.formats=[...]bringt typer bei,2026-10-10T08:07ohne Sekunden alsdatetimezu lesen.
Prüfen
uv run pytest -q tests/test_cronnext.py
uv run cronnext "*/15 9-17 * * 1-5" -n 3 --from 2026-10-10T08:07
uv run cronnext "0 0 13 * 5" -n 3 --from 2026-10-10T08:07
uv run cronnext "61 * * * *"; echo "exit=$?"Erwartet (gekürzt):
................ [100%]
16 passed in 0.04s
2026-10-12 09:00 Mo
2026-10-12 09:15 Mo
2026-10-12 09:30 Mo
2026-10-13 00:00 Di
2026-10-16 00:00 Fr
2026-10-23 00:00 Fr
│ Invalid value: außerhalb 0-59 oder Schritt < 1: '61' │
exit=2
Der zweite Ausdruck war wohl als „Freitag, der 13.” gemeint – cron
läuft aber am 13. oder an jedem Freitag. Genau solche
Überraschungen findet ein cronnext vor dem Deployment.
Fortschritt speichern? Kostenlos registrieren
Runde 6: secretscan – Secrets im Repo finden
Zeitlimit: 20 min · Punkte: 15
Spezifikation
secretscan [DIR](Default.) durchsucht alle Textdateien rekursiv nach vier Regeln:aws-access-key(AKIA/ASIA+ 16 Zeichen),github-token(ghp_u. a. + mindestens 36 Zeichen),private-key(PEM-Header),password-assignment(password,passwd,secret,api_keymit=oder:und einem Wert in Anführungszeichen ab 8 Zeichen).- Übersprungen:
.git,.venv,node_modules,__pycache__, Symlinks, Dateien > 1 MB, Binärdateien (NUL-Byte in den ersten 1024 Bytes) und Zeilen mitsecretscan: ignore. scan(root) -> list[Finding]mitpath,line,rule,secret; sortiert nach Pfad und Zeile.- Ausgabe
pfad:zeile: regel maske, dannN Funde. Das Secret erscheint nie im Klartext:mask()zeigt höchstens die ersten 4 Zeichen (bei mehr als 8), Rest*. - Exit 0: nichts gefunden, Exit 1: Funde.
Tests
cat > tests/test_secretscan.py <<'EOF'
from pathlib import Path
from typer.testing import CliRunner
from wettkampf.secretscan import app, mask, scan
runner = CliRunner()
# Testwerte zur Laufzeit zusammensetzen: So schlägt kein Scanner auf diese Datei an.
AWS = "AKIA" + "IOSFODNN7EXAMPLE" # Beispielschlüssel aus der AWS-Doku
GHP = "ghp_" + "lab" * 12
PEM = "-----BEGIN " + "OPENSSH PRIVATE KEY-----"
def repo(tmp_path: Path) -> Path:
(tmp_path / "src").mkdir()
(tmp_path / ".git").mkdir()
(tmp_path / "src/config.py").write_text(
f'aws_key = "{AWS}"\npassword = "lab-pw-123456"\nok = 1\n', encoding="utf-8"
)
(tmp_path / "deploy.sh").write_text(f"export GH={GHP}\n", encoding="utf-8")
(tmp_path / "id_lab").write_text(f"{PEM}\nabc\n", encoding="utf-8")
(tmp_path / ".git/config").write_text(f"token = '{GHP}'\n", encoding="utf-8")
(tmp_path / "bild.png").write_bytes(b"\x89PNG\x00" + AWS.encode())
(tmp_path / "test.env").write_text(
f"KEY={AWS} # secretscan: ignore\n", encoding="utf-8"
)
return tmp_path
def test_scan_findet_alle_regeln(tmp_path):
found = [(f.path.name, f.line, f.rule) for f in scan(repo(tmp_path))]
assert found == [
("deploy.sh", 1, "github-token"),
("id_lab", 1, "private-key"),
("config.py", 1, "aws-access-key"),
("config.py", 2, "password-assignment"),
]
def test_mask():
assert mask(AWS) == "AKIA****************"
assert mask("kurz") == "****"
def test_cli_zeigt_nie_den_klartext(tmp_path):
result = runner.invoke(app, [str(repo(tmp_path))])
assert result.exit_code == 1
assert "4 Funde" in result.output
assert AWS not in result.output
assert GHP not in result.output
def test_cli_sauber(tmp_path):
(tmp_path / "a.py").write_text("print('hallo')\n", encoding="utf-8")
result = runner.invoke(app, [str(tmp_path)])
assert result.exit_code == 0
assert "0 Funde" in result.output
EOFDie Testdatei setzt ihre Fake-Secrets zur Laufzeit zusammen. Stünde
AKIA… am Stück im Quelltext, würde jeder Scanner – auch
deiner – die Testdatei selbst melden.
Musterlösung
cat > src/wettkampf/secretscan.py <<'EOF'
"""secretscan – Secrets in einem Verzeichnisbaum finden (Ausgabe maskiert)."""
import re
from collections.abc import Iterator
from dataclasses import dataclass
from pathlib import Path
from typing import Annotated
import typer
app = typer.Typer(add_completion=False)
RULES = {
"aws-access-key": re.compile(r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b"),
"github-token": re.compile(r"\bgh[pousr]_[A-Za-z0-9]{36,}\b"),
"private-key": re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----"),
"password-assignment": re.compile(
r"(?i)\b(?:password|passwd|secret|api_key)\s*[:=]\s*['\"]([^'\"]{8,})['\"]"
),
}
SKIP_DIRS = {".git", ".venv", "node_modules", "__pycache__"}
MAX_BYTES = 1_000_000
IGNORE = "secretscan: ignore"
@dataclass(frozen=True)
class Finding:
path: Path
line: int
rule: str
secret: str
def mask(secret: str) -> str:
keep = 4 if len(secret) > 8 else 0
return secret[:keep] + "*" * (len(secret) - keep)
def files(root: Path) -> Iterator[Path]:
"""Alle Textdateien unter root, ohne SKIP_DIRS, große und binäre Dateien."""
for path in sorted(root.rglob("*")):
rel = path.relative_to(root)
if SKIP_DIRS.intersection(rel.parts) or not path.is_file():
continue
if path.is_symlink() or path.stat().st_size > MAX_BYTES:
continue
with path.open("rb") as f:
if b"\x00" in f.read(1024):
continue # binär
yield path
def scan(root: Path) -> list[Finding]:
found = []
for path in files(root):
text = path.read_text(encoding="utf-8", errors="replace")
for no, line in enumerate(text.splitlines(), 1):
if IGNORE in line:
continue
for rule, rx in RULES.items():
for m in rx.finditer(line):
found.append(Finding(path, no, rule, m[m.lastindex or 0]))
return found
@app.command()
def main(
root: Annotated[Path, typer.Argument(exists=True, file_okay=False)] = Path("."),
) -> None:
"""Exit 0: nichts gefunden, Exit 1: Funde. Secrets werden nie ausgegeben."""
found = scan(root)
for f in found:
typer.echo(f"{f.path.relative_to(root)}:{f.line}: {f.rule} {mask(f.secret)}")
typer.echo(f"{len(found)} Funde")
if found:
raise typer.Exit(1)
EOFm[m.lastindex or 0]: Hat die Regel eine Gruppe (der Wert hinterpassword=), wird nur sie gemeldet, sonst der ganze Treffer.SKIP_DIRS.intersection(rel.parts)prüft alle Pfadteile auf einmal –.gitwird in jeder Tiefe übersprungen.errors="replace"statt Absturz bei kaputtem UTF-8; Binärdateien fängt vorher der NUL-Test ab.
Prüfen
uv run pytest -q tests/test_secretscan.py
mkdir -p lab/leak
cat > lab/leak/app.py <<'EOF'
AWS_KEY = "AKIAIOSFODNN7EXAMPLE"
password = "lab-pw-123456" # secretscan: ignore
EOF
cat > lab/leak/values.yaml <<'EOF'
db:
password: "lab-pw-abcdefgh"
EOF
uv run secretscan lab/leak; echo "exit=$?"
uv run secretscan src; echo "exit=$?"Erwartet:
.... [100%]
4 passed in 0.02s
app.py:1: aws-access-key AKIA****************
values.yaml:2: password-assignment lab-***********
2 Funde
exit=1
0 Funde
exit=0
AKIAIOSFODNN7EXAMPLE ist der offizielle
Beispielschlüssel aus der AWS-Dokumentation – ein Lab-Wert, der nirgends
funktioniert.
Fortschritt speichern? Kostenlos registrieren
Runde 7: llm-summarize – ein Log vom LLM bewerten lassen
Zeitlimit: 20 min · Punkte: 15
Spezifikation
llm-summarize LOG [--top 20] [--dry-run]verdichtet ein Log und lässt es von einem lokalen LLM bewerten. Konfiguration wie in Tag 10 überSUMMARIZE_BASE_URL(Default Ollama),SUMMARIZE_MODEL(ministral-3:3b),SUMMARIZE_API_KEY.normalize(line): führenden Zeitstempel entfernen, Secrets (Regeln aussecretscan) durch<secret>, IPv4 durch<ip>, übrige Zahlen durch#ersetzen.digest(lines, top): erste ZeileN Zeilen, M Muster, dann die häufigsten Muster als<n>x <muster>. Nur dieser Digest geht ans Modell – nie das Rohlog.summarize(client, text) -> Report(pydantic:headline,severity∈ ok/warn/crit,findings), strukturierte Ausgabe mittemperature=0.--dry-runzeigt nur den Digest, ohne LLM. Ausgabe sonst[SEVERITY] headlineplus- finding. Exit 0 bei ok, 1 bei warn/crit, 2 wenn das LLM nicht erreichbar ist.
Tests
cat > tests/test_summarize.py <<'EOF'
from types import SimpleNamespace as NS
from unittest.mock import MagicMock
from typer.testing import CliRunner
from wettkampf import summarize as sm
runner = CliRunner()
PW = "lab-pw-" + "123456" # Lab-Wert, zur Laufzeit zusammengesetzt
LOG = f"""2026-10-10T08:00:01Z INFO api ok path=/api/orders ms=12
2026-10-10T08:00:02Z ERROR db connection refused host=10.0.2.15 retry=1
2026-10-10T08:00:03Z ERROR db connection refused host=10.0.2.16 retry=2
2026-10-10T08:00:04Z WARN login failed user=bob password="{PW}"
"""
def test_normalize_entfernt_zeit_ip_zahlen_und_secrets():
lines = LOG.splitlines()
assert sm.normalize(lines[1]) == "ERROR db connection refused host=<ip> retry=#"
expected = 'WARN login failed user=bob password="<secret>"' # secretscan: ignore
assert sm.normalize(lines[3]) == expected
def test_digest_zaehlt_muster():
d = sm.digest(LOG.splitlines(), top=2)
assert d.splitlines() == [
"4 Zeilen, 3 Muster",
"2x ERROR db connection refused host=<ip> retry=#",
"1x INFO api ok path=/api/orders ms=#",
]
def test_summarize_fragt_strukturiert():
report = sm.Report(headline="DB weg", severity="crit", findings=["refused"])
client = MagicMock()
client.chat.completions.parse.return_value = NS(
choices=[NS(message=NS(parsed=report))]
)
assert sm.summarize(client, "2x ERROR ...") == report
kwargs = client.chat.completions.parse.call_args.kwargs
assert kwargs["response_format"] is sm.Report
assert kwargs["temperature"] == 0
def test_cli_dry_run_ohne_llm(tmp_path, monkeypatch):
log = tmp_path / "app.log"
log.write_text(LOG, encoding="utf-8")
monkeypatch.setattr(sm, "make_client", MagicMock(side_effect=AssertionError))
result = runner.invoke(sm.app, [str(log), "--dry-run"])
assert result.exit_code == 0
assert "2x ERROR db connection refused" in result.output
assert "10.0.2.15" not in result.output
assert "lab-pw" not in result.output
def test_cli_exit_code_nach_schwere(tmp_path, monkeypatch):
log = tmp_path / "app.log"
log.write_text(LOG, encoding="utf-8")
report = sm.Report(headline="DB weg", severity="crit", findings=["a", "b"])
monkeypatch.setattr(sm, "make_client", MagicMock())
monkeypatch.setattr(sm, "summarize", lambda client, text: report)
result = runner.invoke(sm.app, [str(log)])
assert result.exit_code == 1
assert result.output.splitlines()[0] == "[CRIT] DB weg"
EOFMusterlösung
cat > src/wettkampf/summarize.py <<'EOF'
"""llm-summarize – ein Log verdichten und von einem lokalen LLM bewerten lassen."""
import os
import re
from collections import Counter
from pathlib import Path
from typing import Annotated, Literal
import openai
import typer
from openai import OpenAI
from pydantic import BaseModel
from wettkampf.secretscan import RULES
app = typer.Typer(add_completion=False)
BASE_URL = os.environ.get("SUMMARIZE_BASE_URL", "http://127.0.0.1:11434/v1")
MODEL = os.environ.get("SUMMARIZE_MODEL", "ministral-3:3b")
SYSTEM = (
"Du bist SRE. Du bekommst eine verdichtete Logdatei: Muster mit Häufigkeit. "
"Antworte auf Deutsch. headline: ein Satz. severity: ok, warn oder crit. "
"findings: höchstens 3 konkrete Auffälligkeiten."
)
STAMP = re.compile(r"^\S*\d{4}-\d{2}-\d{2}\S*\s+")
IP = re.compile(r"\b\d{1,3}(?:\.\d{1,3}){3}\b")
NUMBER = re.compile(r"\b\d+\b")
class Report(BaseModel):
headline: str
severity: Literal["ok", "warn", "crit"]
findings: list[str]
def normalize(line: str) -> str:
"""Zeitstempel weg, IPs und Secrets schwärzen, Zahlen zu '#'."""
line = STAMP.sub("", line.strip())
for rx in RULES.values():
line = rx.sub(lambda m: m[0].replace(m[m.lastindex or 0], "<secret>"), line)
return NUMBER.sub("#", IP.sub("<ip>", line))
def digest(lines: list[str], top: int = 20) -> str:
"""Kompakter, geschwärzter Text statt des ganzen Logs."""
patterns = Counter(normalize(line) for line in lines if line.strip())
out = [f"{sum(patterns.values())} Zeilen, {len(patterns)} Muster"]
out += [f"{n}x {p}" for p, n in patterns.most_common(top)]
return "\n".join(out)
def make_client() -> OpenAI:
key = os.environ.get("SUMMARIZE_API_KEY", "ollama")
return OpenAI(base_url=BASE_URL, api_key=key, timeout=120, max_retries=1)
def summarize(client: OpenAI, text: str) -> Report:
resp = client.chat.completions.parse(
model=MODEL,
messages=[
{"role": "system", "content": SYSTEM},
{"role": "user", "content": text},
],
response_format=Report,
temperature=0,
)
parsed = resp.choices[0].message.parsed
if parsed is None:
raise ValueError("Modell lieferte kein gültiges JSON")
return parsed
@app.command()
def main(
logfile: Annotated[Path, typer.Argument(exists=True, dir_okay=False)],
top: Annotated[int, typer.Option(help="Anzahl Muster für das LLM")] = 20,
dry_run: Annotated[
bool, typer.Option(help="nur zeigen, was gesendet würde")
] = False,
) -> None:
"""Exit 0: ok, 1: warn/crit, 2: LLM nicht erreichbar."""
lines = logfile.read_text(encoding="utf-8", errors="replace").splitlines()
text = digest(lines, top)
if dry_run:
typer.echo(text)
return
try:
report = summarize(make_client(), text)
except openai.APIConnectionError as err:
typer.echo("LLM nicht erreichbar (läuft Ollama?)", err=True)
raise typer.Exit(2) from err
typer.echo(f"[{report.severity.upper()}] {report.headline}")
for finding in report.findings:
typer.echo(f" - {finding}")
if report.severity != "ok":
raise typer.Exit(1)
EOF- Verdichten vor dem Senden spart Tokens (500 Zeilen werden 5) und ist zugleich Datenschutz: IPs und Secrets verlassen den Rechner nicht, auch wenn später eine Cloud-API dahintersteht.
- Die Secret-Regeln kommen aus Runde 6 – ein Modul, zwei Tools.
rx.submit einer Funktion ersetzt nur die Gruppe (den Wert), der Schlüsselpassword=bleibt für das Modell lesbar.
Prüfen
Ein Lab-Log mit einer Störung am Ende:
uv run pytest -q tests/test_summarize.py
uv run python - <<'EOF'
import random
from datetime import UTC, datetime, timedelta
rng = random.Random(15)
t = datetime(2026, 10, 10, 8, 0, tzinfo=UTC)
with open("lab/app.log", "w", encoding="utf-8") as f:
for i in range(500):
t += timedelta(seconds=rng.randint(1, 5))
stamp = t.strftime("%Y-%m-%dT%H:%M:%SZ")
if i > 400 and rng.random() < 0.6:
host = f"10.0.2.{rng.randint(10, 20)}"
msg = f"ERROR db connection refused host={host} retry={rng.randint(1, 5)}"
elif rng.random() < 0.05:
msg = f"WARN slow query ms={rng.randint(900, 3000)} table=orders"
else:
path = rng.choice(["/api/orders", "/api/users"])
msg = f"INFO api ok path={path} ms={rng.randint(5, 80)}"
print(f"{stamp} {msg}", file=f)
EOF
uv run llm-summarize lab/app.log --dry-run
uv run llm-summarize lab/app.log; echo "exit=$?"Erwartet (LLM-Text variiert, gekürzt):
..... [100%]
5 passed in 0.26s
500 Zeilen, 4 Muster
218x INFO api ok path=/api/users ms=#
196x INFO api ok path=/api/orders ms=#
60x ERROR db connection refused host=<ip> retry=#
26x WARN slow query ms=# table=orders
[WARN] API- und Datenbankverkehr läuft stabil, aber langsame Abfragen in der
`orders`-Tabelle auffällig.
- Häufige Datenbankverbindungsfehler (60x) mit `host=<ip>` – potenzielles
Netzwerk- oder Konfigurationsproblem.
- Lange Abfragezeiten in der `orders`-Tabelle (26x) ...
exit=1
Lies kritisch: 60 abgelehnte DB-Verbindungen sind eher
crit als warn, und dass sie alle in den
letzten Minuten liegen, kann das Modell nicht wissen – der Digest hat
keine Zeitachse. Das Tool sortiert vor; entscheiden muss ein Mensch.
Fortschritt speichern? Kostenlos registrieren
Wertung
| Runde | Zeitlimit | Punkte | erreicht |
|---|---|---|---|
| 1 dupfind | 15 min | 10 | [ ] |
| 2 portwait | 15 min | 10 | [ ] |
| 3 jsonq | 25 min | 20 | [ ] |
| 4 envdiff | 15 min | 10 | [ ] |
| 5 cronnext | 25 min | 20 | [ ] |
| 6 secretscan | 20 min | 15 | [ ] |
| 7 llm-summarize | 20 min | 15 | [ ] |
| Summe | 135 min | 100 |
| Punkte | Einstufung |
|---|---|
| 85–100 | Profi: Du baust Ops-Tools schneller, als du sie suchst |
| 65–84 | Solide: Muster sitzen, Details (Zeit, Kanten) noch üben |
| unter 65 | Runden mit 0 Punkten am nächsten Tag ohne Musterlösung wiederholen |
Notiere zu jeder verpassten Runde den Grund in einem Satz („Wochentag-Mapping vergessen”, „typer-Datumsformat nicht gekannt”). Diese Liste ist dein persönlicher Spickzettel.
Kontrollpunkt
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/py-lab/tag15-wettkampf
for t in dupfind portwait jsonq envdiff cronnext secretscan summarize; do
check "Tests $t" "uv run pytest -q tests/test_$t.py"
done
check "ruff sauber" "uv run ruff check && uv run ruff format --check"
check "mypy --strict sauber" "uv run mypy"
check "dupfind meldet Duplikate (Exit 1)" "uv run dupfind lab/dup; test \$? -eq 1"
check "portwait Timeout (Exit 1)" \
"uv run portwait 127.0.0.1:9 --timeout 0.5; test \$? -eq 1"
check "jsonq liest stdin" "echo '{\"a\": [1, 2]}' | uv run jsonq '.a[1]' | grep -qx 2"
check "envdiff verrät keine Werte" \
"! uv run envdiff lab/staging.env lab/prod.env | grep -q lab-pw"
check "cronnext überspringt das Wochenende" "uv run cronnext '0 9 * * 1-5' -n 1 \
--from 2026-10-10T08:00 | grep -q '2026-10-12 09:00 Mo'"
check "secretscan findet das Lab-Leak" "uv run secretscan lab/leak; test \$? -eq 1"
check "eigener Code ohne Secrets" "uv run secretscan src && uv run secretscan tests"
check "llm-summarize schwärzt IPs" \
"! uv run llm-summarize lab/app.log --dry-run | grep -q '10\.0\.2'"Erwartet:
✔ Tests dupfind
✔ Tests portwait
✔ Tests jsonq
✔ Tests envdiff
✔ Tests cronnext
✔ Tests secretscan
✔ Tests summarize
✔ ruff sauber
✔ mypy --strict sauber
✔ dupfind meldet Duplikate (Exit 1)
✔ portwait Timeout (Exit 1)
✔ jsonq liest stdin
✔ envdiff verrät keine Werte
✔ cronnext überspringt das Wochenende
✔ secretscan findet das Lab-Leak
✔ eigener Code ohne Secrets
✔ llm-summarize schwärzt IPs
Port 9 (discard) ist auf einem normalen Mac geschlossen
– ideal für den Timeout-Test.
Challenge
Zusatzrunde (10 min, 5 Bonuspunkte): dupfind hasht heute
jede Datei gleicher Größe komplett. Bei vielen großen ISO-Images
derselben Größe ist das teuer. Schiebe eine Stufe dazwischen: Erst die
ersten 4 KiB vergleichen, den vollen SHA-256 nur für Dateien mit
gleichem Anfang. Ein Test beweist, dass Dateien mit verschiedenem Anfang
nie komplett gehasht werden.
Hinweis: Mit
monkeypatch.setattr(dupfind, "sha256", ...) ersetzt du die
Hash-Funktion im Test durch eine Version, die mitschreibt, welche
Dateien sie sieht.
Lösung
In src/wettkampf/dupfind.py vor
find_duplicates einfügen:
def head(path: Path, size: int = 4096) -> bytes:
with path.open("rb") as f:
return f.read(size)In find_duplicates den Block ab by_hash
(innerhalb der Größen-Schleife) ersetzen:
by_head: defaultdict[bytes, list[Path]] = defaultdict(list)
for path in paths:
by_head[head(path)].append(path)
for same_head in by_head.values():
if len(same_head) < 2:
continue # Anfang unterscheidet sich: kein voller Hash nötig
by_hash: defaultdict[str, list[Path]] = defaultdict(list)
for path in same_head:
by_hash[sha256(path)].append(path)
groups += [(size, sorted(g)) for g in by_hash.values() if len(g) > 1]In tests/test_dupfind.py oben
from wettkampf import dupfind ergänzen und anhängen:
def test_voller_hash_nur_bei_gleichem_anfang(tmp_path, monkeypatch):
make(tmp_path, {"a": "A" + "x" * 9999, "b": "B" + "x" * 9999})
make(tmp_path, {"c": "A" + "x" * 9999})
hashed = []
original = dupfind.sha256
def counting(path):
hashed.append(path.name)
return original(path)
monkeypatch.setattr(dupfind, "sha256", counting)
assert find_duplicates([tmp_path]) == [[tmp_path / "a", tmp_path / "c"]]
assert sorted(hashed) == ["a", "c"]uv run pytest -q tests/test_dupfind.py && uv run mypyErwartet:
...... [100%]
6 passed in 0.06s
Success: no issues found in 8 source files
monkeypatch wirkt, weil find_duplicates den
Namen sha256 zur Laufzeit im Modul nachschlägt. Dieselbe
Stufen-Idee – billig vorfiltern, teuer nur den Rest prüfen – hat
logsum an Tag 14 schnell gemacht.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Für jedes dieser Tools gibt es ausgereifte Vorbilder:
fdupes/rmlint,wait-for-it,jq,dotenv-linter,gitleaks/trufflehog. Selbst bauen lohnt sich, wenn du genau eine Regel deines Teams brauchst oder in einer Umgebung ohne Installationsrechte arbeitest. - Secret-Scanning gehört in pre-commit (Tag 5) und in CI. Ein Fund heißt: Secret rotieren, nicht nur die Zeile löschen – die Git-Historie vergisst nichts.
portwaitin Init-Containern immer mit Timeout; Kubernetes-Probes unddepends_on: condition: service_healthyersetzen es oft ganz.- cron-Ausdrücke vor dem Rollout prüfen und Zeitzonen dokumentieren;
Kubernetes-CronJobs kennen dafür
spec.timeZone. - LLM-Zusammenfassungen sind Vorsortierung, keine Diagnose: Digest statt Rohlog senden, Secrets und personenbezogene Daten vorher entfernen, die Bewertung als Vorschlag kennzeichnen.