HBV-Lab 1.2.0__tar.gz → 1.4.0__tar.gz

{hbv_lab-1.2.0 → hbv_lab-1.4.0}/HBV_Lab/__init__.py

@@ -24,7 +24,7 @@ from .soil import soil_routine
 from .response import response_routine_two_tanks
 from .routing import route_with_maxbas
 
-__version__ = "1.2.0"
+__version__ = "1.4.0"
 
 __all__ = [
     "HBVModel",

{hbv_lab-1.2.0 → hbv_lab-1.4.0}/HBV_Lab/calibration.py

@@ -1,7 +1,7 @@
 class calibration:
 
     def calibrate(self, method='Nelder-Mead', objective='NSE', iterations=100,
-                            verbose=True, plot_results=True):
+                            verbose=True, plot_results=True, progress_callback=None):
         """
         Calibrate an HBV model's parameters to optimize the objective function.
 
@@ -29,11 +29,19 @@ class calibration:
             Whether to print progress information
         plot_results : bool, default True
             Whether to plot the final results after calibration
-            
+        progress_callback : callable, optional
+            Called once per optimizer iteration as
+            ``progress_callback(iteration, total_iterations, current_value, best_value)``,
+            where the values are in human-facing objective terms (e.g. NSE). Useful for
+            driving an external progress UI (e.g. the MCP server). Exceptions raised by
+            the callback are swallowed so they cannot interrupt calibration.
+
         Returns:
         --------
         dict
-            Dictionary containing optimized parameters and performance metrics
+            Dictionary with keys ``parameters`` (optimized parameter dict),
+            ``performance`` (final metrics), ``optimization_result`` (the SciPy result),
+            and ``trajectory`` (best objective value per iteration).
         """
         import scipy.optimize as opt
         import numpy as np
@@ -154,15 +162,21 @@ class calibration:
             else:
                 raise ValueError(f"Unknown objective function: {objective}")
         
-        # Callback function to track progress
+        # Callback function to track progress.
+        # objective_function always returns a value to be MINIMIZED (for NSE/KGE it
+        # returns the negative metric), so the best-so-far starts at +inf for every
+        # objective and improves downward.
         num_iter = [0]
-        best_value = [float('inf') if objective in ['RMSE', 'MAE'] else float('-inf')]
+        best_value = [float('inf')]
         start_time = time.time()
-        
+        # Per-iteration best-so-far objective values, in human-facing terms
+        # (e.g. NSE/KGE as-is, RMSE/MAE as-is). Returned to the caller.
+        trajectory = []
+
         def callback(params):
             num_iter[0] += 1
             current_value = objective_function(params)
-            
+
             # For NSE and KGE, we're minimizing the negative value
             if objective in ['NSE', 'KGE']:
                 display_value = -current_value
@@ -170,10 +184,22 @@ class calibration:
             else:
                 display_value = current_value
                 is_better = current_value < best_value[0]
-            
+
             if is_better:
                 best_value[0] = current_value
-            
+
+            # Best objective so far, in human-facing terms
+            best_display = -best_value[0] if objective in ['NSE', 'KGE'] else best_value[0]
+            trajectory.append(best_display)
+
+            # Optional external progress hook (e.g. for an MCP/agent UI).
+            # Kept defensive: a misbehaving callback must not break calibration.
+            if progress_callback is not None:
+                try:
+                    progress_callback(num_iter[0], iterations, display_value, best_display)
+                except Exception:
+                    pass
+
             if verbose and num_iter[0] % max(1, iterations // 10) == 0:
                 elapsed = time.time() - start_time
                 print(f"Iteration {num_iter[0]}/{iterations}, "
@@ -238,7 +264,8 @@ class calibration:
             return {
                 'parameters': optimized_params,
                 'performance': self.performance_metrics,
-                'optimization_result': result
+                'optimization_result': result,
+                'trajectory': trajectory
             }
             
         except Exception as e:

{hbv_lab-1.2.0 → hbv_lab-1.4.0}/HBV_Lab/mcp_server.py

@@ -27,7 +27,7 @@ import matplotlib
 
 matplotlib.use("Agg")  # headless: no GUI needed on a server
 
-from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp import FastMCP, Context
 
 from . import HBVModel, __version__
 
@@ -68,6 +68,40 @@ def _find_group(model: HBVModel, name: str) -> str | None:
     return None
 
 
+def _downsample(seq, n: int = 20) -> list:
+    """At most ``n`` evenly-spaced rounded points from ``seq`` (keeps first and last).
+
+    Keeps the calibration trajectory compact in the tool result regardless of how many
+    iterations ran.
+    """
+    seq = [round(float(v), 4) for v in seq]
+    if len(seq) <= n:
+        return seq
+    step = (len(seq) - 1) / (n - 1)
+    idx = sorted({int(round(k * step)) for k in range(n)})
+    return [seq[i] for i in idx]
+
+
+def _at_bound(model: HBVModel, rel_tol: float = 0.005) -> list:
+    """List parameters whose value sits within ``rel_tol`` of their min or max bound.
+
+    A parameter pinned to a bound usually means the search range is clipping the true
+    optimum — surfacing it lets the agent widen the range with set_parameter_ranges.
+    """
+    flags = []
+    for group, params in model.params.items():
+        for name, info in params.items():
+            lo, hi, val = info.get("min"), info.get("max"), info.get("default")
+            if lo is None or hi is None or hi <= lo:
+                continue
+            margin = rel_tol * (hi - lo)
+            if val <= lo + margin:
+                flags.append({"parameter": name, "bound": "lower", "value": round(float(val), 4), "limit": float(lo)})
+            elif val >= hi - margin:
+                flags.append({"parameter": name, "bound": "upper", "value": round(float(val), 4), "limit": float(hi)})
+    return flags
+
+
 # --- tools --------------------------------------------------------------------
 @mcp.tool()
 def create_model(name: str = "") -> dict:
@@ -141,14 +175,61 @@ def load_data(
 
 @mcp.tool()
 def get_parameters(model_id: str) -> dict:
-    """Return the model's current parameter values (the 'default' of each), grouped."""
+    """Return the model's current parameter values (the 'default' of each), grouped,
+    plus an ``at_bound`` list flagging any parameter pinned to its min/max range."""
+    model = _get(model_id)
+    return {
+        "parameters": {
+            group: {name: float(info["default"]) for name, info in params.items()}
+            for group, params in model.params.items()
+        },
+        "at_bound": _at_bound(model),
+    }
+
+
+@mcp.tool()
+def get_parameter_ranges(model_id: str) -> dict:
+    """Return the min / max / default of every parameter (the ranges the optimizer and
+    Monte-Carlo uncertainty sampling use), grouped."""
     model = _get(model_id)
     return {
-        group: {name: info["default"] for name, info in params.items()}
+        group: {
+            name: {
+                "min": float(info["min"]),
+                "max": float(info["max"]),
+                "default": float(info["default"]),
+            }
+            for name, info in params.items()
+        }
         for group, params in model.params.items()
     }
 
 
+@mcp.tool()
+def set_parameter_ranges(model_id: str, ranges: dict) -> dict:
+    """Widen or narrow parameter search ranges from a flat mapping, e.g.
+    {"FC": {"min": 50, "max": 500}, "CFMAX": {"max": 10}}.
+
+    Each entry may set any of "min" / "max" / "default"; the group is resolved
+    automatically. Use this when calibrate reports a parameter ``at_bound`` — widen its
+    range, then calibrate again. Unknown names are reported and ignored.
+    """
+    model = _get(model_id)
+    update: dict = {}
+    unknown: list[str] = []
+    for name, spec in ranges.items():
+        group = _find_group(model, name)
+        if group is None:
+            unknown.append(name)
+            continue
+        allowed = {k: spec[k] for k in ("min", "max", "default") if k in spec}
+        if allowed:
+            update.setdefault(group, {})[name] = allowed
+    if update:
+        model.set_parameters(update)
+    return {"updated": update, "unknown_parameters": unknown}
+
+
 @mcp.tool()
 def set_parameters(model_id: str, values: dict) -> dict:
     """Set parameter values from a flat mapping, e.g. {"FC": 250, "MAXBAS": 4}.
@@ -210,35 +291,121 @@ def run_model(model_id: str) -> dict:
 
 
 @mcp.tool()
-def calibrate(
+async def calibrate(
     model_id: str,
     objective: str = "NSE",
     method: str = "Nelder-Mead",
     iterations: int = 1000,
+    ctx: Context = None,
 ) -> dict:
     """Calibrate the model to observed discharge (requires obs data loaded).
 
     ``objective`` is one of NSE / KGE / RMSE / MAE. ``method`` defaults to the
     gradient-free 'Nelder-Mead' (recommended for HBV's piecewise objective).
-    Returns the optimized parameters and final performance metrics.
+
+    Progress: while running, the server emits MCP progress notifications each
+    optimizer iteration (visible in clients that surface them).
+
+    Incremental use: each call continues from the model's *current* parameters, so an
+    agent can call calibrate repeatedly with a small ``iterations`` budget (e.g. 50),
+    inspect the improving metric and ``objective_trajectory`` between calls, and decide
+    whether to keep going, widen parameter ranges, or switch objective.
+
+    Returns the optimized parameters, final metrics, optimizer status, and the
+    best-objective-per-iteration trajectory (downsampled).
     """
+    import asyncio
+
     model = _get(model_id)
-    model.calibrate(
-        method=method,
-        objective=objective,
-        iterations=iterations,
-        verbose=False,
-        plot_results=False,
+    loop = asyncio.get_running_loop()
+    updates: asyncio.Queue = asyncio.Queue()
+
+    def progress_cb(i, total, current, best):
+        # Runs in the worker thread — hand the update back to the event loop safely.
+        loop.call_soon_threadsafe(updates.put_nowait, (i, total, current, best))
+
+    async def report(i, total, current, best):
+        if ctx is None:
+            return
+        try:
+            await ctx.report_progress(i, total)
+            await ctx.info(
+                f"calibrate iter {i}/{total}: {objective}={current:.4f} (best {best:.4f})"
+            )
+        except Exception:
+            pass
+
+    # Run the (blocking) calibration in a worker thread so we can stream progress.
+    task = asyncio.create_task(
+        asyncio.to_thread(
+            model.calibrate,
+            method=method,
+            objective=objective,
+            iterations=iterations,
+            verbose=False,
+            plot_results=False,
+            progress_callback=progress_cb,
+        )
+    )
+    while not task.done():
+        try:
+            i, total, current, best = await asyncio.wait_for(updates.get(), timeout=0.25)
+            await report(i, total, current, best)
+        except asyncio.TimeoutError:
+            pass
+    while not updates.empty():  # flush any stragglers
+        await report(*updates.get_nowait())
+    out = await task  # re-raises any error from the worker thread
+
+    result = out["optimization_result"]
+    traj = out.get("trajectory", [])
+    success = bool(getattr(result, "success", True))
+    message = str(getattr(result, "message", ""))
+
+    # Honest convergence reporting: a maxiter-capped run isn't a "failure" — it just
+    # ran out of budget and (usually) is still improving. Distinguish the cases.
+    still_improving = bool(
+        len(traj) >= 2 and abs(float(traj[-1]) - float(traj[-min(6, len(traj))])) > 1e-3
     )
+    if success:
+        status, guidance = "converged", "Optimizer converged. No further iterations needed."
+    elif "iteration" in message.lower() or "maxiter" in message.lower():
+        status = "hit_iteration_budget"
+        guidance = (
+            "Hit the iteration budget; still improving - call calibrate again to "
+            "continue (it resumes from the current parameters)."
+            if still_improving
+            else "Hit the iteration budget but the objective has plateaued; likely converged."
+        )
+    else:
+        status, guidance = "failed", f"Optimizer stopped without converging: {message}"
+
+    at_bound = _at_bound(model)
+    if at_bound:
+        guidance += (
+            " Some parameters are at their range limits "
+            f"({', '.join(b['parameter'] for b in at_bound)}); consider widening them "
+            "with set_parameter_ranges before re-calibrating."
+        )
+
     return {
         "model_id": model_id,
         "objective": objective,
         "method": method,
+        "n_iterations": int(getattr(result, "nit", len(traj))),
+        "converged": success,
+        "status": status,
+        "still_improving": still_improving,
+        "guidance": guidance,
+        "success": success,  # kept for backward compatibility
+        "message": message,
         "optimized_parameters": {
-            group: {name: round(info["default"], 6) for name, info in params.items()}
+            group: {name: round(float(info["default"]), 6) for name, info in params.items()}
             for group, params in model.params.items()
         },
         "performance_metrics": _metrics(model),
+        "at_bound": at_bound,
+        "objective_trajectory": _downsample(traj, 20),
     }
 
 
@@ -257,6 +424,8 @@ def evaluate_uncertainty(
     model and can be persisted with save_results.
     """
     model = _get(model_id)
+    import numpy as np
+
     out = model.evaluate_uncertainty(
         n_runs=n_runs,
         objective=objective,
@@ -265,12 +434,41 @@ def evaluate_uncertainty(
         plot_results=False,
         verbose=False,
     )
+
+    # 95% prediction-interval diagnostics from the best runs
+    df = out["best_runs"]
+    obs = np.asarray(df["observed"].values, dtype=float)
+    lo = np.asarray(df["q5"].values, dtype=float)
+    hi = np.asarray(df["q95"].values, dtype=float)
+    valid = ~np.isnan(obs)
+    if valid.any():
+        inside = (obs[valid] >= lo[valid]) & (obs[valid] <= hi[valid])
+        coverage_95 = round(float(inside.mean()), 3)
+        mean_band_width = round(float(np.nanmean(hi[valid] - lo[valid])), 4)
+    else:
+        coverage_95 = mean_band_width = None
+
+    # Per-parameter posterior ranges across the best parameter sets
+    posterior: dict = {}
+    for s in out["best_parameter_sets"]:
+        for params in s["parameters"].values():
+            for name, info in params.items():
+                posterior.setdefault(name, []).append(info["default"])
+    posterior_ranges = {
+        name: {"min": round(float(min(v)), 4), "max": round(float(max(v)), 4)}
+        for name, v in posterior.items()
+    }
+
     return {
         "model_id": model_id,
         "objective": objective,
         "n_runs": n_runs,
+        "save_best": save_best,
         "best_performance": round(float(out["best_performance"]), 4),
         "current_performance": round(float(out["original_performance"]), 4),
+        "coverage_95": coverage_95,          # fraction of observations inside the 95% band
+        "mean_band_width": mean_band_width,  # mean (q95 - q5), mm/day
+        "parameter_posterior_ranges": posterior_ranges,
     }
 
 
@@ -309,6 +507,69 @@ def load_model(model_path: str) -> dict:
     return {"model_id": model_id, "performance_metrics": _metrics(model)}
 
 
+@mcp.tool()
+def clone_model(model_id: str, name: str = "") -> dict:
+    """Deep-copy a model (parameters, data, states, results) into a new model_id.
+
+    The canonical split-sample pattern: calibrate ``model-A``, ``clone_model`` it, then
+    ``load_data`` the validation window on the clone and ``run_model`` — the calibrated
+    parameters carry over, no manual parameter transfer needed.
+    """
+    import copy
+
+    src = _get(model_id)
+    new_id = _new_id()
+    _MODELS[new_id] = copy.deepcopy(src)
+    return {"model_id": new_id, "cloned_from": model_id, "name": name}
+
+
+@mcp.tool()
+def copy_parameters(from_model_id: str, to_model_id: str) -> dict:
+    """Copy the calibrated parameters (and ranges) from one model to another.
+
+    Use this to transfer a calibration to a validation model without copying its data.
+    """
+    import copy
+
+    src = _get(from_model_id)
+    dst = _get(to_model_id)
+    dst.params = copy.deepcopy(src.params)
+    return {
+        "from_model_id": from_model_id,
+        "to_model_id": to_model_id,
+        "parameters": {
+            group: {name: float(info["default"]) for name, info in params.items()}
+            for group, params in dst.params.items()
+        },
+    }
+
+
+@mcp.tool()
+def get_metrics(model_id: str) -> dict:
+    """Return the model's current performance metrics without re-running it.
+
+    Empty if the model hasn't been run with observed discharge yet.
+    """
+    model = _get(model_id)
+    return {"model_id": model_id, "performance_metrics": _metrics(model)}
+
+
+@mcp.tool()
+def compare_models(model_ids: list) -> dict:
+    """Tabulate performance metrics across several models side by side.
+
+    Handy for comparing calibration vs validation, or several calibration variants.
+    """
+    rows = []
+    for mid in model_ids:
+        try:
+            model = _get(mid)
+            rows.append({"model_id": mid, "metrics": _metrics(model)})
+        except ValueError as e:
+            rows.append({"model_id": mid, "error": str(e)})
+    return {"comparison": rows}
+
+
 def main() -> None:
     """Console-script / module entry point.
 

{hbv_lab-1.2.0 → hbv_lab-1.4.0}/HBV_Lab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: HBV_Lab
-Version: 1.2.0
+Version: 1.4.0
 Summary: An intuitive, object-oriented and user-friendly Python implementation of a lumped conceptual HBV hydrological model for educational and research purposes.
 Home-page: https://github.com/abdallaox/HBV_python_implementation
 Author: Abdalla Mohammed
@@ -250,12 +250,30 @@ mode deploys cleanly to platforms like Railway, Render or Fly.
 
 #### What the agent can do
 
-Tools: `create_model`, `load_data` (from a CSV/Excel file path), `get_parameters`, `set_parameters`,
-`set_initial_conditions`, `run_model`, `calibrate`, `evaluate_uncertainty`, `plot_results`,
-`save_results`, `save_model`, `load_model`, `list_models`. A typical agent flow is *create → load →
-run → calibrate → plot*. Model state is kept server-side (each tool takes a `model_id`) and large time
-series are passed by **file path**, not through the agent's context — tools return compact metrics and
-output-file paths.
+Tools: `create_model`, `clone_model`, `copy_parameters`, `load_data` (from a CSV/Excel file path),
+`get_parameters`, `set_parameters`, `get_parameter_ranges`, `set_parameter_ranges`,
+`set_initial_conditions`, `run_model`, `calibrate`, `evaluate_uncertainty`, `get_metrics`,
+`compare_models`, `plot_results`, `save_results`, `save_model`, `load_model`, `list_models`. A typical
+agent flow is *create → load → run → calibrate → plot*. Model state is kept server-side (each tool
+takes a `model_id`) and large time series are passed by **file path**, not through the agent's
+context — tools return compact metrics and output-file paths.
+
+**Calibration progress & agent steering.** `calibrate` emits MCP progress notifications every
+optimizer iteration (clients that surface them show a live progress/log view), and its result
+reports an honest convergence `status` (`converged` / `hit_iteration_budget` / `failed`),
+`still_improving`, the best-objective-per-iteration `objective_trajectory`, and an `at_bound` list of
+parameters pinned to their range limits. Because each call continues from the model's *current*
+parameters, an agent can calibrate incrementally — call `calibrate` with a small `iterations` budget,
+inspect the improving metric, and decide whether to keep going, widen ranges (via
+`set_parameter_ranges`), or switch objective between rounds.
+
+**Split-sample made easy.** Calibrate one model, `clone_model` it (or `copy_parameters` to a second
+model), `load_data` the validation window on the clone, and `run_model` — the calibrated parameters
+carry over with no manual transfer. `compare_models` tabulates calibration vs. validation metrics.
+
+**Richer uncertainty.** `evaluate_uncertainty` returns the 95% prediction-band **coverage** (fraction
+of observations inside the band), **mean band width**, and per-parameter **posterior ranges**, not
+just the best/current objective.
 
 ## Inputs & outputs
 

{hbv_lab-1.2.0 → hbv_lab-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: HBV_Lab
-Version: 1.2.0
+Version: 1.4.0
 Summary: An intuitive, object-oriented and user-friendly Python implementation of a lumped conceptual HBV hydrological model for educational and research purposes.
 Home-page: https://github.com/abdallaox/HBV_python_implementation
 Author: Abdalla Mohammed
@@ -250,12 +250,30 @@ mode deploys cleanly to platforms like Railway, Render or Fly.
 
 #### What the agent can do
 
-Tools: `create_model`, `load_data` (from a CSV/Excel file path), `get_parameters`, `set_parameters`,
-`set_initial_conditions`, `run_model`, `calibrate`, `evaluate_uncertainty`, `plot_results`,
-`save_results`, `save_model`, `load_model`, `list_models`. A typical agent flow is *create → load →
-run → calibrate → plot*. Model state is kept server-side (each tool takes a `model_id`) and large time
-series are passed by **file path**, not through the agent's context — tools return compact metrics and
-output-file paths.
+Tools: `create_model`, `clone_model`, `copy_parameters`, `load_data` (from a CSV/Excel file path),
+`get_parameters`, `set_parameters`, `get_parameter_ranges`, `set_parameter_ranges`,
+`set_initial_conditions`, `run_model`, `calibrate`, `evaluate_uncertainty`, `get_metrics`,
+`compare_models`, `plot_results`, `save_results`, `save_model`, `load_model`, `list_models`. A typical
+agent flow is *create → load → run → calibrate → plot*. Model state is kept server-side (each tool
+takes a `model_id`) and large time series are passed by **file path**, not through the agent's
+context — tools return compact metrics and output-file paths.
+
+**Calibration progress & agent steering.** `calibrate` emits MCP progress notifications every
+optimizer iteration (clients that surface them show a live progress/log view), and its result
+reports an honest convergence `status` (`converged` / `hit_iteration_budget` / `failed`),
+`still_improving`, the best-objective-per-iteration `objective_trajectory`, and an `at_bound` list of
+parameters pinned to their range limits. Because each call continues from the model's *current*
+parameters, an agent can calibrate incrementally — call `calibrate` with a small `iterations` budget,
+inspect the improving metric, and decide whether to keep going, widen ranges (via
+`set_parameter_ranges`), or switch objective between rounds.
+
+**Split-sample made easy.** Calibrate one model, `clone_model` it (or `copy_parameters` to a second
+model), `load_data` the validation window on the clone, and `run_model` — the calibrated parameters
+carry over with no manual transfer. `compare_models` tabulates calibration vs. validation metrics.
+
+**Richer uncertainty.** `evaluate_uncertainty` returns the 95% prediction-band **coverage** (fraction
+of observations inside the band), **mean band width**, and per-parameter **posterior ranges**, not
+just the best/current objective.
 
 ## Inputs & outputs
 

{hbv_lab-1.2.0 → hbv_lab-1.4.0}/README.md

@@ -209,12 +209,30 @@ mode deploys cleanly to platforms like Railway, Render or Fly.
 
 #### What the agent can do
 
-Tools: `create_model`, `load_data` (from a CSV/Excel file path), `get_parameters`, `set_parameters`,
-`set_initial_conditions`, `run_model`, `calibrate`, `evaluate_uncertainty`, `plot_results`,
-`save_results`, `save_model`, `load_model`, `list_models`. A typical agent flow is *create → load →
-run → calibrate → plot*. Model state is kept server-side (each tool takes a `model_id`) and large time
-series are passed by **file path**, not through the agent's context — tools return compact metrics and
-output-file paths.
+Tools: `create_model`, `clone_model`, `copy_parameters`, `load_data` (from a CSV/Excel file path),
+`get_parameters`, `set_parameters`, `get_parameter_ranges`, `set_parameter_ranges`,
+`set_initial_conditions`, `run_model`, `calibrate`, `evaluate_uncertainty`, `get_metrics`,
+`compare_models`, `plot_results`, `save_results`, `save_model`, `load_model`, `list_models`. A typical
+agent flow is *create → load → run → calibrate → plot*. Model state is kept server-side (each tool
+takes a `model_id`) and large time series are passed by **file path**, not through the agent's
+context — tools return compact metrics and output-file paths.
+
+**Calibration progress & agent steering.** `calibrate` emits MCP progress notifications every
+optimizer iteration (clients that surface them show a live progress/log view), and its result
+reports an honest convergence `status` (`converged` / `hit_iteration_budget` / `failed`),
+`still_improving`, the best-objective-per-iteration `objective_trajectory`, and an `at_bound` list of
+parameters pinned to their range limits. Because each call continues from the model's *current*
+parameters, an agent can calibrate incrementally — call `calibrate` with a small `iterations` budget,
+inspect the improving metric, and decide whether to keep going, widen ranges (via
+`set_parameter_ranges`), or switch objective between rounds.
+
+**Split-sample made easy.** Calibrate one model, `clone_model` it (or `copy_parameters` to a second
+model), `load_data` the validation window on the clone, and `run_model` — the calibrated parameters
+carry over with no manual transfer. `compare_models` tabulates calibration vs. validation metrics.
+
+**Richer uncertainty.** `evaluate_uncertainty` returns the 95% prediction-band **coverage** (fraction
+of observations inside the band), **mean band width**, and per-parameter **posterior ranges**, not
+just the best/current objective.
 
 ## Inputs & outputs
 

{hbv_lab-1.2.0 → hbv_lab-1.4.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name='HBV_Lab',
-    version='1.2.0',
+    version='1.4.0',
     packages=find_packages(include=['HBV_Lab', 'HBV_Lab.*']),
     install_requires=[
         'numpy',