massive rework & cleanup; implement pydantic validation and extend ch…

…ecks, simplify tests with matrixes, remove cumbersome test fixtures, use simple typing, create and update SolverSettings, rework n_max checks to properly respect calculation times, major performance upgrade to bruteforce solver (closes #66), fix and include gapfill solver, prepare structure for #68 metrics

app/constants.py

@@ -1,5 +1,19 @@
-version = "v1.0.0"
+from pydantic import BaseModel
 
-# solver parameter
-n_max_precise = 9 # 10 takes 30s on a beefy desktop, 9 only 1.2s
-n_max = 500 # around 1 million with n^2
+# used for git tags
+version = "v1.0.1"
+
+
+class SolverSettings(BaseModel):
+ bruteforce_max_combinations: int
+ n_max: int
+
+
+# TODO should be startup parameter
+solverSettings = SolverSettings(
+ # Desktop with Ryzen 2700X:
+ # (4, 3, 2)=1260 => 0.1s, (4, 3, 3)=4200 => 0.8s, (5, 3, 3)=9240 => 8s
+ bruteforce_max_combinations=5000,
+ # that is already unusable x100, but the solver takes it easily
+ n_max=2000
+)

app/main.py

@@ -6,8 +6,7 @@
 from starlette.requests import Request
 from starlette.responses import HTMLResponse, PlainTextResponse
 
-from app.constants import version, n_max_precise, n_max
-
+from app.constants import version, solverSettings
 # don't mark /app as a sources root or pycharm will delete the "app." prefix
 # that's needed for pytest to work correctly
 from app.solver.data.Job import Job
@@ -84,15 +83,9 @@ def get_debug():
 
 
 @app.get("/constants", response_class=HTMLResponse)
-def get_debug():
- static_answer = (
- "Constants:"
- "<ul>"
- f"<li>Max Entries for perfect results: {n_max_precise}</li>"
- f"<li>Max Entries for any result: {n_max}</li>"
- )
-
- return static_answer
+@app.get("/settings", response_class=HTMLResponse)
+def get_settings():
+ return solverSettings
 
 
 # content_type results in browser pretty printing

app/solver/data/Job.py

@@ -1,11 +1,15 @@
-from typing import Iterator, List, Optional, Tuple
+from math import factorial, prod
+from typing import Iterator, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, PositiveInt, NonNegativeInt, model_validator
 
 
 class TargetSize(BaseModel):
- length: int
- quantity: int
+ # frozen might be nice, but that would make reuse in solvers worse
+ model_config = ConfigDict(validate_assignment=True)
+
+ length: PositiveInt
+ quantity: PositiveInt
  name: Optional[str] = ""
 
  def __lt__(self, other):
@@ -19,67 +23,51 @@ def __str__(self):
 
 
 class Job(BaseModel):
- max_length: int
- cut_width: int = 0
- target_sizes: List[TargetSize]
+ model_config = ConfigDict(frozen=True, validate_assignment=True)
 
- # utility
+ max_length: PositiveInt
+ cut_width: NonNegativeInt = 0
+ target_sizes: tuple[TargetSize, ...]
 
- def iterate_sizes(self) -> Iterator[Tuple[int, str | None]]:
+ def iterate_sizes(self) -> Iterator[tuple[int, str | None]]:
  """
  yields all lengths, sorted descending
  """
 
  # sort descending to favor combining larger sizes first
  for target in sorted(self.target_sizes, key=lambda x: x.length, reverse=True):
  for _ in range(target.quantity):
- yield (target.length, target.name)
-
- # NOTE: Not used, so not really refactored at the moment
- def sizes_from_list(self, sizes_list: List[TargetSize]):
- # known_sizes = {}
- #
- # # list to dict to make them unique
- # for size in sizes_list:
- # if size.length in known_sizes:
- # known_sizes[size.length] += size.quantity
- # else:
- # known_sizes[size.length] = size.quantity
-
- self.target_sizes = sizes_list
-
- # NOTE: Can eventually be removed as it does nothing anymore
- def sizes_as_list(self) -> List[TargetSize]:
+ yield target.length, target.name
+
+ def n_targets(self) -> int:
+ """
+ Number of possible combinations of target sizes
+ """
+ return sum([target.quantity for target in self.target_sizes])
+
+ def n_combinations(self) -> int:
  """
- Compatibility function
+ Number of possible combinations of target sizes
  """
- # back to list again for compatibility
- return self.target_sizes
+ return int(factorial(self.n_targets()) / prod([factorial(n.quantity) for n in self.target_sizes]))
 
- def assert_valid(self):
+ @model_validator(mode='after')
+ def assert_valid(self) -> 'Job':
  if self.max_length <= 0:
  raise ValueError(f"Job has invalid max_length {self.max_length}")
  if self.cut_width < 0:
  raise ValueError(f"Job has invalid cut_width {self.cut_width}")
  if len(self.target_sizes) <= 0:
  raise ValueError("Job is missing target_sizes")
- if any(
- target.length > (self.max_length - self.cut_width)
- for target in self.target_sizes
- ):
+ if any(target.length > self.max_length for target in self.target_sizes):
  raise ValueError("Job has target sizes longer than the stock")
-
- def __len__(self) -> int:
- """
- Number of target sizes in job
- """
- return sum([target.quantity for target in self.target_sizes])
+ return self
 
  def __eq__(self, other):
  return (
- self.max_length == other.max_length
- and self.cut_width == other.cut_width
- and self.target_sizes == other.target_sizes
+  self.max_length == other.max_length
+  and self.cut_width == other.cut_width
+  and self.target_sizes == other.target_sizes
  )
 
  def __hash__(self) -> int:

app/solver/data/Result.py

@@ -1,7 +1,7 @@
 from enum import unique, Enum
-from typing import List, Tuple, Optional
+from typing import Optional, TypeAlias
 
-from pydantic import BaseModel
+from pydantic import BaseModel, PositiveInt, model_validator
 
 from app.solver.data.Job import Job
 
@@ -13,12 +13,15 @@ class SolverType(str, Enum): # str as base enables Pydantic-Schemas
  FFD = "FFD"
 
 
+ResultLength: TypeAlias = tuple[tuple[PositiveInt, str | None], ...]
+ResultLengths: TypeAlias = tuple[ResultLength, ...]
+
+
 class Result(BaseModel):
- # allow IDs to skip redundant transmission for future versions
  job: Job
  solver_type: SolverType
- time_us: Optional[int] = -1
- lengths: List[List[Tuple[int, str]]]
+ time_us: Optional[int] = None
+ lengths: ResultLengths
 
  # no trimmings as they can be inferred from difference to job
 
@@ -38,11 +41,11 @@ def exactly(self, other):
  and self.lengths == other.lengths
  )
 
+ @model_validator(mode='after')
  def assert_valid(self):
  self.job.assert_valid()
  if self.solver_type not in SolverType:
  raise ValueError(f"Result has invalid solver_type {self.solver_type}")
- if self.time_us < 0:
- raise ValueError(f"Result has invalid time_us {self.time_us}")
  if len(self.lengths) <= 0:
  raise ValueError("Result is missing lengths")
+ return self