PyAntiGen 2.1.0__tar.gz → 2.1.2__tar.gz

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

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

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

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

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

@@ -45,8 +45,10 @@ pyantigen/engine/Profile_checkpoint.py
 pyantigen/engine/Profile_plan.py
 pyantigen/engine/README.md
 pyantigen/engine/Results.py
+pyantigen/engine/Segmented.py
 pyantigen/engine/Sensitivity_analysis.py
 pyantigen/engine/Simulate.py
+pyantigen/engine/Stop_rules.py
 pyantigen/engine/__init__.py
 pyantigen/generate/AntimonyGen.py
 pyantigen/generate/RxnDict_to_antimony.py
@@ -54,6 +56,7 @@ pyantigen/generate/TelluriumGen.py
 pyantigen/generate/__init__.py
 pyantigen/generate/antimony_utils.py
 pyantigen/generate/data_interpolation.py
+pyantigen/generate/input_schedule.py
 pyantigen/generate/isotopomer_tools.py
 pyantigen/generate/model_generation.py
 pyantigen/generate/models.py

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

@@ -37,8 +37,10 @@
     "pyantigen/engine/Profile_plan.py",
     "pyantigen/engine/README.md",
     "pyantigen/engine/Results.py",
+    "pyantigen/engine/Segmented.py",
     "pyantigen/engine/Sensitivity_analysis.py",
     "pyantigen/engine/Simulate.py",
+    "pyantigen/engine/Stop_rules.py",
     "pyantigen/engine/__init__.py",
     "pyantigen/generate/AntimonyGen.py",
     "pyantigen/generate/RxnDict_to_antimony.py",
@@ -46,6 +48,7 @@
     "pyantigen/generate/__init__.py",
     "pyantigen/generate/antimony_utils.py",
     "pyantigen/generate/data_interpolation.py",
+    "pyantigen/generate/input_schedule.py",
     "pyantigen/generate/isotopomer_tools.py",
     "pyantigen/generate/model_generation.py",
     "pyantigen/generate/models.py",
@@ -121,14 +124,18 @@
     "tests/engine/test_profile_stream.py",
     "tests/engine/test_results_csv_policy.py",
     "tests/engine/test_search_mode.py",
+    "tests/engine/test_segment_sensitivity.py",
+    "tests/engine/test_segmented.py",
     "tests/engine/test_sigma_floor.py",
     "tests/engine/test_slice_screen.py",
     "tests/engine/test_slice_window.py",
     "tests/engine/test_solver_fingerprint.py",
+    "tests/engine/test_stop_rules.py",
     "tests/engine/test_tolerance_floor.py",
     "tests/engine/test_wald_units.py",
     "tests/generate/test_gen_antimony_utils.py",
     "tests/generate/test_gen_data_interpolation.py",
+    "tests/generate/test_gen_input_schedule.py",
     "tests/generate/test_gen_models.py",
     "tests/generate/test_gen_pyantigen_api.py",
     "tests/generate/test_gen_rxndict_to_antimony.py",

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

@@ -0,0 +1,8 @@
+{
+  "tag": "2.1.2",
+  "distance": 0,
+  "node": "g6b3300aa1e0f55f4d35c0849df65cfa2bbbd8183",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-11"
+}

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

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

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

@@ -353,6 +353,11 @@ def _profile_task(job):
     out.pop("frozen_sigmas", None)
     # A location on this machine's disk, meaningless in a stored record.
     out.pop("state_path", None)
+    # An input as well: the settings for the shadow stop rules. What they
+    # observed comes back as `trace`, `shadow_stops` and `stop_reason` below;
+    # `trace` and `shadow_stops` are also inputs when a point is resumed, and
+    # are overwritten with the continued history.
+    stop_rules = out.pop("stop_rules", None)
     out.update({"nll": None, "status": "ok", "n_evals": 0, "wall_s": 0.0,
                 "worker": os.getpid(), "converged": True, "nit": -1,
                 "nfev": -1, "opt_message": "", "interrupted": False})
@@ -384,6 +389,12 @@ def _profile_task(job):
         # because a point stopped before its first simplex is complete has no
         # sorted vertex to read it from.
         best = {"f": float("inf"), "x": x_start}
+        # The shadow stop rules' watcher (pyantigen.engine.Stop_rules). It only
+        # observes -- nothing it computes feeds back into the optimizer -- and
+        # is None unless the job asked for it. `base` is the point's evaluation
+        # count when this job began, so a resumed point numbers on from where
+        # it stopped.
+        shadow = {"mon": None, "base": 0}
 
         # Every profile point pins each floored block at its own sigma_used
         # from the fit rather than letting it re-concentrate (see
@@ -404,6 +415,12 @@ def _profile_task(job):
             if np.isfinite(v) and v < best["f"]:
                 best["f"] = float(v)
                 best["x"] = x_arr.copy()
+            if shadow["mon"] is not None:
+                try:
+                    shadow["mon"].update(shadow["base"] + eval_count["n"],
+                                         best["f"])
+                except Exception:       # a watcher must never fail a point
+                    shadow["mon"] = None
             return v
 
         def time_is_up():
@@ -419,7 +436,8 @@ def _profile_task(job):
             # is just the objective at the fixed value -- exact by definition.
             nll = raw_objective(x_start, x_fixed)
             x_opt = x_start
-            out.update({"converged": True, "nit": 0, "nfev": 1})
+            out.update({"converged": True, "nit": 0, "nfev": 1,
+                        "stop_reason": "exact"})
             eval_count["n"] = 1
         else:
             options, extra_kwargs = nuisance_options(
@@ -429,6 +447,19 @@ def _profile_task(job):
             resumable = str(method).lower() == "nelder-mead" and can_run(
                 options, extra_kwargs)
 
+            def start_shadow(base):
+                if not stop_rules or stop_rules.get("anchor") is None:
+                    return
+                try:
+                    from pyantigen.engine.Stop_rules import PointMonitor
+                    shadow["mon"] = PointMonitor(
+                        stop_rules["anchor"], max_fev, x_start.size,
+                        cfg=stop_rules, trace=job.get("trace"),
+                        fired=job.get("shadow_stops"))
+                    shadow["base"] = int(base)
+                except Exception:       # a watcher must never fail a point
+                    shadow["mon"] = None
+
             res = None
             outcome = "done"
             if resumable:
@@ -457,6 +488,7 @@ def _profile_task(job):
                     # run, and nothing to save either.
                     outcome = "capped"
                 else:
+                    start_shadow(nm_state["nfev"])
                     interval = float(job.get("state_interval_s",
                                              POINT_STATE_INTERVAL_S))
                     last_save = [0.0]
@@ -490,6 +522,8 @@ def _profile_task(job):
                 if nfev_used >= max_fev or nit_used >= max_it:
                     outcome = "capped"
                 else:
+                    start_shadow(nfev_used)
+
                     def guarded(x_nuisance, fixed_val):
                         v = nuisance_objective(x_nuisance, fixed_val)
                         if time_is_up():
@@ -549,6 +583,20 @@ def _profile_task(job):
                 out["nm_simplex"] = np.asarray(nm_state["sim"],
                                                dtype=float).tolist()
 
+            # Why this job's optimization ended, for reading a finished run:
+            # `converged` alone cannot tell a point that met its tolerance from
+            # one that spent its cap and happened to be at the minimum, and at
+            # a 1500 cap most points are the second kind.
+            if outcome == "interrupted":
+                out["stop_reason"] = "interrupted"
+            elif res is None or not np.isfinite(getattr(res, "fun", np.inf)):
+                out["stop_reason"] = "budget-spent"
+            elif outcome == "capped" or not getattr(res, "success", True):
+                out["stop_reason"] = ("maxiter" if getattr(res, "status", None) == 2
+                                      else "maxfev")
+            else:
+                out["stop_reason"] = "tolerance"
+
         if nm_state is not None:
             nfev_total, nit_total = nm_state["nfev"], nm_state["nit"]
         else:
@@ -565,6 +613,11 @@ def _profile_task(job):
             "nit_total": nit_total,
             "status": "ok" if np.isfinite(nll) and nll < FAILURE_VALUE else "sentinel",
         })
+        if shadow["mon"] is not None:
+            try:
+                out.update(shadow["mon"].finish(nfev_total, best["f"]))
+            except Exception:
+                pass
     except Exception as exc:
         out.update({"status": f"error: {type(exc).__name__}: {exc}",
                     "nll": FAILURE_VALUE, "interrupted": False})

{pyantigen-2.1.0 → pyantigen-2.1.2}/pyantigen/engine/Optimize.py

@@ -5166,7 +5166,8 @@ def _carry_resume_state(keep, res):
     allowance never advancing and its optimizer state never moving.
     """
     for field in ("interrupted", "converged", "nfev_total", "nit_total",
-                  "nm_simplex", "opt_message"):
+                  "nm_simplex", "opt_message", "stop_reason", "trace",
+                  "shadow_stops"):
         if field in res:
             keep[field] = res[field]
     return keep
@@ -5233,10 +5234,17 @@ def run_parallel_profile(
     max_extend=8, extend_growth=2.0, bracket_rtol=0.05,
     screen=None, open_decades=None, grid_spacing="linear",
     adaptive_pass1=False, max_step_decades=0.7, n_workers=None,
-    first_probe="max",
+    first_probe="max", shadow_stop_rules=True,
 ):
     """Profile likelihood for every parameter as parallel batches.
 
+    *shadow_stop_rules* attaches a watcher to every point (see
+    :mod:`pyantigen.engine.Stop_rules`): a sparse trace of the best value reached
+    and the evaluation at which each candidate stop rule would first have
+    fired, written into the record, and summarised at the end of the run. It
+    never stops anything. ``False`` turns it off; a dict overrides the rule
+    constants.
+
     Five passes:
       1. coarse grid, cold-started from the optimum, fully parallel;
       2. outward extension: any side whose points all sit below the threshold
@@ -5369,6 +5377,15 @@ def run_parallel_profile(
             # this one's travel into a rate. See _predicted_travel.
             "x_step": x_step,
         }
+        if shadow_stop_rules:
+            cfg = dict(shadow_stop_rules) if isinstance(shadow_stop_rules, dict) else {}
+            cfg.setdefault("threshold", float(threshold))
+            cfg["anchor"] = float(nll_at_optimum)
+            job["stop_rules"] = cfg
+            if resume_from is not None:
+                # One history across launches of the same point.
+                job["trace"] = resume_from.get("trace")
+                job["shadow_stops"] = resume_from.get("shadow_stops")
         # Every job carries an explicit starting simplex, from its neighbour
         # where there is one and from the Wald SE otherwise. Leaving it to
         # scipy is what the two constructors exist to avoid: its 5%-of-value
@@ -5466,6 +5483,14 @@ def run_parallel_profile(
         key = ProfileCheckpointKey(res["x_fixed"])
         prev = completed.get(name, {}).get(key)
         keep = res
+        # A planner restart (see Profile_plan) that ran to its end is counted on
+        # the point, so a relaunch does not restart it again: the planner reads
+        # the count to decide whether a value past the threshold can be trusted.
+        finished_rerun = (str(res.get("pass_label", "")).endswith("rerun")
+                          and res.get("status") == "ok"
+                          and not res.get("interrupted"))
+        if prev is not None and finished_rerun:
+            res["reruns_tried"] = int(prev.get("reruns_tried") or 0) + 1
         # Two evaluations at the same fixed value are both upper bounds on the
         # profile, so the lower one is the better estimate. Nothing in passes 1,
         # 2 or 4 re-visits a point, but keeping the rule here means the store
@@ -5477,8 +5502,17 @@ def run_parallel_profile(
             # Dropping it would resume the point forever against a budget that
             # never moves.
             if not (prev.get("interrupted") and res.get("status") == "ok"):
-                return
-            keep = _carry_resume_state(dict(prev), res)
+                if not finished_rerun:
+                    return
+                # A restart that did not lower the point: the value stands, but
+                # the point has had its restart. Written as a tie, which the
+                # store resolves to the later record.
+                keep = dict(prev)
+                keep["reruns_tried"] = res["reruns_tried"]
+            else:
+                keep = _carry_resume_state(dict(prev), res)
+                if finished_rerun:
+                    keep["reruns_tried"] = res["reruns_tried"]
         if checkpoint is not None and keep.get("status") == "ok":
             checkpoint.append(keep)
         completed.setdefault(name, {})[key] = keep
@@ -5765,6 +5799,21 @@ def run_parallel_profile(
         param_names, res_x, meta, anchor, where, nll_at_optimum)
     _print_profile_convergence(convergence)
     _print_profile_reach(convergence["reach"])
+    if shadow_stop_rules:
+        try:
+            from pyantigen.engine.Stop_rules import (
+                format_shadow_summary, shadow_summary)
+            cfg = (dict(shadow_stop_rules)
+                   if isinstance(shadow_stop_rules, dict) else {})
+            cfg.setdefault("threshold", float(threshold))
+            text = format_shadow_summary(shadow_summary(
+                [r for pts in completed.values() for r in pts.values()],
+                nll_at_optimum, cfg))
+            if text:
+                print(f"\n{text}", flush=True)
+        except Exception as exc:        # reporting must never end a run
+            print(f"[profile] shadow stop rules: summary failed ({exc})",
+                  flush=True)
     if convergence["incomplete"]:
         parts = []
         if still_unfinished:
@@ -5940,6 +5989,8 @@ def _run_warm_passes(nll_batch_profile, completed, param_names, res_x, meta,
                 # probe) and is counted by the refinement budget, so it must
                 # survive a warm re-run regardless of which value won.
                 keep["phase"] = prev.get("phase", res.get("phase", 1))
+                if prev.get("reruns_tried"):
+                    keep["reruns_tried"] = prev["reruns_tried"]
             keep["warm_refined"] = int(
                 (prev or {}).get("warm_refined", 0)) + 1
             # How much re-running this point warm actually lowered it. This is

{pyantigen-2.1.0 → pyantigen-2.1.2}/pyantigen/engine/Preequil_cache.py

@@ -128,6 +128,15 @@ class PreequilCache:
         if block is None:
             return solver_settings
 
+        # The cached block is integrated on its own, without the schedule's
+        # steps (see Segmented). A schedule that switches inside it cannot be
+        # replayed from a cached end state.
+        schedule = solver_settings.get("schedule")
+        if schedule is not None:
+            from pyantigen.engine.Segmented import switches_before
+            if switches_before(r, schedule, float(block["end"])):
+                return solver_settings
+
         configure_integrator(r, solver_settings)
         key = _digest(save_model_state(r), block, solver_settings)