Writing context managers

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 binds the Tag itself"""
    out = []
    tag = Tag("p", out)
    with tag as t:
        assert t is tag, f"the as target is {t!r}, expected the Tag: return self from __enter__"


def test_nested_lines():
    """Nested tags open and close in the right order"""
    out = []
    with Tag("ul", out):
        with Tag("li", out):
            out.append("tea")
    assert out == ["<ul>", "<li>", "tea", "</li>", "</ul>"], f"the lines are {out!r}"


def test_closes_on_error():
    """The closing line is written even when the block raises"""
    out = []
    try:
        with Tag("p", out):
            raise ValueError("boom")
    except ValueError:
        pass
    assert out == ["<p>", "</p>"], f"after an error the lines are {out!r}, expected ['<p>', '</p>']"


def test_does_not_suppress():
    """An exception in the block still reaches the caller"""
    try:
        with Tag("p", []):
            raise ValueError("boom")
    except ValueError:
        return
    raise AssertionError("the ValueError was swallowed: __exit__ must not return True")

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():
    """A listed exception is suppressed and stored"""
    with Ignore(ValueError) as guard:
        raise ValueError("bad number")
    assert isinstance(guard.caught, ValueError), f"guard.caught is {guard.caught!r}, expected the ValueError"


def test_subclasses_count():
    """Ignore(LookupError) also suppresses KeyError"""
    with Ignore(LookupError) as guard:
        {}["missing"]
    assert isinstance(guard.caught, KeyError), f"guard.caught is {guard.caught!r}, expected a KeyError"


def test_other_types_propagate():
    """An exception that is not listed reaches the caller"""
    try:
        with Ignore(ValueError):
            raise KeyError("id")
    except KeyError:
        return
    raise AssertionError("Ignore(ValueError) swallowed a KeyError")


def test_clean_block():
    """Without an exception, caught stays None"""
    with Ignore(ValueError) as guard:
        pass
    assert guard.caught is None, f"guard.caught is {guard.caught!r} after a clean block"