ruff fixes

Author: pareronia

justfile

@@ -17,6 +17,7 @@ java_unittest_cmd := "org.junit.platform.console.ConsoleLauncher"
 julia_source_dir := "src/main/julia"
 pmd_cache_dir := ".cache/pmd"
 pmd_html_dir := "htmlpmd"
+ruff_files := env("RUFF_FILES", "src/main/python")
 rust_source_dir := "src/main/rust"
 rust_srcs := "import pathlib; print(' '.join(map(str, list(pathlib.Path('src/main/rust').rglob('*.rs')))))"
 rust_dst := "build/rs"
@@ -117,7 +118,7 @@ vim-file-debug file *type:
 # Linting: ruff check
 [group("linting")]
 ruff-check: (msg-blue "Running ruff check")
-    @{{ ruff }} --quiet check "{{ source_dir }}"
+    @{{ ruff }} --quiet check {{ ruff_files }}
 
 # Linting: vulture - unused code
 [group("linting")]
@@ -127,7 +128,7 @@ vulture: (msg-blue "Running vulture")
 # Linting: ruff format check
 [group("linting")]
 ruff-format-check: (msg-blue "Running ruff format check")
-    @{{ ruff }} format --quiet --check "{{ source_dir }}"
+    @{{ ruff }} format --quiet --check {{ ruff_files }}
 
 # Linting: mypy
 [group("linting")]
@@ -168,7 +169,7 @@ rustfmt-check: (msg-blue "Running rustfmt check against rust source files...")
 
 # Linting: all
 [group("linting")]
-lint: vulture shellcheck rustfmt-check ruff-check
+lint: vulture shellcheck rustfmt-check ruff-check ruff-format-check
 
 # Run python
 [group("python")]

pyproject.toml

@@ -29,9 +29,16 @@ force_single_line = true
 skip_gitignore = true
 include_trailing_comma = true
 
-[tool.black]
+[tool.ruff]
 line-length = 79
 
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = ["COM", "D1", "PLR2004", "PT", "S101", "T20"]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+
 [tool.mypy]
 strict = true
 

src/main/python/AoC2015_01.py

@@ -28,18 +28,19 @@
 
 class Solution(SolutionBase[Input, Output1, Output2]):
     def parse_input(self, input_data: InputData) -> Input:
-        return list(input_data)[0]
+        return next(iter(input_data))
 
-    def part_1(self, input: Input) -> Output1:
-        return len(input) - 2 * input.count(")")
+    def part_1(self, string: Input) -> Output1:
+        return len(string) - 2 * string.count(")")
 
-    def part_2(self, input: Input) -> Output2:
+    def part_2(self, string: Input) -> Output2:
         sum_ = 0
-        for i, c in enumerate(input):
+        for i, c in enumerate(string):
             sum_ += 1 if c == "(" else -1
             if sum_ == -1:
                 return i + 1
-        raise RuntimeError("Unreachable")
+        msg = "Unreachable"
+        raise RuntimeError(msg)
 
     @aoc_samples(
         (

src/main/python/AoC2015_03.py

@@ -26,10 +26,10 @@
 
 class Solution(SolutionBase[Input, Output1, Output2]):
     def parse_input(self, input_data: InputData) -> Input:
-        return [Heading.from_str(ch) for ch in list(input_data)[0]]
+        return [Heading.from_str(ch) for ch in next(iter(input_data))]
 
     def count_unique_positions(self, positions: list[Position]) -> int:
-        return len({p for p in positions})
+        return len(set(positions))
 
     def add_navigation_instruction(
         self, navigation: Navigation, c: Heading
@@ -41,19 +41,19 @@ def part_1(self, inputs: Input) -> Output1:
         for c in inputs:
             self.add_navigation_instruction(navigation, c)
         return self.count_unique_positions(
-            navigation.get_visited_positions(True)
+            navigation.get_visited_positions(include_start_position=True)
         )
 
     def part_2(self, inputs: Input) -> Output2:
-        santa_navigation = Navigation(START, Heading.NORTH)
-        robot_navigation = Navigation(START, Heading.NORTH)
+        santa_nav = Navigation(START, Heading.NORTH)
+        robot_nav = Navigation(START, Heading.NORTH)
         for i, c in enumerate(inputs):
             self.add_navigation_instruction(
-                robot_navigation if i % 2 else santa_navigation, c
+                robot_nav if i % 2 else santa_nav, c
             )
         return self.count_unique_positions(
-            santa_navigation.get_visited_positions(True)
-            + robot_navigation.get_visited_positions(True)
+            santa_nav.get_visited_positions(include_start_position=True)
+            + robot_nav.get_visited_positions(include_start_position=True)
         )
 
     @aoc_samples(

src/main/python/AoC2015_04.py

@@ -18,7 +18,7 @@
 
 class Solution(SolutionBase[Input, Output1, Output2]):
     def parse_input(self, input_data: InputData) -> Input:
-        return list(input_data)[0]
+        return next(iter(input_data))
 
     def find_md5_starting_with_zeroes(self, seed: str, zeroes: int) -> int:
         i = 0
@@ -28,7 +28,7 @@ def find_md5_starting_with_zeroes(self, seed: str, zeroes: int) -> int:
             i += 1
             spinner(i)
             str2hash = seed + str(i)
-            val = md5(str2hash.encode()).hexdigest()  # nosec
+            val = md5(str2hash.encode()).hexdigest()  # noqa: S324
         return i
 
     def part_1(self, seed: Input) -> Output1:

src/main/python/AoC2015_06.py

@@ -45,39 +45,29 @@ def from_string(cls, action: str) -> Action:
             case _:
                 return Action.TOGGLE
 
-    def apply(
+    def apply(  # noqa: C901
         self, lights: list[list[int]], start: Cell, end: Cell, mode: Mode
     ) -> None:
-        match self:
-            case Action.TURN_ON:
-                match mode:
-                    case Mode.MODE_1:
-                        for r in range(start.row, end.row + 1):
-                            for c in range(start.col, end.col + 1):
+        for r in range(start.row, end.row + 1):
+            for c in range(start.col, end.col + 1):
+                match self:
+                    case Action.TURN_ON:
+                        match mode:
+                            case Mode.MODE_1:
                                 lights[r][c] = 1
-                    case Mode.MODE_2:
-                        for r in range(start.row, end.row + 1):
-                            for c in range(start.col, end.col + 1):
+                            case Mode.MODE_2:
                                 lights[r][c] += 1
-            case Action.TURN_OFF:
-                match mode:
-                    case Mode.MODE_1:
-                        for r in range(start.row, end.row + 1):
-                            for c in range(start.col, end.col + 1):
+                    case Action.TURN_OFF:
+                        match mode:
+                            case Mode.MODE_1:
                                 lights[r][c] = 0
-                    case Mode.MODE_2:
-                        for r in range(start.row, end.row + 1):
-                            for c in range(start.col, end.col + 1):
+                            case Mode.MODE_2:
                                 lights[r][c] = max(lights[r][c] - 1, 0)
-            case Action.TOGGLE:
-                match mode:
-                    case Mode.MODE_1:
-                        for r in range(start.row, end.row + 1):
-                            for c in range(start.col, end.col + 1):
+                    case Action.TOGGLE:
+                        match mode:
+                            case Mode.MODE_1:
                                 lights[r][c] = 0 if lights[r][c] == 1 else 1
-                    case Mode.MODE_2:
-                        for r in range(start.row, end.row + 1):
-                            for c in range(start.col, end.col + 1):
+                            case Mode.MODE_2:
                                 lights[r][c] += 2
 
 

src/main/python/AoC2015_07.py

@@ -39,16 +39,15 @@ def parse_input(self, input_data: InputData) -> Input:
                 if first.isnumeric():
                     wires[second] = int(first)
                     continue
-                else:
-                    in1, op, in2 = splits[0], "SET", None
+                in1, op, in2 = splits[0], "SET", None
             elif len(splits) == 2:
                 in1, op, in2 = splits[1], "NOT", None
             else:
                 in1, op, in2 = splits[0], splits[1], splits[2]
             gates.append((in1, op, in2, second))
         return wires, gates
 
-    def solve(self, wires: Wires, gates: list[Gate], wire: str) -> int:
+    def solve(self, wires: Wires, gates: list[Gate], wire: str) -> int:  # noqa: C901
         def exec_op(in1: str, op: str, in2: str | None, out: str) -> None:
             match op:
                 case "SET":
@@ -84,12 +83,12 @@ def exec_op(in1: str, op: str, in2: str | None, out: str) -> None:
                 q.append((in1, op, in2, out))
         return wires[wire]
 
-    def part_1(self, input: Input) -> Output1:
-        wires, gates = input
+    def part_1(self, inputs: Input) -> Output1:
+        wires, gates = inputs
         return self.solve(wires.copy(), gates, "a")
 
-    def part_2(self, input: Input) -> Output2:
-        wires, gates = input
+    def part_2(self, inputs: Input) -> Output2:
+        wires, gates = inputs
         wires_2 = wires.copy()
         wires_2["b"] = self.solve(wires.copy(), gates, "a")
         return self.solve(wires_2, gates, "a")

src/main/python/AoC2015_08.py

@@ -47,14 +47,14 @@ class Solution(SolutionBase[Input, Output1, Output2]):
     def parse_input(self, input_data: InputData) -> Input:
         return input_data
 
-    def solve(self, input: Input, mode: Mode) -> int:
-        return sum(mode.overhead(s) for s in input)
+    def solve(self, inputs: Input, mode: Mode) -> int:
+        return sum(mode.overhead(s) for s in inputs)
 
-    def part_1(self, input: Input) -> Output1:
-        return self.solve(input, Mode.DECODE)
+    def part_1(self, inputs: Input) -> Output1:
+        return self.solve(inputs, Mode.DECODE)
 
-    def part_2(self, input: Input) -> Output2:
-        return self.solve(input, Mode.ENCODE)
+    def part_2(self, inputs: Input) -> Output2:
+        return self.solve(inputs, Mode.ENCODE)
 
     @aoc_samples(
         (

src/main/python/AoC2015_09.py

@@ -8,9 +8,12 @@
 import itertools
 import sys
 from collections import defaultdict
-from typing import Iterator
+from typing import TYPE_CHECKING
 from typing import NamedTuple
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 from aoc.common import InputData
 from aoc.common import SolutionBase
 from aoc.common import aoc_samples

src/main/python/AoC2015_10.py

@@ -111,7 +111,7 @@
 
 
 class Solution(SolutionBase[Input, Output1, Output2]):
-    """https://github.com/maneatingape/advent-of-code-rust/blob/3a95adb336f4e9af3ca509b17aa60d6360510290/src/year2015/day10.rs"""  # noqa E501
+    """https://github.com/maneatingape/advent-of-code-rust/blob/3a95adb336f4e9af3ca509b17aa60d6360510290/src/year2015/day10.rs."""
 
     def parse_input(self, input_data: InputData) -> Input:
         elements = [line.split() for line in ELEMENTS.splitlines()]
@@ -121,7 +121,7 @@ def parse_input(self, input_data: InputData) -> Input:
         for i, sp in enumerate(elements):
             sequence[i] = sp[0]
             decays[i] = [indices[x] for x in sp[4:]]
-        return sequence, decays, list(input_data)[0]
+        return sequence, decays, next(iter(input_data))
 
     def _solve(self, string: str, iterations: int) -> str:
         current = string
@@ -139,17 +139,17 @@ def _solve(self, string: str, iterations: int) -> str:
         return current
 
     def solve(self, inputs: Input, iterations: int) -> int:
-        sequence, decays, input = inputs
+        sequence, decays, input_ = inputs
         current = [0 for _ in range(N)]
-        current[sequence.index(input)] = 1
+        current[sequence.index(input_)] = 1
         for _ in range(iterations):
             nxt = [0 for _ in range(N)]
             for i, c in enumerate(current):
                 if c > 0:
                     for d in decays[i]:
                         nxt[d] += c
             current = nxt
-        return sum(c * len(s) for c, s in zip(current, sequence))
+        return sum(c * len(s) for c, s in zip(current, sequence, strict=True))
 
     def part_1(self, inputs: Input) -> Output1:
         return self.solve(inputs, iterations=40)