PyAntiGen 2.1.0__tar.gz → 2.1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 2.1.0
+Version: 2.1.1
 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.1}/PyAntiGen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 2.1.0
+Version: 2.1.1
 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.1}/PyAntiGen.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ pyantigen/engine/README.md
 pyantigen/engine/Results.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

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

@@ -39,6 +39,7 @@
     "pyantigen/engine/Results.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",
@@ -125,6 +126,7 @@
     "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",

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

@@ -0,0 +1,8 @@
+{
+  "tag": "2.1.1",
+  "distance": 0,
+  "node": "g6282b0d51a9efb9b414f250be15a996d5e131645",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-08"
+}

{pyantigen-2.1.0 → pyantigen-2.1.1}/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.1'
+__version_tuple__ = version_tuple = (2, 1, 1)
 
-__commit_id__ = commit_id = 'g664f039a1'
+__commit_id__ = commit_id = 'g6282b0d51'

{pyantigen-2.1.0 → pyantigen-2.1.1}/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.1}/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
@@ -5765,6 +5782,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:

{pyantigen-2.1.0 → pyantigen-2.1.1}/pyantigen/engine/Profile_plan.py

@@ -21,9 +21,14 @@ What it reads, per side of each parameter, in the optimizer's own space:
 * a side whose points are all below the threshold is extended outward by the
   curve-fitted step (``_extension_growth``), capped at ``max_step_decades`` per
   step so a flat curve cannot launch a jump of several decades;
-* a side that has crossed only on a point that did not converge has that point
-  re-run warm from its inner neighbour, because an unconverged dNLL is an upper
-  bound and a crossing read from one is not a crossing;
+* a side that has crossed only on points that did not converge is narrowed, not
+  repeated: an unconverged dNLL is an upper bound, so a crossing read from one
+  is not a crossing, and re-running the same far point from the same start
+  reproduces it exactly. The probe goes between the innermost converged point
+  below the threshold and the innermost unconverged one above it (sqrt(dNLL)
+  interpolation), warm from the former, and waits while anything is still
+  running inside that bracket. Only once the bracket is tight is the outer
+  point itself re-run;
 * a bracketed side is narrowed by sqrt(dNLL) interpolation until the bracket is
   tight, then filled in toward ``n_grid`` points so the curve has a shape.
 
@@ -300,21 +305,57 @@ def plan_next_points(n_free, *, param_names, completed, in_flight, res_x,
                 continue
 
             if above_t:
-                # Crossed only on points that did not converge. Re-run the
-                # innermost of them warm from its inner neighbour.
+                # Crossed only on points that did not converge. Each is an
+                # upper bound, so the crossing lies somewhere inside the
+                # bracket (nearest converged-below point, innermost of them).
                 tgt = above_t[0]
-                key = (name, ProfileCheckpointKey(tgt["x_fixed"]))
-                d_t = _ext_distance(p_opt, tgt["x_fixed"], is_log)
+                x_t = tgt["x_fixed"]
+                d_t = _ext_distance(p_opt, x_t, is_log)
                 inner_c = [r for r in below
                            if _ext_distance(p_opt, r["x_fixed"], is_log) < d_t]
-                if key not in attempted and not any(
-                        _near(tgt["x_fixed"], f, abs(tgt["x_fixed"] - p_opt))
-                        for f in fl):
-                    cands.append({"i": i, "name": name,
-                                  "x": float(tgt["x_fixed"]),
-                                  "seed": inner_c[-1] if inner_c else None,
-                                  "phase": 3, "kind": "rerun", "tier": 1,
-                                  "sign": sign, "attempt_key": key})
+                inner = inner_c[-1] if inner_c else None
+                x_in = inner["x_fixed"] if inner else p_opt
+                # Anything still running between the optimum and the failed
+                # point is about to become a better inner neighbour, or to
+                # replace the point we would plan. Planning now would seed from
+                # whatever has landed so far -- often nothing -- and a cold
+                # restart of a deterministic optimizer from the same start
+                # reproduces the failed point to the last digit.
+                if any(_ext_distance(p_opt, f, is_log) < d_t for f in fl):
+                    continue
+                tight = _bracket_is_tight(x_in, x_t, p_opt, is_log,
+                                          bracket_rtol)
+                if not tight:
+                    # Narrow the bracket toward the threshold instead of
+                    # repeating the far point: a probe between the inner
+                    # neighbour and the failed point is a short, warm
+                    # continuation and so can converge where the long one
+                    # could not. dnll at the failed point is too high, which
+                    # puts the probe on the near side of the crossing; the
+                    # next round narrows from there.
+                    d_in_nll = dn(inner) if inner else 0.0
+                    r_in, r_out = np.sqrt(max(d_in_nll, 0.0)), np.sqrt(dn(tgt))
+                    frac = ((np.sqrt(thr) - r_in) / (r_out - r_in)
+                            if r_out > r_in + 1e-12 else 0.5)
+                    frac = float(min(max(frac, 0.05), 0.95))
+                    x = x_in + frac * (x_t - x_in)
+                    if free(x, abs(x_t - p_opt)) and \
+                            ProfileCheckpointKey(x) not in completed.get(name, {}):
+                        cands.append({"i": i, "name": name, "x": float(x),
+                                      "seed": inner, "phase": 1,
+                                      "kind": "narrow", "tier": 1,
+                                      "sign": sign})
+                    continue
+                # The bracket is tight and the outer end still has not
+                # converged: give it one more go, warm from the inner point.
+                # With no inner point and a cold original this would be the
+                # same computation again, so it is not planned.
+                key = (name, ProfileCheckpointKey(x_t))
+                if key not in attempted and (
+                        inner is not None or tgt.get("warm_seeded")):
+                    cands.append({"i": i, "name": name, "x": float(x_t),
+                                  "seed": inner, "phase": 3, "kind": "rerun",
+                                  "tier": 1, "sign": sign, "attempt_key": key})
                 continue
 
             # ── below the threshold everywhere so far: step outward ────────

pyantigen-2.1.1/pyantigen/engine/Stop_rules.py

@@ -0,0 +1,205 @@
+"""Shadow stop rules for profile points: record what they would have done.
+
+A profile point is a nuisance minimization, and its only use to the planner
+(:mod:`pyantigen.engine.Profile_plan`) is a verdict on the value it reaches U, an
+upper bound on the profile there, against the threshold. Most of the 1500
+evaluations a point is allowed buy digits that do not change the verdict:
+
+* U already below the threshold is a proof that the profile is, and more
+  evaluations only lower it;
+* U that is creeping down from far above the threshold will not get there
+  within the cap, and its magnitude is not trusted either way;
+* U that has stopped improving by more than a fraction of its distance from the
+  threshold has said everything it is going to say.
+
+None of this has been calibrated against real trajectories, and loosening the
+optimizer's tolerance blind has cost accuracy here before (see the TOLERANCES
+note in Optimizer_settings). So this module only *watches*. For each point it
+keeps a sparse trace of the best value reached, and the first evaluation at which
+each rule would have fired. Nothing is ever stopped. The numbers are for reading
+off a finished run (:func:`shadow_summary`) and tuning the constants below
+before any of them is allowed to end a point.
+
+The rules, with U = best nll reached - anchor and thr the profile threshold:
+
+``below``      U < ``below_frac`` * thr. A proof, needs no minimum spend.
+``hopeless``   U > ``u_trust`` and, extrapolating the log-rate of the last
+               window to the evaluation cap, U would still be above ``u_trust``.
+               The extrapolation is optimistic -- Nelder-Mead's descent usually
+               slows -- so a point it fires on is very unlikely to have got
+               anywhere useful.
+``settled``    U improved by less than ``kappa`` * |U - thr| over the last
+               window: the tolerance scales with the distance from the decision,
+               so a U of 7.6 needs ~0.4 and a U of 0.04 needs almost nothing.
+               Measured on progress over a window, not on the simplex spread,
+               which fires on a collapsed simplex in a curved valley.
+
+The two window rules wait for ``max(MIN_EVALS, MIN_EVALS_PER_DIM * (n + 1))``
+evaluations plus one window, so the initial simplex has been built and the
+descent has started.
+"""
+import math
+
+DEFAULTS = {
+    "threshold": 1.9207,
+    "below_frac": 0.25,
+    "u_trust": 20.0,
+    "kappa": 0.05,
+    "window": 100,
+    "sample_every": 25,
+}
+MIN_EVALS = 60
+MIN_EVALS_PER_DIM = 5
+
+RULES = ("below", "hopeless", "settled")
+
+
+class PointMonitor:
+    """Watches one point's best-so-far; never alters it.
+
+    *trace* and *fired* continue those of an earlier launch of the same point,
+    so a point resumed after the clock stopped keeps one history.
+    """
+
+    def __init__(self, anchor, max_fev, n_nuis, cfg=None, trace=None, fired=None):
+        c = dict(DEFAULTS)
+        c.update({k: v for k, v in (cfg or {}).items() if k in DEFAULTS})
+        self.cfg = c
+        self.anchor = float(anchor)
+        self.max_fev = (float(max_fev) if max_fev is not None
+                        and math.isfinite(float(max_fev)) else None)
+        self.min_evals = max(MIN_EVALS, MIN_EVALS_PER_DIM * (int(n_nuis) + 1))
+        self.trace = [list(map(float, p)) for p in (trace or [])]
+        self.fired = {k: dict(v) for k, v in (fired or {}).items()}
+        self._last_n = int(self.trace[-1][0]) if self.trace else 0
+        self._best = self.trace[-1][1] if self.trace else math.inf
+
+    # -- feeding -----------------------------------------------------------
+    def update(self, nfev, best_nll):
+        """Call after every evaluation with the running total and best so far."""
+        if best_nll is None or not math.isfinite(best_nll):
+            return
+        nfev = int(nfev)
+        if nfev <= self._last_n and self.trace:
+            return
+        self._best = float(best_nll)
+        self._last_n = nfev
+        u = self._best - self.anchor
+        if "below" not in self.fired and u < self.cfg["below_frac"] * self.cfg["threshold"]:
+            self.fired["below"] = {"nfev": nfev, "U": u}
+        if nfev == 1 or nfev % self.cfg["sample_every"] == 0:
+            self.trace.append([nfev, self._best])
+            self._window_rules(nfev, u)
+
+    def _reference(self, nfev):
+        """The last sample at least one window back, or None."""
+        want = nfev - self.cfg["window"]
+        ref = None
+        for n, b in self.trace:
+            if n <= want:
+                ref = (n, b)
+            else:
+                break
+        return ref
+
+    def _window_rules(self, nfev, u):
+        if nfev < self.min_evals + self.cfg["window"]:
+            return
+        ref = self._reference(nfev)
+        if ref is None:
+            return
+        n_ref, b_ref = ref
+        u_ref = b_ref - self.anchor
+        thr, u_trust = self.cfg["threshold"], self.cfg["u_trust"]
+        gain = u_ref - u
+
+        if "settled" not in self.fired and gain < self.cfg["kappa"] * abs(u - thr):
+            self.fired["settled"] = {"nfev": nfev, "U": u, "gain": gain}
+
+        if ("hopeless" not in self.fired and u > u_trust and self.max_fev is not None
+                and u_ref > 0 and u > 0):
+            span = nfev - n_ref
+            rate = math.log(u_ref / u) / span if span > 0 else 0.0
+            u_cap = (u * math.exp(-rate * max(self.max_fev - nfev, 0.0))
+                     if rate > 0 else u)
+            if u_cap > u_trust:
+                self.fired["hopeless"] = {"nfev": nfev, "U": u, "U_cap": u_cap}
+
+    # -- reporting ---------------------------------------------------------
+    def finish(self, nfev, best_nll):
+        """The fields to merge into the point's record."""
+        if best_nll is not None and math.isfinite(best_nll):
+            if not self.trace or int(self.trace[-1][0]) != int(nfev):
+                self.trace.append([int(nfev), float(best_nll)])
+        return {"trace": self.trace, "shadow_stops": self.fired}
+
+
+# ---------------------------------------------------------------------------
+# Reading a finished run
+# ---------------------------------------------------------------------------
+
+def _verdict_class(u, thr, u_trust):
+    if u < thr:
+        return "below"
+    return "mid" if u < u_trust else "high"
+
+
+def shadow_summary(records, anchor, cfg=None):
+    """What the rules would have saved, and what they would have got wrong.
+
+    *records* is any iterable of point records carrying ``shadow_stops``. For
+    each rule: how many points it fired on, the evaluations it would have
+    saved (the point's ``nfev_total`` minus the evaluation it fired at), and how
+    many of those points ended in a different class -- below the threshold,
+    between it and ``u_trust``, or above -- than the value the rule fired on.
+    A class change is the only thing that matters to the planner, so that count
+    is the cost of the rule, in the only currency that counts.
+    """
+    c = dict(DEFAULTS)
+    c.update({k: v for k, v in (cfg or {}).items() if k in DEFAULTS})
+    thr, u_trust = c["threshold"], c["u_trust"]
+    out = {r: {"fired": 0, "saved": 0, "class_changed": 0, "examples": []}
+           for r in RULES}
+    n_points, spent = 0, 0
+    for rec in records:
+        stops = rec.get("shadow_stops")
+        nll, total = rec.get("nll"), rec.get("nfev_total")
+        if stops is None or nll is None or total is None:
+            continue
+        n_points += 1
+        spent += int(total)
+        u_final = float(nll) - float(anchor)
+        for rule, hit in stops.items():
+            if rule not in out:
+                continue
+            o = out[rule]
+            o["fired"] += 1
+            o["saved"] += max(int(total) - int(hit["nfev"]), 0)
+            if (_verdict_class(hit["U"], thr, u_trust)
+                    != _verdict_class(u_final, thr, u_trust)):
+                o["class_changed"] += 1
+                if len(o["examples"]) < 5:
+                    o["examples"].append({
+                        "param": rec.get("param_name"), "x": rec.get("x_fixed"),
+                        "nfev": hit["nfev"], "U_at_fire": hit["U"],
+                        "U_final": u_final})
+    return {"n_points": n_points, "evals_spent": spent, "rules": out}
+
+
+def format_shadow_summary(summary):
+    """The summary as log lines."""
+    s = summary
+    if not s["n_points"]:
+        return ""
+    lines = [f"[profile] shadow stop rules (nothing was stopped): "
+             f"{s['n_points']} point(s), {s['evals_spent']} evaluation(s) spent"]
+    for rule in RULES:
+        o = s["rules"][rule]
+        lines.append(f"    {rule:<9} fired on {o['fired']:>3}, would have saved "
+                     f"{o['saved']:>6} eval(s), class changed on "
+                     f"{o['class_changed']}")
+        for e in o["examples"]:
+            lines.append(f"        changed: {e['param']} at {e['x']:.6g}: "
+                         f"U {e['U_at_fire']:.3g} at eval {e['nfev']} -> "
+                         f"{e['U_final']:.3g} final")
+    return "\n".join(lines)

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

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