Refactor the challenge interface to be able to provide custom input.

Author: nekeal

src/aoc/base.py

@@ -1,83 +1,81 @@
 import abc
-import logging
 from pathlib import Path
-from typing import Any
+from typing import Any, ClassVar
 
-import __main__
+from typing_extensions import Protocol
+
+from aoc.input_providers import InputProvider
 
 REPO_ROOT = Path(__file__).parent.parent.parent
-logger = logging.getLogger(__name__)
 
 
-class BaseChallenge(abc.ABC):
+def get_day_from_module(module_name: str) -> int:
+    """Return the day of this challenge based on the module name."""
+    return int(module_name.split(".")[-1].split("_")[1])
+
+
+class ChallengeProtocol(Protocol):
+    def part_1(self, input_lines: list[str]) -> Any:
+        ...
+
+    def part_2(self, input_lines: list[str]) -> Any:
+        ...
+
+
+class BaseChallenge(ChallengeProtocol, abc.ABC):
     """Base class for all challenges."""
 
-    def __init__(self, use_test_data: bool = False, data_dir: Path | None = None):
-        self._use_test_data = use_test_data
+    day: ClassVar[int]
+
+    def __init__(
+        self,
+        input_provider: InputProvider,
+    ):
+        self._input_provider = input_provider
         self._input_lines: dict[int | None, list[str]] = {}
-        self._data_dir = data_dir or REPO_ROOT.joinpath("data")
 
-    @property
-    def day(self) -> int:
+    def __init_subclass__(cls, **kwargs):
+        cls.day = cls._get_day()
+
+    @classmethod
+    def _get_day(cls) -> int:
+        import __main__
+
         """Return the day of this challenge based on the module name."""
-        if self.__module__ == "__main__":  # challenge is run directly
+        if cls.__module__ == "__main__":  # challenge is run directly
             return int(Path(__main__.__file__).parent.name.split("_")[1])
-        return int(self.__module__.split(".")[-1].split("_")[1])
-
-    def get_input_filename(self, part: int | None = None) -> str:
-        """Return the input filename for this challenge."""
-        base_filename = (
-            f"{self.day:02}_test_input"
-            if self._use_test_data
-            else f"{self.day:02}_input"
-        )
-        default_filename = f"{base_filename}.txt"
-        if part is not None:
-            filename = f"{base_filename}_part_{part}.txt"
-            if self._data_dir.joinpath(filename).exists():
-                return filename
-            else:
-                logger.info(
-                    "File %s does not exist. Using default instead %s",
-                    filename,
-                    default_filename,
-                )
-        return default_filename
-
-    def get_input_file_path(self, filename: str) -> Path:
-        """Return the input filename for this challenge."""
-        return self._data_dir.joinpath(filename)
+        return get_day_from_module(cls.__module__)
 
     def get_input_lines(self, part: int | None = None) -> list[str]:
         """Return the input lines for this challenge. Relative to this file"""
-        filename = self.get_input_filename(part)
-        print(f"Using data from {filename}")
         if not self._input_lines.get(part):
             self._input_lines[part] = (
-                self.get_input_file_path(filename).read_text().splitlines()
+                self._input_provider.provide_input(part).strip().split("\n")
             )
         return self._input_lines[part]
 
     def set_input_lines(self, lines: list[str], part: int | None = None):
         self._input_lines[part] = lines
 
     @abc.abstractmethod
-    def part_1(self) -> Any:
+    def part_1(self, input_lines: list[str]) -> Any:
         """Return the solution for part 1 of this challenge."""
         ...
 
     @abc.abstractmethod
-    def part_2(self) -> Any:
+    def part_2(self, input_lines: list[str]) -> Any:
         """Return the solution for part 2 of this challenge."""
         ...
 
     def solve(self) -> tuple[Any, Any]:
         """Return solutions for this challenge as a 2 element tuple."""
-        return self.part_1(), self.part_2()
+        return self.part_1(self.get_input_lines(part=1)), self.part_2(
+            self.get_input_lines(part=2)
+        )
 
     def run(self):
-        solution1 = self.part_1()
+        solution1 = self.part_1(self.get_input_lines(part=1))
         print(f"Day {self.day} - Part 1: {solution1}")
-        solution2 = self.part_2()
+        solution2 = self.part_2(self.get_input_lines(part=2))
         print(f"Day {self.day} - Part 2: {solution2}\n")
         return solution1, solution2

src/aoc/base_tests.py

@@ -3,6 +3,7 @@
 import pytest
 
 from aoc.base import BaseChallenge
+from aoc.input_providers import SmartFileInputProvider
 
 
 class Empty:
@@ -39,19 +40,32 @@ def __init_subclass__(cls, **kwargs):
     def test_on_sample_data_part_1(self):
         if (expected_result := self.expected_results_from_test_data[0]) == Empty:
             pytest.skip("No expected result for part one of test data set.")
-        assert self.challenge_class(use_test_data=True).part_1() == expected_result
+
+        challenge = self.challenge_class(
+            SmartFileInputProvider(self.challenge_class.day, use_test_data=True)
+        )
+        assert challenge.part_1(challenge.get_input_lines(part=1)) == expected_result
 
     def test_on_sample_data_part_2(self):
         if (expected_result := self.expected_results_from_test_data[1]) == Empty:
             pytest.skip("No expected results for part two of test data set.")
-        assert self.challenge_class(use_test_data=True).part_2() == expected_result
+        challenge = self.challenge_class(
+            SmartFileInputProvider(self.challenge_class.day, use_test_data=True)
+        )
+        assert challenge.part_2(challenge.get_input_lines(part=2)) == expected_result
 
     def test_on_real_data_part_1(self):
         if (expected_result := self.expected_results_from_real_data[0]) == Empty:
             pytest.skip("No expected result for part one of real data set.")
-        assert self.challenge_class().part_1() == expected_result
+        challenge = self.challenge_class(
+            SmartFileInputProvider(self.challenge_class.day)
+        )
+        assert challenge.part_1(challenge.get_input_lines(part=1)) == expected_result
 
     def test_on_real_data_part_2(self):
         if (expected_result := self.expected_results_from_real_data[1]) == Empty:
             pytest.skip("No expected results for part two of real data set.")
-        assert self.challenge_class().part_2() == expected_result
+        challenge = self.challenge_class(
+            SmartFileInputProvider(self.challenge_class.day)
+        )
+        assert challenge.part_2(challenge.get_input_lines(part=2)) == expected_result

src/aoc/input_providers.py

@@ -0,0 +1,71 @@
+import abc
+from dataclasses import dataclass
+from pathlib import Path
+
+from aoc.logger import logger
+
+
+@dataclass
+class InputProvider(abc.ABC):
+    day: int
+
+    @abc.abstractmethod
+    def provide_input(self, part: int | None) -> str:
+        ...
+
+    @property
+    def _day(self) -> int:
+        import __main__
+
+        """Return the day of this challenge based on the module name."""
+        if self.__module__ == "__main__":  # challenge is run directly
+            return int(Path(__main__.__file__).parent.name.split("_")[1])
+        return int(self.__module__.split(".")[-1].split("_")[1])
+
+
+@dataclass
+class SmartFileInputProvider(InputProvider):
+    use_test_data: bool = False
+
+    def __post_init__(self):
+        self._data_dir = Path(__file__).parents[2].joinpath("data")
+
+    def provide_input(self, part: int | None) -> str:
+        filename = self.get_input_filename(part)
+        print("Using data from", filename)
+        return self.get_input_file_path(self.get_input_filename(part)).read_text()
+
+    def get_input_filename(self, part: int | None = None) -> str:
+        """Return the input filename for this challenge."""
+        base_filename = (
+            f"{self.day:02}_test_input"
+            if self.use_test_data
+            else f"{self.day:02}_input"
+        )
+        default_filename = f"{base_filename}.txt"
+        if part is not None:
+            filename = f"{base_filename}_part_{part}.txt"
+            if self._data_dir.joinpath(filename).exists():
+                return filename
+            else:
+                logger.info(
+                    "File %s does not exist. Using default instead %s",
+                    filename,
+                    default_filename,
+                )
+        return default_filename
+
+    def get_input_file_path(self, filename: str) -> Path:
+        """Return the input filename for this challenge."""
+        return self._data_dir.joinpath(filename)
+
+
+@dataclass
+class SingleFileInputProvider(InputProvider):
+    input_path: Path
+
+    def provide_input(self, part: int | None) -> str:
+        if not self.input_path.exists():
+            raise FileNotFoundError(f"File {self.input_path.resolve()} does not exist.")
+        print("Using data from", self.input_path.name)
+        return self.input_path.read_text()

src/aoc/logger.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger(__name__)

src/aoc/main.py

@@ -12,6 +12,8 @@
 from aocd.models import Puzzle
 from mypy.nodes import TypeGuard
 
+from aoc.input_providers import SingleFileInputProvider, SmartFileInputProvider
+
 app = typer.Typer(no_args_is_help=True)
 
 
@@ -53,12 +55,17 @@ def import_challenge_module(day: int):
     return module
 
 
-def run_challenge(day: int, test_data: bool):
+def run_challenge(day: int, test_data: bool, input_path: Path | None = None):
     module = import_challenge_module(day)
+    input_provider = (
+        SingleFileInputProvider(day=day, input_path=input_path)
+        if input_path
+        else SmartFileInputProvider(day=day, use_test_data=test_data)
+    )
     if test_data:
-        module.Challenge(use_test_data=True).run()
+        module.Challenge(input_provider=input_provider).run()
     else:
-        module.Challenge(use_test_data=False).run()
+        module.Challenge(input_provider=input_provider).run()
 
 
 def get_puzzle_object(year: int, day: int) -> Puzzle | None:
@@ -92,13 +99,16 @@ def write_input_data(puzzle, real_input_data):
 
 @app.command()
 def run(
-    day: int = typer.Argument(..., help="Day of the challenge to run."),
+    day: Annotated[int, typer.Argument(..., help="Day of the challenge to run.")],
+    file: Annotated[
+        Path | None, typer.Option(..., "--file", "-f", help="File to run.")
+    ] = None,
     test_data: bool = typer.Option(
         False, "--test-data", "-t", help="Run challenge also for test data."
     ),
 ):
     """Run the challenge."""
-    run_challenge(day, test_data)
+    run_challenge(day, test_data, file)
 
 
 @app.command()
@@ -209,11 +219,11 @@ def new_day(
             "--directory",
             help="Path to a directory with challenges",
         ),
-    ] = "src/aoc",
+    ] = Path("src/aoc"),
     data_directory: Annotated[
         Path,
         typer.Option(help="Path to a directory with data."),
-    ] = "data",
+    ] = Path("data"),
     template_directory: Annotated[
         Path,
         typer.Option(

src/aoc/templates/day_template/__init__.py

@@ -1,14 +1,24 @@
+import sys
+from pathlib import Path
+
 from aoc.base import BaseChallenge
+from aoc.input_providers import SingleFileInputProvider, SmartFileInputProvider
 
 
 class Challenge(BaseChallenge):
-    def part_1(self):
+    def part_1(self, input_lines: list[str]) -> int | str:
         return
 
-    def part_2(self):
+    def part_2(self, input_lines: list[str]) -> int | str:
         return
 
 
 if __name__ == "__main__":
-    Challenge().run()
-    Challenge(use_test_data=True).run()
+    if len(sys.argv) > 1:
+        input_provider = SingleFileInputProvider(
+            Challenge.day, input_path=Path(sys.argv[1])
+        )
+        Challenge(input_provider).run()
+    else:
+        Challenge(SmartFileInputProvider(Challenge.day, use_test_data=True)).run()
+        Challenge(SmartFileInputProvider(Challenge.day)).run()

tests/data/custom_input.txt

@@ -0,0 +1,3 @@
+10
+11
+12

tests/test_cli.py

@@ -40,3 +40,52 @@ def test_setting_up_new_day_creates_directories_in_configured_places(
         assert (tmp_path / "data" / "11_input.txt").read_text() == "1"
         assert (tmp_path / "data" / "11_test_input.txt").read_text() == "2"
         assert (tmp_path / "src" / "day_11").exists()
+
+
+class TestRunningSolution:
+    def test_run_for_a_specific_day_with_default_data(self, tmp_path: Path):
+        result = runner.invoke(
+            app,
+            [
+                "run",
+                "0",
+            ],
+        )
+        if result.exception:
+            raise result.exception
+        assert result.exit_code == 0, result.exc_info
+        assert "Day 0 - Part 1: 1" in result.stdout
+        assert "Day 0 - Part 2: 55" in result.stdout
+
+    def test_run_for_a_specific_day_with_test_data(self, tmp_path: Path):
+        result = runner.invoke(
+            app,
+            [
+                "run",
+                "0",
+                "-t",
+            ],
+        )
+        if result.exception:
+            raise result.exception
+        assert result.exit_code == 0, result.exc_info
+        assert "00_test_input.txt" in result.stdout
+        assert "Day 0 - Part 1: 1" in result.stdout
+        assert "Day 0 - Part 2: 21" in result.stdout
+
+    def test_run_for_a_specific_day_with_a_custom_file(self, tmp_path: Path):
+        result = runner.invoke(
+            app,
+            [
+                "run",
+                "0",
+                "-f",
+                Path(__file__).parent / "data/custom_input.txt",
+            ],
+        )
+        if result.exception:
+            raise result.exception
+        assert result.exit_code == 0, result.exc_info
+        assert "Using data from custom_input.txt" in result.stdout
+        assert "Day 0 - Part 1: 1" in result.stdout
+        assert "Day 0 - Part 2: 33" in result.stdout