stricter type checking

Author: StevenBtw

solvor/a_star.py

@@ -67,7 +67,7 @@ def astar[S](
     max_cost: float | None = None,
 ) -> Result:
     """A* search with heuristic guidance, returns optimal path when weight=1."""
-    is_goal = goal if callable(goal) else lambda s: s == goal
+    is_goal: Callable[[S], bool] = goal if callable(goal) else lambda s: s == goal  # ty: ignore[invalid-assignment]
 
     g: dict[S, float] = {start: 0.0}
     parent: dict[S, S] = {}

solvor/anneal.py

@@ -100,8 +100,9 @@ def anneal[T](
     rng = Random(seed)
     evaluate = Evaluator(objective_fn, minimize)
 
+    schedule: CoolingSchedule
     if callable(cooling):
-        schedule = cooling
+        schedule = cooling  # ty: ignore[invalid-assignment]
     else:
         schedule = exponential_cooling(cooling)
 

solvor/bfs.py

@@ -56,7 +56,7 @@ def bfs[S](
     max_iter: int = 1_000_000,
 ) -> Result:
     """Breadth-first search, guarantees shortest path in unweighted graphs."""
-    is_goal = (lambda s: s == goal) if not callable(goal) and goal is not None else goal
+    is_goal: Callable[[S], bool] | None = (lambda s: s == goal) if not callable(goal) and goal is not None else goal  # ty: ignore[invalid-assignment]
 
     parent: dict[S, S] = {}
     visited: set[S] = {start}
@@ -93,7 +93,7 @@ def dfs[S](
     max_iter: int = 1_000_000,
 ) -> Result:
     """Depth-first search, finds a path (not necessarily shortest)."""
-    is_goal = (lambda s: s == goal) if not callable(goal) and goal is not None else goal
+    is_goal: Callable[[S], bool] | None = (lambda s: s == goal) if not callable(goal) and goal is not None else goal  # ty: ignore[invalid-assignment]
 
     parent: dict[S, S] = {}
     visited: set[S] = {start}

solvor/cp_encoder.py

@@ -541,7 +541,7 @@ def decode_sat_solution(sat_sol: dict[int, bool]) -> dict[str, int]:
                         break
             return cp_sol
 
-        solution = decode_sat_solution(sat_result.solution)  # type: ignore[arg-type]
+        solution = decode_sat_solution(sat_result.solution)
 
         if sat_result.solutions is not None:
             cp_solutions = tuple(decode_sat_solution(s) for s in sat_result.solutions)

solvor/dijkstra.py

@@ -57,7 +57,7 @@ def dijkstra[S](
     max_cost: float | None = None,
 ) -> Result:
     """Find shortest path in a weighted graph with non-negative edges."""
-    is_goal = goal if callable(goal) else lambda s: s == goal
+    is_goal: Callable[[S], bool] = goal if callable(goal) else lambda s: s == goal  # ty: ignore[invalid-assignment]
 
     g: dict[S, float] = {start: 0.0}
     parent: dict[S, S] = {}

solvor/dlx.py

@@ -161,6 +161,7 @@ def _build_links(matrix, columns=None, secondary=None):
                     first = node
                     prev_node = node
                 else:
+                    assert prev_node is not None
                     node.left = prev_node
                     prev_node.right = node
                     prev_node = node

solvor/flow.py

@@ -42,7 +42,7 @@
 
 
 def max_flow[Node](
-    graph: dict[Node, list[tuple[Node, int, ...]]],
+    graph: dict[Node, list[tuple[Node, int] | tuple[Node, int, int]]],
     source: Node,
     sink: Node,
 ) -> Result:
@@ -202,7 +202,7 @@ def solve_assignment(
     result = min_cost_flow(graph, source, sink, min(n, m))
 
     assignment = [-1] * n
-    flow_solution: dict[tuple[str, str], float] = result.solution  # type: ignore[assignment]
+    flow_solution: dict[tuple[str, str], float] = result.solution
     for (u, v), f in flow_solution.items():
         if f > 0 and u.startswith("L") and v.startswith("R"):
             i = int(u[1:])

solvor/rust/__init__.py

@@ -154,9 +154,9 @@ def floyd_warshall(n_nodes, edges, *, directed=True) -> Result:
 
     @functools.wraps(fn)
     def wrapper(
-        *args: P.args,
+        *args,
         backend: Literal["auto", "rust", "python"] | None = None,
-        **kwargs: P.kwargs,
+        **kwargs,
     ) -> T:
         selected = get_backend(backend)
         if selected == "rust":