Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 8: Daten – costreport

Ziel: Ein CLI costreport bauen, das eine Cloud-Kosten-CSV auswertet und als Markdown berichtet · Dauer: ca. 120 min · Voraussetzung: Tag 7

Briefing

  • csv und json aus der Standardbibliothek reichen für die meisten Ops-Daten.
  • Geld nie als float: Decimal zum Parsen, gespeichert als int in Cent.
  • sqlite3 ist eine vollwertige SQL-Datenbank in einer Datei – ohne Server.
  • polars rechnet spaltenorientiert und lazy; wir bauen dieselbe Auswertung zweimal und lassen einen Test prüfen, dass beide gleich rechnen.
  • Kaputte Zeilen werden gezählt und gemeldet, nicht still verschluckt.
kosten.csv --> csv.DictReader --> CostRow --> sqlite3 GROUP BY --+
     |                                                           +--> Summary
     +-----> polars scan_csv --> group_by/agg -------------------+       |
                                                              Markdown / JSON

Drill 1: Projekt und Lab-Daten

cd ~/py-lab
uv init -q --package --name costreport tag08-costreport
cd tag08-costreport && mkdir tests
uv add -q polars typer
uv add -q --dev pytest ruff
cat > gen_data.py <<'EOF'
"""Erzeugt kosten.csv: ein Monat Cloud-Kosten (Lab-Daten, reproduzierbar)."""

import csv
import random
from datetime import date, timedelta

rng = random.Random(42)
SERVICES = {"EC2": 120, "S3": 15, "RDS": 60, "EKS": 45, "CloudWatch": 8, "Lambda": 3}
ACCOUNTS = {
    "prod": ("platform", 1.0),
    "staging": ("platform", 0.3),
    "data": ("data", 0.6),
}

with open("kosten.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["date", "account", "service", "team", "cost_usd"])
    for day in range(30):
        d = date(2026, 9, 1) + timedelta(days=day)
        for account, (team, factor) in ACCOUNTS.items():
            for service, base in SERVICES.items():
                cost = base * factor * rng.uniform(0.8, 1.2)
                if d.day == 17 and service == "EC2" and account == "data":
                    cost *= 6  # vergessener GPU-Cluster
                w.writerow([d.isoformat(), account, service, team, f"{cost:.2f}"])
    w.writerow(["2026-09-30", "prod", "Support", "", "29.00"])  # ohne Team
    w.writerow(["2026-09-30", "prod", "EC2", "platform", "-50.00"])  # Gutschrift
    w.writerow(["2026-09-31", "prod", "S3", "platform", "1.00"])  # kaputtes Datum
    w.writerow(["2026-09-30", "data", "RDS", "data", "n/a"])  # kaputter Betrag
EOF
python3 gen_data.py && wc -l kosten.csv && head -3 kosten.csv && tail -4 kosten.csv

Erwartet:

     545 kosten.csv
date,account,service,team,cost_usd
2026-09-01,prod,EC2,platform,126.69
2026-09-01,prod,S3,platform,12.15
2026-09-30,prod,Support,,29.00
2026-09-30,prod,EC2,platform,-50.00
2026-09-31,prod,S3,platform,1.00
2026-09-30,data,RDS,data,n/a

Warum? Echte Billing-Exporte (AWS CUR, Azure Cost Export) haben genau diese Macken: fehlende Tags, Gutschriften, kaputte Werte. random.Random(42) macht die Daten reproduzierbar – deine Zahlen sind identisch mit denen im Buch.

Fortschritt speichern? Kostenlos registrieren

Drill 2: CSV lesen – mit Decimal und Cent

uv run python -c 'print(0.1 + 0.2)'

Erwartet:

0.30000000000000004

Deshalb: Betrag als Decimal parsen, als ganze Cent speichern.

cat > src/costreport/__init__.py <<'EOF'
"""costreport – Cloud-Kosten-CSV auswerten."""
EOF
cat > src/costreport/load.py <<'EOF'
"""CSV einlesen und validieren: Geld in Cent als int, nie als float."""

import csv
import logging
from dataclasses import dataclass
from datetime import date
from decimal import Decimal, InvalidOperation
from pathlib import Path

log = logging.getLogger(__name__)


@dataclass(frozen=True, slots=True)
class CostRow:
    day: date
    account: str
    service: str
    team: str
    cents: int


def parse_row(raw: dict[str, str]) -> CostRow:
    try:
        amount = Decimal(raw["cost_usd"])
    except InvalidOperation:
        raise ValueError(f"ungültiger Betrag {raw['cost_usd']!r}") from None
    return CostRow(
        day=date.fromisoformat(raw["date"]),
        account=raw["account"].strip(),
        service=raw["service"].strip(),
        team=raw["team"].strip() or "unassigned",
        cents=round(amount * 100),
    )


def read_costs(path: Path) -> tuple[list[CostRow], int]:
    """Gibt gültige Zeilen und die Zahl übersprungener Zeilen zurück."""
    rows: list[CostRow] = []
    skipped = 0
    with path.open(newline="", encoding="utf-8") as f:
        for lineno, raw in enumerate(csv.DictReader(f), start=2):
            try:
                rows.append(parse_row(raw))
            except (ValueError, KeyError) as exc:
                log.warning("Zeile %d übersprungen: %s", lineno, exc)
                skipped += 1
    return rows, skipped
EOF
uv run python - <<'EOF'
import logging
from pathlib import Path

from costreport.load import read_costs

logging.basicConfig(level=logging.WARNING, format="%(levelname)s %(message)s")
rows, skipped = read_costs(Path("kosten.csv"))
print(len(rows), "Zeilen,", skipped, "übersprungen")
print(rows[0])
print(sum(r.cents for r in rows) / 100, "USD")
EOF

Erwartet:

WARNING Zeile 544 übersprungen: day 31 must be in range 1..30 for month 9 in yea...
WARNING Zeile 545 übersprungen: ungültiger Betrag 'n/a'
542 Zeilen, 2 übersprungen
CostRow(day=datetime.date(2026, 9, 1), account='prod', service='EC2', team='plat...
14775.28 USD

Warum? csv.DictReader liefert pro Zeile ein dict mit den Spaltennamen als Schlüssel. parse_row macht daraus einen typisierten CostRow oder wirft ValueError – die Schleife entscheidet, was mit Fehlern passiert. start=2 zählt die Kopfzeile mit, damit die Zeilennummer im Editor stimmt.

Fortschritt speichern? Kostenlos registrieren

Drill 3: SQL mit sqlite3

Erst der gemeinsame Ergebnistyp, dann die SQL-Engine.

cat > src/costreport/summary.py <<'EOF'
"""Ergebnis-Datentyp, den beide Engines (sqlite3, polars) liefern."""

from dataclasses import dataclass


@dataclass(frozen=True)
class Summary:
    rows: int
    total_cents: int
    by_service: list[tuple[str, int]]  # absteigend nach Kosten
    by_team: list[tuple[str, int]]
    peak_day: tuple[str, int]  # (ISO-Datum, Cent)
EOF
cat > src/costreport/store.py <<'EOF'
"""Aggregation mit sqlite3: SQL aus der Standardbibliothek."""

import sqlite3
from collections.abc import Iterable

from costreport.load import CostRow
from costreport.summary import Summary

SCHEMA = """
CREATE TABLE IF NOT EXISTS costs (
    day TEXT NOT NULL, account TEXT NOT NULL, service TEXT NOT NULL,
    team TEXT NOT NULL, cents INTEGER NOT NULL
)
"""


def load_db(rows: Iterable[CostRow], path: str = ":memory:") -> sqlite3.Connection:
    conn = sqlite3.connect(path)
    conn.execute(SCHEMA)
    with conn:  # Transaktion: alles oder nichts
        conn.execute("DELETE FROM costs")
        conn.executemany(
            "INSERT INTO costs VALUES (?, ?, ?, ?, ?)",
            ((r.day.isoformat(), r.account, r.service, r.team, r.cents) for r in rows),
        )
    return conn


def group(conn: sqlite3.Connection, column: str, limit: int = -1) -> list[tuple]:
    if column not in {"service", "team", "day"}:  # nie Nutzereingaben ins SQL
        raise ValueError(column)
    sql = (
        f"SELECT {column}, SUM(cents) AS c FROM costs "
        f"GROUP BY {column} ORDER BY c DESC, {column} LIMIT ?"
    )
    return conn.execute(sql, (limit,)).fetchall()


def summarize(conn: sqlite3.Connection, top: int = 5) -> Summary:
    rows, total = conn.execute("SELECT COUNT(*), SUM(cents) FROM costs").fetchone()
    return Summary(
        rows=rows,
        total_cents=total or 0,
        by_service=group(conn, "service", top),
        by_team=group(conn, "team"),
        peak_day=group(conn, "day", 1)[0],
    )
EOF
uv run python - 2>/dev/null <<'EOF'
from pathlib import Path

from costreport.load import read_costs
from costreport.store import group, load_db, summarize

rows, _ = read_costs(Path("kosten.csv"))
conn = load_db(rows, "kosten.db")
print(group(conn, "team"))
print(summarize(conn, top=3))
EOF

Erwartet (gekürzt):

[('platform', 978298), ('data', 496330), ('unassigned', 2900)]
Summary(rows=542, total_cents=1477528, by_service=[('EC2', 719637), ('RDS', 34...

Warum? Werte gehen immer als ?-Parameter ins SQL, nie per f-String – sonst SQL-Injection. Spaltennamen lassen sich nicht parametrisieren, deshalb die Allowlist in group(). with conn: öffnet eine Transaktion, die bei einer Exception zurückgerollt wird.

Die Datei kosten.db kannst du mit dem sqlite3-CLI von macOS direkt befragen:

sqlite3 -header -column kosten.db "SELECT account, SUM(cents)/100.0 AS usd
  FROM costs GROUP BY account ORDER BY usd DESC"

Erwartet:

account  usd
-------  -------
prod     7540.87
data     4963.3
staging  2271.11

Fortschritt speichern? Kostenlos registrieren

Drill 4: Dasselbe mit polars

cat > src/costreport/frames.py <<'EOF'
"""Dieselbe Auswertung mit polars: spaltenorientiert, lazy, schnell."""

from pathlib import Path

import polars as pl

from costreport.summary import Summary


def read_frame(path: Path) -> pl.LazyFrame:
    return (
        pl.scan_csv(path, schema_overrides={"cost_usd": pl.String, "date": pl.String})
        .with_columns(
            day=pl.col("date").str.to_date(strict=False),
            team=pl.col("team").fill_null("unassigned"),
            cents=(pl.col("cost_usd").cast(pl.Float64, strict=False) * 100)
            .round()
            .cast(pl.Int64),
        )
        .drop_nulls(["day", "cents"])  # kaputte Zeilen raus
        .select("day", "account", "service", "team", "cents")
    )


def count_raw(path: Path) -> int:
    return pl.scan_csv(path).select(pl.len()).collect().item()


def group(lf: pl.LazyFrame, column: str, limit: int | None = None) -> list[tuple]:
    df = (
        lf.group_by(column)
        .agg(pl.col("cents").sum())
        .sort(["cents", column], descending=[True, False])
        .head(limit)
        .collect()
    )
    return [(str(k), int(v)) for k, v in df.iter_rows()]


def summarize(path: Path, top: int = 5) -> Summary:
    lf = read_frame(path)
    rows, total = lf.select(pl.len(), pl.col("cents").sum()).collect().row(0)
    return Summary(
        rows=rows,
        total_cents=total,
        by_service=group(lf, "service", top),
        by_team=group(lf, "team"),
        peak_day=group(lf, "day", 1)[0],
    )
EOF
uv run python - <<'EOF'
from pathlib import Path

from costreport.frames import read_frame, summarize

print(read_frame(Path("kosten.csv")).collect().head(3))
print(summarize(Path("kosten.csv"), top=3))
EOF

Erwartet (gekürzt):

shape: (3, 5)
┌────────────┬─────────┬─────────┬──────────┬───────┐
│ day        ┆ account ┆ service ┆ team     ┆ cents │
│ date       ┆ str     ┆ str     ┆ str      ┆ i64   │
╞════════════╪═════════╪═════════╪══════════╪═══════╡
│ 2026-09-01 ┆ prod    ┆ EC2     ┆ platform ┆ 12669 │
...
Summary(rows=542, total_cents=1477528, by_service=[('EC2', 719637), ('RDS', 34...

Warum? scan_csv liest nichts sofort, sondern baut einen Plan (LazyFrame); erst collect() führt ihn aus – polars optimiert dazwischen, z. B. liest es nur benötigte Spalten. strict=False macht aus kaputten Werten null, drop_nulls wirft sie raus. Gleiches Ergebnis wie SQL – genau das prüft gleich ein Test.

Achtung: Der Weg über Float64 ist für Beträge mit zwei Nachkommastellen dank round() exakt. Bei mehr Stellen (z. B. AWS-Preise mit 10 Dezimalen) pl.Decimal verwenden.

Frage sqlite3 polars
Abhängigkeit keine (Standardbibliothek) ca. 170 MB installiert
Stärke Persistenz, Ad-hoc-SQL, Mehrfachzugriff große Dateien, Parquet, schnelle Aggregation
Typisch Tool-Zustand, Cache, kleine Inventare Billing-Exporte, Logs, Analysen

Fortschritt speichern? Kostenlos registrieren

Drill 5: Markdown und JSON

cat > src/costreport/report.py <<'EOF'
"""Summary -> Markdown-Report oder JSON."""

import json

from costreport.summary import Summary


def usd(cents: int) -> str:
    return f"{cents / 100:,.2f} USD"


def table(title: str, items: list[tuple[str, int]], total: int) -> list[str]:
    lines = [f"## {title}", "", f"| {title} | Kosten | Anteil |", "|---|--:|--:|"]
    for name, cents in items:
        lines.append(f"| {name} | {usd(cents)} | {cents / total:.1%} |")
    return [*lines, ""]


def to_markdown(s: Summary, source: str, skipped: int = 0) -> str:
    day, day_cents = s.peak_day
    lines = [
        f"# Kostenreport {source}",
        "",
        f"- Gesamt: **{usd(s.total_cents)}** aus {s.rows} Zeilen",
        f"- Teuerster Tag: {day} mit {usd(day_cents)}",
    ]
    if skipped:
        lines.append(f"- Achtung: {skipped} ungültige Zeilen übersprungen")
    lines.append("")
    lines += table("Service", s.by_service, s.total_cents)
    lines += table("Team", s.by_team, s.total_cents)
    return "\n".join(lines)


def to_json(s: Summary) -> str:
    data = {
        "rows": s.rows,
        "total_cents": s.total_cents,
        "peak_day": dict([s.peak_day]),
        "by_service": dict(s.by_service),
        "by_team": dict(s.by_team),
    }
    return json.dumps(data, indent=2)
EOF

Warum? report.py kennt nur Summary – nicht CSV, SQL oder polars. Dadurch ist der Report leicht testbar und eine dritte Engine (z. B. DuckDB) bräuchte keine Zeile Änderung hier. {cents / total:.1%} formatiert direkt als Prozent.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Das CLI

cat > src/costreport/cli.py <<'EOF'
"""CLI: costreport kosten.csv [--top 5] [--engine sqlite|polars] [-o report.md]"""

import logging
from enum import StrEnum
from pathlib import Path
from typing import Annotated

import typer

from costreport import frames, store
from costreport.load import read_costs
from costreport.report import to_json, to_markdown

app = typer.Typer(add_completion=False)


class Engine(StrEnum):
    sqlite = "sqlite"
    polars = "polars"


@app.command()
def main(
    csv_file: Annotated[Path, typer.Argument(exists=True, dir_okay=False)],
    top: Annotated[int, typer.Option(min=1, help="Top-N Services")] = 5,
    engine: Annotated[Engine, typer.Option()] = Engine.sqlite,
    out: Annotated[Path | None, typer.Option("-o", help="Report-Datei")] = None,
    as_json: Annotated[bool, typer.Option("--json")] = False,
    db: Annotated[str, typer.Option(help="SQLite-Datei (nur sqlite)")] = ":memory:",
) -> None:
    """Wertet eine Cloud-Kosten-CSV aus und schreibt einen Markdown-Report."""
    logging.basicConfig(level=logging.WARNING, format="%(levelname)s %(message)s")
    if engine is Engine.sqlite:
        rows, skipped = read_costs(csv_file)
        summary = store.summarize(store.load_db(rows, db), top)
    else:
        summary = frames.summarize(csv_file, top)
        skipped = frames.count_raw(csv_file) - summary.rows
    text = to_json(summary) if as_json else to_markdown(summary, csv_file.name, skipped)
    if out:
        out.write_text(text + "\n", encoding="utf-8")
        typer.echo(f"Report geschrieben: {out}", err=True)
    else:
        typer.echo(text)
EOF
cat > src/costreport/__init__.py <<'EOF'
"""costreport – Cloud-Kosten-CSV auswerten."""

from costreport.cli import app


def main() -> None:
    app()
EOF
cat > src/costreport/__main__.py <<'EOF'
from costreport import main

main()
EOF
cat >> pyproject.toml <<'EOF'

[tool.ruff.lint]
extend-select = ["E501", "B", "UP", "SIM"]

[tool.pytest.ini_options]
testpaths = ["tests"]
EOF
uv run costreport kosten.csv --top 2 --engine polars | head -6

Erwartet:

# Kostenreport kosten.csv

- Gesamt: **14,775.28 USD** aus 542 Zeilen
- Teuerster Tag: 2026-09-17 mit 899.85 USD
- Achtung: 2 ungültige Zeilen übersprungen

Warum? StrEnum als Typ macht --engine zur Auswahl mit Prüfung und Hilfetext. exists=True lässt typer die Datei prüfen, bevor dein Code läuft. Logs und „Report geschrieben” gehen nach stderr, damit stdout sauber pipebar bleibt.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Tests – beide Engines müssen gleich rechnen

cat > tests/conftest.py <<'EOF'
from pathlib import Path

import pytest

CSV = """\
date,account,service,team,cost_usd
2026-09-01,prod,EC2,platform,0.10
2026-09-01,prod,EC2,platform,0.20
2026-09-01,data,S3,data,5.00
2026-09-02,prod,RDS,,1.50
2026-09-02,prod,EC2,platform,-0.05
2026-09-31,prod,S3,platform,1.00
2026-09-02,data,RDS,data,n/a
"""


@pytest.fixture
def csv_file(tmp_path: Path) -> Path:
    path = tmp_path / "kosten.csv"
    path.write_text(CSV)
    return path
EOF
cat > tests/test_load.py <<'EOF'
from datetime import date

import pytest

from costreport.load import parse_row, read_costs

RAW = {"date": "2026-09-01", "account": "prod", "service": "EC2"}


def test_parse_row_uses_cents_and_default_team():
    row = parse_row(RAW | {"team": " ", "cost_usd": "12.345"})
    assert (row.day, row.team, row.cents) == (date(2026, 9, 1), "unassigned", 1234)


@pytest.mark.parametrize("cost", ["n/a", "", "NaN"])
def test_parse_row_rejects_bad_amounts(cost):
    with pytest.raises(ValueError):
        parse_row(RAW | {"team": "x", "cost_usd": cost})


def test_read_costs_skips_bad_lines(csv_file):
    rows, skipped = read_costs(csv_file)
    assert (len(rows), skipped) == (5, 2)
    assert sum(r.cents for r in rows) == 10 + 20 + 500 + 150 - 5  # kein Float-Fehler
EOF
cat > tests/test_engines.py <<'EOF'
import pytest

from costreport import frames, store
from costreport.load import read_costs


def test_sqlite_and_polars_agree(csv_file):
    rows, _ = read_costs(csv_file)
    via_sql = store.summarize(store.load_db(rows), top=2)
    via_polars = frames.summarize(csv_file, top=2)
    assert via_sql == via_polars
    assert via_sql.by_service == [("S3", 500), ("RDS", 150)]
    assert via_sql.peak_day == ("2026-09-01", 530)


def test_group_rejects_unknown_column(csv_file):
    conn = store.load_db(read_costs(csv_file)[0])
    with pytest.raises(ValueError):
        store.group(conn, "team; DROP TABLE costs")
EOF
cat > tests/test_cli.py <<'EOF'
import json

from typer.testing import CliRunner

from costreport.cli import app


def test_markdown_report_to_file(csv_file, tmp_path):
    out = tmp_path / "report.md"
    result = CliRunner().invoke(app, [str(csv_file), "-o", str(out)])
    assert result.exit_code == 0
    text = out.read_text()
    assert text.startswith("# Kostenreport kosten.csv")
    assert "2 ungültige Zeilen" in text
    assert "| unassigned | 1.50 USD | 22.2% |" in text


def test_json_with_polars(csv_file):
    result = CliRunner().invoke(app, [str(csv_file), "--engine", "polars", "--json"])
    assert json.loads(result.stdout)["total_cents"] == 675
EOF
uv run pytest -q && uv run ruff check . && uv run ruff format --check .

Erwartet:

.........                                                                [100%]
9 passed in 0.09s
All checks passed!
14 files already formatted

Warum? test_sqlite_and_polars_agree vergleicht zwei unabhängige Implementierungen – findet eine davon einen Rundungs- oder Filterfehler, wird der Test rot. Die Mini-CSV in conftest.py enthält jede Macke der echten Daten, und tmp_path sorgt dafür, dass kein Test im Projektordner schreibt.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Das Tool ist fertig

uv run costreport kosten.csv -o report.md --db kosten.db
head -12 report.md
uv run costreport kosten.csv --engine polars --json 2>/dev/null | jq '.by_team'
sqlite3 kosten.db "SELECT day, SUM(cents)/100.0 FROM costs
  WHERE service='EC2' AND account='data' GROUP BY day ORDER BY 2 DESC LIMIT 2"

Erwartet:

WARNING Zeile 544 übersprungen: day 31 must be in range 1..30 for month 9 in yea...
WARNING Zeile 545 übersprungen: ungültiger Betrag 'n/a'
Report geschrieben: report.md
# Kostenreport kosten.csv

- Gesamt: **14,775.28 USD** aus 542 Zeilen
- Teuerster Tag: 2026-09-17 mit 899.85 USD
- Achtung: 2 ungültige Zeilen übersprungen

## Service

| Service | Kosten | Anteil |
|---|--:|--:|
| EC2 | 7,196.37 USD | 48.7% |
| RDS | 3,483.11 USD | 23.6% |
{
  "platform": 978298,
  "data": 496330,
  "unassigned": 2900
}
2026-09-17|501.8
2026-09-20|85.55

Der Report zeigt den teuersten Tag, SQL findet die Ursache: EC2 im Account data am 17. – der vergessene GPU-Cluster aus gen_data.py. report.md kannst du direkt in ein Ticket oder einen Merge Request kopieren.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/py-lab/tag08-costreport
check "Tests grün" "uv run pytest -q"
check "ruff sauber" "uv run ruff check . && uv run ruff format --check ."
check "Report hat Summe" "grep -q '14,775.28 USD' report.md"
check "Engines gleich" "diff <(uv run costreport kosten.csv --json) \
  <(uv run costreport kosten.csv --json --engine polars)"
check "SQLite-Datei befüllt" \
  "test \$(sqlite3 kosten.db 'SELECT COUNT(*) FROM costs') = 542"
check "kein float für Geld" "! grep -n 'float(' src/costreport/load.py"

Erwartet:

✔ Tests grün
✔ ruff sauber
✔ Report hat Summe
✔ Engines gleich
✔ SQLite-Datei befüllt
✔ kein float für Geld

Challenge

Der Report soll auffällige Tage automatisch markieren: alle Tage, deren Kosten über dem 1,5-Fachen des Tagesmedians liegen.

Hinweis: In frames.py erst nach day gruppieren, dann daily["cents"].median() und filter().

Lösung

An src/costreport/frames.py anhängen:

def spikes(path: Path, factor: float = 1.5) -> list[tuple[str, int]]:
    """Tage, deren Kosten über factor x Median liegen."""
    daily = read_frame(path).group_by("day").agg(pl.col("cents").sum()).collect()
    limit = factor * daily["cents"].median()
    hits = daily.filter(pl.col("cents") > limit).sort("day")
    return [(str(d), int(c)) for d, c in hits.iter_rows()]

In src/costreport/cli.py den Import um usd ergänzen und vor if out: einfügen:

from costreport.report import to_json, to_markdown, usd
...
    if not as_json:
        text += "\n## Auffällige Tage (> 1,5 x Median)\n"
        for day, cents in frames.spikes(csv_file):
            text += f"\n- {day}: {usd(cents)}"

Test an tests/test_engines.py anhängen:

def test_spikes(csv_file):
    assert frames.spikes(csv_file) == [("2026-09-01", 530)]
uv run pytest -q && uv run costreport kosten.csv 2>/dev/null | tail -3

Erwartet:

..........                                                               [100%]
10 passed in 0.17s
## Auffällige Tage (> 1,5 x Median)

- 2026-09-17: 899.85 USD

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Echte Billing-Exporte (AWS CUR 2.0, Azure, GCP BigQuery-Export) sind Parquet und Gigabytes groß: pl.scan_parquet() statt CSV, lazy bleiben, nur benötigte Spalten lesen.
  • Währungen und Wechselkurse explizit führen; nie Beträge verschiedener Währungen addieren.
  • Kostenzuordnung lebt von Tags: unassigned als eigene Kennzahl berichten und Tag-Pflicht per Policy (SCP, Azure Policy, Kyverno) durchsetzen.
  • SQLite ist für ein Tool perfekt, aber nicht für parallele Schreiber über Netzlaufwerke; für geteilte Daten PostgreSQL oder ein Warehouse.
  • Reports mit Kostendaten können vertraulich sein (Vertragspreise, Rabatte) – Ablageort und Empfänger klären.