solver-support 0.1.1__tar.gz → 0.2.1__tar.gz

{solver_support-0.1.1/solver_support.egg-info → solver_support-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solver-support
-Version: 0.1.1
+Version: 0.2.1
 Summary: Generic Conjure / Savile Row / Fast Downward / SymK / ENHSP / UPF solver pipeline
 Author: András Salamon
 License-Expression: BSD-3-Clause

{solver_support-0.1.1 → solver_support-0.2.1}/docs/timing-model.md

@@ -85,6 +85,45 @@ fields. All times are seconds unless noted.
 - **Best-effort**: a hard timeout can kill Savile Row before it writes `.info`,
   leaving the split absent (`None`).
 
+#### Backends
+
+Savile Row drives five backends, chosen by a solver config's `backend:` key and
+described by one row each in `CommandBuilderMixin.SAVILEROW_BACKENDS`. A config
+with no `backend:` key is the SAT arm, which is what every pre-existing config
+relies on. The row supplies three things that vary and nothing that does not; the
+arg-set key is *derived* as `<backend>_args`, so it needs no row.
+
+| `backend:` | arg-set key | solver's own time limit | binary flag |
+|---|---|---|---|
+| *(absent)* / `sat` | `sat_args` | `--time=N` (s) | `-satsolver-bin` |
+| `minion` | `minion_args` | *(none)* | `-minion-bin` |
+| `ortools` | `ortools_args` | `--time_limit=N` (s) | `-fzn-bin` |
+| `gecode` | `gecode_args` | `-time N` (**ms**) | `-gecode-bin` |
+| `chuffed` | `chuffed_args` | `--time-out N` (**ms**) | `-chuffed-bin` |
+
+Savile Row's own `-timelimit` is always added, always in seconds, and covers
+translation plus solving. The solver's limit is passed through `-solver-options`
+in addition, so the solver stops itself and reports rather than being killed with
+nothing to show. Repeated `-solver-options` accumulate, so a tune preset may
+carry its own without displacing the timeout.
+
+**The units are a trap.** Gecode and Chuffed take milliseconds and neither says
+so in its flag name. An unscaled value does not fail loudly — a 30s budget
+becomes 30ms and the solver gives up instantly, which reads as a hard instance.
+`timeout_scale` in the table is what converts; a config overriding
+`solver_timeout_option` changes the flag's *name* only, since the unit belongs to
+the solver rather than to the spelling.
+
+**Only the SAT arm records intermediate objectives.** It is the one configuration
+where Savile Row runs the optimisation loop itself; every other backend optimises
+internally, leaving nothing for `-record-intermediate-objective-values` to see.
+So for a non-SAT backend `_generate_objective_file_path` returns `None` and no
+`.obj` file is named or cleared, and `_check_continue_scan` falls back to the raw
+objective read out of the *solution* by the injected extractor. A consumer that
+wires only the objective-file route will find continue-scan stops at the first
+solving horizon on those backends instead of improving — wire
+`set_raw_objective_from_solution` to use them for optimisation models.
+
 ### Fast Downward / SymK (PDDL models)
 
 - **Shape**: not a horizon scan — one `solving` phase whose A\* (blind) / symbolic

{solver_support-0.1.1 → solver_support-0.2.1}/solver_support/__init__.py

@@ -13,7 +13,7 @@ unconfigured pipeline. A consumer registers its scoring (see :mod:`objective`)
 and its packaging paths (see :mod:`model_registry`) once at its own import time.
 """
 
-__version__ = "0.1.1"
+__version__ = "0.2.1"
 
 # --- model registry (loader + command builders + packaging injection) ---
 from .model_registry import (

{solver_support-0.1.1 → solver_support-0.2.1}/solver_support/command_builders.py

@@ -24,6 +24,84 @@ from .model_registry import ModelRegistryError
 class CommandBuilderMixin:
     """The ``build_*_command`` methods mixed into :class:`ModelRegistry`."""
 
+    #: The Savile Row backends, one row each. Everything the argv assembler needs
+    #: to know about a backend lives here, so adding one is a single entry plus
+    #: its ``<backend>_args`` presets in the config - not an edit spread across an
+    #: arg-set lookup, a binary flag and a timeout dialect. The arg-set key is
+    #: *derived* (``<backend>_args``) rather than tabulated, so it needs no row.
+    #:
+    #: ``sat`` is the implicit default: a config with no ``backend:`` key is the
+    #: kissat SAT backend every pre-existing config relies on.
+    #:
+    #: ``timeout_option`` is the *solver's own* time limit, handed to it through
+    #: Savile Row's ``-solver-options``; Savile Row's own ``-timelimit`` (covering
+    #: translation plus solving) is added for every backend regardless. Giving the
+    #: solver its own budget means it stops itself and reports, rather than being
+    #: killed with nothing to show.
+    #:
+    #: ``timeout_scale`` converts the seconds this API speaks into the unit that
+    #: solver expects. Gecode and Chuffed both want milliseconds and neither says
+    #: so in its flag name, which makes the mistake silent rather than loud: a 30s
+    #: budget passed unscaled becomes 30ms, and the solver gives up instantly
+    #: looking for all the world like a hard instance.
+    SAVILEROW_BACKENDS = {
+        'sat': {
+            'bin_option': '-satsolver-bin',
+            'timeout_option': '--time={value}',
+            'timeout_scale': 1,
+            # Savile Row drives the optimisation loop itself when the backend is a
+            # SAT solver, so it can record each improving objective as it goes.
+            # Every other backend optimises internally, leaving SR nothing to see.
+            'records_objectives': True,
+        },
+        'minion': {
+            'bin_option': '-minion-bin',
+            # Minion takes no time limit of its own here: -timelimit is enough.
+            'timeout_option': None,
+            'timeout_scale': 1,
+            'records_objectives': False,
+        },
+        'ortools': {
+            # SR calls OR-Tools through its "standard FlatZinc" route, so the
+            # generic -fzn-bin names the binary; Gecode and Chuffed have their own.
+            'bin_option': '-fzn-bin',
+            'timeout_option': '--time_limit={value}',  # an Abseil flag, seconds
+            'timeout_scale': 1,
+            'records_objectives': False,
+        },
+        'gecode': {
+            'bin_option': '-gecode-bin',
+            'timeout_option': '-time {value}',  # "time (in ms) cutoff"
+            'timeout_scale': 1000,
+            'records_objectives': False,
+        },
+        'chuffed': {
+            'bin_option': '-chuffed-bin',
+            # Named --time-out but documented "Time out in milliseconds".
+            'timeout_option': '--time-out {value}',
+            'timeout_scale': 1000,
+            'records_objectives': False,
+        },
+    }
+
+    def records_intermediate_objectives(self, solver_name: str) -> bool:
+        """Whether this solver's backend writes the intermediate-objective file.
+
+        True only for Savile Row's SAT arm, which is the one configuration where
+        Savile Row runs the optimisation loop and can report improving objectives
+        as it finds them. Callers use this to avoid naming (and clearing) a file
+        that will never be written; with no such file, continue-scan falls back to
+        the injected solution extractor. Resolves through
+        :meth:`get_tune_backend`, so the Conjure path answers for the kissat
+        solve it delegates to, and non-savilerow solvers answer False.
+        """
+        backend_solver = self.get_tune_backend(solver_name)
+        if self.get_solver_type(backend_solver) != 'savilerow':
+            return False
+        backend = self.get_solver_config(backend_solver).get('backend', 'sat')
+        spec = self.SAVILEROW_BACKENDS.get(backend)
+        return bool(spec and spec['records_objectives'])
+
     def build_savilerow_command(self, model_path: str, param_path: str,
                                use_srjava: bool = False,
                                timeout: Optional[int] = None,
@@ -46,31 +124,50 @@ class CommandBuilderMixin:
             objective_file_path: path for intermediate objective values file (default: obj.txt)
             extra_options: additional command line options to pass to Savile Row
             solver_name: name of the solver configuration to use (default: 'kissat').
-                The backend (kissat vs minion) is a property of this config:
-                a config with ``backend: minion`` uses its tune presets'
-                minion_args and Minion's timeout dialect, otherwise the kissat
-                SAT arg-set is used.
+                The backend is a property of this config, named by its
+                ``backend:`` key and described by ``SAVILEROW_BACKENDS``: it
+                selects the arg-set key, the solver's own timeout dialect, and
+                the flag that names its binary. No ``backend:`` key means the
+                kissat SAT backend, which is what every pre-existing config
+                relies on.
             tune: name of a ``tune:`` preset to apply instead of the config's
                 ``default_tune`` (kissat: 'safe'/'bare'/'srdefault'/'gac';
-                minion: 'bare'). The preset supplies this backend's arg-set
-                (sat_args for kissat, minion_args for minion). A name that is
-                unknown or lacks this backend's arg key falls back to
-                ``default_tune``. This is the savilerow arm of the same ``--tune``
-                dial fd uses for its search presets.
+                minion: 'bare'). The preset supplies this backend's arg-set,
+                under the key ``<backend>_args`` - sat_args, minion_args,
+                ortools_args, and so on. A name that is unknown or lacks this
+                backend's arg key falls back to ``default_tune``. This is the
+                savilerow arm of the same ``--tune`` dial fd uses for its search
+                presets.
 
         Returns:
             Complete command as list of strings.
 
         Raises:
-            ModelRegistryError: If savilerow solver not found in config, or the
-                resolved tune has no arg-set for this backend.
+            ModelRegistryError: If savilerow solver not found in config, if the
+                config names a backend that is not in ``SAVILEROW_BACKENDS``, or
+                if the resolved tune has no arg-set for this backend.
         """
         solver_config = self.get_solver_config(solver_name)
 
-        # The backend solver (kissat SAT vs Minion CP) is declared by the config,
-        # not passed in: `--solver minion` selects the minion backend config. This
-        # replaced the old cross-cutting `--minion` boolean.
-        use_minion = solver_config.get('backend') == 'minion'
+        # The backend solver is declared by the config, not passed in: `--solver
+        # minion` selects the minion backend config. This replaced the old
+        # cross-cutting `--minion` boolean. Absent means the kissat SAT backend,
+        # which is what every pre-existing config relies on.
+        #
+        # An unrecognised name is an error rather than a fallback. The lenient
+        # `_effective_tune` lookup below can afford to shrug at a typo because a
+        # wrong tune still runs the right solver; a typo'd backend would silently
+        # build the SAT arm's argv - a run that succeeds while comparing the wrong
+        # solver, which is worse than no run at all. Same reasoning as
+        # `is_valid_tune`, applied one level up.
+        backend = solver_config.get('backend', 'sat')
+        spec = self.SAVILEROW_BACKENDS.get(backend)
+        if spec is None:
+            known = ', '.join(sorted(self.SAVILEROW_BACKENDS))
+            raise ModelRegistryError(
+                f"Solver '{solver_name}' declares unknown backend '{backend}' "
+                f"(known backends: {known})"
+            )
 
         # Choose command variant
         if use_srjava:
@@ -90,12 +187,14 @@ class CommandBuilderMixin:
                     self._savilerow_native_warning_shown = True
                 command = solver_config['command']
 
-        # Choose the argument set from the active tune preset. kissat presets
-        # carry sat_args, minion presets carry minion_args; a tune that is
-        # unknown or lacks this backend's key falls back to default_tune (the
-        # lenient behaviour the fd builder uses too). The model-default tune is
-        # resolved by the caller, so `tune` here is already the effective name.
-        arg_key = 'minion_args' if use_minion else 'sat_args'
+        # Choose the argument set from the active tune preset. Each backend reads
+        # its own key, named after it: sat_args, minion_args, ortools_args, and so
+        # on. Deriving the name rather than tabulating it is what lets a new
+        # backend arrive without touching this line. A tune that is unknown or
+        # lacks this backend's key falls back to default_tune (the lenient
+        # behaviour the fd builder uses too). The model-default tune is resolved
+        # by the caller, so `tune` here is already the effective name.
+        arg_key = f'{backend}_args'
         tunes = solver_config.get('tune', {})
         tune_name = self._effective_tune(solver_config, tune, arg_key)
         preset = tunes.get(tune_name, {})
@@ -104,26 +203,41 @@ class CommandBuilderMixin:
                 f"Solver '{solver_name}' tune '{tune_name}' has no {arg_key}"
             )
         args = preset[arg_key].copy()
-        if not use_minion:
-            # Add objective recording arguments only when needed
-            if objective_file_path is not None:
-                args.extend(["-record-intermediate-objective-values", objective_file_path])
+        if spec['records_objectives'] and objective_file_path is not None:
+            # Only the SAT arm has intermediate objectives to record, because it
+            # is the only one where Savile Row runs the optimisation loop rather
+            # than the solver. Asking any other backend for them names a file that
+            # is never written.
+            args.extend(["-record-intermediate-objective-values", objective_file_path])
+
+        # Name the backend's binary only when the config pins one. Each backend
+        # has its own flag for this (-fzn-bin, -gecode-bin, -minion-bin, ...), and
+        # left unset Savile Row's default applies - so the registry never has to
+        # bake one machine's build into a shared config.
+        solver_bin = solver_config.get('solver_bin')
+        if solver_bin:
+            args.extend([spec['bin_option'], solver_bin])
 
         # Add timeout arguments
         if timeout is None:
             timeout = solver_config['default_timeout']
 
-        # Different timeout handling for minion vs SAT solver
         if timeout is not None:
-            if use_minion:
-                # For minion, just use -timelimit (no solver-options needed)
-                args.extend(["-timelimit", str(timeout)])
-            else:
-                # For SAT solver (kissat), use both -solver-options and -timelimit
-                args.extend([
-                    "-solver-options", f"--time={timeout}",
-                    "-timelimit", str(timeout)
-                ])
+            # The solver's own limit, in whatever flag and unit that solver
+            # speaks. A config may override the dialect (or set it to null to
+            # suppress it) without the core having to learn a new backend.
+            option = solver_config.get('solver_timeout_option', spec['timeout_option'])
+            if option:
+                scale = spec['timeout_scale']
+                # Left untouched when the solver already speaks seconds, so those
+                # argvs keep their exact previous form (--time=45, never 45.0).
+                value = timeout if scale == 1 else int(timeout * scale)
+                args.extend(["-solver-options", option.format(value=value)])
+            # Savile Row's own limit covers translation plus solving and is always
+            # in seconds. Always added, so a backend with no limit of its own is
+            # still bounded - and one that has its own stops itself and reports,
+            # rather than being killed with nothing to show.
+            args.extend(["-timelimit", str(timeout)])
 
         # Add extra options if provided
         if extra_options:

{solver_support-0.1.1 → solver_support-0.2.1}/solver_support/solver_horizon.py

@@ -32,8 +32,20 @@ class HorizonBasedSolver(Solver):
         self._stop_at_first = False  # regime: first stops the scan at the first solving horizon
         self.solver_name = solver_name  # the backend config (kissat/minion/...)
 
-    def _generate_objective_file_path(self, n: int) -> Path:
-        """Generate the objective file path for a given horizon."""
+    def _generate_objective_file_path(self, n: int) -> Optional[Path]:
+        """Generate the objective file path for a given horizon, or None.
+
+        None when the active backend does not write one. Only Savile Row's SAT
+        arm runs the optimisation loop that emits intermediate objectives, so for
+        a Minion or FlatZinc backend the file would be named, cleared, and then
+        never appear. Returning None here rather than gating each call site keeps
+        the three of them identical, and leaves continue-scan to read the
+        objective out of the solution via the injected extractor - which is the
+        only route those backends have.
+        """
+        if not global_state.model_registry.records_intermediate_objectives(
+                self.solver_name):
+            return None
         return ObjectiveFileManager.generate_objective_path(
             self.runner.summary.instance,
             self.runner.summary.solver,
@@ -43,8 +55,10 @@ class HorizonBasedSolver(Solver):
             tune=self.runner.summary.tune_slot
         )
 
-    def _prepare_objective_file(self, obj_file: Path) -> None:
+    def _prepare_objective_file(self, obj_file: Optional[Path]) -> None:
         """Prepare the objective file by removing any existing file."""
+        if obj_file is None:
+            return
         ObjectiveFileManager.prepare_objective_file(obj_file, self.logger)
 
     def _parse_objective_file(self, obj_file: Path) -> Optional[int]:

{solver_support-0.1.1 → solver_support-0.2.1/solver_support.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solver-support
-Version: 0.1.1
+Version: 0.2.1
 Summary: Generic Conjure / Savile Row / Fast Downward / SymK / ENHSP / UPF solver pipeline
 Author: András Salamon
 License-Expression: BSD-3-Clause

{solver_support-0.1.1 → solver_support-0.2.1}/solver_support.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ solver_support.egg-info/not-zip-safe
 solver_support.egg-info/requires.txt
 solver_support.egg-info/top_level.txt
 tests/conftest.py
+tests/test_command_builders.py
 tests/test_helpers.py
 tests/test_horizon_utils.py
 tests/test_import.py

solver_support-0.2.1/tests/fixtures/models.yaml

@@ -0,0 +1,205 @@
+# Synthetic model registry for the core's own tests.
+#
+# The core ships without a registry -- a consumer injects the path to its own
+# models.yaml (see docs/injection-api.md). Tests that reach the registry wire
+# THIS file instead, so the core is exercised against a config it owns rather
+# than against whichever consumer happens to be installed beside it. Keep it
+# minimal: add only what a test actually reads, and keep the shape faithful to a
+# real consumer config (that shape is the contract the loader and the accessors
+# implement).
+
+models:
+  # A constructed UPF model: built in Python, solved through the UPF driver.
+  upf:
+    path: upf.py
+    solver: upffd
+    detection_type: upf
+    format-name: upf
+    proves-unsat: true
+    description: constructed UPF model, solved by Fast Downward via UPF
+
+  # An optimisation model whose objective is recorded in the solution file, so
+  # the horizon scan compares objectives between horizons.
+  scored:
+    path: models/Scored.eprime
+    solver: kissat
+    detection_type: scored
+    format-name: compact
+    objective-in-solution: true
+    description: optimisation model carrying its objective in the solution
+
+solvers:
+  upffd:
+    # Fast Downward through the Unified Planning Framework. The engine and the
+    # FD search config are BOTH resolved from the effective --tune, which is
+    # what UpfPlanSolver turns into `-s <engine>` and `--fd-search <search>`.
+    solver_type: upfplan
+    command: upfplan
+    extensions:
+      - .pddl
+    default_timeout: 600
+    engine_name: fast-downward
+    default_tune: optimal
+    tune:
+      optimal:
+        fd_search: "astar(blind())"
+        description: cost-optimal blind A*
+      satisficing:
+        fd_search: "lazy_greedy([ff()])"
+        description: satisficing greedy best-first with FF
+
+  kissat:
+    solver_type: savilerow
+    command: savilerow
+    extensions:
+      - .eprime
+    default_timeout: 600
+    description: SAT backend driven through Savile Row
+
+  # The Savile Row backends, with tune presets, for the command builder tests.
+  # Separate from `kissat` above so that adding them cannot perturb the tests
+  # which rely on that entry having no presets.
+  #
+  # One entry per backend, plus two that pin a solver binary. Two, because the
+  # flag that names the binary differs per backend (-fzn-bin vs -gecode-bin), so
+  # a single pinned entry could not tell a per-backend flag apart from a
+  # hardcoded one.
+  srsat:
+    # No `backend:` key at all -- the shape every pre-existing SAT config has.
+    solver_type: savilerow
+    command: savilerow
+    extensions:
+      - .eprime
+    default_timeout: null
+    default_tune: default
+    tune:
+      default:
+        sat_args:
+          - "-run-solver"
+          - "-sat"
+        description: SAT backend
+
+  srminion:
+    solver_type: savilerow
+    command: savilerow
+    extensions:
+      - .eprime
+    default_timeout: null
+    backend: minion
+    default_tune: default
+    tune:
+      default:
+        minion_args:
+          - "-run-solver"
+        description: Minion backend
+
+  srortools:
+    solver_type: savilerow
+    command: savilerow
+    extensions:
+      - .eprime
+    default_timeout: null
+    backend: ortools
+    default_tune: default
+    tune:
+      default:
+        ortools_args:
+          - "-run-solver"
+          - "-or-tools"
+        description: OR-Tools CP-SAT backend
+
+  srgecode:
+    solver_type: savilerow
+    command: savilerow
+    extensions:
+      - .eprime
+    default_timeout: null
+    backend: gecode
+    default_tune: default
+    tune:
+      default:
+        gecode_args:
+          - "-run-solver"
+          - "-gecode"
+        description: Gecode FlatZinc backend
+
+  srchuffed:
+    solver_type: savilerow
+    command: savilerow
+    extensions:
+      - .eprime
+    default_timeout: null
+    backend: chuffed
+    default_tune: default
+    tune:
+      default:
+        chuffed_args:
+          - "-run-solver"
+          - "-chuffed"
+        description: Chuffed FlatZinc backend
+
+  srortoolsbin:
+    # Same as srortools, but pinning the solver binary by name.
+    solver_type: savilerow
+    command: savilerow
+    extensions:
+      - .eprime
+    default_timeout: null
+    backend: ortools
+    solver_bin: fzn-ortools
+    default_tune: default
+    tune:
+      default:
+        ortools_args:
+          - "-run-solver"
+          - "-or-tools"
+        description: OR-Tools CP-SAT backend, binary pinned
+
+  srgecodebin:
+    # The same pin on a different backend, which must reach a different flag.
+    # Also carries a timeout-dialect override, so one entry covers both config
+    # escape hatches: the flag name is the config's to change, while the unit
+    # stays the solver's (still milliseconds here).
+    solver_type: savilerow
+    command: savilerow
+    extensions:
+      - .eprime
+    default_timeout: null
+    backend: gecode
+    solver_bin: fzn-gecode-6
+    solver_timeout_option: "-overall-time {value}"
+    default_tune: default
+    tune:
+      default:
+        gecode_args:
+          - "-run-solver"
+          - "-gecode"
+        description: Gecode backend, binary pinned
+
+  srbadbackend:
+    # A wrong backend name: must be rejected, not silently run as SAT.
+    #
+    # `or-tools` rather than an obviously-mangled string, because this is the
+    # mistake someone would actually make: Savile Row's flag is `-or-tools`, so a
+    # config author copying the name out of the documentation writes the
+    # hyphenated form. A test that only rejects gibberish would not have caught
+    # the near-miss that matters.
+    solver_type: savilerow
+    command: savilerow
+    extensions:
+      - .eprime
+    default_timeout: null
+    backend: or-tools
+    default_tune: default
+    tune:
+      default:
+        # Carries sat_args too, which is what makes the silent-fallback failure
+        # possible at all: without them the mistake would surface as a missing
+        # arg-set rather than as a wrong-but-working command line.
+        sat_args:
+          - "-run-solver"
+          - "-sat"
+        ortools_args:
+          - "-run-solver"
+          - "-or-tools"
+        description: deliberately misspelled backend

solver_support-0.2.1/tests/test_command_builders.py

@@ -0,0 +1,203 @@
+"""Backend dispatch in ``build_savilerow_command``.
+
+Savile Row drives five backends: a SAT solver, Minion, and three FlatZinc solvers
+(OR-Tools CP-SAT, Gecode, Chuffed). Which one a config selects, which tune key
+holds its arguments, how its time limit is spelled and in what unit, and which
+flag names its binary all hang off one ``backend:`` key, so the dispatch is worth
+pinning in one place -- including the two backwards-compatibility properties a
+new backend could quietly break: a config with NO ``backend:`` key must still
+behave as the SAT backend, and Minion's argv must not move.
+
+The unit conversions are the reason several of these tests exist. Gecode and
+Chuffed both take their limit in milliseconds and neither says so in the flag
+name, so an unscaled value is not a crash but a solver that gives up in 30ms and
+reports the instance as hard.
+"""
+
+import pytest
+
+from solver_support.model_registry import ModelRegistry, ModelRegistryError
+
+MODEL = "model.eprime"
+PARAM = "instance.param"
+
+#: Every backend the builder knows, with the arg it is expected to emit.
+ALL_BACKENDS = [
+    ("srsat", "-sat"),
+    ("srminion", "-run-solver"),
+    ("srortools", "-or-tools"),
+    ("srgecode", "-gecode"),
+    ("srchuffed", "-chuffed"),
+]
+
+
+def build(registry, solver, **kwargs):
+    return registry.build_savilerow_command(MODEL, PARAM, solver_name=solver, **kwargs)
+
+
+def solver_options(cmd):
+    """The values of every ``-solver-options`` flag in a command."""
+    return [cmd[i + 1] for i, a in enumerate(cmd) if a == "-solver-options"]
+
+
+@pytest.fixture
+def registry(fixture_registry):
+    return ModelRegistry()
+
+
+class TestBackendArgSets:
+    """Each backend takes its arguments from its own ``<backend>_args`` key."""
+
+    @pytest.mark.parametrize("solver,expected", ALL_BACKENDS)
+    def test_backend_uses_its_own_arg_set(self, registry, solver, expected):
+        assert expected in build(registry, solver)
+
+    def test_sat_config_without_backend_key_still_uses_sat_args(self, registry):
+        # The regression that matters: every pre-existing SAT config omits
+        # `backend:` entirely, so the default must remain the SAT arm.
+        cmd = build(registry, "srsat")
+        assert "-sat" in cmd
+        assert "-or-tools" not in cmd
+
+    def test_minion_argv_unchanged(self, registry):
+        cmd = build(registry, "srminion")
+        assert cmd == ["savilerow", "-run-solver", MODEL, PARAM]
+
+    def test_missing_arg_set_for_backend_raises(self, registry):
+        # `kissat` in the fixture config has no tune presets at all.
+        with pytest.raises(ModelRegistryError, match="sat_args"):
+            build(registry, "kissat")
+
+
+class TestUnknownBackend:
+    """A misspelled backend is an error, not a quiet fallback to SAT."""
+
+    def test_unknown_backend_raises(self, registry):
+        # `srbadbackend` says `backend: or-tools` -- the hyphenated spelling of
+        # Savile Row's own flag, and so the near-miss a config author is most
+        # likely to write -- and carries sat_args, so the lenient path would have
+        # built a working SAT command line: a run that succeeds while measuring
+        # the wrong solver.
+        with pytest.raises(ModelRegistryError, match="unknown backend 'or-tools'"):
+            build(registry, "srbadbackend")
+
+    def test_error_lists_the_known_backends(self, registry):
+        with pytest.raises(ModelRegistryError, match="chuffed, gecode, minion"):
+            build(registry, "srbadbackend")
+
+
+class TestTimeoutDialects:
+    """Each backend spells its own time limit, in its own unit."""
+
+    def test_sat_takes_seconds(self, registry):
+        assert solver_options(build(registry, "srsat", timeout=45)) == ["--time=45"]
+
+    def test_ortools_takes_seconds(self, registry):
+        assert solver_options(build(registry, "srortools", timeout=45)) == [
+            "--time_limit=45"]
+
+    def test_gecode_takes_milliseconds(self, registry):
+        assert solver_options(build(registry, "srgecode", timeout=45)) == [
+            "-time 45000"]
+
+    def test_chuffed_takes_milliseconds(self, registry):
+        assert solver_options(build(registry, "srchuffed", timeout=45)) == [
+            "--time-out 45000"]
+
+    def test_minion_takes_no_solver_option(self, registry):
+        cmd = build(registry, "srminion", timeout=45)
+        assert solver_options(cmd) == []
+        assert cmd[cmd.index("-timelimit") + 1] == "45"
+
+    @pytest.mark.parametrize("solver,_", ALL_BACKENDS)
+    def test_savilerow_timelimit_is_always_seconds(self, registry, solver, _):
+        # SR's own -timelimit covers translation plus solving and never scales,
+        # whatever unit the backend solver happens to speak.
+        cmd = build(registry, solver, timeout=45)
+        assert cmd[cmd.index("-timelimit") + 1] == "45"
+
+    @pytest.mark.parametrize("solver,_", ALL_BACKENDS)
+    def test_no_timeout_emits_no_limit(self, registry, solver, _):
+        cmd = build(registry, solver)
+        assert "-timelimit" not in cmd
+        assert solver_options(cmd) == []
+
+    def test_config_may_override_the_dialect(self, registry):
+        # The flag name is the config's to change; the unit stays the solver's,
+        # so the override is still scaled to milliseconds.
+        assert solver_options(build(registry, "srgecodebin", timeout=45)) == [
+            "-overall-time 45000"]
+
+
+class TestObjectiveRecording:
+    """Intermediate-objective recording is a SAT facility."""
+
+    def test_sat_records_intermediate_objectives(self, registry):
+        cmd = build(registry, "srsat", objective_file_path="obj.txt")
+        assert "-record-intermediate-objective-values" in cmd
+        assert cmd[cmd.index("-record-intermediate-objective-values") + 1] == "obj.txt"
+
+    @pytest.mark.parametrize("solver", ["srminion", "srortools", "srgecode",
+                                        "srchuffed"])
+    def test_other_backends_do_not_record(self, registry, solver):
+        # They optimise internally, so Savile Row is not running the loop and has
+        # no intermediate values to see.
+        cmd = build(registry, solver, objective_file_path="obj.txt")
+        assert "-record-intermediate-objective-values" not in cmd
+
+    @pytest.mark.parametrize("solver,expected", [
+        ("srsat", True),
+        ("kissat", True),       # no `backend:` key -- still the SAT arm
+        ("srminion", False),
+        ("srortools", False),
+        ("srgecode", False),
+        ("srchuffed", False),
+        ("upffd", False),       # not a savilerow solver at all
+    ])
+    def test_records_intermediate_objectives_query(self, registry, solver, expected):
+        # The horizon loop asks this before naming an objective file, so that it
+        # does not name and clear a file the backend will never write.
+        assert registry.records_intermediate_objectives(solver) is expected
+
+
+class TestSolverBinary:
+    """The solver binary is named only when pinned, with that backend's flag."""
+
+    @pytest.mark.parametrize("solver,_", ALL_BACKENDS)
+    def test_omitted_when_unset(self, registry, solver, _):
+        # Leaving it to Savile Row's default keeps one machine's build out of a
+        # shared registry.
+        cmd = build(registry, solver)
+        assert not any(a.endswith("-bin") for a in cmd)
+
+    def test_ortools_uses_the_standard_flatzinc_flag(self, registry):
+        cmd = build(registry, "srortoolsbin")
+        assert cmd[cmd.index("-fzn-bin") + 1] == "fzn-ortools"
+
+    def test_gecode_uses_its_own_flag(self, registry):
+        # The point of the pair: a per-backend flag, not one hardcoded name.
+        cmd = build(registry, "srgecodebin")
+        assert "-fzn-bin" not in cmd
+        assert cmd[cmd.index("-gecode-bin") + 1] == "fzn-gecode-6"
+
+
+class TestBackendTable:
+    """The table is the single place a backend is described."""
+
+    def test_every_backend_is_fully_specified(self):
+        required = {"bin_option", "timeout_option", "timeout_scale",
+                    "records_objectives"}
+        for name, spec in ModelRegistry.SAVILEROW_BACKENDS.items():
+            assert set(spec) == required, name
+
+    def test_only_the_sat_arm_records_objectives(self):
+        recording = {n for n, s in ModelRegistry.SAVILEROW_BACKENDS.items()
+                     if s["records_objectives"]}
+        assert recording == {"sat"}
+
+
+@pytest.mark.parametrize("solver,_", ALL_BACKENDS)
+def test_model_and_param_come_last(registry, solver, _):
+    """Savile Row takes the model and param as trailing positionals."""
+    cmd = build(registry, solver, timeout=10, objective_file_path="obj.txt")
+    assert cmd[-2:] == [MODEL, PARAM]

solver_support-0.1.1/tests/fixtures/models.yaml

@@ -1,57 +0,0 @@
-# Synthetic model registry for the core's own tests.
-#
-# The core ships without a registry -- a consumer injects the path to its own
-# models.yaml (see docs/injection-api.md). Tests that reach the registry wire
-# THIS file instead, so the core is exercised against a config it owns rather
-# than against whichever consumer happens to be installed beside it. Keep it
-# minimal: add only what a test actually reads, and keep the shape faithful to a
-# real consumer config (that shape is the contract the loader and the accessors
-# implement).
-
-models:
-  # A constructed UPF model: built in Python, solved through the UPF driver.
-  upf:
-    path: upf.py
-    solver: upffd
-    detection_type: upf
-    format-name: upf
-    proves-unsat: true
-    description: constructed UPF model, solved by Fast Downward via UPF
-
-  # An optimisation model whose objective is recorded in the solution file, so
-  # the horizon scan compares objectives between horizons.
-  scored:
-    path: models/Scored.eprime
-    solver: kissat
-    detection_type: scored
-    format-name: compact
-    objective-in-solution: true
-    description: optimisation model carrying its objective in the solution
-
-solvers:
-  upffd:
-    # Fast Downward through the Unified Planning Framework. The engine and the
-    # FD search config are BOTH resolved from the effective --tune, which is
-    # what UpfPlanSolver turns into `-s <engine>` and `--fd-search <search>`.
-    solver_type: upfplan
-    command: upfplan
-    extensions:
-      - .pddl
-    default_timeout: 600
-    engine_name: fast-downward
-    default_tune: optimal
-    tune:
-      optimal:
-        fd_search: "astar(blind())"
-        description: cost-optimal blind A*
-      satisficing:
-        fd_search: "lazy_greedy([ff()])"
-        description: satisficing greedy best-first with FF
-
-  kissat:
-    solver_type: savilerow
-    command: savilerow
-    extensions:
-      - .eprime
-    default_timeout: 600
-    description: SAT backend driven through Savile Row