def parse_int(text: str) -> int:
    try:
        value = int(text)
        return value
    except ValueError as exc:
        raise ValueError(f"Not an integer: {text!r}") from exc


def safe_ratio(a_text: str, b_text: str) -> float:
    try:
        a = parse_int(a_text)
        b = parse_int(b_text)
        return a / b
    except ZeroDivisionError:
        return float("inf")
    finally:
        print("Cleanup always runs (finally).")


# Usage
print("Result:", safe_ratio("12", "3"))
print("Result:", safe_ratio("12", "0"))
try:
    print("Result:", safe_ratio("nope", "2"))
except ValueError as e:
    print("Caught:", e)

def parse_int(text: str) -> int:
    try:
        return int(text)
    except ValueError as exc:
        raise ValueError(f"Not an integer: {text!r}") from exc


def safe_ratio_with_context(pairs: list[tuple[str, str]]) -> list[float]:
    results: list[float] = []
    errors: list[str] = []

    for a_text, b_text in pairs:
        try:
            a = parse_int(a_text)
            b = parse_int(b_text)
            results.append(a / b)
        except ZeroDivisionError:
            results.append(float("inf"))
        except ValueError as e:
            errors.append(str(e))
            results.append(float("nan"))
        finally:
            print("Cleanup always runs (finally).")

    print("Errors:", errors)
    return results


# Usage
pairs = [("8", "2"), ("8", "0"), ("x", "2"), ("3", "y")]
res = safe_ratio_with_context(pairs)
print("Results:", res)

from typing import Iterable


def normalize_and_sum(values: Iterable[object], *, scale: float = 1.0) -> float:
    def to_float(x: object) -> float:
        return float(x)

    converted = (to_float(v) for v in values)
    non_negative = filter(lambda n: n >= 0.0, converted)
    scaled = map(lambda n: n * scale, non_negative)

    return sum(scaled, 0.0)


# Usage
raw = ["3", -1, 2.5, "-4", 0, "10"]
print("Sum:", normalize_and_sum(raw, scale=2.0))

from typing import Iterable, Callable, Optional


def first_scaled_match(
    values: Iterable[object],
    predicate: Callable[[float], bool],
    *,
    scale: float = 1.0
) -> Optional[float]:
    def to_float(x: object) -> float:
        return float(x)

    converted = (to_float(v) for v in values)
    non_negative = filter(lambda n: n >= 0.0, converted)
    scaled = map(lambda n: n * scale, non_negative)

    for s in scaled:
        if predicate(s):
            return s
    return None


# Usage
raw = ["3", -1, 2.5, "-4", 0, "10"]
# scaled values with scale=2.0 are: 6.0, 5.0, 0.0, 20.0 (in that order)
# first value > 12.0 is 20.0
found = first_scaled_match(raw, lambda x: x > 12.0, scale=2.0)
print("First scaled > 12:", found)

# Another predicate that will not match
not_found = first_scaled_match(raw, lambda x: x < 0.0, scale=2.0)
print("First scaled < 0:", not_found)

import os
import tempfile


class TempFileManager:
    def __init__(self, prefix: str = "nums_", header: str = "HEADER"):
        self.prefix = prefix
        self.header = header
        self.path = None
        self.file = None

    def __enter__(self):
        fd, self.path = tempfile.mkstemp(prefix=self.prefix, text=True)
        os.close(fd)  # We will reopen using a higher-level file object.
        self.file = open(self.path, "w+", encoding="utf-8")
        self.file.write(self.header + "\n")
        self.file.flush()
        return self.file

    def __exit__(self, exc_type, exc, tb) -> bool:
        try:
            if self.file is not None:
                self.file.close()
        finally:
            if self.path is not None and os.path.exists(self.path):
                os.remove(self.path)
        return False  # Do not swallow exceptions.


def process_numbers(manager: TempFileManager, numbers) -> str:
    with manager as f:
        for n in numbers:
            f.write(str(n) + "\n")
        f.seek(0)
        return f.read()


if __name__ == "__main__":
    mgr = TempFileManager(header="NUMBERS")
    content = process_numbers(mgr, [10, 20, 30])
    print(content, end="")

from typing import Any, Dict, List, Tuple


class _TxView:
    def __init__(self, working: Dict[Any, Any]):
        self._working = working

    def __getitem__(self, key: Any) -> Any:
        if key not in self._working:
            raise KeyError(key)
        return self._working[key]

    def __setitem__(self, key: Any, value: Any) -> None:
        self._working[key] = value

    def __delitem__(self, key: Any) -> None:
        if key not in self._working:
            raise KeyError(key)
        del self._working[key]

    def get(self, key: Any) -> Any:
        # Not used by the required runner, but helpful for debugging.
        return self._working.get(key)


class TransactionalStore:
    def __init__(self, base: Dict[Any, Any]):
        self._base = base
        self._working = None

    def __enter__(self) -> _TxView:
        # Snapshot for rollback/commit.
        self._working = dict(self._base)
        return _TxView(self._working)

    def __exit__(self, exc_type, exc, tb) -> bool:
        if exc_type is None:
            # Commit: replace base with working contents.
            self._base.clear()
            self._base.update(self._working)
        else:
            # Rollback: discard working changes.
            pass
        self._working = None
        return False  # Do not swallow exceptions.


def run_transaction(store: TransactionalStore, operations: List[Tuple[str, Any, Any]]) -> List[Any]:
    results = []
    with store as tx:
        for op, key, value in operations:
            if op == "set":
                tx[key] = value
            elif op == "get":
                results.append(tx[key])  # Must raise KeyError if missing.
            elif op == "del":
                del tx[key]
            else:
                raise ValueError(f"Unknown op: {op}")
    return results


if __name__ == "__main__":
    base = {"a": 1}
    store = TransactionalStore(base)

    # Successful transaction: should commit.
    ops_ok = [
        ("set", "b", 2),
        ("get", "a", None),
        ("del", "a", None),
        ("get", "b", None),
    ]
    res_ok = run_transaction(store, ops_ok)
    print("results_ok:", res_ok)
    print("base_after_ok:", base)

    # Failing transaction: should rollback.
    ops_fail = [
        ("set", "c", 3),
        ("get", "missing", None),  # triggers KeyError
    ]
    try:
        run_transaction(store, ops_fail)
    except KeyError as e:
        print("caught:", repr(e))
    print("base_after_fail:", base)

from typing import Callable


def make_transformer(kind: str, shift: int) -> Callable[[int], int]:
    # Closure captures shift by reference to the outer variable name.
    # Late binding: transformer reads shift at call time.
    def transformer(x: int) -> int:
        if kind == "mul":
            return x * shift
        raise ValueError(f"Unknown transformer kind: {kind!r}")

    return transformer


def apply_expr(op: str, a: int, b: int) -> int:
    match op:
        case "add":
            return a + b
        case "mul":
            return a * b
        case "sub":
            return a - b
        case _:
            raise ValueError(f"Unknown operation: {op!r}")


def evaluate(op: str, a: int, b: int) -> int:
    try:
        if op == "mul":
            transform = make_transformer("mul", b)
            return transform(a)
        return apply_expr(op, a, b)
    except ValueError as exc:
        raise RuntimeError("Computation failed") from exc


# Usage
ops = ["add", "mul", "sub", "div"]
a = 10
b = 4
for op in ops:
    try:
        print(op, "=>", evaluate(op, a, b))
    except RuntimeError as e:
        print(op, "=>", e)

from typing import Callable


def make_accumulator(mode: str, initial: int) -> Callable[[int], int]:
    # Closure captures initial by reference to the outer variable name.
    # Late binding: acc reads and updates initial at call time.
    def acc(x: int) -> int:
        nonlocal initial
        if mode == "add":
            initial = initial + x
            return initial
        if mode == "mul":
            initial = initial * x
            return initial
        raise ValueError(f"Unknown accumulator mode: {mode!r}")

    return acc


def apply_operation(op: str, a: int, b: int) -> int:
    match op:
        case "add":
            return a + b
        case "mul":
            return a * b
        case "pow":
            if not isinstance(b, int) or b < 0:
                raise ValueError(f"Invalid exponent for pow: {b!r}")
            return a ** b
        case _:
            raise ValueError(f"Unknown operation: {op!r}")


def compute_sequence(op: str, mode: str, a: int, b: int, steps: int) -> int:
    try:
        acc = make_accumulator(mode, a)
        for i in range(steps):
            t = apply_operation(op, a, b + i)
            a = acc(t)
        return a
    except ValueError as exc:
        raise RuntimeError("Sequence failed") from exc


# Usage
cases = [
    ("pow", "add", 2, 3, 3),
    ("pow", "mul", 2, -1, 2),
]
for idx, (op, mode, a, b, steps) in enumerate(cases, start=1):
    try:
        result = compute_sequence(op, mode, a, b, steps)
        print(f"Case {idx} => {result}")
    except RuntimeError as e:
        print(f"Case {idx} => {e}")