Descriptors and 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():
    """Values can be read and changed inside the range"""
    t = Thermostat(21, 17)
    t.target = 25
    assert (t.target, t.eco) == (25, 17), f"got {(t.target, t.eco)!r}, expected (25, 17)"


def test_rejects_out_of_range():
    """A value outside low..high raises ValueError"""
    t = Thermostat(21, 17)
    try:
        t.eco = 25
    except ValueError:
        assert t.eco == 17, f"after the failed assignment eco is {t.eco!r}, expected 17"
        return
    raise AssertionError("t.eco = 25 was accepted, but eco only allows 5 to 20")


def test_stored_under_private_names():
    """Each value lives in the instance dictionary under _ plus its name"""
    t = Thermostat(21, 17)
    assert vars(t) == {"_target": 21, "_eco": 17}, f"vars(t) is {vars(t)!r}"


def test_instances_are_independent():
    """Two thermostats keep their own values"""
    a = Thermostat(21, 17)
    b = Thermostat(10, 8)
    assert (a.target, b.target) == (21, 10), f"got {(a.target, b.target)!r}: are values stored on the descriptor?"


def test_class_access_returns_descriptor():
    """Thermostat.target gives the Bounded object itself"""
    assert isinstance(Thermostat.target, Bounded), f"Thermostat.target is {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 is the sum of the rows"""
    assert Report([1, 2, 3]).total == 6, f"total is {Report([1, 2, 3]).total!r}, expected 6"


def test_computed_once():
    """The function runs only on the first access"""
    report = Report([1, 2])
    for _ in range(3):
        report.total
    assert report.runs == 1, f"the function ran {report.runs} times, expected once"


def test_cached_in_instance_dict():
    """After the first access the value sits in the instance dictionary"""
    report = Report([4])
    report.total
    assert vars(report).get("total") == 4, f"vars(report) is {vars(report)!r}"


def test_uses_the_attribute_name():
    """The cache key is the name the descriptor was assigned to"""
    class Box:
        @lazy
        def size(self):
            return 7

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


def test_class_access_returns_descriptor():
    """Report.total gives the lazy object itself"""
    assert isinstance(Report.total, lazy), f"Report.total is {Report.total!r}"