Kontextmanager schreiben

from types import TracebackType


class Tag:
    """Writes an opening line on entry and the closing line on exit."""

    def __init__(self, name: str, out: list[str]) -> None:
        self.name = name
        self.out = out

    # Add __enter__: append "<name>" to self.out and return self.
    # Add __exit__: append "</name>", even when the block raised,
    # and do not suppress the exception.


if __name__ == "__main__":
    lines: list[str] = []
    with Tag("ul", lines):
        with Tag("li", lines) as item:
            item.out.append("tea")
    print(lines)

from main import Tag


def test_as_gives_the_tag():
    """with Tag(...) as t bindet den Tag selbst"""
    out = []
    tag = Tag("p", out)
    with tag as t:
        assert t is tag, f"das as-Ziel ist {t!r}, erwartet war der Tag: geben Sie self aus __enter__ zurück"


def test_nested_lines():
    """Verschachtelte Tags öffnen und schließen in der richtigen Reihenfolge"""
    out = []
    with Tag("ul", out):
        with Tag("li", out):
            out.append("tea")
    assert out == ["<ul>", "<li>", "tea", "</li>", "</ul>"], f"die Zeilen sind {out!r}"


def test_closes_on_error():
    """Die schließende Zeile wird auch bei einer Ausnahme im Block geschrieben"""
    out = []
    try:
        with Tag("p", out):
            raise ValueError("boom")
    except ValueError:
        pass
    assert out == ["<p>", "</p>"], f"nach einem Fehler sind die Zeilen {out!r}, erwartet war ['<p>', '</p>']"


def test_does_not_suppress():
    """Eine Ausnahme im Block erreicht weiterhin den Aufrufer"""
    try:
        with Tag("p", []):
            raise ValueError("boom")
    except ValueError:
        return
    raise AssertionError("der ValueError wurde verschluckt: __exit__ darf nicht True zurückgeben")

from types import TracebackType


class Ignore:
    """Suppresses the given exception types and remembers what it caught."""

    def __init__(self, *types: type[BaseException]) -> None:
        self.types = types
        self.caught: BaseException | None = None

    def __enter__(self) -> "Ignore":
        return self

    def __exit__(
        self,
        exc_type: type[BaseException] | None,
        exc: BaseException | None,
        tb: TracebackType | None,
    ) -> bool:
        # Suppress (return True) only exceptions of self.types or their
        # subclasses, and store the exception in self.caught.
        return False


if __name__ == "__main__":
    prices: dict[str, int] = {}
    with Ignore(KeyError) as guard:
        prices["tea"]
    print("caught:", repr(guard.caught))

from main import Ignore


def test_suppresses_listed_type():
    """Eine angegebene Ausnahme wird unterdrückt und gespeichert"""
    with Ignore(ValueError) as guard:
        raise ValueError("bad number")
    assert isinstance(guard.caught, ValueError), f"guard.caught ist {guard.caught!r}, erwartet war der ValueError"


def test_subclasses_count():
    """Ignore(LookupError) unterdrückt auch KeyError"""
    with Ignore(LookupError) as guard:
        {}["missing"]
    assert isinstance(guard.caught, KeyError), f"guard.caught ist {guard.caught!r}, erwartet war ein KeyError"


def test_other_types_propagate():
    """Eine nicht angegebene Ausnahme erreicht den Aufrufer"""
    try:
        with Ignore(ValueError):
            raise KeyError("id")
    except KeyError:
        return
    raise AssertionError("Ignore(ValueError) hat einen KeyError verschluckt")


def test_clean_block():
    """Ohne Ausnahme bleibt caught None"""
    with Ignore(ValueError) as guard:
        pass
    assert guard.caught is None, f"guard.caught ist {guard.caught!r} nach einem sauberen Block"