Fix linting.

src/holt59/aoc/2022/day12.py

@@ -122,8 +122,8 @@ lines = sys.stdin.read().splitlines()
 
 grid = [[ord(cell) - ord("a") for cell in line] for line in lines]
 
-start: tuple[int, int]
-end: tuple[int, int]
+start: tuple[int, int] | None = None
+end: tuple[int, int] | None = None
 
 # for part 2
 start_s: list[tuple[int, int]] = []
@@ -138,6 +138,9 @@ for i_row, row in enumerate(grid):
         elif col == 0:
             start_s.append((i_row, i_col))
 
+assert start is not None
+assert end is not None
+
 # fix values
 grid[start[0]][start[1]] = 0
 grid[end[0]][end[1]] = ord("z") - ord("a")

src/holt59/aoc/2022/day15.py

@@ -1,20 +1,22 @@
 import sys
+from typing import Any
 
 import numpy as np
-import parse
+import parse  # type: ignore
+from numpy.typing import NDArray
 
 
 def part1(sensor_to_beacon: dict[tuple[int, int], tuple[int, int]], row: int) -> int:
-    no_beacons_row_l: list[np.ndarray] = []
+    no_beacons_row_l: list[NDArray[np.floating[Any]]] = []
 
     for (sx, sy), (bx, by) in sensor_to_beacon.items():
         d = abs(sx - bx) + abs(sy - by)  # closest
 
-        no_beacons_row_l.append(sx - np.arange(0, d - abs(sy - row) + 1))
-        no_beacons_row_l.append(sx + np.arange(0, d - abs(sy - row) + 1))
+        no_beacons_row_l.append(sx - np.arange(0, d - abs(sy - row) + 1))  # type: ignore
+        no_beacons_row_l.append(sx + np.arange(0, d - abs(sy - row) + 1))  # type: ignore
 
     beacons_at_row = set(bx for (bx, by) in sensor_to_beacon.values() if by == row)
-    no_beacons_row = set(np.concatenate(no_beacons_row_l)).difference(beacons_at_row)
+    no_beacons_row = set(np.concatenate(no_beacons_row_l)).difference(beacons_at_row)  # type: ignore
 
     return len(no_beacons_row)
 
@@ -56,11 +58,12 @@ def part2_cplex(
 
     for (sx, sy), (bx, by) in sensor_to_beacon.items():
         d = abs(sx - bx) + abs(sy - by)
-        m.add_constraint(m.abs(x - sx) + m.abs(y - sy) >= d + 1, ctname=f"ct_{sx}_{sy}")
+        m.add_constraint(m.abs(x - sx) + m.abs(y - sy) >= d + 1, ctname=f"ct_{sx}_{sy}")  # type: ignore
 
     m.set_objective("min", x + y)
 
     s = m.solve()
+    assert s is not None
 
     vx = int(s.get_value(x))
     vy = int(s.get_value(y))
@@ -72,7 +75,7 @@ lines = sys.stdin.read().splitlines()
 sensor_to_beacon: dict[tuple[int, int], tuple[int, int]] = {}
 
 for line in lines:
-    r = parse.parse(
+    r: dict[str, str] = parse.parse(  # type: ignore
         "Sensor at x={sx}, y={sy}: closest beacon is at x={bx}, y={by}", line
     )
     sensor_to_beacon[int(r["sx"]), int(r["sy"])] = (int(r["bx"]), int(r["by"]))

src/holt59/aoc/2022/day18.py

@@ -1,5 +1,4 @@
 import sys
-from typing import FrozenSet
 
 import numpy as np
 

src/holt59/aoc/2022/day19.py

@@ -1,9 +1,9 @@
 import sys
-from typing import Literal
+from typing import Any, Literal
 
 import numpy as np
-import parse
-from tqdm import tqdm
+import parse  # pyright: ignore[reportMissingTypeStubs]
+from numpy.typing import NDArray
 
 Reagent = Literal["ore", "clay", "obsidian", "geode"]
 REAGENTS: tuple[Reagent, ...] = (
@@ -35,7 +35,7 @@ class State:
             self.robots = robots
             self.reagents = reagents
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: object) -> bool:
         return (
             isinstance(other, State)
             and self.robots == other.robots
@@ -66,7 +66,7 @@ lines = sys.stdin.read().splitlines()
 
 blueprints: list[dict[Reagent, IntOfReagent]] = []
 for line in lines:
-    r = parse.parse(
+    r: list[int] = parse.parse(  # type: ignore
         "Blueprint {}: "
         "Each ore robot costs {:d} ore. "
         "Each clay robot costs {:d} ore. "
@@ -94,11 +94,12 @@ def run(blueprint: dict[Reagent, dict[Reagent, int]], max_time: int) -> int:
         name: max(blueprint[r].get(name, 0) for r in REAGENTS) for name in REAGENTS
     }
 
-    state_after_t: dict[int, set[State]] = {0: [State()]}
+    state_after_t: dict[int, set[State]] = {0: {State()}}
 
     for t in range(1, max_time + 1):
         # list of new states at the end of step t that we are going to prune later
         states_for_t: set[State] = set()
+        robots_that_can_be_built: list[Reagent]
 
         for state in state_after_t[t - 1]:
             robots_that_can_be_built = [
@@ -132,7 +133,7 @@ def run(blueprint: dict[Reagent, dict[Reagent, int]], max_time: int) -> int:
             for robot in robots_that_can_be_built:
                 robots = state.robots.copy()
                 robots[robot] += 1
-                reagents = {
+                reagents: IntOfReagent = {
                     reagent: state.reagents[reagent]
                     + state.robots[reagent]
                     - blueprint[robot].get(reagent, 0)
@@ -151,7 +152,7 @@ def run(blueprint: dict[Reagent, dict[Reagent, int]], max_time: int) -> int:
             ]
         )
 
-        to_keep = []
+        to_keep: list[NDArray[np.integer[Any]]] = []
         while len(np_states) > 0:
             first_dom = (np_states[1:] >= np_states[0]).all(axis=1).any()