PyAntiGen 2.1.5__tar.gz → 2.1.6__tar.gz

{pyantigen-2.1.5 → pyantigen-2.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 2.1.5
+Version: 2.1.6
 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.5 → pyantigen-2.1.6}/PyAntiGen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 2.1.5
+Version: 2.1.6
 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.6/PyAntiGen.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.1.6",
+  "distance": 0,
+  "node": "g9171689079d2fc724733c9b7be5620f998df09cf",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-19"
+}

{pyantigen-2.1.5 → pyantigen-2.1.6}/pyantigen/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.1.5'
-__version_tuple__ = version_tuple = (2, 1, 5)
+__version__ = version = '2.1.6'
+__version_tuple__ = version_tuple = (2, 1, 6)
 
-__commit_id__ = commit_id = 'g244c235d3'
+__commit_id__ = commit_id = 'g917168907'

{pyantigen-2.1.5 → pyantigen-2.1.6}/pyantigen/engine/Optimize.py

@@ -8279,6 +8279,11 @@ def predict_concentrations(params, observable_data, model, param_names, observab
         model.setIntegrator('cvode')
         model.integrator.absolute_tolerance = 1e-8
         _model_cache.put(model, "_scalar_abs_tol", 1e-8)
+        # This helper takes no solver settings, so it cannot ask for pinning.
+        # Drop any policy an earlier configure_integrator left on the model, or
+        # its reference scale -- taken for a different parameter vector -- would
+        # keep pinning here.
+        _model_cache.put(model, "_tolerance_policy", None)
         model.integrator.relative_tolerance = 1e-8
         model.integrator.setValue('stiff', True)
         model.integrator.variable_step_size = True

{pyantigen-2.1.5 → pyantigen-2.1.6}/pyantigen/engine/Simulate.py

@@ -288,10 +288,19 @@ TOLERANCE_CAP_RATIO = None
 
 
 def tolerance_policy(solver_settings):
-    """``{"pin": bool, "cap_ratio": float | None}`` from *solver_settings*."""
-    pin = bool(solver_settings.get("tolerance_pinning", TOLERANCE_PINNING))
+    """``{"pin": bool, "cap_ratio": float | None}`` from *solver_settings*.
+
+    ``tolerance_pinning`` must be a real bool: ``bool("false")`` is True, so a
+    string from a config file would switch pinning on while reading as off.
+    """
+    pin = solver_settings.get("tolerance_pinning", TOLERANCE_PINNING)
+    if not isinstance(pin, (bool, np.bool_)):
+        raise TypeError(f"tolerance_pinning must be True or False, got {pin!r}")
+    pin = bool(pin)
     cap = solver_settings.get("tolerance_cap_ratio", TOLERANCE_CAP_RATIO)
     if cap is not None:
+        if isinstance(cap, (bool, np.bool_, str)):
+            raise TypeError(f"tolerance_cap_ratio must be a number, got {cap!r}")
         cap = float(cap)
         if not cap > 0:
             raise ValueError(f"tolerance_cap_ratio must be positive, got {cap}")
@@ -313,20 +322,30 @@ def _remember_tolerance_policy(r, solver_settings, scalar):
     if not policy["pin"]:
         _model_cache.put(r, "_tolerance_policy", None)
         return
+    # The model clock is the test for "still at the initial state": reset() and
+    # resetAll() return it to exactly 0.0 whatever was simulated before (a model
+    # has no other start time), and save/restore_model_state carry 'time' with
+    # the amounts, so a restored state brings its clock back with it. A clock
+    # that is not 0 means the model has been integrated, whatever its start.
     try:
         at_start = float(r.getCurrentTime()) == 0.0
     except Exception:
         at_start = False
     if at_start:
+        # At the initial time the reference is re-derived every time, and a
+        # failure to do so drops the old one: it belongs to an earlier parameter
+        # vector, and pinning to it would silently use the wrong scales. (Away
+        # from t=0 the stored reference is kept on purpose -- see above.)
+        reference = None
         try:
             vec = np.asarray(r.integrator.getAbsoluteToleranceVector(), float)
             ids = state_vector_ids(r)
             n = min(len(ids), len(vec))
             if float(scalar) > 0 and n:
-                _model_cache.put(r, "_atol_reference",
-                                 (list(ids[:n]), vec[:n] / float(scalar)))
+                reference = (list(ids[:n]), vec[:n] / float(scalar))
         except Exception:
             pass
+        _model_cache.put(r, "_atol_reference", reference)
     if _model_cache.get(r, "_atol_reference") is None:
         # Never saw the initial state, so there is no initial scale to pin to.
         import warnings
@@ -359,6 +378,8 @@ def apply_tolerance_vector(r, scalar=None, floor=_MIN_ABSOLUTE_TOLERANCE):
     try:
         current = np.asarray(r.integrator.getAbsoluteToleranceVector(), float)
     except Exception:
+        # A vector that cannot be read cannot be floored either (the floor reads
+        # it first), so there is nothing to fall back to.
         return 0
     if len(current) < len(ids):
         return floor_tolerance_vector(r, floor)
@@ -368,12 +389,22 @@ def apply_tolerance_vector(r, scalar=None, floor=_MIN_ABSOLUTE_TOLERANCE):
         want = np.minimum(want, policy["cap_ratio"] * scalar)
     want = np.maximum(want, floor)
     n = 0
+    failed = []
     for i in np.flatnonzero(~np.isclose(current[:len(ids)], want, rtol=1e-9, atol=0.0)):
         try:
             r.integrator.setIndividualTolerance(ids[i], float(want[i]))
             n += 1
         except Exception:
-            pass
+            failed.append(ids[i])
+    if failed and not _model_cache.get(r, "_tolerance_set_warned"):
+        # Once per model: a state left at its drifted tolerance is what pinning
+        # exists to prevent, so it must not be silent, but this runs before
+        # every block and would otherwise repeat for the whole fit.
+        import warnings
+        _model_cache.put(r, "_tolerance_set_warned", True)
+        warnings.warn(f"tolerance_pinning could not set the absolute tolerance of "
+                      f"{len(failed)} state(s) (first: {failed[0]!r}); they keep "
+                      f"RoadRunner's derived value", RuntimeWarning, stacklevel=2)
     return n
 
 
@@ -728,6 +759,15 @@ def safe_simulate(r, solver_settings, observed_species, depth=0, label=None):
     # corrupted/advanced state that cannot be reverted without this snapshot.
     saved_state = save_model_state(r)
 
+    # A sub-call of a subdivision begins wherever the previous one left the
+    # vector: re-derived from the decayed state after a restore, or loosened by
+    # a ladder. The top-level call is pinned by its caller (_run_blocks,
+    # SegmentRunner); the halves are not, so pin them here, from the configured
+    # scalar. Each half then tries the configured accuracy and runs its own
+    # ladder if that fails.
+    if depth > 0:
+        apply_tolerance_vector(r)
+
     # Fast path: try once with whatever settings the model already has.
     try:
         res = _run(r, start, end, points, times, observed_species)
@@ -814,6 +854,7 @@ def safe_simulate(r, solver_settings, observed_species, depth=0, label=None):
 
             # Restore original integrator settings on success
             r.integrator.absolute_tolerance = orig_abs_tol
+            apply_tolerance_vector(r, scalar=orig_abs_tol)
             r.integrator.relative_tolerance = orig_rel_tol
             r.integrator.maximum_num_steps = orig_max_steps
             try:
@@ -892,6 +933,7 @@ def safe_simulate(r, solver_settings, observed_species, depth=0, label=None):
         
         # Restore original integrator settings before returning
         r.integrator.absolute_tolerance = orig_abs_tol
+        apply_tolerance_vector(r, scalar=orig_abs_tol)
         r.integrator.relative_tolerance = orig_rel_tol
         r.integrator.maximum_num_steps = orig_max_steps
         try:
@@ -910,6 +952,7 @@ def safe_simulate(r, solver_settings, observed_species, depth=0, label=None):
 
     # If all else fails, restore original settings and raise exception
     r.integrator.absolute_tolerance = orig_abs_tol
+    apply_tolerance_vector(r, scalar=orig_abs_tol)
     r.integrator.relative_tolerance = orig_rel_tol
     r.integrator.maximum_num_steps = orig_max_steps
     try:
@@ -941,6 +984,9 @@ def configure_integrator(r, solver_settings):
     Mutates *solver_settings* with the defaults, as the original inline version
     did, so callers that read the values back afterwards still see them.
     """
+    # Before anything is touched: a bad pinning setting is a configuration
+    # error, and should not leave the integrator half set up.
+    tolerance_policy(solver_settings)
     solver_settings["integrator"] = solver_settings.get("integrator", "cvode")
     solver_settings["absolute_tolerance"] = solver_settings.get("absolute_tolerance", 1e-8)
     solver_settings["relative_tolerance"] = solver_settings.get("relative_tolerance", 1e-8)

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

@@ -1,8 +0,0 @@
-{
-  "tag": "2.1.5",
-  "distance": 0,
-  "node": "g244c235d347fa7cf25440401efc2e02f1a6955e2",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-15"
-}