PyAntiGen 2.0.2__tar.gz → 2.1.0__tar.gz

{pyantigen-2.0.2 → pyantigen-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 2.0.2
+Version: 2.1.0
 Summary: Declarative generation, simulation and identifiability analysis of compartmental Antimony/SBML models
 Author-email: Don Elbert <elbert5770@gmail.com>
 License-Expression: MIT

{pyantigen-2.0.2 → pyantigen-2.1.0}/PyAntiGen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 2.0.2
+Version: 2.1.0
 Summary: Declarative generation, simulation and identifiability analysis of compartmental Antimony/SBML models
 Author-email: Don Elbert <elbert5770@gmail.com>
 License-Expression: MIT

{pyantigen-2.0.2 → pyantigen-2.1.0}/PyAntiGen.egg-info/SOURCES.txt

@@ -32,8 +32,10 @@ pyantigen/engine/Event_times.py
 pyantigen/engine/Fast_profile.py
 pyantigen/engine/Fit_cache.py
 pyantigen/engine/Identifiability.py
+pyantigen/engine/Model_cache.py
 pyantigen/engine/Model_optimize.py
 pyantigen/engine/Model_simulate.py
+pyantigen/engine/Multistart.py
 pyantigen/engine/Nelder_mead.py
 pyantigen/engine/Noise_floor.py
 pyantigen/engine/Optimize.py

{pyantigen-2.0.2 → pyantigen-2.1.0}/PyAntiGen.egg-info/scm_file_list.json

@@ -24,8 +24,10 @@
     "pyantigen/engine/Fast_profile.py",
     "pyantigen/engine/Fit_cache.py",
     "pyantigen/engine/Identifiability.py",
+    "pyantigen/engine/Model_cache.py",
     "pyantigen/engine/Model_optimize.py",
     "pyantigen/engine/Model_simulate.py",
+    "pyantigen/engine/Multistart.py",
     "pyantigen/engine/Nelder_mead.py",
     "pyantigen/engine/Noise_floor.py",
     "pyantigen/engine/Optimize.py",
@@ -104,13 +106,20 @@
     "tests/engine/test_fast_profile.py",
     "tests/engine/test_fit_cache.py",
     "tests/engine/test_hessian_steps.py",
+    "tests/engine/test_model_cache.py",
+    "tests/engine/test_multistart_candidates.py",
+    "tests/engine/test_multistart_gradient.py",
+    "tests/engine/test_multistart_resume.py",
     "tests/engine/test_multistart_sampler.py",
+    "tests/engine/test_multistart_stage.py",
+    "tests/engine/test_multistart_triage.py",
     "tests/engine/test_nelder_mead.py",
     "tests/engine/test_point_identity.py",
     "tests/engine/test_profile_grid_open.py",
     "tests/engine/test_profile_quadratic.py",
     "tests/engine/test_profile_records.py",
     "tests/engine/test_profile_stream.py",
+    "tests/engine/test_results_csv_policy.py",
     "tests/engine/test_search_mode.py",
     "tests/engine/test_sigma_floor.py",
     "tests/engine/test_slice_screen.py",

pyantigen-2.1.0/PyAntiGen.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.1.0",
+  "distance": 0,
+  "node": "g664f039a120684d736966bef028ad1f83320d9bc",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-06"
+}

{pyantigen-2.0.2 → pyantigen-2.1.0}/pyantigen/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.0.2'
-__version_tuple__ = version_tuple = (2, 0, 2)
+__version__ = version = '2.1.0'
+__version_tuple__ = version_tuple = (2, 1, 0)
 
-__commit_id__ = commit_id = 'g6b1549beb'
+__commit_id__ = commit_id = 'g664f039a1'

{pyantigen-2.0.2 → pyantigen-2.1.0}/pyantigen/engine/Evaluator.py

@@ -239,14 +239,40 @@ def _worker_nll(x, frozen_sigmas=None):
     )
 
 
-def _eval_task(x, frozen_sigmas=None):
+def _eval_context(eval_mode):
+    """Context for one task: the solver limits an ``eval_mode`` asks for.
+
+    ``eval_mode`` is a plain dict so it pickles cheaply:
+
+        {"retry_limits": (max_attempts, max_depth), "relax": factor}
+
+    Applied around ONE task and undone after it, never at worker start-up: both
+    settings are process-global, and the same worker goes on to serve profile
+    points and diagnostics that must run exactly as configured. Absent or empty,
+    this does nothing.
+    """
+    from contextlib import ExitStack
+
+    stack = ExitStack()
+    if eval_mode:
+        from pyantigen.engine.Simulate import relaxed_tolerances, retry_limits
+        limits = eval_mode.get("retry_limits")
+        if limits:
+            stack.enter_context(retry_limits(limits[0], limits[1]))
+        if eval_mode.get("relax"):
+            stack.enter_context(relaxed_tolerances(eval_mode["relax"]))
+    return stack
+
+
+def _eval_task(x, frozen_sigmas=None, eval_mode=None):
     """Evaluate one parameter vector. Never raises across the pool boundary."""
     if _WORKER["spec"] is None:
         return (FAILURE_VALUE, "worker-not-initialized", 0.0)
 
     t0 = time.time()
     try:
-        val = _worker_nll(x, frozen_sigmas=frozen_sigmas)
+        with _eval_context(eval_mode):
+            val = _worker_nll(x, frozen_sigmas=frozen_sigmas)
         _WORKER["n_evals"] += 1
         status = "ok" if np.isfinite(val) and val < FAILURE_VALUE else "sentinel"
         return (float(val), status, time.time() - t0)
@@ -791,9 +817,12 @@ class ParallelEvaluator:
     # -- evaluation --------------------------------------------------------
 
     def evaluate_batch(self, xs, label=None, heartbeat_s=_HEARTBEAT_SECONDS,
-                       frozen_sigmas=None):
+                       frozen_sigmas=None, eval_mode=None):
         """Evaluate every parameter vector in *xs*; return losses in input order.
 
+        ``eval_mode`` ({"retry_limits": (attempts, depth), "relax": factor})
+        runs each evaluation under those solver limits; see :func:`_eval_context`.
+
         Uses submit/wait, not map -- see profile_batch's docstring for the
         general reasoning. map() (the previous implementation here) returns
         nothing until the WHOLE batch is done, so one slow straggler among
@@ -833,7 +862,7 @@ class ParallelEvaluator:
                   flush=True)
 
         try:
-            futures = {self._pool.submit(_eval_task, x, frozen_sigmas): i
+            futures = {self._pool.submit(_eval_task, x, frozen_sigmas, eval_mode): i
                       for i, x in enumerate(xs)}
         except RuntimeError as exc:
             if "bootstrapping phase" in str(exc):

{pyantigen-2.0.2 → pyantigen-2.1.0}/pyantigen/engine/Fit_cache.py

@@ -156,6 +156,13 @@ def fit_fingerprint(param_names, x0_lin, bounds_lin, scales, groups, model_text,
     for k in ("profile_method", "profile_optimizer_kwargs", "profile_grid",
               "profile_without_opt"):
         kwargs.pop(k, None)
+    # The multi-start stage decides where the fit starts, which matters only
+    # when there is more than one start. Dropped otherwise so that giving every
+    # spec a default stage does not invalidate the fits already cached.
+    if int(n_starts or 1) <= 1:
+        for k in ("multistart_method", "multistart_optimizer_kwargs",
+                  "multistart_limits", "multistart_triage", "multistart_gradient"):
+            kwargs.pop(k, None)
 
     key = {
             "format": _FORMAT,
@@ -175,8 +182,9 @@ def fit_fingerprint(param_names, x0_lin, bounds_lin, scales, groups, model_text,
             "data": data_hash,
     }
     # Left out at the default so fits cached before the sampler existed keep
-    # their hash; it matters only when n_starts > 1.
-    if (start_sampler or "lhs") != "lhs":
+    # their hash, and left out at one start, where nothing is sampled, so that
+    # a project-wide default of "sobol" does not invalidate single-start fits.
+    if int(n_starts or 1) > 1 and (start_sampler or "lhs") != "lhs":
         key["start_sampler"] = start_sampler
     blob = json.dumps(key, sort_keys=True, default=_json_default)
     fit_hash = hashlib.sha256(blob.encode("utf-8")).hexdigest()[:16]
@@ -379,6 +387,58 @@ class FitCache:
         data["complete"] = block
         return self._write(data)
 
+    def save_stage(self, state):
+        """Checkpoint of the multi-start stage in progress.
+
+        Written after every candidate scored and every local fit finished, so a
+        kill costs the evaluation or fit in flight and nothing before it. Kept
+        under its own key: the stage is not the fit, and the fit's partial must
+        not appear until the stage is over (see ``_persist_stage_result``). Must
+        already be plain JSON data.
+        """
+        if not self.enabled:
+            return False
+        data = self._read() or {}
+        data["multistart_stage"] = state
+        return self._write(data)
+
+    def load_stage(self):
+        """The stage checkpoint :meth:`save_stage` kept, or None."""
+        data = self._read()
+        block = data.get("multistart_stage") if data else None
+        return block if isinstance(block, dict) else None
+
+    def clear_stage(self):
+        """Drop the stage checkpoint, once the stage's result is on record."""
+        if not self.enabled:
+            return False
+        data = self._read()
+        if not data or "multistart_stage" not in data:
+            return False
+        data.pop("multistart_stage")
+        return self._write(data)
+
+    def save_multistart(self, report):
+        """Keep the multi-start stage's report with the fit it produced.
+
+        Stored beside the ``complete``/``partial`` records, not inside them, so it
+        survives both: a relaunch that resumes the standard fit skips the stage,
+        and one that reuses a finished fit skips both, yet the result written at
+        the end should still say how the starting point was found. *report* must
+        already be plain JSON data (see ``Multistart.json_safe``).
+        """
+        if not self.enabled:
+            return False
+        data = self._read() or {}
+        data["multistart"] = report
+        return self._write(data)
+
+    def load_multistart(self):
+        """The report :meth:`save_multistart` kept, or None."""
+        data = self._read()
+        block = data.get("multistart") if data else None
+        return block if isinstance(block, dict) else None
+
     def save_partial(self, x_lin, fun, n_evals=None, force=False, nm_state=None,
                      interval=None, de_state=None, cal_x_lin=None):
         """Record the best point so far, at most once per *interval*.

pyantigen-2.1.0/pyantigen/engine/Model_cache.py

@@ -0,0 +1,75 @@
+"""Per-model caches, stored on the RoadRunner instance without touching ``__getattr__``.
+
+The engine keeps a few values on each RoadRunner so they are computed once per
+model rather than once per evaluation (the state keys, the available symbols,
+the parameter baseline, the configured tolerance). The obvious way to read one
+back -- ``try: r._x`` / ``except AttributeError``, or ``getattr(r, "_x", None)`` --
+is a trap, because RoadRunner defines::
+
+    def __getattr__(self, name):
+        if name != "this" and name in self._getIds(SelectionRecord_ALL):
+            return self[name]
+        raise AttributeError(name)
+
+``__getattr__`` runs only after normal lookup has failed, so every *miss* builds
+the list of every selection id the model has, to learn that the name is not one
+of them. That list is roughly quadratic in model size: about a millisecond on a
+25-species model, over a second on 400 species, and on a model with ~9,000 ODEs
+~70 million ids, about 18 minutes and 16 GB per miss. A model pays it once per
+cache slot per instance, which is why small models never notice and a large one
+spends an hour before its first result.
+
+Reading through the instance ``__dict__`` never reaches ``__getattr__``, so a
+miss costs a dictionary lookup whatever the model size. Writing needs no care:
+RoadRunner defines no ``__setattr__``, so ``r._x = v`` is an ordinary
+instance-dict write.
+
+Use :func:`get` and :func:`put` for every engine-private attribute on a
+RoadRunner. ``tests/engine/test_model_cache.py`` fails if any of the engine's own
+cache reads causes a ``_getIds`` call.
+"""
+
+
+def _target(r):
+    """The object whose ``__dict__`` holds the caches.
+
+    ``OptRoadRunnerProxy`` wraps a RoadRunner in ``_r`` and forwards attribute
+    writes to it, so a cache written through the proxy lives on the RoadRunner.
+    Reading ``vars(proxy)`` would look in the proxy's own dict instead, which is
+    never where the value is.
+    """
+    try:
+        d = vars(r)
+    except TypeError:               # no __dict__ (slots, builtins): nothing cached
+        return None
+    inner = d.get("_r")
+    if inner is not None and "_opt_param_names" in d:
+        return inner
+    return r
+
+
+def get(r, name, default=None):
+    """The value cached on *r* under *name*, or *default*. Never calls ``__getattr__``."""
+    t = _target(r)
+    if t is None:
+        return default
+    try:
+        return vars(t).get(name, default)
+    except TypeError:
+        return default
+
+
+def put(r, name, value):
+    """Cache *value* on *r* under *name*. Returns whether it was stored.
+
+    A target that refuses attributes is tolerated, as the call sites always did:
+    the value is then recomputed next time instead of reused.
+    """
+    t = _target(r)
+    if t is None:
+        return False
+    try:
+        vars(t)[name] = value
+    except Exception:
+        return False
+    return True

{pyantigen-2.0.2 → pyantigen-2.1.0}/pyantigen/engine/Model_optimize.py

@@ -973,12 +973,20 @@ def _slice_dnll_at_optimum(param_vals, dnll, opt_val, rtol=1e-6):
     return float(y[i])
 
 
-def _save_likelihood_slice_plot(opt, param_names, plot_path, model_name, tag="ALL"):
-    """Run likelihood slice once per parameter and save plot."""
+def _save_likelihood_slice_plot(opt, param_names, plot_path, model_name, tag="ALL",
+                                slice_settings=None):
+    """Run likelihood slice once per parameter and save plot.
+
+    slice_settings is the spec's ``slice_settings`` ({"n_points", "range_factor"});
+    absent keys keep the values that used to be fixed here, 20 and 2.0.
+    """
     from datetime import datetime
     import numpy as np
     import matplotlib.pyplot as plt
 
+    n_points = int((slice_settings or {}).get("n_points", 20))
+    range_factor = float((slice_settings or {}).get("range_factor", 2.0))
+
     slice_func = opt.get("stats", {}).get("likelihood_slice")
     if not slice_func:
         print("Warning: no likelihood_slice closure in opt['stats'] — skipping plot.")
@@ -1004,7 +1012,7 @@ def _save_likelihood_slice_plot(opt, param_names, plot_path, model_name, tag="AL
     results = None
     if slice_all is not None:
         try:
-            results = slice_all(n_points=20, range_factor=2.0)
+            results = slice_all(n_points=n_points, range_factor=range_factor)
         except Exception as exc:
             print(f"  batched slice failed ({exc}); falling back per parameter.")
 
@@ -1014,7 +1022,7 @@ def _save_likelihood_slice_plot(opt, param_names, plot_path, model_name, tag="AL
             if results is not None and pname in results:
                 pv, nr = results[pname]
             else:
-                pv, nr = slice_func(i, n_points=20, range_factor=2.0)
+                pv, nr = slice_func(i, n_points=n_points, range_factor=range_factor)
             cache[i] = (pv, nr)
             slice_traces[pname] = {"x": np.asarray(pv).tolist(),
                                    "y": np.asarray(nr).tolist()}
@@ -1233,7 +1241,9 @@ def setup_optimization_from_groups(settings, optimization_settings, EXPERIMENT_d
 
         if settings.get("slice_analysis") and opt.get("stats", {}).get("likelihood_slice"):
             _save_likelihood_slice_plot(opt, optimization_settings.param_names, paths["plot_path"],
-                                        MODEL_NAME, tag=groups_tag)
+                                        MODEL_NAME, tag=groups_tag,
+                                        slice_settings=getattr(optimization_settings,
+                                                               "slice_settings", None))
         if (settings.get("profile_likelihood_analysis") or settings.get("fast_profile_likelihood_analysis")) and opt.get("stats", {}).get("profile_likelihood"):
             _save_profile_likelihood_plot(
                 opt, optimization_settings.param_names, paths["plot_path"],