Anhang B: Abschlussprüfung
Ziel: Nachweisen, dass du ein Python-Tool allein von der Spezifikation bis zur CI-geprüften Auslieferung bauen kannst · Dauer: 150 min Praxis + 20 min Fragen · Voraussetzung: Tag 15
Regeln
- Du baust ein Tool:
healthzprüft HTTP-Endpunkte aus einer TOML-Datei parallel und meldet das Ergebnis als Tabelle oder JSON mit sauberem Exit-Code. - Erlaubt: Anhang A,
--help, docs.python.org, die Doku von typer, httpx und pydantic. Nicht erlaubt: KI-Assistenten und Code aus den Kapiteln kopieren. - Die vorgegebene Testdatei darfst du nicht ändern. Gewertet wird ausschließlich mit dem Prüfskript am Ende.
- Bestanden: mindestens 70 von 100 Punkten und Aufgabe A6 (Qualität) erfüllt.
mkdir -p ~/py-lab/pruefung && cd ~/py-lab/pruefung
uv init -q -p 3.14 --package --name healthz healthz
cd healthz && mkdir -p tests lab/wwwTeil 1: Praktische Prüfung
Spezifikation
healthz check services.toml [--json] [--concurrency 10]
healthz --version
└─ config.load_config() ──► [Service, ...] ──► checks.check_all() ──► [Result, ...]
ConfigError ──► Exit 2 pydantic TaskGroup + Semaphore Exit 0 | 1
healthz.checks.Service(pydantic):name(nicht leer),url(nur http/https, ohne Zugangsdaten wiehttps://user:pw@host),expect: int = 200,timeout: float = 2.0(größer 0).healthz.checks.Result:name,url,ok,status(int | None),ms(Dauer),error(Name der Exception oder leer).healthz.config.load_config(path) -> list[Service]liest[[service]]-Tabellen. Fehlende Datei, kaputtes TOML, ungültige Felder, keine Services oder doppelte Namen:ConfigError.async healthz.checks.check_all(services, client, concurrency=10) -> list[Result]: ein gemeinsamerhttpx.AsyncClient, höchstensconcurrencygleichzeitige Requests, Ergebnisse in der Reihenfolge der Eingabe.okheißt: Status gleichexpect. Netzfehler werden zuok=False, status=None, error="ConnectError"– nie zu einer Exception.- CLI (
healthz = "healthz.cli:app", typer):checkgibt pro Service eine Zeile aus, mit--jsoneine Liste von Objekten mit genau den Feldern vonResult. Exit 0: alle ok, 1: mindestens einer nicht ok, 2:ConfigError(Meldung auf stderr).--versiongibthealthz <version>aus. - Qualität: ruff mit
extend-select = ["E501", "B", "UP", "SIM", "I", "S"], mypy strict aufsrc, pytest mit Coverage mindestens 80 %. - Auslieferung: Version 1.0.0, Wheel in
dist/, GitHub-Actions-Workflow.github/workflows/ci.yml(uv, ruff, mypy, pytest).
Vorgegebene Tests
cat > tests/test_pruefung.py <<'EOF'
"""Vorgegebene Prüfungstests – nicht ändern."""
import asyncio
import json
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import httpx
import pytest
from typer.testing import CliRunner
from healthz.checks import Service, check_all
from healthz.cli import app
from healthz.config import ConfigError, load_config
runner = CliRunner()
OK_TOML = """
[[service]]
name = "api"
url = "https://api.lab/healthz"
[[service]]
name = "db"
url = "http://db.lab:8080/"
expect = 204
timeout = 0.5
"""
def write(tmp_path, text):
path = tmp_path / "services.toml"
path.write_text(text, encoding="utf-8")
return path
def test_load_config(tmp_path):
services = load_config(write(tmp_path, OK_TOML))
assert [s.name for s in services] == ["api", "db"]
assert (services[0].expect, services[0].timeout) == (200, 2.0)
assert (services[1].expect, services[1].timeout) == (204, 0.5)
@pytest.mark.parametrize(
"text",
[
"", # keine Services
"kaputt =", # kein TOML
'[[service]]\nname = "x"\n', # url fehlt
'[[service]]\nname = "x"\nurl = "ftp://x.lab/"\n', # nur http(s)
'[[service]]\nname = "x"\nurl = "https://u:[email protected]/"\n', # Zugangsdaten
'[[service]]\nname = "x"\nurl = "https://x.lab/"\ntimeout = 0\n',
OK_TOML + '\n[[service]]\nname = "api"\nurl = "https://b.lab/"\n', # doppelt
],
)
def test_load_config_fehler(tmp_path, text):
with pytest.raises(ConfigError):
load_config(write(tmp_path, text))
def handler(request: httpx.Request) -> httpx.Response:
if request.url.host == "down.lab":
raise httpx.ConnectError("refused", request=request)
return httpx.Response(200 if request.url.host == "ok.lab" else 503)
def test_check_all_reihenfolge_und_fehler():
services = [
Service(name="ok", url="https://ok.lab/"),
Service(name="bad", url="https://bad.lab/"),
Service(name="down", url="https://down.lab/"),
Service(name="anders", url="https://ok.lab/", expect=204),
]
async def run():
transport = httpx.MockTransport(handler)
async with httpx.AsyncClient(transport=transport) as client:
return await check_all(services, client, concurrency=2)
results = asyncio.run(run())
assert [(r.name, r.ok, r.status) for r in results] == [
("ok", True, 200),
("bad", False, 503),
("down", False, None),
("anders", False, 200),
]
assert "ConnectError" in results[2].error
assert all(r.ms >= 0 for r in results)
class Lab(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200 if self.path == "/healthz" else 404)
self.end_headers()
def log_message(self, *args):
pass
@pytest.fixture
def lab_url():
server = ThreadingHTTPServer(("127.0.0.1", 0), Lab)
threading.Thread(target=server.serve_forever, daemon=True).start()
yield f"http://127.0.0.1:{server.server_address[1]}"
server.shutdown()
def test_cli_exit_codes_und_json(tmp_path, lab_url):
good = f'[[service]]\nname = "lab"\nurl = "{lab_url}/healthz"\n'
assert runner.invoke(app, ["check", str(write(tmp_path, good))]).exit_code == 0
bad = good + f'\n[[service]]\nname = "weg"\nurl = "{lab_url}/weg"\n'
result = runner.invoke(app, ["check", str(write(tmp_path, bad)), "--json"])
assert result.exit_code == 1
data = json.loads(result.output)
assert [(d["name"], d["ok"], d["status"]) for d in data] == [
("lab", True, 200),
("weg", False, 404),
]
assert set(data[0]) == {"name", "url", "ok", "status", "ms", "error"}
def test_cli_config_fehler_und_version(tmp_path):
result = runner.invoke(app, ["check", str(write(tmp_path, "kaputt ="))])
assert result.exit_code == 2
version = runner.invoke(app, ["--version"])
assert version.exit_code == 0
assert version.output.startswith("healthz ")
EOFLab-Daten
echo ok > lab/www/healthz
cat > lab/services.toml <<'EOF'
[[service]]
name = "lab"
url = "http://127.0.0.1:8781/healthz"
[[service]]
name = "fehlt"
url = "http://127.0.0.1:8781/gibt-es-nicht"
[[service]]
name = "aus"
url = "http://127.0.0.1:9/"
timeout = 0.5
EOFDen Lab-Server startest du zum Ausprobieren selbst; das Prüfskript startet ihn eigenständig:
uv run python -m http.server 8781 --bind 127.0.0.1 --directory lab/wwwAufgaben
| Aufgabe | Inhalt | Punkte |
|---|---|---|
| A1 | Projekt: Python 3.14, Kommando healthz zeigt auf
healthz.cli:app |
5 |
| A2 | load_config mit pydantic-Validierung und
ConfigError |
15 |
| A3 | check_all: TaskGroup, Semaphore, Fehler pro Service
abfangen |
20 |
| A4 | CLI: Tabelle, --json, Exit-Codes 0/1/2,
--version |
15 |
| A5 | mindestens 3 eigene Tests (z. B. Timeout, leere Liste) | 10 |
| A6 | ruff, ruff format, mypy strict, Coverage ≥ 80 % | 10 |
| A7 | Version 1.0.0 per uv version, Wheel per
uv build |
10 |
| A8 | Live: lab, fehlt, aus liefern
ok/nicht ok/nicht ok |
10 |
| A9 | CI-Workflow, gültig laut actionlint | 5 |
Erwartete Ausgabe im Live-Test (Zeiten variieren):
OK 200 76ms lab http://127.0.0.1:8781/healthz
FAIL 404 12ms fehlt http://127.0.0.1:8781/gibt-es-nicht
FAIL ConnectError 2ms aus http://127.0.0.1:9/
Prüfskript
cat > pruefung.sh <<'EOF'
#!/usr/bin/env bash
# Prüfskript Abschlussprüfung: vergibt Punkte je Aufgabe
cd ~/py-lab/pruefung/healthz || exit 1
P=0
pts() {
if eval "$3" >/dev/null 2>&1; then echo "✔ $2 (+$1)"; P=$((P + $1))
else echo "✘ $2 (0/$1)"; fi
}
T="uv run pytest -q --no-cov tests/test_pruefung.py"
uv run python -m http.server 8781 --bind 127.0.0.1 --directory lab/www \
>/dev/null 2>&1 &
sleep 2
pts 5 "A1 Projekt und Kommando" "grep -qx 3.14 .python-version && \
grep -q '^healthz = \"healthz.cli:app\"' pyproject.toml"
pts 15 "A2 Konfiguration" "$T -k load_config"
pts 20 "A3 Parallele Checks" "$T -k check_all"
pts 15 "A4 CLI und Exit-Codes" "$T -k cli"
pts 10 "A5 Eigene Tests (mind. 3)" \
"test \$(uv run pytest -q --no-cov --collect-only | grep -c '::') -ge 14"
pts 10 "A6 Qualität" "uv run ruff check && uv run ruff format --check && \
uv run mypy && uv run pytest -q"
pts 10 "A7 Version 1.0.0 und Wheel" "uv run healthz --version | \
grep -qx 'healthz 1.0.0' && test -f dist/healthz-1.0.0-py3-none-any.whl"
pts 10 "A8 Live gegen Lab-Server" "uv run healthz check lab/services.toml --json \
| jq -e '[.[].ok] == [true, false, false]'"
pts 5 "A9 CI-Workflow gültig" \
"test -f .github/workflows/ci.yml && uvx --from actionlint-py actionlint"
pkill -f 'http.server 8781'
echo "Punkte: $P / 100"
EOF
bash pruefung.shErwartet bei voller Lösung:
✔ A1 Projekt und Kommando (+5)
✔ A2 Konfiguration (+15)
✔ A3 Parallele Checks (+20)
✔ A4 CLI und Exit-Codes (+15)
✔ A5 Eigene Tests (mind. 3) (+10)
✔ A6 Qualität (+10)
✔ A7 Version 1.0.0 und Wheel (+10)
✔ A8 Live gegen Lab-Server (+10)
✔ A9 CI-Workflow gültig (+5)
Punkte: 100 / 100
--no-cov schaltet die Coverage-Schwelle für die
Teilläufe ab – sonst scheiterte A2 allein daran, dass vier Tests nicht
80 % des Codes abdecken. Die vorgegebenen Tests zählen 11, mit drei
eigenen sind es 14.
Tipp: Arbeite in der Reihenfolge der Tests:
uv run pytest -q --no-cov -k load_configzuerst grün bekommen, danncheck_all, dann das CLI. Qualität und Auslieferung gehen in den letzten 20 Minuten schnell, wenn ruff und mypy von Anfang an mitlaufen.
Eine geprüfte Referenzlösung liegt im Begleitmaterial unter
code/anhang-b-healthz/. Sieh sie dir erst nach der Prüfung
an.
Teil 2: Fragen
Je Frage ein bis zwei Sätze, ohne Hilfsmittel. 20 von 25 richtig: Theorie bestanden.
- Was liegt in
uv.lock, was in.venv, und was davon gehört ins Repo? - Was bewirkt
uv init --packagegegenüberuv init, und wozu dient[project.scripts]? - Warum ist
def f(items=[])ein Fehler, und wie löst@dataclassdas? - Was ist der Unterschied zwischen
Iterable[LogEntry]undlist[LogEntry]als Parametertyp? - Wozu dient der
*indef summarize(entries, *, since=None)? - Warum lassen sich naive und zeitzonenbehaftete
datetime-Werte nicht vergleichen, und was ist die Regel im Buch? - Warum
subprocess.run([...])stattsubprocess.run("...", shell=True)? - Welche Exit-Codes verwendet das Buch, und warum ist 2 für Bedienfehler reserviert?
- Was bewirkt
raise CertError(...) from err? - Warum patcht man
checkcert.core.socket.create_connectionund nichtsocket.create_connection? - Wofür sind
tmp_path,monkeypatchundcaplogin pytest gut? - Was prüft
mypy --strictzusätzlich, und warum reicht ein Typ-Hint allein nicht? - Warum braucht ein HTTP-Client immer einen Timeout, und welche Statuscodes wiederholt man mit Backoff?
- Was erledigt pydantic an der Grenze eines Tools, das ein normales Dict nicht kann?
- Wann hilft
asyncio, wannProcessPoolExecutor, und warum helfen Threads im Standard-Build nicht bei CPU-Last? - Was macht eine
TaskGroup, wenn ein Task eine Exception wirft? - Warum rechnet
costreportGeld in Cent alsint(oderDecimal) statt alsfloat? - Was zeigen
tottimeundcumtimein cProfile? - Warum hat
@cacheaufparse_stamplogsumlangsamer gemacht, und wann wäre es richtig? - Was spart ein Generator gegenüber einer Liste, und wann wird bei
read_entriesdie Datei geöffnet? - Warum teilt
logsumdie Datei in Byte-Bereiche, statt Zeilen an die Prozesse zu schicken? - Was unterscheidet
uv tool install, ein Wheel und ein zipapp beim Ausliefern? - Wozu
stream_options={"include_usage": True}, und was misst die TTFT? - Warum ist eine strukturierte LLM-Ausgabe mit pydantic zwar formal, aber nicht inhaltlich verlässlich?
- Nenne drei Guardrails für eine Agenten-Schleife mit Tool Calling.
Lösungsschlüssel
uv.lockpinnt alle Versionen exakt (ins Repo),.venvist die lokale Umgebung (nie ins Repo,uv syncbaut sie neu).- Ein installierbares Paket im
src/-Layout mit Build-Backend;[project.scripts]macht eine Funktion oder App zu einem Kommando im PATH. - Der Default wird einmal beim Definieren erzeugt und von allen
Aufrufen geteilt; dataclasses verbieten veränderliche Defaults und
verlangen
field(default_factory=list). Iterableakzeptiert alles Durchlaufbare, auch Generatoren – die Funktion verspricht nur einmaliges Iterieren und bleibt speicherfreundlich.- Alle Parameter danach sind keyword-only; Aufrufe bleiben lesbar und Parameter lassen sich später umsortieren.
- Ohne Zeitzone ist der Zeitpunkt mehrdeutig, Python wirft
TypeError; das Buch rechnet immer in UTC und macht Eingaben ohne Zone zu UTC. - Die Argumentliste wird ohne Shell übergeben, Leerzeichen und
;in Dateinamen bleiben harmlos – keine Command Injection. - 0 ok, 1 fachlicher Befund, 2 Bedienfehler, 3 Umgebung kaputt bzw. Nagios UNKNOWN; 2 ist die Konvention von argparse/click/typer, ein Retry hilft dort nicht.
- Es wirft die eigene Exception und hängt die ursprüngliche als
__cause__an; der Traceback zeigt beide, Tests können die Ursache prüfen. - Patchen muss man dort, wo der Name nachgeschlagen wird – im Modul
checkcert.core, dassocketimportiert hat. tmp_path: frischer Ordner pro Test;monkeypatch: Attribute und Umgebungsvariablen temporär ersetzen;caplog: Log-Meldungen einfangen und prüfen.- Typ-Hints an jeder Funktion, kein implizites
Any, keine ungeprüften Optionals; Python selbst ignoriert Hints zur Laufzeit. - Ohne Timeout hängt ein Tool bei einem toten Server ewig; wiederholt werden 429, 500, 502, 503, 504 und Transportfehler – mit Backoff und Jitter, 4xx sonst nicht.
- Typen umwandeln und prüfen (URL, Datum, Literal), Pflichtfelder erzwingen, verständliche Fehler liefern und ein JSON-Schema erzeugen.
asynciobei viel Warten auf Netz/Disk, Prozesse bei CPU-Last; der GIL lässt im Standard-Build nur einen Thread gleichzeitig Python-Code ausführen.- Sie bricht die übrigen Tasks ab und wirft eine
ExceptionGroup, die man mitexcept*zerlegt. floatkann Beträge wie 0,10 nicht exakt darstellen; Summen über tausende Zeilen weichen sonst um Cents ab.tottimeist die Zeit in der Funktion selbst,cumtimeinklusive aller aufgerufenen Funktionen.- Nur 25 % Treffer: Hashing und Verwaltung kosten mehr, und der
unbegrenzte Cache hält 748 000 Objekte; richtig bei vielen
Wiederholungen, dann mit
lru_cache(maxsize=…). - Es lebt immer nur ein Eintrag im Speicher statt aller; die Datei
wird erst beim ersten
next()geöffnet, also innerhalb vonsummarize. - Pickling von Millionen Strings kostet mehr als das Parsen; Byte-Bereiche übertragen nur zwei Zahlen, jeder Prozess liest selbst.
uv tool installlegt ein eigenes venv mit Kommando an; ein Wheel ist das Standardpaket für Index und pip; ein zipapp ist eine Datei, braucht aber ein passendes Python auf dem Ziel.- Ohne die Option liefert der Stream keine Token-Zahlen; TTFT ist die Zeit bis zum ersten Token, also die gefühlte Wartezeit.
- Das Schema erzwingt Form und Typen, nicht Wahrheit: Das Modell kann gültiges JSON mit falschem Befehl oder falscher Bewertung liefern.
- Allowlist der Tools, Argumente validieren, Obergrenzen für Schritte, Tool-Aufrufe und Zeit; außerdem nur read-only Tools und nie LLM-Text an eine Shell.
Teil 3: Selbsteinschätzung
| Thema | kann ich | im Lab gemacht |
|---|---|---|
| uv, Projekte, ruff, pytest (Tag 0) | [ ] | [ ] |
| Syntax, Comprehensions (Tag 1) | [ ] | [ ] |
| Funktionen, dataclasses, Module, mypy (Tag 2) | [ ] | [ ] |
| typer, pathlib, subprocess, Exit-Codes (Tag 3) | [ ] | [ ] |
| Exceptions, Logging, Fixtures, Mocks (Tag 4) | [ ] | [ ] |
| Packaging, pre-commit, Versionierung (Tag 5) | [ ] | [ ] |
| httpx, Retries, pydantic (Tag 6) | [ ] | [ ] |
| asyncio, TaskGroup, Threads vs. Prozesse (Tag 7) | [ ] | [ ] |
| csv, sqlite3, polars (Tag 8) | [ ] | [ ] |
| FastAPI, TestClient, Dockerfile (Tag 9) | [ ] | [ ] |
| LLM-APIs, Streaming, strukturierte Ausgabe (Tag 10) | [ ] | [ ] |
| Embeddings, RAG, Evaluation (Tag 11) | [ ] | [ ] |
| Tool Calling, Agenten-Loop, MCP (Tag 12) | [ ] | [ ] |
| scikit-learn, PyTorch-Einstieg (Tag 13) | [ ] | [ ] |
| Profiling, Optimierung, Verteilung, CI (Tag 14) | [ ] | [ ] |
| Tools unter Zeitdruck (Tag 15) | [ ] | [ ] |
Jede Zeile ohne zwei Kreuze: das Kapitel noch einmal durcharbeiten – diesmal ohne die Erwartet-Blöcke vorher zu lesen.