Refactor code for API (#3)

Co-authored-by: Mikael CAPELLE <mikael.capelle@thalesaleniaspace.com>
Co-authored-by: Mikaël Capelle <capelle.mikael@gmail.com>
Reviewed-on: #3

src/holt59/aoc/2022/day21.py

@@ -1,6 +1,7 @@
 import operator
-import sys
-from typing import Callable
+from typing import Any, Callable, Iterator
+
+from ..base import BaseSolver
 
 
 def compute(monkeys: dict[str, int | tuple[str, str, str]], monkey: str) -> int:
@@ -77,31 +78,31 @@ def invert(
     return monkeys
 
 
-lines = sys.stdin.read().splitlines()
+class Solver(BaseSolver):
+    def solve(self, input: str) -> Iterator[Any]:
+        lines = [line.strip() for line in input.splitlines()]
 
-monkeys: dict[str, int | tuple[str, str, str]] = {}
+        monkeys: dict[str, int | tuple[str, str, str]] = {}
 
-op_monkeys: set[str] = set()
+        op_monkeys: set[str] = set()
 
-for line in lines:
-    parts = line.split(":")
-    name = parts[0].strip()
+        for line in lines:
+            parts = line.split(":")
+            name = parts[0].strip()
 
-    try:
-        value = int(parts[1].strip())
-        monkeys[name] = value
-    except ValueError:
-        op1, ope, op2 = parts[1].strip().split()
-        monkeys[name] = (op1, ope, op2)
+            try:
+                value = int(parts[1].strip())
+                monkeys[name] = value
+            except ValueError:
+                op1, ope, op2 = parts[1].strip().split()
+                monkeys[name] = (op1, ope, op2)
 
-        op_monkeys.add(name)
+                op_monkeys.add(name)
 
+        yield compute(monkeys.copy(), "root")
 
-answer_1 = compute(monkeys.copy(), "root")
-print(f"answer 1 is {answer_1}")
-
-# assume the second operand of 'root' can be computed, and the first one depends on
-# humn, which is the case is my input and the test input
-p1, _, p2 = monkeys["root"]  # type: ignore
-answer_2 = compute(invert(monkeys, "humn", compute(monkeys.copy(), p2)), "humn")
-print(f"answer 2 is {answer_2}")
+        # assume the second operand of 'root' can be computed, and the first one depends on
+        # humn, which is the case is my input and the test input
+        assert isinstance(monkeys["root"], tuple)
+        p1, _, p2 = monkeys["root"]  # type: ignore
+        yield compute(invert(monkeys, "humn", compute(monkeys.copy(), p2)), "humn")