Deskriptoren und Properties

from typing import Any


class Bounded:
    """A number that must stay between low and high (inclusive)."""

    def __init__(self, low: float, high: float) -> None:
        self.low = low
        self.high = high

    # Add __set_name__: remember the name and store values under "_" + name.
    # Add __get__: return the descriptor itself on class access, else the value.
    # Add __set__: raise ValueError outside low..high, else store the value.


class Thermostat:
    target = Bounded(5, 30)
    eco = Bounded(5, 20)

    def __init__(self, target: float, eco: float) -> None:
        self.target = target
        self.eco = eco


if __name__ == "__main__":
    t = Thermostat(21, 17)
    print(t.target, t.eco)
    try:
        t.target = 40
    except ValueError as err:
        print(err)

from main import Bounded, Thermostat


def test_get_and_set():
    """Werte lassen sich innerhalb des Bereichs lesen und ändern"""
    t = Thermostat(21, 17)
    t.target = 25
    assert (t.target, t.eco) == (25, 17), f"erhalten {(t.target, t.eco)!r}, erwartet (25, 17)"


def test_rejects_out_of_range():
    """Ein Wert außerhalb von low..high löst ValueError aus"""
    t = Thermostat(21, 17)
    try:
        t.eco = 25
    except ValueError:
        assert t.eco == 17, f"nach der gescheiterten Zuweisung ist eco {t.eco!r}, erwartet 17"
        return
    raise AssertionError("t.eco = 25 wurde angenommen, aber eco erlaubt nur 5 bis 20")


def test_stored_under_private_names():
    """Jeder Wert liegt im Instanz-Dictionary unter _ plus seinem Namen"""
    t = Thermostat(21, 17)
    assert vars(t) == {"_target": 21, "_eco": 17}, f"vars(t) ist {vars(t)!r}"


def test_instances_are_independent():
    """Zwei Thermostate behalten ihre eigenen Werte"""
    a = Thermostat(21, 17)
    b = Thermostat(10, 8)
    assert (a.target, b.target) == (21, 10), f"erhalten {(a.target, b.target)!r}: werden die Werte auf dem Deskriptor gespeichert?"


def test_class_access_returns_descriptor():
    """Thermostat.target liefert das Bounded-Objekt selbst"""
    assert isinstance(Thermostat.target, Bounded), f"Thermostat.target ist {Thermostat.target!r}"

from collections.abc import Callable
from typing import Any


class lazy:
    """Computes the value on first access and caches it on the instance."""

    def __init__(self, func: Callable[[Any], Any]) -> None:
        self.func = func

    def __set_name__(self, owner: type, name: str) -> None:
        self.name = name

    def __get__(self, instance: object, owner: type | None = None) -> Any:
        if instance is None:
            return self
        # Store the value so that later lookups never reach __get__ again.
        return self.func(instance)


class Report:
    def __init__(self, rows: list[int]) -> None:
        self.rows = rows
        self.runs = 0

    @lazy
    def total(self) -> int:
        self.runs += 1
        return sum(self.rows)


if __name__ == "__main__":
    report = Report([3, 4, 5])
    print(report.total, report.total, report.runs)

from main import Report, lazy


def test_value():
    """total ist die Summe der Zeilen"""
    assert Report([1, 2, 3]).total == 6, f"total ist {Report([1, 2, 3]).total!r}, erwartet 6"


def test_computed_once():
    """Die Funktion läuft nur beim ersten Zugriff"""
    report = Report([1, 2])
    for _ in range(3):
        report.total
    assert report.runs == 1, f"die Funktion lief {report.runs}-mal, erwartet einmal"


def test_cached_in_instance_dict():
    """Nach dem ersten Zugriff liegt der Wert im Instanz-Dictionary"""
    report = Report([4])
    report.total
    assert vars(report).get("total") == 4, f"vars(report) ist {vars(report)!r}"


def test_uses_the_attribute_name():
    """Der Cache-Schlüssel ist der Name, dem der Deskriptor zugewiesen wurde"""
    class Box:
        @lazy
        def size(self):
            return 7

    box = Box()
    box.size
    assert vars(box) == {"size": 7}, f"vars(box) ist {vars(box)!r}, erwartet {{'size': 7}}"


def test_class_access_returns_descriptor():
    """Report.total liefert das lazy-Objekt selbst"""
    assert isinstance(Report.total, lazy), f"Report.total ist {Report.total!r}"