Schwache Referenzen und ein zehnmal schnellerer Bericht

class Customer:
    def __init__(self, cid: int, name: str) -> None:
        self.cid = cid
        self.name = name


def customer_names(orders: list[tuple[int, str]], customers: list[Customer]) -> list[str]:
    """The customer's name for every (customer id, amount) order, in order."""
    names = []
    for cid, _amount in orders:
        for customer in customers:
            if customer.cid == cid:
                names.append(customer.name)
                break
    return names

from main import Customer, customer_names


class CountingList(list):
    """Eine Liste, die zählt, wie oft über sie iteriert wird."""

    loops = 0

    def __iter__(self):
        CountingList.loops += 1
        return super().__iter__()


def test_names():
    """Jede Bestellung bekommt den Namen ihres Kunden, in Reihenfolge"""
    customers = [Customer(1, "Ada"), Customer(2, "Bo")]
    got = customer_names([(2, "5.00"), (1, "3.50"), (2, "1.00")], customers)
    assert got == ["Bo", "Ada", "Bo"], f"Ergebnis {got!r}, erwartet ['Bo', 'Ada', 'Bo']"


def test_one_pass_over_customers():
    """500 Bestellungen durchlaufen die Kundenliste einmal, nicht einmal pro Bestellung"""
    customers = CountingList(Customer(i, f"c{i}") for i in range(100))
    orders = [(i % 100, "1.00") for i in range(500)]
    CountingList.loops = 0
    got = customer_names(orders, customers)
    assert got[:2] == ["c0", "c1"] and len(got) == 500, "die Namen stimmen nicht"
    assert CountingList.loops <= 1, f"über die Kundenliste wurde {CountingList.loops}-mal iteriert; bauen Sie einmal ein Dict nach id"


def test_no_orders():
    """Keine Bestellungen: eine leere Liste"""
    got = customer_names([], [Customer(1, "Ada")])
    assert got == [], f"Ergebnis {got!r}, erwartet []"

from decimal import Decimal


def revenue(orders: list[tuple[int, str]]) -> dict[int, Decimal]:
    """Exact revenue per customer id from (customer id, amount) orders."""
    totals: dict[int, float] = {}
    for cid, amount in orders:
        totals[cid] = totals.get(cid, 0.0) + float(amount)
    return {cid: Decimal(total) for cid, total in totals.items()}

from decimal import Decimal

from main import revenue


def test_exact_cents():
    """Drei Bestellungen zu 0.10 ergeben genau 0.30"""
    got = revenue([(7, "0.10"), (7, "0.10"), (7, "0.10")])
    assert got == {7: Decimal("0.30")}, f"Ergebnis {got!r}, erwartet {{7: Decimal('0.30')}}"
    assert str(got[7]) == "0.30", f"Ergebnis {str(got[7])!r}, erwartet '0.30' mit beiden Stellen"


def test_per_customer():
    """Jede Kunden-id bekommt ihre eigene Summe, in Reihenfolge des ersten Auftretens"""
    got = revenue([(2, "19.99"), (1, "5.00"), (2, "0.01")])
    assert list(got) == [2, 1], f"Schlüssel {list(got)!r}, erwartet [2, 1]"
    assert got[2] == Decimal("20.00") and got[1] == Decimal("5.00"), f"Ergebnis {got!r}"


def test_no_orders():
    """Keine Bestellungen: ein leeres Dict"""
    assert revenue([]) == {}, "keine Bestellungen sollten {} ergeben"

from collections.abc import Callable
from decimal import Decimal


class Report:
    def __init__(self, totals: dict[int, Decimal]) -> None:
        self.totals = totals


class ReportCache:
    """Shares reports that are still in use, without keeping any of them alive."""

    def __init__(self) -> None:
        self._reports: dict[str, Report] = {}

    def get(self, key: str, build: Callable[[], Report]) -> Report:
        report = self._reports.get(key)
        if report is None:
            report = build()
            self._reports[key] = report
        return report

    def __len__(self) -> int:
        return len(self._reports)

import gc
from decimal import Decimal

from main import Report, ReportCache


class Builder:
    """Baut einen Bericht und zählt, wie oft das nötig war."""

    def __init__(self):
        self.calls = 0

    def __call__(self):
        self.calls += 1
        return Report({1: Decimal("0.30")})


def test_shares_live_report():
    """Solange ein Bericht genutzt wird, liefert get dasselbe Objekt und baut einmal"""
    cache, build = ReportCache(), Builder()
    first = cache.get("2026-09", build)
    second = cache.get("2026-09", build)
    assert second is first, "get hat einen zweiten Bericht gebaut, obwohl der erste noch genutzt wird"
    assert build.calls == 1, f"build wurde {build.calls}-mal aufgerufen, erwartet 1"


def test_does_not_keep_alive():
    """Sobald niemand den Bericht nutzt, gibt der Cache ihn frei"""
    cache = ReportCache()
    report = cache.get("2026-09", Builder())
    del report
    gc.collect()
    assert len(cache) == 0, f"der Cache hält noch {len(cache)} Bericht(e); speichern Sie sie in einem weakref.WeakValueDictionary"


def test_rebuilds_after_drop():
    """Ein verworfener Bericht wird beim nächsten get neu gebaut"""
    cache, build = ReportCache(), Builder()
    cache.get("2026-09", build)
    gc.collect()
    report = cache.get("2026-09", build)
    assert build.calls == 2, f"build wurde {build.calls}-mal aufgerufen, erwartet 2"
    assert report.totals == {1: Decimal("0.30")}, "der neu gebaute Bericht hat falsche Summen"