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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: algobattle-base
-Version: 4.3.2
+Version: 4.3.4
 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.4}/algobattle/battle.py

@@ -3,10 +3,12 @@
 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 +18,6 @@ from typing import (
     Annotated,
     Any,
     ClassVar,
-    Iterable,
     Literal,
     ParamSpec,
     Protocol,
@@ -26,9 +27,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 +39,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 +52,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 +64,7 @@ the new battle type directly.
 """
 T = TypeVar("T")
 P = ParamSpec("P")
-Type = type
+_type = type
 
 
 class ProgramLogConfigTime(StrEnum):
@@ -91,7 +82,7 @@ class ProgramLogConfigLocation(StrEnum):
     inline = "inline"
 
 
-class ProgramLogConfigView(Protocol):  # noqa: D101
+class ProgramLogConfigView(Protocol):
     when: ProgramLogConfigTime = ProgramLogConfigTime.error
     output: ProgramLogConfigLocation = ProgramLogConfigLocation.inline
 
@@ -100,7 +91,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 +168,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
@@ -211,8 +202,7 @@ class FightHandler:
         *,
         with_results: Literal[False] = False,
         **kwargs: Unpack[RunKwargs],
-    ) -> Fight:
-        ...
+    ) -> Fight: ...
 
     @overload
     async def run(
@@ -221,8 +211,7 @@ class FightHandler:
         *,
         with_results: Literal[True],
         **kwargs: Unpack[RunKwargs],
-    ) -> tuple[Fight, GeneratorResult, SolverResult | None]:
-        ...
+    ) -> tuple[Fight, GeneratorResult, SolverResult | None]: ...
 
     async def run(
         self,
@@ -260,12 +249,7 @@ class FightHandler:
             The resulting info about the executed fight, and the results if the flag has been set.
         """
         gen_result, sol_result = await self.run_raw(max_size=max_size, **kwargs)
-        if gen_result.instance is None or gen_result.solution is None:
-            score = 1
-        elif sol_result is None or sol_result.solution is None:
-            score = 0
-        else:
-            score = self.calculate_score(gen_result, sol_result)
+        score = self.calculate_score(gen_result, sol_result)
         fight = Fight.from_results(
             score=score,
             max_size=max_size,
@@ -331,7 +315,7 @@ class FightHandler:
         )
         return gen_result, sol_result
 
-    def calculate_score(self, gen_result: GeneratorResult, sol_result: SolverResult) -> float:
+    def calculate_score(self, gen_result: GeneratorResult, sol_result: SolverResult | None) -> float:
         """Calculates the score achieved by the solver in this fight.
 
         Both results need to contain all instance and/or solution data required.
@@ -343,9 +327,25 @@ class FightHandler:
         Returns:
             A number in [0, 1] with higher numbers meaning the solver performed better.
         """
-        assert gen_result.instance is not None
-        assert sol_result.solution is not None
+        # We first need to check whether the generator somehow failed. This can happen in three cases:
+        # it doesn't produce an instance, it creates an invalid instance or it doesn't create a needed solution
+        # note that gen_result.instance and gen_result.error will both contain data if the generator outputted an
+        # invalid instance and/or solution
+        if (
+            gen_result.instance is None
+            or gen_result.error is not None
+            or (self.problem.with_solution and gen_result.solution is None)
+        ):
+            return 1
+        # sol_result is None only if the generator failed, which needs to be caught by the above check
+        assert sol_result is not None
+        # The solver failed if it didn't output a solution or the solution contains some error
+        if sol_result.solution is None or sol_result.error is not None:
+            return 0
+
         if self.problem.with_solution:
+            # we need this assert since type checkers can't see the dependency between self.problem.with_solution
+            # and gen_result.solution that is created by the last check in the first "if"
             assert gen_result.solution is not None
             score = self.problem.score(
                 gen_result.instance, solver_solution=sol_result.solution, generator_solution=gen_result.solution
@@ -394,7 +394,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 +446,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,8 +459,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):
         """Object containing custom diplay data.
@@ -560,7 +559,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 +619,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 +636,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 +658,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 +680,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 +714,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 +759,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%")