feat: Rework variable and constraint format

Variables and constraints are now lists (technically sets) with a description
of each type. This is more flexible than the previous approach and allows
iterative refinement.

Author: olafmersmann

examples/demo.py

@@ -1,4 +1,4 @@
-from opltools import Suite, Problem, Library, Link, Variables, ValueRange
+from opltools import Suite, Problem, Library, Link, Variable, ValueRange
 from pydantic_yaml import to_yaml_str
 from opltools.schema import Implementation
 
@@ -10,24 +10,24 @@
     language="python",
     links=[
         Link(type="repository", url="https://github.com/numbbo/coco-experiment"),
-        Link(type="package", url="https://pypi.org/project/coco-experiment/")
+        Link(type="package", url="https://pypi.org/project/coco-experiment/"),
     ],
-    evaluation_time="sub second"
+    evaluation_time="sub second",
 )
 
 for fnr in range(1, 25):
     id = f"fn_bbob_f{fnr}"
     things[f"fn_bbob_f{fnr}"] = Problem(
         name=f"BBOB F_{fnr}",
         objectives={1},
-        variables=Variables(continuous=ValueRange(min=1, max=80)),
-        implementations=["impl_py_cocoex"]
+        variables={Variable(type="continuous", dim=ValueRange(min=1, max=80))},
+        implementations=["impl_py_cocoex"],
     )
 
 things["suite_bbob"] = Suite(
     name="BBOB",
     problems={f"fn_bbob_f{fnr}" for fnr in range(1, 25)},
-    implementations=["impl_py_cocoex"]
+    implementations=["impl_py_cocoex"],
 )
 
 library = Library(things)

pyproject.toml

@@ -16,6 +16,11 @@ dependencies = [
 [project.scripts]
 opl = "opltools.cli:main"
 
+[project.optional-dependencies]
+cli = [
+    "rich>=15.0.0",
+]
+
 [build-system]
 requires = ["uv_build>=0.11.7,<0.12.0"]
 build-backend = "uv_build"

src/opltools/__init__.py

@@ -1,4 +1,16 @@
-from .schema import Problem, Suite, Generator, Implementation, Library, YesNoSome, Link, Reference, Variables, ValueRange, Constraints
+from .schema import (
+    Problem,
+    Suite,
+    Generator,
+    Implementation,
+    Library,
+    YesNoSome,
+    Link,
+    Reference,
+    Variable,
+    ValueRange,
+    Constraint,
+)
 
 __all__ = [
     "Problem",
@@ -9,7 +21,7 @@
     "YesNoSome",
     "Link",
     "Reference",
-    "Constraints",
-    "Variables",
-    "ValueRange"
+    "Constraint",
+    "Variable",
+    "ValueRange",
 ]

src/opltools/cli.py

@@ -20,7 +20,9 @@ def cmd_validate(args):
         return 0
     except ValidationError as e:
         for error in e.errors():
-            loc = " -> ".join(str(p) for p in error["loc"]) if error["loc"] else "(root)"
+            loc = (
+                " -> ".join(str(p) for p in error["loc"]) if error["loc"] else "(root)"
+            )
             print(f"{args.file}: {loc}: {error['msg']}")
         return 1
 
@@ -29,7 +31,9 @@ def main():
     parser = argparse.ArgumentParser(prog="opl", description="OPL tools")
     subparsers = parser.add_subparsers(dest="command", required=True)
 
-    validate_parser = subparsers.add_parser("validate", help="Validate a YAML file against the Library schema")
+    validate_parser = subparsers.add_parser(
+        "validate", help="Validate a YAML file against the Library schema"
+    )
     validate_parser.add_argument("file", help="YAML file to validate")
 
     args = parser.parse_args()

src/opltools/schema.py

@@ -2,31 +2,28 @@
 from typing_extensions import Self
 from pydantic import BaseModel, RootModel, ConfigDict, model_validator
 
+from .yesnosome import YesNoSome
 from .utils import ValueRange, union_range
 
 
 class OPLType(Enum):
     problem = "problem"
     suite = "suite"
     generator = "generator"
-    implementation = 'implementation'
-
-
-class YesNoSome(Enum):
-    yes = "yes"
-    no = "no"
-    some = "some"
-    unknown = "?"
+    implementation = "implementation"
 
 
 class Link(BaseModel):
     type: str | None = None
     url: str
 
+    def __hash__(self):
+        return hash(self.type) + hash(self.url)
+
 
 class Thing(BaseModel):
     type: OPLType
-    model_config = ConfigDict(extra='allow')
+    model_config = ConfigDict(extra="allow")
 
 
 class Objectives(RootModel):
@@ -37,45 +34,64 @@ def union(self, other: Self) -> Self:
         return self
 
 
-class Variables(BaseModel):
-    continuous: int | set[int] | ValueRange = 0
-    integer: int | set[int] | ValueRange = 0
-    binary: int | set[int] | ValueRange = 0
-    categorical: int | set[int] | ValueRange = 0
+class VariableType(Enum):
+    continuous = "continuous"
+    integer = "integer"
+    binary = "binary"
+    categorical = "categorical"
+    unknown = "unknown"
 
-    def union(self, other: Self) -> Self:
-        self.continuous = union_range(self.continuous, other.continuous)
-        self.integer = union_range(self.integer, other.integer)
-        self.binary = union_range(self.integer, other.binary)
-        self.categorical = union_range(self.integer, other.categorical)
-        return self
 
+class Variable(BaseModel):
+    type: VariableType = VariableType.unknown
+    dim: int | set[int] | ValueRange | None = 0
 
-class Constraints(BaseModel):
-    box: int | set[int] | ValueRange = 0
-    linear: int | set[int] | ValueRange = 0
-    function: int | set[int] | ValueRange = 0
+    def __hash__(self):
+        if isinstance(self.dim, set):
+            dim_hash = hash(frozenset(self.dim))
+        else:
+            dim_hash = hash(self.dim)
+        return hash(self.type) + dim_hash
 
-    def union(self, other: Variables) -> Self:
-        self.box = union_range(self.box, other.box)
-        self.linear = union_range(self.linear, other.linear)
-        self.function = union_range(self.function, other.function)
-        return self
+
+class ConstraintType(Enum):
+    box = "box"
+    linear = "linear"
+    function = "function"
+    unknown = "unknown"
+
+
+class Constraint(BaseModel):
+    type: ConstraintType = ConstraintType.unknown
+    hard: YesNoSome | None = None
+    equality: YesNoSome | None = None
+    number: int | set[int] | ValueRange | None = None
+
+    def __hash__(self):
+        number = frozenset(self.number) if isinstance(self.number, set) else self.number
+        return hash((self.type, self.hard, self.equality, number))
 
 
 class Reference(BaseModel):
     title: str
     authors: list[str]
     link: Link | None = None
 
+    def __hash__(self):
+        return (
+            hash(self.title)
+            + sum([hash(author) for author in self.authors])
+            + hash(self.link)
+        )
+
 
 class Usage(BaseModel):
     language: str
     code: str
 
 
 class Implementation(Thing):
-    type: OPLType= OPLType.implementation
+    type: OPLType = OPLType.implementation
     name: str
     description: str
     links: list[Link] | None = None
@@ -92,9 +108,8 @@ class ProblemLike(Thing):
     references: set[Reference] | None = None
     implementations: set[str] | None = None
     objectives: set[int] | None = None
-    variables: Variables | None = None
-    constraints: Constraints | None = None
-    soft_constraints: Constraints | None = None
+    variables: set[Variable] | None = None
+    constraints: set[Constraint] | None = None
     dynamic_type: set[str] | None = None
     noise_type: set[str] | None = None
     allows_partial_evaluation: YesNoSome | None = None
@@ -104,59 +119,90 @@ class ProblemLike(Thing):
     code_examples: set[str] | None = None
     source: set[str] | None = None
 
+    def __hash__(self):
+        return hash((self.type, self.name))
+
 
 class Problem(ProblemLike):
-    type:OPLType = OPLType.problem
+    type: OPLType = OPLType.problem
     instances: ValueRange | list[str] | None = None
 
 
 class Suite(ProblemLike):
-    type:OPLType = OPLType.suite
+    type: OPLType = OPLType.suite
     problems: set[str] | None = None
 
 
 class Generator(ProblemLike):
-    type:OPLType = OPLType.generator
+    type: OPLType = OPLType.generator
 
 
 class Library(RootModel):
-    root: dict[str, Problem | Generator | Suite | Implementation] | None
+    root: dict[str, Problem | Generator | Suite | Implementation] = {}
 
-    def _check_id_references(self, ids, type:OPLType) -> None:
-        if not self.root:
-            return
+    def _check_id_references(self, ids, type: OPLType) -> None:
         for id in ids:
             if id in self.root:
                 if self.root[id].type != type:
-                    raise ValueError(f"ID {id} is a {self.root[id].name}, expected a {type.name}")
+                    raise ValueError(
+                        f"ID {id} is a {self.root[id].name}, expected a {type.name}"
+                    )
             else:
                 raise ValueError(f"Missing {type.name} with id '{id}'")
 
-    def _fixup_fidelity(self, suite: Suite) -> Suite:
+    # For a given suite, make sure the fidelty_levels property contains
+    # the fidelity_levels of all problems in the suite.
+    def _fixup_suite_fidelity(self, suite: Suite):
+        if suite.problems:
+            if not suite.fidelity_levels:
+                suite.fidelity_levels = set()
+            for pid in suite.problems:
+                problem = self.root[pid]
+                assert isinstance(problem, Problem)
+                if problem.fidelity_levels:
+                    suite.fidelity_levels.update(problem.fidelity_levels)
+
         return suite
 
-    @model_validator(mode="after")
-    def validate(self) -> Self:
-        if not self.root:
-            return self
+    def _fixup_suite_variables(self, suite: Suite):
+        if not suite.problems:
+            return
 
+        if suite.variables is None:
+            suite.variables = set()
+        for pid in suite.problems:
+            problem = self.root[pid]
+            assert isinstance(problem, Problem)
+            if problem.variables is not None:
+                suite.variables.update(problem.variables)
+
+    @model_validator(mode="after")
+    def _validate(self) -> Self:
         # Make sure all problems referenced in suites exists
         for id, thing in self.root.items():
             if isinstance(thing, Suite) and thing.problems:
                 for problem_id in thing.problems:
                     if problem_id not in self.root:
-                        raise ValueError(f"Suite {id} references problem with undefined id '{problem_id}'.")
+                        raise ValueError(
+                            f"Suite {id} references problem with undefined id '{problem_id}'."
+                        )
                     if self.root[problem_id].type != OPLType.problem:
-                        raise ValueError(f"Suite {id} references problem with id '{problem_id}' but id is a {self.root[problem_id].type.name}.")
+                        raise ValueError(
+                            f"Suite {id} references problem with id '{problem_id}' but id is a {self.root[problem_id].type.name}."
+                        )
+                self._fixup_suite_fidelity(thing)
         return self
 
+
 __all__ = [
-    "Problem",
-    "Suite",
+    "Constraint",
     "Generator",
     "Implementation",
     "Library",
-    "YesNoSome",
     "Link",
-    "Reference"
+    "Problem",
+    "Reference",
+    "Suite",
+    "Variable",
+    "YesNoSome",
 ]

src/opltools/utils.py

@@ -4,14 +4,17 @@
 
 class ValueRange(BaseModel):
     min: int | None
-    max: int | None
+    max: int | None = None
 
     @model_validator(mode="after")
     def _check(self) -> Self:
-        if not self.min and not self.max:
+        if self.min is None and self.max is None:
             raise ValueError("Variable range should have at least a min or max value.")
         return self
 
+    def __hash__(self):
+        return hash((self.min, self.max))
+
 
 def _none_min(a, b):
     if a and b:
@@ -32,13 +35,12 @@ def _none_max(a, b):
 
 
 def union_range(
-    a: int | set[int] | ValueRange,
-    b: int | set[int] | ValueRange
+    a: int | set[int] | ValueRange, b: int | set[int] | ValueRange
 ) -> int | set[int] | ValueRange:
     if isinstance(a, int):
-        a = { a }
+        a = {a}
     if isinstance(b, int):
-        b = { b }
+        b = {b}
 
     if isinstance(a, set) and isinstance(b, set):
         res = a.union(b)
@@ -55,7 +57,7 @@ def union_range(
                 res.min = min(v, res.min)
         if res.max:
             for v in b:
-                res.max = max(v, res.max)#
+                res.max = max(v, res.max)  #
         return res
 
     raise Exception("BAM")