Improve boolean args and enable ruff checks for it

Author: nikobockerman

adventofcode/tooling/map.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import enum
 from typing import TYPE_CHECKING, Literal, assert_never, overload
 
 from .coordinates import X, Y
@@ -19,6 +20,11 @@ def __init__(self) -> None:
         super().__init__("data must be rectangular")
 
 
+class IterDirection(enum.Enum):
+    Rows = enum.auto()
+    Columns = enum.auto()
+
+
 class Map2d[Map2dDataType]:
     __slots__ = ("_sequence_data", "_width", "_height", "_br_y", "_br_x")
 
@@ -158,23 +164,23 @@ def iter_data_by_columns(
 
     @overload
     def iter_data(
-        self,
-        *,
-        columns_first: bool,
+        self, *, direction: IterDirection
     ) -> Iterable[tuple[X, Iterable[tuple[Y, Map2dDataType]]]]: ...
     @overload
     def iter_data(
-        self,
-        *,
-        columns_first: Literal[False] = False,
+        self, *, direction: Literal[IterDirection.Rows] = IterDirection.Rows
     ) -> Iterable[tuple[Y, Iterable[tuple[X, Map2dDataType]]]]: ...
     @overload
     def iter_data(
-        self, first_y: Y, first_x: X, *, columns_first: bool
+        self, first_y: Y, first_x: X, *, direction: IterDirection
     ) -> Iterable[tuple[X, Iterable[tuple[Y, Map2dDataType]]]]: ...
     @overload
     def iter_data(
-        self, first_y: Y, first_x: X, *, columns_first: Literal[False] = False
+        self,
+        first_y: Y,
+        first_x: X,
+        *,
+        direction: Literal[IterDirection.Rows] = IterDirection.Rows,
     ) -> Iterable[tuple[Y, Iterable[tuple[X, Map2dDataType]]]]: ...
     @overload
     def iter_data(
@@ -184,7 +190,7 @@ def iter_data(
         last_y: Y,
         last_x: X,
         *,
-        columns_first: bool,
+        direction: IterDirection,
     ) -> Iterable[tuple[X, Iterable[tuple[Y, Map2dDataType]]]]: ...
     @overload
     def iter_data(
@@ -194,7 +200,7 @@ def iter_data(
         last_y: Y,
         last_x: X,
         *,
-        columns_first: Literal[False] = False,
+        direction: Literal[IterDirection.Rows] = IterDirection.Rows,
     ) -> Iterable[tuple[Y, Iterable[tuple[X, Map2dDataType]]]]: ...
 
     def iter_data(
@@ -204,7 +210,7 @@ def iter_data(
         last_y: Y | None = None,
         last_x: X | None = None,
         *,
-        columns_first: bool = False,
+        direction: IterDirection = IterDirection.Rows,
     ) -> (
         Iterable[tuple[Y, Iterable[tuple[X, Map2dDataType]]]]
         | Iterable[tuple[X, Iterable[tuple[Y, Map2dDataType]]]]
@@ -232,10 +238,11 @@ def iter_data(
         if first_y > self._br_y and last_y >= self._br_y:
             return
 
-        if not columns_first:
-            yield from self.iter_data_by_lines(first_y, first_x, last_y, last_x)
-        else:
-            yield from self.iter_data_by_columns(first_y, first_x, last_y, last_x)
+        match direction:
+            case IterDirection.Rows:
+                yield from self.iter_data_by_lines(first_y, first_x, last_y, last_x)
+            case IterDirection.Columns:
+                yield from self.iter_data_by_columns(first_y, first_x, last_y, last_x)
 
     def str_lines(
         self, get_symbol: Callable[[Map2dDataType], str] | None = None

adventofcode/y2023/d1.py

@@ -4,7 +4,7 @@
 _STR_DIGITS = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine"]
 
 
-def _find_first_and_last_int(input_str: str, use_texts: bool) -> tuple[str, str]:
+def _find_first_and_last_int(input_str: str, *, use_texts: bool) -> tuple[str, str]:
     first: str | None = None
     last: str | None = None
     for ind, c in enumerate(input_str):
@@ -33,17 +33,17 @@ def _int_chars_to_int(s1: str, s2: str) -> int:
     return int(s1 + s2)
 
 
-def _p1_ints(lines: Iterable[str], use_texts: bool) -> Iterable[int]:
+def _p1_ints(lines: Iterable[str], *, use_texts: bool) -> Iterable[int]:
     for line in lines:
         logging.debug("line=%s", line)
-        value = _int_chars_to_int(*_find_first_and_last_int(line, use_texts))
+        value = _int_chars_to_int(*_find_first_and_last_int(line, use_texts=use_texts))
         logging.debug("value=%s", value)
         yield value
 
 
 def p1(input_str: str) -> int:
-    return sum(_p1_ints(input_str.splitlines(), False))
+    return sum(_p1_ints(input_str.splitlines(), use_texts=False))
 
 
 def p2(input_str: str) -> int:
-    return sum(_p1_ints(input_str.splitlines(), True))
+    return sum(_p1_ints(input_str.splitlines(), use_texts=True))

adventofcode/y2023/d13.py

@@ -3,7 +3,7 @@
 from collections.abc import Iterable
 
 from adventofcode.tooling.coordinates import X, Y
-from adventofcode.tooling.map import Map2d
+from adventofcode.tooling.map import IterDirection, Map2d
 
 
 def _parse_maps(input_str: str) -> Iterable[Map2d[str]]:
@@ -31,19 +31,21 @@ def _compare_datas(
 
 
 def _find_consecutive_rows_or_columns(
-    map_: Map2d[str], start_pos: int, find_column_not_row: bool, allowed_mismatches: int
+    map_: Map2d[str],
+    start_pos: int,
+    direction: IterDirection,
+    allowed_mismatches: int,
 ) -> tuple[int, int] | None:
-    if find_column_not_row:
-        first_y = Y(0)
-        first_x = X(start_pos)
-    else:
-        first_y = Y(start_pos)
-        first_x = X(0)
+    match direction:
+        case IterDirection.Rows:
+            first_y = Y(start_pos)
+            first_x = X(0)
+        case IterDirection.Columns:
+            first_y = Y(0)
+            first_x = X(start_pos)
     for (i1, data1), (_, data2) in itertools.pairwise(
         (i, [sym for _, sym in sym_iter])
-        for i, sym_iter in map_.iter_data(
-            first_y, first_x, columns_first=find_column_not_row
-        )
+        for i, sym_iter in map_.iter_data(first_y, first_x, direction=direction)
     ):
         match_res = _compare_datas(data1, data2, allowed_mismatches)
         if match_res is None:
@@ -59,23 +61,24 @@ def _map_data_iter_to_data(d: tuple[int, str]) -> str:
 def _check_if_datas_around_reflection_match(
     map_: Map2d[str],
     pos_before_reflection: int,
-    find_column_not_row: bool,
+    direction: IterDirection,
     allowed_mismatches: int,
 ) -> int | None:
-    if find_column_not_row:
-        before_first_y = Y(0)
-        before_first_x = X(pos_before_reflection - 1)
-        before_last_y = map_.br_y
-        before_last_x = X(-1)
-        after_first_y = Y(0)
-        after_first_x = X(pos_before_reflection + 2)
-    else:
-        before_first_y = Y(pos_before_reflection - 1)
-        before_first_x = X(0)
-        before_last_y = Y(-1)
-        before_last_x = map_.br_x
-        after_first_y = Y(pos_before_reflection + 2)
-        after_first_x = X(0)
+    match direction:
+        case IterDirection.Rows:
+            before_first_y = Y(pos_before_reflection - 1)
+            before_first_x = X(0)
+            before_last_y = Y(-1)
+            before_last_x = map_.br_x
+            after_first_y = Y(pos_before_reflection + 2)
+            after_first_x = X(0)
+        case IterDirection.Columns:
+            before_first_y = Y(0)
+            before_first_x = X(pos_before_reflection - 1)
+            before_last_y = map_.br_y
+            before_last_x = X(-1)
+            after_first_y = Y(0)
+            after_first_x = X(pos_before_reflection + 2)
 
     mismatches = 0
 
@@ -102,7 +105,7 @@ def _check_if_datas_around_reflection_match(
 
 
 def _find_reflection_line(
-    map_: Map2d[str], find_column_not_row: bool, required_mismatches: int = 0
+    map_: Map2d[str], direction: IterDirection, required_mismatches: int = 0
 ) -> int | None:
     logging.debug(
         "Searching for reflection with %d required mismatches", required_mismatches
@@ -111,7 +114,7 @@ def _find_reflection_line(
     while True:
         remaining_mismatches = required_mismatches
         found_data_info = _find_consecutive_rows_or_columns(
-            map_, search_start_pos, find_column_not_row, remaining_mismatches
+            map_, search_start_pos, direction, remaining_mismatches
         )
         if found_data_info is None:
             logging.debug(
@@ -131,7 +134,7 @@ def _find_reflection_line(
         )
 
         check_res = _check_if_datas_around_reflection_match(
-            map_, first_pos, find_column_not_row, remaining_mismatches
+            map_, first_pos, direction, remaining_mismatches
         )
         if check_res is None:
             logging.debug(
@@ -159,12 +162,16 @@ def _resolve(input_str: str, required_mismatches_per_map: int) -> int:
             map_.width,
             map_,
         )
-        match_index = _find_reflection_line(map_, False, required_mismatches_per_map)
+        match_index = _find_reflection_line(
+            map_, IterDirection.Rows, required_mismatches_per_map
+        )
         if match_index is not None:
             line_or_column = "L"
             match_multiplier = 100
         else:
-            match_index = _find_reflection_line(map_, True, required_mismatches_per_map)
+            match_index = _find_reflection_line(
+                map_, IterDirection.Columns, required_mismatches_per_map
+            )
             assert match_index is not None
             line_or_column = "C"
             match_multiplier = 1

adventofcode/y2023/d14.py

@@ -3,7 +3,7 @@
 
 from adventofcode.tooling.coordinates import Coord2d, X, Y
 from adventofcode.tooling.directions import CardinalDirection as Dir
-from adventofcode.tooling.map import Map2d
+from adventofcode.tooling.map import IterDirection, Map2d
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -35,7 +35,7 @@ def _coord_columns_first(outer: Y | X, inner: Y | X) -> Coord2d:
         | Iterable[tuple[X, Iterable[tuple[Y, str]]]]
     )
     if direction == Dir.N:
-        map_iter = map_.iter_data(columns_first=True)
+        map_iter = map_.iter_data(direction=IterDirection.Columns)
         coord_func = _coord_columns_first
 
         def set_rock(

adventofcode/y2023/d20.py

@@ -16,8 +16,8 @@
 
 
 _PulseValue = NewType("_PulseValue", bool)
-_PulseLow = _PulseValue(False)
-_PulseHigh = _PulseValue(True)
+_PulseLow = _PulseValue(False)  # noqa: FBT003
+_PulseHigh = _PulseValue(True)  # noqa: FBT003
 
 _ModuleName = NewType("_ModuleName", str)
 

adventofcode/y2023/d6.py

@@ -1,3 +1,4 @@
+import enum
 from collections.abc import Iterable
 from functools import reduce
 
@@ -38,15 +39,27 @@ def p2(input_str: str) -> int:
     time = int(reduce(lambda t1, t2: t1 + t2, (str(t) for t, _ in d)))
     distance = int(reduce(lambda d1, d2: d1 + d2, (str(d) for _, d in d)))
 
+    class ScenarioOrdering(enum.Enum):
+        FASTEST = enum.auto()
+        SLOWEST = enum.auto()
+
     def first_possible_button_press_time(
-        max_time: int, distance_to_beat: int, forward: bool
+        max_time: int, distance_to_beat: int, ordering: ScenarioOrdering
     ) -> int:
-        r = range(1, max_time) if forward else range(max_time - 1, 0, -1)
+        match ordering:
+            case ScenarioOrdering.FASTEST:
+                r = range(1, max_time)
+            case ScenarioOrdering.SLOWEST:
+                r = range(max_time - 1, 0, -1)
         for button_press_time in r:
             if _is_winning_scenario(button_press_time, max_time, distance_to_beat):
                 return button_press_time
         raise AssertionError
 
-    first_button_press_time = first_possible_button_press_time(time, distance, True)
-    last_button_press_time = first_possible_button_press_time(time, distance, False)
+    first_button_press_time = first_possible_button_press_time(
+        time, distance, ScenarioOrdering.FASTEST
+    )
+    last_button_press_time = first_possible_button_press_time(
+        time, distance, ScenarioOrdering.SLOWEST
+    )
     return len(range(first_button_press_time, last_button_press_time)) + 1

pyproject.toml

@@ -63,8 +63,6 @@ ignore = [
     "C901",
     "COM812",
     "D10",
-    "FBT001",
-    "FBT003",
     "FIX",
     "ISC001",
     "PLR2004",