iints-sdk-python35 1.3.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

iints/__init__.py

@@ -11,7 +11,7 @@ except ImportError:  # pragma: no cover - Python < 3.8 fallback
 try:
     __version__ = version("iints-sdk-python35")
 except PackageNotFoundError:  # pragma: no cover - source tree fallback
-    __version__ = "1.3.2"
+    __version__ = "1.5.0"
 
 # Note to developers: this SDK is currently maintained by a single author.
 # Please report bugs via GitHub issues and feel free to contribute fixes via PRs.

iints/ai/assistant.py

@@ -122,3 +122,6 @@ class IINTSAssistant:
 
     def generate_report(self, run: dict[str, Any]) -> AIResponse:
         return self._run_task("generate_report", run)
+
+    def review_realism(self, run: dict[str, Any]) -> AIResponse:
+        return self._run_task("review_realism", run)

iints/ai/backends/ollama.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 import json
 import os
+from ipaddress import ip_address
 from http.client import IncompleteRead, RemoteDisconnected
 from time import sleep
 from urllib import error, request
+from urllib.parse import urlparse
 
 
 DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434"
@@ -35,10 +37,38 @@ class OllamaBackend:
         timeout_seconds: float = 120.0,
     ) -> None:
         self.model_name = model_name
-        self.base_url = (base_url or os.getenv("OLLAMA_HOST") or DEFAULT_OLLAMA_HOST).rstrip("/")
+        raw_base_url = base_url or os.getenv("OLLAMA_HOST") or DEFAULT_OLLAMA_HOST
+        self.base_url = self._validate_base_url(raw_base_url)
         self.timeout_seconds = timeout_seconds
         self.resolved_model_name: str | None = None
 
+    @staticmethod
+    def _is_loopback_host(hostname: str) -> bool:
+        if hostname == "localhost":
+            return True
+        try:
+            return ip_address(hostname).is_loopback
+        except ValueError:
+            return False
+
+    @classmethod
+    def _validate_base_url(cls, raw_base_url: str) -> str:
+        parsed = urlparse(raw_base_url)
+        if parsed.scheme not in {"http", "https"}:
+            raise ValueError(
+                "OLLAMA_HOST/base_url must use http or https. Other URL schemes are blocked."
+            )
+        if not parsed.hostname:
+            raise ValueError("OLLAMA_HOST/base_url must include a hostname.")
+        if parsed.path not in {"", "/"}:
+            raise ValueError("OLLAMA_HOST/base_url must not include a path component.")
+        if not cls._is_loopback_host(parsed.hostname) and os.getenv("IINTS_ALLOW_REMOTE_OLLAMA") != "1":
+            raise ValueError(
+                "Remote Ollama endpoints are disabled by default. "
+                "Use localhost/127.0.0.1 or set IINTS_ALLOW_REMOTE_OLLAMA=1 explicitly."
+            )
+        return raw_base_url.rstrip("/")
+
     def _pull_hint(self) -> str:
         return f"ollama pull {self.model_name}"
 
@@ -102,7 +132,7 @@ class OllamaBackend:
             headers["Content-Type"] = "application/json"
         req = request.Request(url, data=body, headers=headers, method=method)
         try:
-            with request.urlopen(req, timeout=self.timeout_seconds) as response:
+            with request.urlopen(req, timeout=self.timeout_seconds) as response:  # nosec B310 - base_url is scheme/host validated
                 text = response.read().decode("utf-8")
         except error.HTTPError as exc:
             detail = exc.read().decode("utf-8", errors="replace").strip()

iints/ai/cli.py

@@ -43,6 +43,7 @@ def _default_prepared_payload(task: str, ai_dir: Path) -> Path:
         "trends": ["trends_payload.json"],
         "anomalies": ["anomalies_payload.json"],
         "report": ["report_payload.json"],
+        "review": ["review_payload.json", "report_payload.json"],
     }.get(task, [])
     for filename in candidates:
         candidate = ai_dir / filename
@@ -95,6 +96,14 @@ def _write_output(path: Path | None, response: AIResponse) -> None:
     path.write_text(response.text + "\n", encoding="utf-8")
 
 
+def _default_output_for_review(input_path: Path, output: Path | None) -> Path | None:
+    if output is not None:
+        return output
+    if input_path.is_dir():
+        return input_path / "ai" / "realism_review.md"
+    return None
+
+
 def _render_response(console: Console, title: str, response: AIResponse, output: Path | None) -> None:
     console.print(Panel(response.text, title=title, border_style="cyan"))
     console.print(
@@ -438,3 +447,45 @@ def report(
     except Exception as exc:
         console.print(f"[bold red]Error:[/bold red] {exc}")
         raise typer.Exit(code=1)
+
+
+@app.command("review")
+def review(
+    input_json: Annotated[Path, typer.Argument(help="Prepared run directory or JSON file with run-level simulation outputs.")],
+    mdmp_cert: Annotated[Optional[Path], typer.Option(help="Signed MDMP artifact required before AI analysis can run.")] = None,
+    mode: Annotated[str, typer.Option(help="AI backend mode. Use 'local' for Ollama/Ministral.")] = "auto",
+    model: Annotated[str, typer.Option(help="Ollama model name to use.")] = DEFAULT_MINISTRAL_MODEL,
+    minimum_grade: Annotated[str, typer.Option(help="Minimum MDMP grade required to allow analysis.")] = "research_grade",
+    public_key: Annotated[Optional[Path], typer.Option(help="Explicit MDMP public key for verification.")] = None,
+    trust_store: Annotated[Optional[Path], typer.Option(help="MDMP trust store for verification.")] = None,
+    ollama_host: Annotated[Optional[str], typer.Option(help="Override the Ollama base URL.")] = None,
+    timeout_seconds: Annotated[float, typer.Option(help="HTTP timeout for Ollama generation requests.")] = 120.0,
+    output: Annotated[Optional[Path], typer.Option(help="Optional file path to save the realism review.")] = None,
+) -> None:
+    console = Console()
+    try:
+        resolved_input, resolved_cert, resolved_public_key = _resolve_cli_inputs(
+            task="review",
+            input_path=input_json,
+            mdmp_cert=mdmp_cert,
+            public_key=public_key,
+            trust_store=trust_store,
+        )
+        payload = _load_json_payload(resolved_input, "Input JSON")
+        assistant = _build_assistant(
+            mdmp_cert=resolved_cert,
+            mode=mode,
+            model=model,
+            minimum_grade=minimum_grade,
+            public_key=resolved_public_key,
+            trust_store=trust_store,
+            ollama_host=ollama_host,
+            timeout_seconds=timeout_seconds,
+        )
+        resolved_output = _default_output_for_review(input_json, output)
+        response = assistant.review_realism(payload)
+        _write_output(resolved_output, response)
+        _render_response(console, "IINTS AI Realism Review", response, resolved_output)
+    except Exception as exc:
+        console.print(f"[bold red]Error:[/bold red] {exc}")
+        raise typer.Exit(code=1)

iints/ai/mdmp_guard.py

@@ -14,9 +14,8 @@ def _load_mdmp_verifier() -> type[Any]:
         module = importlib.import_module("mdmp_core")
     except Exception as exc:
         raise ImportError(
-            "MDMP verification requires the optional standalone package.\n"
-            "Install with: pip install iints-sdk-python35[mdmp]\n"
-            "or: pip install 'mdmp-protocol>=0.3.0'"
+            "MDMP verification requires the bundled MDMP crypto support.\n"
+            "Install with: pip install iints-sdk-python35[mdmp]"
         ) from exc
     verifier_cls = getattr(module, "MDMPVerifier", None)
     if verifier_cls is None:

iints/ai/prepare.py

@@ -97,6 +97,13 @@ def _sample_trace(df: pd.DataFrame, *, max_rows: int = 48) -> list[dict[str, Any
     return [_normalize_series_record(record) for record in sampled.to_dict(orient="records")]
 
 
+def _max_glucose_delta_per_step(df: pd.DataFrame, glucose_column: str) -> float:
+    clean = pd.to_numeric(df[glucose_column], errors="coerce").dropna()
+    if clean.empty or len(clean) < 2:
+        return 0.0
+    return float(clean.diff().abs().dropna().max())
+
+
 def _position_for_label(df: pd.DataFrame, label: Any) -> int:
     location = df.index.get_loc(label)
     if isinstance(location, int):
@@ -166,9 +173,12 @@ def _build_summary(df: pd.DataFrame, run_metadata: dict[str, Any], audit_summary
         "mean_glucose_mgdl": _normalize_value(float(glucose.mean())),
         "min_glucose_mgdl": _normalize_value(float(glucose.min())),
         "max_glucose_mgdl": _normalize_value(float(glucose.max())),
+        "max_glucose_delta_per_step_mgdl": _normalize_value(_max_glucose_delta_per_step(df, glucose_column)),
         "time_in_range_70_180_pct": _normalize_value(_time_in_band_pct(glucose, 70.0, 180.0)),
         "time_below_70_pct": _normalize_value(float((glucose < 70.0).mean() * 100.0)),
+        "time_below_54_pct": _normalize_value(float((glucose < 54.0).mean() * 100.0)),
         "time_above_180_pct": _normalize_value(float((glucose > 180.0).mean() * 100.0)),
+        "time_above_250_pct": _normalize_value(float((glucose > 250.0).mean() * 100.0)),
         "delivered_insulin_total_units": _normalize_value(_safe_sum(df, "delivered_insulin_units")),
         "recommended_insulin_total_units": _normalize_value(_safe_sum(df, "algo_recommended_insulin_units")),
         "safety_trigger_count": _bool_sum(df, "safety_triggered"),
@@ -228,6 +238,23 @@ def _build_payloads(
             "trace_sample": trace_sample,
             "baseline_comparison": baseline_comparison,
         },
+        "review_payload.json": {
+            **common,
+            "audit_summary": audit_summary,
+            "baseline_comparison": baseline_comparison,
+            "trace_sample": trace_sample,
+            "review_focus": {
+                "goal": "Judge whether the simulation or imported dataset looks physiologically plausible and internally coherent.",
+                "checks": [
+                    "glucose range plausibility",
+                    "excursion size and recovery behavior",
+                    "time in range and severe hypo/hyper exposure",
+                    "insulin delivery realism relative to observed glucose behavior",
+                    "safety trigger and override consistency",
+                ],
+            },
+            "run_manifest": run_manifest,
+        },
         "step_riskiest.json": {
             **common,
             **risk_payload,
@@ -245,7 +272,7 @@ def _load_mdmp_signer_tools() -> tuple[type[Any], Any]:
         module = importlib.import_module("mdmp_core")
     except Exception as exc:
         raise ImportError(
-            "Local AI certification requires the optional standalone MDMP package.\n"
+            "Local AI certification requires the bundled MDMP crypto support.\n"
             "Install with: pip install 'iints-sdk-python35[mdmp]'"
         ) from exc
 

iints/ai/prompts.py

@@ -4,7 +4,13 @@ import json
 from typing import Any, Literal
 
 
-TaskName = Literal["explain_decision", "analyze_trends", "detect_anomalies", "generate_report"]
+TaskName = Literal[
+    "explain_decision",
+    "analyze_trends",
+    "detect_anomalies",
+    "generate_report",
+    "review_realism",
+]
 MAX_PROMPT_PAYLOAD_CHARS = 12000
 
 SYSTEM_PROMPT = (
@@ -52,6 +58,18 @@ TASK_TEMPLATES: dict[TaskName, str] = {
         "5. Research-only conclusion\n\n"
         "Input JSON:\n{data}"
     ),
+    "review_realism": (
+        "Review this simulation or imported-data payload and judge whether the results look physiologically plausible for research use.\n"
+        "Be conservative and do not overclaim. If the payload is incomplete, say so clearly.\n"
+        "Respond in markdown with these sections:\n"
+        "1. Overall realism verdict (Likely realistic / Needs review / Likely unrealistic)\n"
+        "2. Strong realism signals\n"
+        "3. Questionable or unrealistic patterns\n"
+        "4. Concrete feedback points the SDK developer can improve\n"
+        "5. Suggested follow-up validation checks\n\n"
+        "Focus on glycemic ranges, excursion patterns, insulin behavior, safety overrides, and whether the data looks internally coherent.\n\n"
+        "Input JSON:\n{data}"
+    ),
 }
 
 

iints/analysis/booth_demo.py

@@ -196,6 +196,7 @@ def _build_jury_brief(
             "```bash",
             "iints ai local-check --model ministral-3:3b",
             f"iints ai report {run_outputs['03_supervisor_override']['output_dir']} --model ministral-3:3b",
+            f"iints ai review {run_outputs['03_supervisor_override']['output_dir']} --model ministral-3:3b",
             f"iints ai explain {run_outputs['03_supervisor_override']['output_dir']} --model ministral-3:3b",
             "```",
             "",
@@ -247,6 +248,7 @@ def _build_commands_markdown(
         "```bash\n"
         "iints ai local-check --model ministral-3:3b\n"
         f"iints ai report {supervisor_dir} --model ministral-3:3b\n"
+        f"iints ai review {supervisor_dir} --model ministral-3:3b\n"
         f"iints ai explain {supervisor_dir} --model ministral-3:3b\n"
         "```\n"
     )
@@ -296,6 +298,7 @@ def _build_live_demo_script_text(
         "- If Ollama is ready, run:\n"
         "  iints ai local-check --model ministral-3:3b\n"
         f"  iints ai report {run_outputs['03_supervisor_override']['output_dir']} --model ministral-3:3b\n"
+        f"  iints ai review {run_outputs['03_supervisor_override']['output_dir']} --model ministral-3:3b\n"
         f"  iints ai explain {run_outputs['03_supervisor_override']['output_dir']} --model ministral-3:3b\n"
         "- Say: the local model explains the result, but only after the SDK has prepared the run artifacts.\n\n"
         "7. IF THE JURY ASKS WHY THIS MATTERS\n"

iints/analysis/carelink_workbench.py

@@ -202,6 +202,23 @@ def _prepare_ai_payloads(
             "profile_24h": profile_records,
             "trace_sample": trace_sample,
         },
+        "review_payload.json": {
+            **common,
+            "daily_summary": daily_records,
+            "profile_24h": profile_records,
+            "trace_sample": trace_sample,
+            "top_alerts": alert_counts,
+            "top_sensor_exceptions": sensor_exception_counts,
+            "review_focus": {
+                "goal": "Judge whether the imported glucose history looks internally coherent and physiologically plausible.",
+                "checks": [
+                    "time in range versus extreme exposure",
+                    "daily variability and day-to-day stability",
+                    "consistency between glucose, carbs, and insulin logs",
+                    "frequency of alerts and sensor exceptions",
+                ],
+            },
+        },
         "anomalies_payload.json": {
             **common,
             "lowest_readings": [

iints/analysis/clinical_metrics.py

@@ -144,6 +144,12 @@ class ClinicalMetricsCalculator:
         """
         self.target_range = target_range
         self.tight_range = tight_range
+
+    @staticmethod
+    def _percentage(mask: pd.Series) -> float:
+        if len(mask) == 0:
+            return 0.0
+        return float(mask.sum()) / float(len(mask)) * 100.0
         
     def calculate_tir(self, 
                       glucose: pd.Series, 
@@ -169,13 +175,13 @@ class ClinicalMetricsCalculator:
     def calculate_all_tir_metrics(self, glucose: pd.Series) -> Dict[str, float]:
         """Calculate all TIR-related metrics"""
         return {
-            'tir_70_180': self.calculate_tir(glucose, 70, 180),
-            'tir_70_140': self.calculate_tir(glucose, 70, 140),
-            'tir_70_110': self.calculate_tir(glucose, 70, 110),
-            'tir_below_70': self.calculate_tir(glucose, 0, 70),
-            'tir_below_54': self.calculate_tir(glucose, 0, 54),
-            'tir_above_180': self.calculate_tir(glucose, 180, 600),
-            'tir_above_250': self.calculate_tir(glucose, 250, 600)
+            'tir_70_180': self._percentage((glucose >= 70) & (glucose <= 180)),
+            'tir_70_140': self._percentage((glucose >= 70) & (glucose <= 140)),
+            'tir_70_110': self._percentage((glucose >= 70) & (glucose <= 110)),
+            'tir_below_70': self._percentage(glucose < 70),
+            'tir_below_54': self._percentage(glucose < 54),
+            'tir_above_180': self._percentage(glucose > 180),
+            'tir_above_250': self._percentage(glucose > 250)
         }
     
     def calculate_gmi(self, glucose: pd.Series) -> float:

iints/analysis/validator.py

@@ -4,6 +4,12 @@ from typing import Dict, List, Tuple, Optional, Any
 from dataclasses import dataclass
 from enum import Enum
 
+from iints.core.safety.config import (
+    SENSOR_GLUCOSE_MAX_MGDL,
+    SENSOR_GLUCOSE_MIN_MGDL,
+    SENSOR_MAX_GLUCOSE_RATE_PER_MIN_MGDL,
+)
+
 class ReliabilityLevel(Enum):
     HIGH = "high"
     MEDIUM = "medium" 
@@ -22,9 +28,9 @@ class DataIntegrityValidator:
     """Validates data integrity for reverse engineering analysis."""
     
     def __init__(self):
-        # Physiological limits
-        self.max_glucose_rate = 10  # mg/dL per minute
-        self.glucose_range = (20, 600)  # Physiologically possible range
+        # Broad CGM/sensor fail-soft limits
+        self.max_glucose_rate = SENSOR_MAX_GLUCOSE_RATE_PER_MIN_MGDL
+        self.glucose_range = (SENSOR_GLUCOSE_MIN_MGDL, SENSOR_GLUCOSE_MAX_MGDL)
         self.max_insulin_per_step = 5.0  # Units per 5-min step
         
     def validate_glucose_data(self, glucose_values: List[float], timestamps: List[float]) -> ValidationResult:
@@ -270,4 +276,4 @@ class ReverseEngineeringValidator:
             "issues": all_issues,
             "warnings": all_warnings,
             "category_scores": {category: result.reliability_score for category, result in validation_results.items()}
-        }
+        }

iints/core/patient/bergman_model.py

@@ -46,7 +46,7 @@ class BergmanParameters:
     n: float = 0.23         # 1/min  — fractional insulin degradation
     Ib: float = 7.0         # mU/L   — basal plasma insulin
     Vi: float = 0.05        # L/kg   — insulin distribution volume
-    gamma: float = 0.004    # (mU/L)/(mg/dL)/min — endogenous secretion gain
+    gamma: float = 0.0      # (mU/L)/(mg/dL)/min — endogenous secretion gain (0 for T1D default)
     h: float = 80.0         # mg/dL  — secretion glucose threshold
 
     # --- Gut absorption ---
@@ -330,7 +330,8 @@ class BergmanPatientModel:
         dXdt = -p.p2 * X + p.p3 * max(I - p.Ib, 0.0)
 
         # --- dI/dt ---
-        # Endogenous pancreatic secretion (blunted in T1D, but kept for generality)
+        # T1D defaults keep endogenous secretion disabled (gamma=0). Override
+        # gamma explicitly if you intentionally want residual beta-cell function.
         secretion = p.gamma * max(G - p.h, 0.0)
         dIdt = -p.n * (I - p.Ib) + secretion + u_insulin_mu_per_min / Vi_abs
 

iints/core/patient/models.py

@@ -14,7 +14,7 @@ class CustomPatientModel:
     This model is intended for educational and stress-testing purposes, not for clinical accuracy.
     """
     def __init__(self, basal_insulin_rate: float = 0.8, insulin_sensitivity: float = 50.0,
-                 carb_factor: float = 10.0, glucose_decay_rate: float = 0.002,
+                 carb_factor: float = 10.0, glucose_decay_rate: float = 0.05,
                  initial_glucose: float = 120.0, glucose_absorption_rate: float = 0.03,
                  basal_glucose_target: Optional[float] = None,
                  insulin_action_duration: float = 300.0, # minutes, e.g., 5 hours

iints/core/patient/patient_factory.py

@@ -63,14 +63,14 @@ class PatientFactory:
         """Get a diverse set of patients for population studies."""
         if not SIMGLUCOSE_AVAILABLE:
             # Create diverse custom patients with different parameters
-            return [
-                CustomPatientModel(initial_glucose=120, insulin_sensitivity=40),  # High sensitivity
-                CustomPatientModel(initial_glucose=120, insulin_sensitivity=60),  # Low sensitivity
-                CustomPatientModel(initial_glucose=120, carb_factor=8),          # Fast carb absorption
-                CustomPatientModel(initial_glucose=120, carb_factor=12),         # Slow carb absorption
-                CustomPatientModel(initial_glucose=120, glucose_decay_rate=0.0015), # Slow metabolism
-                CustomPatientModel(initial_glucose=120, glucose_decay_rate=0.0035), # Fast metabolism
-            ]
+                return [
+                    CustomPatientModel(initial_glucose=120, insulin_sensitivity=40),  # High sensitivity
+                    CustomPatientModel(initial_glucose=120, insulin_sensitivity=60),  # Low sensitivity
+                    CustomPatientModel(initial_glucose=120, carb_factor=8),          # Fast carb absorption
+                    CustomPatientModel(initial_glucose=120, carb_factor=12),         # Slow carb absorption
+                    CustomPatientModel(initial_glucose=120, glucose_decay_rate=0.03), # Slower homeostatic drift
+                    CustomPatientModel(initial_glucose=120, glucose_decay_rate=0.07), # Faster homeostatic drift
+                ]
         else:
             # Use FDA-approved virtual patients
             selected_patients = [

iints/core/patient/profile.py

@@ -18,7 +18,7 @@ class PatientProfile:
     dawn_end_hour: float = 8.0
 
     # Advanced knobs (optional)
-    glucose_decay_rate: float = 0.002
+    glucose_decay_rate: float = 0.05
     glucose_absorption_rate: float = 0.03
     insulin_action_duration: float = 300.0
     insulin_peak_time: float = 75.0

iints/core/safety/config.py

@@ -2,16 +2,25 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+SENSOR_GLUCOSE_MIN_MGDL = 40.0
+SENSOR_GLUCOSE_MAX_MGDL = 500.0
+SENSOR_MAX_GLUCOSE_DELTA_PER_5_MIN_MGDL = 20.0
+SENSOR_MAX_GLUCOSE_RATE_PER_MIN_MGDL = 4.0
+SIMULATION_GLUCOSE_FLOOR_MGDL = 20.0
+SIMULATION_GLUCOSE_CEILING_MGDL = 600.0
+
 
 @dataclass
 class SafetyConfig:
     """
     Central safety configuration for simulator, input validation, and supervisor.
     """
-    # Input validation limits
-    min_glucose: float = 20.0
-    max_glucose: float = 600.0
-    max_glucose_delta_per_5_min: float = 35.0
+    # Broad CGM/sensor plausibility limits.
+    # These are intentionally device-aware fail-soft bounds, not a claim about
+    # the full physiologic envelope of blood glucose inside the simulator.
+    min_glucose: float = SENSOR_GLUCOSE_MIN_MGDL
+    max_glucose: float = SENSOR_GLUCOSE_MAX_MGDL
+    max_glucose_delta_per_5_min: float = SENSOR_MAX_GLUCOSE_DELTA_PER_5_MIN_MGDL
 
     # Supervisor thresholds
     hypoglycemia_threshold: float = 70.0

iints/core/safety/input_validator.py

@@ -1,6 +1,11 @@
 from typing import Any, Dict, Optional
 
-from iints.core.safety.config import SafetyConfig
+from iints.core.safety.config import (
+    SENSOR_GLUCOSE_MAX_MGDL,
+    SENSOR_GLUCOSE_MIN_MGDL,
+    SENSOR_MAX_GLUCOSE_DELTA_PER_5_MIN_MGDL,
+    SafetyConfig,
+)
 
 class InputValidator:
     """
@@ -9,16 +14,16 @@ class InputValidator:
     This component makes the system robust against common sensor errors.
     """
     def __init__(self,
-                 min_glucose: float = 20.0,
-                 max_glucose: float = 600.0,
-                 max_glucose_delta_per_5_min: float = 35.0,
+                 min_glucose: float = SENSOR_GLUCOSE_MIN_MGDL,
+                 max_glucose: float = SENSOR_GLUCOSE_MAX_MGDL,
+                 max_glucose_delta_per_5_min: float = SENSOR_MAX_GLUCOSE_DELTA_PER_5_MIN_MGDL,
                  safety_config: Optional[SafetyConfig] = None):
         """
         Initializes the validator with plausible biological limits.
 
         Args:
-            min_glucose (float): The absolute minimum plausible glucose value (mg/dL).
-            max_glucose (float): The absolute maximum plausible glucose value (mg/dL).
+            min_glucose (float): Broad fail-soft lower bound for incoming CGM/sensor values (mg/dL).
+            max_glucose (float): Broad fail-soft upper bound for incoming CGM/sensor values (mg/dL).
             max_glucose_delta_per_5_min (float): The maximum plausible change in glucose
                                                  over a 5-minute period (mg/dL).
         """
@@ -62,7 +67,7 @@ class InputValidator:
         Raises:
             ValueError: If the value is outside biological plausibility limits.
         """
-        # 1. Absolute biological plausibility check
+        # 1. Broad CGM/sensor plausibility check
         if not (self.min_glucose <= glucose_value <= self.max_glucose):
             raise ValueError(
                 f"BIOLOGICAL_PLAUSIBILITY_ERROR: Glucose {glucose_value} mg/dL is outside the "

iints/data/adapter.py

@@ -10,6 +10,8 @@ import numpy as np
 from pathlib import Path
 from typing import Dict, List, Optional, Union, Any
 
+from iints.core.safety.config import SENSOR_GLUCOSE_MAX_MGDL, SENSOR_GLUCOSE_MIN_MGDL
+
 class DataAdapter:
     """Universal data adapter for IINTS-AF framework"""
     
@@ -51,8 +53,11 @@ class DataAdapter:
             raise ValueError(f"Missing required columns: {missing_cols}")
         
         # Validate glucose range
-        if df['glucose'].min() < 20 or df['glucose'].max() > 600:
-            raise ValueError("Glucose values outside physiological range (20-600 mg/dL)")
+        if df['glucose'].min() < SENSOR_GLUCOSE_MIN_MGDL or df['glucose'].max() > SENSOR_GLUCOSE_MAX_MGDL:
+            raise ValueError(
+                "Glucose values outside broad CGM/sensor-valid range "
+                f"({int(SENSOR_GLUCOSE_MIN_MGDL)}-{int(SENSOR_GLUCOSE_MAX_MGDL)} mg/dL)"
+            )
     
     def load_ohio_dataset(self, patient_id: str) -> pd.DataFrame:
         """Load Ohio T1DM dataset with clinical benchmarks"""

iints/data/ingestor.py

@@ -3,6 +3,8 @@ from pathlib import Path
 from typing import Dict, Any, Union, Optional
 import yaml
 
+from iints.core.safety.config import SENSOR_GLUCOSE_MAX_MGDL, SENSOR_GLUCOSE_MIN_MGDL
+
 class DataIngestor:
     """
     Standardized Data Bridge for ingesting various diabetes datasets into a
@@ -64,8 +66,11 @@ class DataIngestor:
         
         # Basic quality checks (from DATA_SCHEMA.md)
         if 'glucose' in df.columns:
-            if not ((df['glucose'] >= 20) & (df['glucose'] <= 600)).all():
-                raise ValueError("Glucose values outside acceptable range (20-600 mg/dL)")
+            if not ((df['glucose'] >= SENSOR_GLUCOSE_MIN_MGDL) & (df['glucose'] <= SENSOR_GLUCOSE_MAX_MGDL)).all():
+                raise ValueError(
+                    "Glucose values outside acceptable CGM/sensor range "
+                    f"({int(SENSOR_GLUCOSE_MIN_MGDL)}-{int(SENSOR_GLUCOSE_MAX_MGDL)} mg/dL)"
+                )
         if 'insulin' in df.columns and not df['insulin'].isna().all():
             if not ((df['insulin'] >= 0) & (df['insulin'] <= 50)).all():
                 raise ValueError("Insulin values outside acceptable range (0-50 units)")

iints/data/quality_checker.py

@@ -10,6 +10,12 @@ from datetime import datetime, timedelta
 import pandas as pd
 import numpy as np
 
+from iints.core.safety.config import (
+    SENSOR_GLUCOSE_MAX_MGDL,
+    SENSOR_GLUCOSE_MIN_MGDL,
+    SENSOR_MAX_GLUCOSE_RATE_PER_MIN_MGDL,
+)
+
 
 @dataclass
 class QualityReport:
@@ -100,14 +106,16 @@ class DataQualityChecker:
     
     # Physiological limits for glucose values
     GLUCOSE_LIMITS = {
-        'minimum': 20,    # mg/dL - physiologically possible minimum
-        'maximum': 600,   # mg/dL - physiologically possible maximum
+        'minimum': SENSOR_GLUCOSE_MIN_MGDL,  # mg/dL - broad CGM/sensor-valid minimum
+        'maximum': SENSOR_GLUCOSE_MAX_MGDL,  # mg/dL - broad CGM/sensor-valid maximum
         'critical_low': 54,   # mg/dL - clinically significant low
         'critical_high': 350  # mg/dL - clinically significant high
     }
-    
+
     PHYSIOLOGICAL_RATES = {
-        'max_glucose_change_per_min': 19.9 # mg/dL/min - Detecting changes of 20 mg/dL/min or more
+        # Broad fail-soft CGM plausibility cap; common CGM trend-arrow systems
+        # already treat >2 mg/dL/min as "rapid", so this keeps a conservative margin.
+        'max_glucose_change_per_min': SENSOR_MAX_GLUCOSE_RATE_PER_MIN_MGDL
     }
     
     # Expected sampling intervals (in minutes)

iints/data/registry.py

@@ -5,8 +5,10 @@ import urllib.request
 import zipfile
 import hashlib
 import shutil
+from ipaddress import ip_address
 from pathlib import Path
 from typing import Any, Dict, List, Optional, IO, cast
+from urllib.parse import urlparse
 
 try:  # Python 3.9+
     from importlib.resources import files
@@ -54,10 +56,30 @@ def list_dataset_ids() -> List[str]:
     return ids
 
 
+def _is_loopback_host(hostname: str) -> bool:
+    if hostname == "localhost":
+        return True
+    try:
+        return ip_address(hostname).is_loopback
+    except ValueError:
+        return False
+
+
+def _validate_download_url(url: str) -> str:
+    parsed = urlparse(url)
+    if parsed.scheme == "https":
+        return url
+    if parsed.scheme == "http" and parsed.hostname and _is_loopback_host(parsed.hostname):
+        return url
+    raise DatasetFetchError(
+        "Dataset download URL must use https, or http only for localhost/loopback development mirrors."
+    )
+
+
 def _download_file(url: str, output_path: Path) -> Path:
     output_path.parent.mkdir(parents=True, exist_ok=True)
     try:
-        urllib.request.urlretrieve(url, output_path)
+        urllib.request.urlretrieve(_validate_download_url(url), output_path)  # nosec B310 - URL is scheme validated before download
     except Exception as exc:
         raise DatasetFetchError(f"Failed to download {url}: {exc}") from exc
     return output_path

iints/highlevel.py

@@ -442,7 +442,7 @@ def run_population(
         dawn_phenomenon_strength=patient_params.get("dawn_phenomenon_strength", 0.0),
         dawn_start_hour=patient_params.get("dawn_start_hour", 4.0),
         dawn_end_hour=patient_params.get("dawn_end_hour", 8.0),
-        glucose_decay_rate=patient_params.get("glucose_decay_rate", 0.002),
+        glucose_decay_rate=patient_params.get("glucose_decay_rate", 0.05),
         glucose_absorption_rate=patient_params.get("glucose_absorption_rate", 0.03),
         insulin_peak_time=patient_params.get("insulin_peak_time", 75.0),
         meal_mismatch_epsilon=patient_params.get("meal_mismatch_epsilon", 1.0),