puzzleshelf 0.0.1__tar.gz

puzzleshelf-0.0.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.3
+Name: puzzleshelf
+Version: 0.0.1
+Summary: A code puzzle solving framework
+Author: Sean Malloy
+Author-email: Sean Malloy <sfmalloy.dev@gmail.com>
+Requires-Dist: httpx>=0.28.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# PuzzleShelf
+
+Docs coming soon.
+
+Note on connectors that have the ability to download inputs: none of them are official in any way, and require you to provide your own user-agent.

puzzleshelf-0.0.1/README.md

@@ -0,0 +1,5 @@
+# PuzzleShelf
+
+Docs coming soon.
+
+Note on connectors that have the ability to download inputs: none of them are official in any way, and require you to provide your own user-agent.

puzzleshelf-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "puzzleshelf"
+version = "0.0.1"
+description = "A code puzzle solving framework"
+readme = "README.md"
+authors = [
+    { name = "Sean Malloy", email = "sfmalloy.dev@gmail.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "httpx>=0.28.1",
+]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.format]
+quote-style = 'single'
+
+[tool.ruff.lint]
+select = ["B", "E", "F", "I"]
+ignore = ["E501"]
+
+[build-system]
+requires = ["uv_build>=0.9.7,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.15.21",
+]

puzzleshelf-0.0.1/src/puzzleshelf/connectors/__init__.py

@@ -0,0 +1,3 @@
+from .connector import Connector as Connector
+from .flipflop_codes import FlipFlopCodesConnector as FlipFlopCodesConnector
+from .offline import OfflineConnector as OfflineConnector

puzzleshelf-0.0.1/src/puzzleshelf/connectors/connector.py

@@ -0,0 +1,39 @@
+from abc import ABCMeta, abstractmethod
+from os import PathLike
+from pathlib import Path
+
+from ..types import Id
+
+
+class Connector(metaclass=ABCMeta):
+    input_dir: Path
+    name: str
+    session_token: str | None
+    user_agent: str | None
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        input_dir: str | PathLike,
+        session_token: str | None = None,
+        user_agent: str | None = None,
+    ):
+        self.name = name
+        self.session_token = session_token
+        self.user_agent = user_agent
+        self.input_dir = Path(input_dir)
+
+    @abstractmethod
+    def download_input(self, *, event_id: Id, problem_id: Id): ...
+
+    @abstractmethod
+    def read_input(self, *, problem_id: Id, part: int | None = None): ...
+
+    def _build_filepath(self, event_id: Id, problem_id: Id, part: int) -> Path:
+        filepath = self.input_dir / self.name / str(event_id)
+        if part:
+            filepath = filepath / str(problem_id) / f'{part}.txt'
+        else:
+            filepath = filepath / f'{problem_id}.txt'
+        return filepath

puzzleshelf-0.0.1/src/puzzleshelf/connectors/flipflop_codes.py

@@ -0,0 +1,36 @@
+import os
+from io import TextIOWrapper
+from os import PathLike
+
+import httpx
+
+from ..types import Id
+from .connector import Connector
+
+BASE_URL = 'https://flipflop.slome.org'
+
+
+class FlipFlopCodesConnector(Connector):
+    def __init__(self, *, year: int, user_agent: str, input_dir: str | PathLike):
+        super().__init__(session_token=os.getenv('FLIPFLOP_CODES_SESSION'), user_agent=user_agent, input_dir=input_dir)
+        self._year = year
+
+    def download_input(self, *, problem_id: Id, part: int | None = None):
+        """
+        Download input file if it does not exist already.
+        """
+        path = self._build_filepath(self._year, problem_id, part)
+        if path.exists():
+            return
+
+        res = httpx.get(
+            f'{BASE_URL}/{self._year}/{problem_id}/input',
+            headers={'PHPSESSID': self.session_token, 'User-Agent': self.user_agent},
+        )
+        if res.text == 'You must be logged in to view the input!':
+            raise RuntimeError('Unable to download input: double check session token.')
+        with open(path, 'w') as f:
+            f.write(res.text)
+
+    def read_input(self, *, problem_id: Id, part: int | None = None) -> TextIOWrapper:
+        return open(self._build_filepath(self._year, problem_id, part))

puzzleshelf-0.0.1/src/puzzleshelf/connectors/offline.py

@@ -0,0 +1,15 @@
+from os import PathLike
+
+from .connector import Connector
+
+
+class OfflineConnector(Connector):
+    def __init__(self, *, input_dir: str | PathLike):
+        super().__init__(name='flipflop-codes', input_dir=input_dir)
+
+    def download_input(self, *, event_id, problem_id):
+        """Does nothing on purpose"""
+        return
+
+    def read_input(self, *, problem_id, part=None):
+        return open(self._build_filepath(problem_id, part))

puzzleshelf-0.0.1/src/puzzleshelf/puzzleshelf.py

@@ -0,0 +1,67 @@
+from os import PathLike
+from pathlib import Path
+
+from .connectors import Connector, OfflineConnector
+from .types import Id, ParserFunction, SolverFunction
+
+
+class PuzzleShelf:
+    _name: str
+    _input_dir: Path
+    _connector: Connector | None
+
+    _parsers: dict[Id, ParserFunction]
+    _solvers: dict[tuple[Id, Id], SolverFunction]
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        input_dir: str | PathLike = Path('./inputs'),
+        connector: Connector | None = None,
+    ):
+        """
+        Object that stores references to solver and parser functions for a given puzzle event.
+
+        :name: Name of this shelf
+        :event_id: Typically the year the event takes place
+        :input_dir: Directory to store input files
+        """
+        self._name = name
+        self._input_dir = Path(str(input_dir))
+        self._connector = connector if connector else OfflineConnector
+        self._parsers = dict()
+        self._solvers = dict()
+
+    def _load_input_file(self, id: Id):
+        path = self._input_dir / f'input_{id}.txt'
+        if not path.exists():
+            raise RuntimeError(f'Input path does not exist: {path}')
+        return open(path)
+
+    def parser(self, id: Id):
+        def decorator(fn: ParserFunction):
+            self._parsers[id] = fn
+
+        return decorator
+
+    def solver(self, id: Id, *, part: Id | None = None):
+        def decorator(fn: SolverFunction):
+            self._solvers[(id, part)] = fn
+
+        return decorator
+
+    def run(self, id: Id, *, part: Id | None = None):
+        file = self._connector.read_input(problem_id=id, part=part)
+        parse = self._parsers.get(id)
+        parsed_input = file if not parse else parse(file)
+        if not isinstance(parsed_input, tuple):
+            parsed_input = (parsed_input,)
+
+        solve = self._solvers.get((id, part))
+        if not solve:
+            raise RuntimeError(f'Solver does not exist: {id}{f" {part}" if part else ""}') from None
+
+        result = solve(*parsed_input)
+        file.close()
+        return result

puzzleshelf-0.0.1/src/puzzleshelf/types.py

@@ -0,0 +1,6 @@
+from io import TextIOWrapper
+from typing import Any, Callable
+
+Id = str | int
+ParserFunction = Callable[[TextIOWrapper], Any]
+SolverFunction = Callable[[tuple[Any, ...]], Any]