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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solver-support
-Version: 0.1.1
+Version: 0.2.2
 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.2}/docs/timing-model.md

@@ -76,15 +76,76 @@ fields. All times are seconds unless noted.
   `solver_time`, attaching them to the matching phase. Recorded for *every*
   horizon, so intermediate UNSAT horizons carry the split too.
 - **The rest of the file**: those two are what the phase model needs, but the
-  same `.info` carries the encoding size and search counters (`SATVars`,
-  `SATClauses`, `SolverNodes`, `SolverSatisfiable`, ...).
-  `SolverStatsExtractor.extract_savilerow_info(path)` returns every `Key:Value`
-  pair with keys verbatim and values coerced to int/float, for a consumer
-  reporting those columns; `extract_savilerow_info_times` is the renaming subset
-  of it that the core itself uses.
+  same `.info` carries the encoding size, the search counters, and the outcome
+  flags. All of it is recorded verbatim on the phase under
+  `solver_stats['savilerow_info']`, so a consumer never has to go back to the
+  `.info` files — which matters because that would depend on the run's output
+  directory rather than its summary, and so stops working once those files are
+  cleaned up. `SolverStatsExtractor.extract_savilerow_info(path)` is the parser
+  (keys verbatim, values coerced to int/float, `{}` for a missing file);
+  `extract_savilerow_info_times` is the renaming subset that produces the two
+  fields above.
+- **Nested, not flattened, and deliberately not curated.** `solver_stats` is the
+  core's normalised cross-solver vocabulary; `savilerow_info` is one solver's own
+  keys in its own spelling, so nesting keeps CamelCase off the snake_case
+  namespace. It is verbatim because the backends do not agree on which keys
+  exist — measured on one model:
+
+  | key | minion | ortools | gecode | chuffed | kissat |
+  |---|:-:|:-:|:-:|:-:|:-:|
+  | `SavileRowTotalTime` `SolverTotalTime` `SolverSatisfiable` `SolverTimeOut` `SavileRowTimeOut` `SavileRowClauseOut` | ✓ | ✓ | ✓ | ✓ | ✓ |
+  | `SolverNodes` | ✓ | — | ✓ | ✓ | ✓ |
+  | `SolverFailures` `SolverTotalWallTime` | — | ✓ | ✓ | ✓ | — |
+  | `SolverSetupTime` `SolverSolveTime` `SolverSolutionsFound` | ✓ | — | — | — | — |
+  | `SATVars` `SATClauses` `SolverMemOut` | — | — | — | — | ✓ |
+
+  Any allow-list would already be wrong, and would need extending for every new
+  backend or Savile Row version. Note `SolverSatisfiable` is one of the six every
+  backend emits: it distinguishes a **refuted horizon** from one that gave up —
+  which is *not* problem-level unsat, since a bounded model cannot prove that
+  (see `hlim`, above).
 - **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.2}/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.2"
 
 # --- model registry (loader + command builders + packaging injection) ---
 from .model_registry import (

{solver_support-0.1.1 → solver_support-0.2.2}/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.2}/solver_support/model_registry.py

@@ -9,6 +9,7 @@ from the original bash run script.
 
 from pathlib import Path
 from typing import Dict, Any, Optional, List, Tuple, Callable
+import copy
 import shutil
 import yaml
 
@@ -95,8 +96,14 @@ class ModelRegistry(CommandBuilderMixin):
         
         self.config = {'models': {}, 'solvers': {}}
         self._savilerow_native_warning_shown = False  # Track if we've shown the warning
+        # Every file merged in, in the order merged, so a caller can report what
+        # actually contributed. Without this the answer is only reconstructible
+        # by re-running the same two searches by hand - and the user-override one
+        # depends on the cwd at construction time, so it is not reproducible
+        # later. See `dump_config`.
+        self.config_sources: List[Path] = []
         self._load_yaml_config(default_yaml)
-        
+
         # Then, load user configuration to override defaults
         user_yaml = config_path or self._find_user_yaml_config()
         if user_yaml:
@@ -145,10 +152,11 @@ class ModelRegistry(CommandBuilderMixin):
         try:
             with open(config_path, 'r') as f:
                 user_config = yaml.safe_load(f)
-            
+
             # Deep merge user config with existing config
             self._deep_merge(self.config, user_config)
-            
+            self.config_sources.append(Path(str(config_path)))
+
         except Exception as e:
             raise ModelRegistryError(f"Failed to load config file {config_path}: {e}")
     
@@ -165,7 +173,76 @@ class ModelRegistry(CommandBuilderMixin):
                 self._deep_merge(base[key], value)
             else:
                 base[key] = value
-    
+
+    def effective_config(self, resolved: bool = False) -> Dict[str, Any]:
+        """The configuration actually in force, as a plain dict.
+
+        A deep copy of the merge of every file in ``config_sources``: the
+        consumer's bundled config first, then any user override merged over it.
+        Answering "what is in force?" otherwise means reading both files and
+        performing the merge by eye - and the override's location depends on the
+        working directory at construction time, so it cannot reliably be
+        reconstructed afterwards.
+
+        With ``resolved``, values a *builder* supplies when a key is absent are
+        written out explicitly - currently a savilerow solver's implicit
+        ``backend: sat``, the one default whose absence changes which arg-set,
+        timeout dialect and binary flag are used. Only real config keys are ever
+        added, so a resolved dump still loads; see :meth:`dump_config` for why
+        loading one back is not what it is for.
+
+        The copy is deep, so a caller may edit the result without disturbing the
+        live registry.
+        """
+        config = copy.deepcopy(self.config)
+        if resolved:
+            for solver_config in config.get('solvers', {}).values():
+                if (isinstance(solver_config, dict)
+                        and solver_config.get('solver_type') == 'savilerow'):
+                    solver_config.setdefault('backend', 'sat')
+        return config
+
+    def dump_config(self, resolved: bool = False, header: bool = True) -> str:
+        """The effective configuration as YAML text, for inspection.
+
+        Intended for a consumer's ``--show-registry``-style flag: it answers what
+        the registry resolved to and which files contributed. It is deliberately
+        *not* a config generator. Two reasons, both stated in the emitted header:
+
+        - Comments are not preserved. A config's comments carry the reasoning for
+          its arg-sets and timeouts, and a YAML round-trip drops all of them, so
+          the dump is a view of the configuration rather than a replacement.
+        - Overrides are deep-merged, so adopting a full dump as a user config
+          pins every key at today's value and silently shadows later changes to
+          the bundled config. A partial override is the supported shape: copy
+          only the keys being changed.
+        """
+        text = yaml.safe_dump(self.effective_config(resolved=resolved),
+                              sort_keys=False, default_flow_style=False,
+                              allow_unicode=True)
+        if not header:
+            return text
+
+        lines = ["# Effective solver-support registry, merged in this order:"]
+        lines.extend(f"#   {i}. {source}"
+                     for i, source in enumerate(self.config_sources, start=1))
+        if not self.config_sources:
+            lines.append("#   (none)")
+        if resolved:
+            lines.append("#")
+            lines.append("# Defaults a builder would supply are written out "
+                         "explicitly here.")
+        lines.extend([
+            "#",
+            "# For reading, not for adopting wholesale. Comments in the source",
+            "# files are not preserved, and overrides are deep-merged - so using",
+            "# this whole file as an override would pin every key at today's",
+            "# value and silently shadow later changes. Copy only what you mean",
+            "# to change.",
+            "",
+        ])
+        return "\n".join(lines) + "\n" + text
+
     def get_model_path(self, model_type: str) -> Path:
         """
         Get the file path for a model type.

{solver_support-0.1.1 → solver_support-0.2.2}/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]:
@@ -213,11 +227,31 @@ class HorizonBasedSolver(Solver):
                 self.runner.summary.phases[-1].solver_stats['objbound'] = self._best_objective
 
     def _record_savilerow_times(self, param_file: Path, n: int) -> None:
-        """Attach Savile Row's tailoring/solver time split to horizon n's phase.
+        """Attach Savile Row's ``.info`` stats to horizon n's phase.
 
         Reads the ``<param_file>.info`` stats file Savile Row writes for this
         horizon and records ``savilerow_time`` (tailoring) and ``solver_time``
         on the phase, alongside the wall-clock ``duration`` already stored.
+
+        The whole file is also kept verbatim under ``savilerow_info``. The two
+        renamed times are what the phase model needs, but the same file carries
+        the encoding-size and search-effort numbers (``SATVars``, ``SolverNodes``,
+        ``SolverFailures``, ...) and the outcome flags (``SolverSatisfiable``
+        distinguishes a refuted horizon from one that gave up; ``SolverTimeOut``
+        / ``SavileRowTimeOut`` attribute a timeout to the solver or to
+        tailoring). Without this a consumer wanting any of them has to re-parse
+        the ``.info`` files itself, which duplicates the parser and needs the
+        run's output directory rather than just its summary - so it stops working
+        once those files are cleaned up.
+
+        Kept **nested and verbatim** rather than flattened in. ``solver_stats``
+        is the core's normalised, cross-solver vocabulary; these are one solver's
+        own keys in its own spelling, and the backends do not even agree on which
+        of them exist - Minion alone emits ``SolverSetupTime`` /
+        ``SolverSolveTime`` / ``SolverSolutionsFound``, the FlatZinc backends
+        alone ``SolverTotalWallTime``, kissat alone ``SATVars`` / ``SATClauses``.
+        A curated allow-list would therefore be wrong already, and nesting also
+        keeps CamelCase keys from colliding with the snake_case ones beside them.
         ``param_file`` is whatever parameter file Savile Row was run on - the
         Essence Prime ``.param`` for the direct Savile Row path, or the
         Conjure-translated ``.eprime-param`` for the Essence path - since Savile
@@ -228,12 +262,15 @@ class HorizonBasedSolver(Solver):
         the matching ``solving-horizon-{n}`` phase so it cannot scribble on an
         unrelated phase.
         """
+        info = SolverStatsExtractor.extract_savilerow_info(f"{param_file}.info")
         times = SolverStatsExtractor.extract_savilerow_info_times(f"{param_file}.info")
-        if not times:
+        if not times and not info:
             return
         phases = self.runner.summary.phases
         if phases and phases[-1].name == f"solving-horizon-{n}":
             phases[-1].solver_stats.update(times)
+            if info:
+                phases[-1].solver_stats['savilerow_info'] = info
 
     def _build_savilerow_command(self, model_path: str, param_path: str, timeout: Optional[int], obj_file: Optional[Path] = None) -> List[str]:
         """

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solver-support
-Version: 0.1.1
+Version: 0.2.2
 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.2}/solver_support.egg-info/SOURCES.txt

@@ -28,11 +28,14 @@ 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
+tests/test_registry_dump.py
 tests/test_run_summary.py
 tests/test_run_summary_success.py
+tests/test_savilerow_info_recording.py
 tests/test_solution_naming.py
 tests/test_solver_runner.py
 tests/test_solver_stats.py