algobattle-base 4.3.2__tar.gz → 4.3.3__tar.gz

{algobattle_base-4.3.2 → algobattle_base-4.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: algobattle-base
-Version: 4.3.2
+Version: 4.3.3
 Summary: The Algobattle lab course package.
 Author: Imogen Hergeth, Jan Dreier, Henri Lotze
 License: MIT
@@ -22,9 +22,7 @@ Requires-Dist: typing-extensions>=4.15.0
 Requires-Dist: tomlkit>=0.13.3
 Requires-Dist: jinja2>=3.1.6
 Provides-Extra: dev
-Requires-Dist: black>=23.12.1; extra == "dev"
-Requires-Dist: flake8>=6.1.0; extra == "dev"
-Requires-Dist: flake8-docstrings>=1.7.0; extra == "dev"
+Requires-Dist: ruff>=0.13.2; extra == "dev"
 Requires-Dist: mkdocs>=1.5.3; extra == "dev"
 Requires-Dist: mkdocs-material>=9.5.3; extra == "dev"
 Requires-Dist: pymdown-extensions>=10.7; extra == "dev"

{algobattle_base-4.3.2 → algobattle_base-4.3.3}/algobattle/battle.py

@@ -3,10 +3,11 @@
 This module contains the :class:`Battle` class, which speciefies how each type of battle is fought and scored,
 some basic battle types, and related classed.
 """
+from abc import abstractmethod
+from collections.abc import Iterable
 from dataclasses import dataclass, field
 from enum import StrEnum
 from importlib.metadata import entry_points
-from abc import abstractmethod
 from inspect import isclass
 from itertools import count
 from pathlib import Path
@@ -16,7 +17,6 @@ from typing import (
     Annotated,
     Any,
     ClassVar,
-    Iterable,
     Literal,
     ParamSpec,
     Protocol,
@@ -26,9 +26,8 @@ from typing import (
     Unpack,
     overload,
 )
-from typing_extensions import TypedDict
-from annotated_types import Ge
 
+from annotated_types import Ge
 from pydantic import (
     ConfigDict,
     Field,
@@ -39,11 +38,10 @@ from pydantic import (
     ValidatorFunctionWrapHandler,
 )
 from pydantic_core import CoreSchema
-from pydantic_core.core_schema import (
-    tagged_union_schema,
-    with_info_wrap_validator_function,
-)
+from pydantic_core.core_schema import tagged_union_schema, with_info_wrap_validator_function
+from typing_extensions import TypedDict
 
+from algobattle.problem import InstanceModel, Problem, SolutionModel
 from algobattle.program import (
     Generator,
     GeneratorResult,
@@ -53,15 +51,7 @@ from algobattle.program import (
     Solver,
     SolverResult,
 )
-from algobattle.problem import InstanceModel, Problem, SolutionModel
-from algobattle.util import (
-    Encodable,
-    EncodableModel,
-    ExceptionInfo,
-    BaseModel,
-    Role,
-)
-
+from algobattle.util import BaseModel, Encodable, EncodableModel, ExceptionInfo, Role
 
 _BattleConfig: TypeAlias = Any
 """Type alias used to generate correct typings when subclassing :class:`Battle`.
@@ -73,7 +63,7 @@ the new battle type directly.
 """
 T = TypeVar("T")
 P = ParamSpec("P")
-Type = type
+_type = type
 
 
 class ProgramLogConfigTime(StrEnum):
@@ -91,7 +81,7 @@ class ProgramLogConfigLocation(StrEnum):
     inline = "inline"
 
 
-class ProgramLogConfigView(Protocol):  # noqa: D101
+class ProgramLogConfigView(Protocol):
     when: ProgramLogConfigTime = ProgramLogConfigTime.error
     output: ProgramLogConfigLocation = ProgramLogConfigLocation.inline
 
@@ -100,7 +90,7 @@ class ProgramRunInfo(BaseModel):
     """Data about a program's execution."""
 
     runtime: float = 0
-    overriden: RunConfigOverride = Field(default_factory=dict)
+    overriden: RunConfigOverride = Field(default_factory=RunConfigOverride, validate_default=True)
     error: ExceptionInfo | None = None
     battle_data: SerializeAsAny[EncodableModel] | None = None
     instance: SerializeAsAny[InstanceModel] | None = None
@@ -177,7 +167,7 @@ class FightUi(ProgramUi, Protocol):
         """Informs the ui that the fight has finished running and has been added to the battle's `.fight_results`."""
 
 
-class RunKwargs(TypedDict, total=False):
+class RunKwargs(TypedDict, total=False, closed=True):
     """The keyword arguments used by the FightHandler.run family of functions."""
 
     timeout_generator: float | None
@@ -394,7 +384,7 @@ class Battle(BaseModel):
         """Type of battle that will be used."""
 
         @classmethod
-        def __get_pydantic_core_schema__(cls, source: Type, handler: GetCoreSchemaHandler) -> CoreSchema:
+        def __get_pydantic_core_schema__(cls, source: _type, handler: GetCoreSchemaHandler) -> CoreSchema:
             # there's two bugs we need to catch:
             # 1. this function is called during the pydantic BaseModel metaclass's __new__, so the BattleConfig class
             # won't be ready at that point and be missing in the namespace
@@ -446,7 +436,7 @@ class Battle(BaseModel):
                         installed = ", ".join(b.name() for b in Battle._battle_types.values())
                         raise ValueError(
                             f"The specified battle type '{passed}' is not installed. Installed types are: {installed}"
-                        )
+                        ) from e
 
             return with_info_wrap_validator_function(check_installed, subclass_schema)
 
@@ -459,7 +449,7 @@ class Battle(BaseModel):
 
         if TYPE_CHECKING:
             # to hint that we're gonna fill this with arbitrary data belonging to some supposed battle type
-            def __getattr__(self, __attr: str) -> Any:
+            def __getattr__(self, attr: str, /) -> Any:
                 ...
 
     class UiData(BaseModel):
@@ -560,7 +550,7 @@ class Iterated(Battle):
         exit after that many failures, or `"unlimited"` to never exit early.
         """
 
-    class UiData(Battle.UiData):  # noqa: D106
+    class UiData(Battle.UiData):
         reached: list[int]
         cap: int
         note: str
@@ -620,7 +610,7 @@ class Iterated(Battle):
         return 0 if len(self.results) == 0 else sum(self.results) / len(self.results)
 
     @staticmethod
-    def format_score(score: float) -> str:  # noqa: D102
+    def format_score(score: float) -> str:
         return str(int(score))
 
 
@@ -637,7 +627,7 @@ class Averaged(Battle):
         num_fights: int = 10
         """Number of iterations in each round."""
 
-    class UiData(Battle.UiData):  # noqa: D106
+    class UiData(Battle.UiData):
         round: int
 
     async def run_battle(self, fight: FightHandler, config: Config, min_size: int, ui: BattleUi) -> None:
@@ -659,7 +649,7 @@ class Averaged(Battle):
             return sum(f.score for f in self.fights) / len(self.fights)
 
     @staticmethod
-    def format_score(score: float) -> str:  # noqa: D102
+    def format_score(score: float) -> str:
         return format(score, ".0%")
 
 
@@ -681,7 +671,7 @@ class FightHistory(Encodable):
     gen_sols: set[Role]
     sol_sols: set[Role]
 
-    def encode(self, target: Path, role: Role) -> None:  # noqa: D102
+    def encode(self, target: Path, role: Role) -> None:
         target.mkdir()
         for i, fight in enumerate(self.history):
             fight_dir = target / str(i)
@@ -715,16 +705,16 @@ class Improving(Battle):
         """Number of fights that will be fought."""
         weighting: Annotated[float, Ge(0)] = 1.1
         """How much each successive fight should be weighted more than the previous."""
-        scores: set[Role] = {Role.generator, Role.solver}
+        scores: set[Role] = {Role.generator, Role.solver} # noqa: RUF012
         """Who to show each fight's scores to."""
-        instances: set[Role] = {Role.generator, Role.solver}
+        instances: set[Role] = {Role.generator, Role.solver} # noqa: RUF012
         """Who to show the instances to."""
-        generator_solutions: set[Role] = {Role.generator}
+        generator_solutions: set[Role] = {Role.generator} # noqa: RUF012
         """Who to show the generator's solutions to, if the problem requires them."""
-        solver_solutions: set[Role] = {Role.solver}
+        solver_solutions: set[Role] = {Role.solver} # noqa: RUF012
         """Who to show the solver's solutions to."""
 
-    class UiData(Battle.UiData):  # noqa: D106
+    class UiData(Battle.UiData):
         round: int
 
     async def run_battle(self, fight: FightHandler, config: Config, min_size: int, ui: BattleUi) -> None:
@@ -760,5 +750,5 @@ class Improving(Battle):
             return total / quotient
 
     @staticmethod
-    def format_score(score: float) -> str:  # noqa: D102
+    def format_score(score: float) -> str:
         return format(score, ".0%")

{algobattle_base-4.3.2 → algobattle_base-4.3.3}/algobattle/cli.py

@@ -2,68 +2,69 @@
 
 Provides a command line interface to start matches and observe them. See `battle --help` for further options.
 """
+
+import operator
+import shutil
+import sys
+from collections.abc import Iterable
 from enum import StrEnum
 from functools import cached_property
-import operator
+from importlib.metadata import version as pkg_version
 from os import environ
 from pathlib import Path
 from random import choice
 from shutil import rmtree
 from subprocess import PIPE, Popen
-import sys
-from typing import Annotated, Any, ClassVar, Iterable, Literal, Optional, Self, cast
-from typing_extensions import override
-from importlib.metadata import version as pkg_version
+from typing import Annotated, Any, ClassVar, Literal, Self, cast
 from zipfile import ZipFile
-import shutil
 
 from anyio import run as run_async_fn
 from click import Choice
-from click.core import Parameter
+from click.core import Context, Parameter
 from pydantic import Field, TypeAdapter, ValidationError
-from typer import Typer, Argument, Option, Abort, get_app_dir, launch
-from rich.console import Group, RenderableType, Console
+from rich.columns import Columns
+from rich.console import Console, Group, RenderableType
 from rich.live import Live
-from rich.table import Table, Column
+from rich.padding import Padding
+from rich.panel import Panel
 from rich.progress import (
-    Progress,
-    TextColumn,
-    SpinnerColumn,
     BarColumn,
     MofNCompleteColumn,
-    TimeElapsedColumn,
+    Progress,
     ProgressColumn,
+    SpinnerColumn,
     Task,
+    TextColumn,
+    TimeElapsedColumn,
 )
-from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.rule import Rule
+from rich.table import Column, Table
 from rich.text import Text
-from rich.columns import Columns
-from rich.prompt import Prompt, Confirm
 from rich.theme import Theme
-from rich.rule import Rule
-from rich.padding import Padding
 from rich.traceback import Traceback
-from tomlkit import TOMLDocument, comment, parse as parse_toml, dumps as dumps_toml, table, nl as toml_newline
+from tomlkit import TOMLDocument, comment, dumps as dumps_toml, nl as toml_newline, parse as parse_toml, table
 from tomlkit.exceptions import ParseError
 from tomlkit.items import Table as TomlTable
+from typer import Abort, Argument, Option, Typer, get_app_dir, launch
+from typing_extensions import override
 
 from algobattle.battle import Battle
-from algobattle.match import AlgobattleConfig, EmptyUi, Match, MatchConfig, MatchupStr, TeamInfo, Ui, ProjectConfig
+from algobattle.match import AlgobattleConfig, EmptyUi, Match, MatchConfig, MatchupStr, ProjectConfig, TeamInfo, Ui
 from algobattle.problem import Instance, Problem, Solution
 from algobattle.program import Generator, Matchup, Solver
+from algobattle.templates import Language, PartialTemplateArgs, TemplateArgs, write_problem_template, write_templates
 from algobattle.util import (
+    BaseModel,
     BuildError,
     DockerNotRunning,
     EncodableModel,
     ExceptionInfo,
     Role,
     RunningTimer,
-    BaseModel,
     TempDir,
     timestamp,
 )
-from algobattle.templates import Language, PartialTemplateArgs, TemplateArgs, write_problem_template, write_templates
-
 
 __all__ = ("app",)
 
@@ -75,16 +76,14 @@ For more detailed documentation, visit our website at http://algobattle.org/docs
 app = Typer(pretty_exceptions_show_locals=True, help=help_message)
 packager = Typer(help="Subcommands to package problems and programs into `.algo` files.")
 app.add_typer(packager, name="package")
-theme = Theme(
-    {
-        "success": "green",
-        "warning": "orange3",
-        "error": "red",
-        "attention": "magenta2",
-        "heading": "blue",
-        "info": "dim cyan",
-    }
-)
+theme = Theme({
+    "success": "green",
+    "warning": "orange3",
+    "error": "red",
+    "attention": "magenta2",
+    "heading": "blue",
+    "info": "dim cyan",
+})
 console = Console(theme=theme)
 
 
@@ -101,7 +100,7 @@ class _General(BaseModel):
 
 
 class CliConfig(BaseModel):
-    general: _General = Field(default_factory=dict, validate_default=True)
+    general: _General = Field(default_factory=_General, validate_default=True)
     default_project_table: ProjectConfig | None = Field(default=None)
 
     _doc: TOMLDocument
@@ -138,8 +137,7 @@ class CliConfig(BaseModel):
     @property
     def default_project_doc(self) -> TomlTable | None:
         """The default exec config for each problem."""
-        exec: Any = self._doc.get("default_project_table", None)
-        return exec
+        return self._doc.get("default_project_table", None)
 
     @cached_property
     def install_cmd(self) -> list[str]:
@@ -167,6 +165,7 @@ class CliConfig(BaseModel):
 
 @app.command("run")
 def run_match(
+    *,
     path: Annotated[
         Path, Argument(exists=True, help="Path to either a config file or a directory containing one.")
     ] = Path(),
@@ -184,27 +183,25 @@ def run_match(
         save = False
     except KeyboardInterrupt:
         console.print("[error]Stopping match execution")
-    finally:
-        try:
-            if config.project.points > 0 and result.active_teams:
-                points = result.calculate_points()
-                leaderboard = Table(
-                    Column("Team", justify="center"),
-                    Column("Points", justify="right"),
-                    title="[heading]Leaderboard",
-                )
-                for team, pts in sorted(points.items(), key=operator.itemgetter(1)):
-                    leaderboard.add_row(team, f"{pts:.1f}")
-                console.print(Padding(leaderboard, (1, 0, 0, 0)))
-
-            if save:
-                out_path = config.project.results.joinpath(f"match-{timestamp()}.json")
-                config.project.results.mkdir(parents=True, exist_ok=True)
-                out_path.write_text(result.format(error_detail=config.project.error_detail))
-                console.print("Saved match result to ", out_path)
-            return result
-        except KeyboardInterrupt:
-            raise Abort
+    try:
+        if config.project.points > 0 and result.active_teams:
+            points = result.calculate_points()
+            leaderboard = Table(
+                Column("Team", justify="center"),
+                Column("Points", justify="right"),
+                title="[heading]Leaderboard",
+            )
+            for team, pts in sorted(points.items(), key=operator.itemgetter(1)):
+                leaderboard.add_row(team, f"{pts:.1f}")
+            console.print(Padding(leaderboard, (1, 0, 0, 0)))
+        if save:
+            out_path = config.project.results.joinpath(f"match-{timestamp()}.json")
+            config.project.results.mkdir(parents=True, exist_ok=True)
+            out_path.write_text(result.format(error_detail=config.project.error_detail))
+            console.print("Saved match result to ", out_path)
+    except KeyboardInterrupt as e:
+        raise Abort from e
+    return result
 
 
 def _init_program(target: Path, lang: Language, args: PartialTemplateArgs, role: Role) -> None:
@@ -233,17 +230,15 @@ class ClickLanguage(Choice):
     def __init__(self, case_sensitive: bool = True) -> None:
         super().__init__([lang.value for lang in Language], case_sensitive)
 
-    def get_metavar(self, param: Parameter) -> str:
+    def get_metavar(self, param: Parameter, ctx: Context) -> str:
         return "LANGUAGE"
 
 
 @app.command(epilog=f"Supported languages are: {', '.join(Language)}.")
 def init(
-    target: Annotated[
-        Optional[Path], Argument(file_okay=False, writable=True, help="The folder to initialize.")
-    ] = None,
+    target: Annotated[Path | None, Argument(file_okay=False, writable=True, help="The folder to initialize.")] = None,
     problem_: Annotated[
-        Optional[str],
+        str | None,
         Option(
             "--problem",
             "-p",
@@ -251,15 +246,15 @@ def init(
         ),
     ] = None,
     language: Annotated[
-        Optional[Language],
+        Language | None,
         Option("--language", "-l", help="The language to use for the programs.", click_type=ClickLanguage()),
     ] = None,
     generator: Annotated[
-        Optional[Language],
+        Language | None,
         Option("--generator", "-g", help="The language to use for the generator.", click_type=ClickLanguage()),
     ] = None,
     solver: Annotated[
-        Optional[Language],
+        Language | None,
         Option("--solver", "-s", help="The language to use for the solver.", click_type=ClickLanguage()),
     ] = None,
     schemas: Annotated[bool, Option(help="Whether to also save the problem's IO schemas.")] = False,
@@ -282,10 +277,28 @@ def init(
     if language:
         generator = solver = language
     config = CliConfig.load()
-    team_name = config.general.team_name or choice(
-        ("Dogs", "Cats", "Otters", "Red Pandas", "Crows", "Rats", "Cockatoos", "Dingos", "Penguins", "Kiwis", "Orcas")
-        + ("Bearded Dragons", "Macaws", "Wombats", "Wallabies", "Owls", "Seals", "Octopuses", "Frogs", "Jellyfish")
-    )
+    team_name = config.general.team_name or choice((
+        "Dogs",
+        "Cats",
+        "Otters",
+        "Red Pandas",
+        "Crows",
+        "Rats",
+        "Cockatoos",
+        "Dingos",
+        "Penguins",
+        "Kiwis",
+        "Orcas",
+        "Bearded Dragons",
+        "Macaws",
+        "Wombats",
+        "Wallabies",
+        "Owls",
+        "Seals",
+        "Octopuses",
+        "Frogs",
+        "Jellyfish",
+    ))
 
     if new:  # create a new problem
         if problem_ is None:
@@ -304,12 +317,12 @@ def init(
             target = Path()
         try:
             parsed_config = AlgobattleConfig.from_file(target, relativize_paths=False)
-        except FileNotFoundError:
+        except FileNotFoundError as e:
             console.print("[error]You must use a problem spec file or target a directory with an existing config.")
-            raise Abort
+            raise Abort from e
         except ValueError as e:
             console.print("[error]The Algobattle config file is not formatted properly\n", e)
-            raise Abort
+            raise Abort from e
         console.print("Using existing project data")
         if len(parsed_config.teams) == 1:
             team_name = next(iter(parsed_config.teams.keys()))
@@ -323,9 +336,8 @@ def init(
 
     elif (problem := Path(problem_)).is_file():  # use a problem spec file
         with TempDir() as unpack_dir:
-            with console.status("Extracting problem data"):
-                with ZipFile(problem) as problem_zip:
-                    problem_zip.extractall(unpack_dir)
+            with console.status("Extracting problem data"), ZipFile(problem) as problem_zip:
+                problem_zip.extractall(unpack_dir)
 
             parsed_config = AlgobattleConfig.from_file(unpack_dir, relativize_paths=False)
             if target is None:
@@ -333,7 +345,7 @@ def init(
 
             target.mkdir(parents=True, exist_ok=True)
             problem_data = list(unpack_dir.iterdir())
-            if any(((target / path.name).exists() for path in problem_data)):
+            if any(target.joinpath(path.name).exists() for path in problem_data):
                 copy_problem_data = Confirm.ask(
                     "[attention]The target directory already contains an algobattle project, "
                     "do you want to replace it?",
@@ -363,9 +375,10 @@ def init(
     problem_name = parsed_config.match.problem
     if deps := parsed_config.problem.dependencies:
         cmd = config.install_cmd
-        with console.status(f"Installing {problem_name}'s dependencies"), Popen(
-            cmd + deps, env=environ.copy(), stdout=PIPE, stderr=PIPE, text=True
-        ) as installer:
+        with (
+            console.status(f"Installing {problem_name}'s dependencies"),
+            Popen(cmd + deps, env=environ.copy(), stdout=PIPE, stderr=PIPE, text=True) as installer,
+        ):
             assert installer.stdout is not None
             assert installer.stderr is not None
             for line in installer.stdout:
@@ -506,7 +519,7 @@ def test_team(config: AlgobattleConfig, team: str, size: int | None = None) -> T
 @app.command()
 def test(
     project: Annotated[Path, Argument(help="The project folder to use.")] = Path(),
-    size: Annotated[Optional[int], Option(help="The size of instance the generator will be asked to create.")] = None,
+    size: Annotated[int | None, Option(help="The size of instance the generator will be asked to create.")] = None,
 ) -> Literal["success", "error"]:
     """Tests whether the programs install successfully and run on dummy instances without crashing."""
     if not (project.is_file() or project.joinpath("algobattle.toml").is_file()):
@@ -542,10 +555,10 @@ def config() -> None:
 def package_problem(
     project: Annotated[Path, Argument(exists=True, resolve_path=True, help="Path to the project directory.")] = Path(),
     description: Annotated[
-        Optional[Path], Option(exists=True, dir_okay=False, help="Path to a problem description file.")
+        Path | None, Option(exists=True, dir_okay=False, help="Path to a problem description file.")
     ] = None,
     out: Annotated[
-        Optional[Path], Option("--out", "-o", dir_okay=False, file_okay=False, help="Location of the output.")
+        Path | None, Option("--out", "-o", dir_okay=False, file_okay=False, help="Location of the output.")
     ] = None,
 ) -> None:
     """Packages problem data into an `.algo` file."""
@@ -571,22 +584,23 @@ def package_problem(
         parsed_config = AlgobattleConfig.from_file(config)
     except (ValidationError, ParseError) as e:
         console.print(f"[error]Improperly formatted config file[/]\nError: {e}")
-        raise Abort
+        raise Abort from e
     problem_name = parsed_config.match.problem
     try:
         with console.status("Loading problem"):
-            parsed_config.loaded_problem
+            # we need to access the property so that it gets loaded
+            parsed_config.loaded_problem # noqa: B018
     except ValueError as e:
         console.print(f"[error]Couldn't load the problem file[/]\nError: {e}")
-        raise Abort
+        raise Abort from e
     except RuntimeError as e:
         error = e.__cause__
         if error is None:
             console.print(f"[error]Couldn't load the problem file[/]\nError: {e}")
-            raise Abort
+            raise Abort from e
         trace = Traceback.from_exception(error.__class__, error, error.__traceback__)
         console.print("[error]Couldn't execute the problem file[/]\nError:", trace)
-        raise Abort
+        raise Abort from e
 
     if "project" in config_doc:
         config_doc.remove("project")
@@ -613,7 +627,7 @@ def package_problem(
 def package_programs(
     project: Annotated[Path, Argument(help="The project folder to use.")] = Path(),
     team: Annotated[
-        Optional[str],
+        str | None,
         Option(
             help="Name of team whose programs should be packaged. If None are specified, every team's are packaged."
         ),
@@ -789,9 +803,6 @@ class CliUi(Live, Ui):
         self.config = config
         super().__init__(None, refresh_per_second=10, transient=True, console=console)
 
-    def __enter__(self) -> Self:
-        return cast(Self, super().__enter__())
-
     def _update_renderable(self) -> None:
         if self.build is None:
             renderable = Group(self.display_match(self.match, self.config.match), *self.battle_panels.values())
@@ -809,10 +820,7 @@ class CliUi(Live, Ui):
             title="[heading]Match overview",
         )
         for matchup, battle in match.battles.items():
-            if battle.runtime_error is None:
-                res = battle.format_score(battle.score(config.battle))
-            else:
-                res = ":warning:"
+            res = battle.format_score(battle.score(config.battle)) if battle.runtime_error is None else ":warning:"
             table.add_row(matchup.generator, matchup.solver, res)
         return Padding(table, pad=(1, 0, 0, 0))
 
@@ -868,7 +876,7 @@ class CliUi(Live, Ui):
         fights = battle.fights[-1:-6:-1]
         panel = self.battle_panels[matchup]
         table = panel._fights_table()
-        for i, fight in zip(range(len(battle.fights), len(battle.fights) - len(fights), -1), fights):
+        for i, fight in zip(range(len(battle.fights), len(battle.fights) - len(fights), -1), fights, strict=True):
             if fight.generator.error:
                 info = f"[error]Generator failed[/]: {fight.generator.error.message}"
             elif fight.solver and fight.solver.error: