iints-sdk-python35 0.1.15__tar.gz → 0.1.16__tar.gz

{iints_sdk_python35-0.1.15/src/iints_sdk_python35.egg-info → iints_sdk_python35-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iints-sdk-python35
-Version: 0.1.15
+Version: 0.1.16
 Summary: A pre-clinical Edge-AI SDK for diabetes management validation.
 Author-email: Rune Bobbaers <rune.bobbaers@gmail.com>
 Project-URL: Homepage, https://github.com/python35/IINTS-SDK

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "iints-sdk-python35" 
-version = "0.1.15"
+version = "0.1.16"
 authors = [
   { name="Rune Bobbaers", email="rune.bobbaers@gmail.com" },
 ]

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/__init__.py

@@ -3,7 +3,10 @@
 import pandas as pd # Required for type hints like pd.DataFrame
 from typing import Optional
 
-__version__ = "0.1.15"
+__version__ = "0.1.16"
+
+# 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.
 
 # API Components for Algorithm Development
 from .api.base_algorithm import (

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/api/base_algorithm.py

@@ -12,6 +12,13 @@ class AlgorithmInput:
     carb_intake: float = 0.0
     patient_state: Dict[str, Any] = field(default_factory=dict)
     current_time: float = 0.0 # Added current_time
+    carbs_on_board: float = 0.0
+    isf: Optional[float] = None
+    icr: Optional[float] = None
+    dia_minutes: Optional[float] = None
+    basal_rate_u_per_hr: Optional[float] = None
+    glucose_trend_mgdl_min: Optional[float] = None
+    predicted_glucose_30min: Optional[float] = None
 
 
 @dataclass

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/core/algorithms/correction_bolus.py

@@ -28,15 +28,21 @@ class CorrectionBolus(InsulinAlgorithm):
     def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
         self.why_log = [] # Clear the log for this prediction cycle
 
-        basal_rate_units_per_minute = self.settings["fixed_basal_rate"] / 60.0
+        basal_rate = self.settings["fixed_basal_rate"]
+        if data.basal_rate_u_per_hr is not None:
+            basal_rate = float(data.basal_rate_u_per_hr)
+        basal_rate_units_per_minute = basal_rate / 60.0
         basal_insulin = basal_rate_units_per_minute * data.time_step
-        self._log_reason(f"Basal insulin calculated ({self.settings['fixed_basal_rate']} U/hr)", "basal_delivery", basal_insulin)
+        self._log_reason(f"Basal insulin calculated ({basal_rate} U/hr)", "basal_delivery", basal_insulin)
 
         carb_intake = data.carb_intake
         meal_bolus = 0.0
         if carb_intake > 0:
-            meal_bolus = carb_intake / self.settings["carb_ratio"]
-            self._log_reason(f"Meal bolus calculated for {carb_intake:.0f}g carbs (CR: {self.settings['carb_ratio']})", "meal_response", meal_bolus)
+            carb_ratio = self.settings["carb_ratio"]
+            if data.icr is not None:
+                carb_ratio = float(data.icr)
+            meal_bolus = carb_intake / carb_ratio
+            self._log_reason(f"Meal bolus calculated for {carb_intake:.0f}g carbs (CR: {carb_ratio})", "meal_response", meal_bolus)
         else:
             self._log_reason("No meal bolus needed (no carb intake)", "meal_response", 0.0)
 
@@ -44,8 +50,11 @@ class CorrectionBolus(InsulinAlgorithm):
         correction_bolus = 0.0
         if data.current_glucose > self.settings["target_glucose"]:
             glucose_deviation = data.current_glucose - self.settings["target_glucose"]
-            correction_bolus = glucose_deviation / self.settings["insulin_sensitivity_factor"]
-            self._log_reason(f"Correction bolus calculated for high glucose (Current: {data.current_glucose:.0f}mg/dL, Target: {self.settings['target_glucose']:.0f}mg/dL, ISF: {self.settings['insulin_sensitivity_factor']})", "glucose_correction", correction_bolus)
+            isf = self.settings["insulin_sensitivity_factor"]
+            if data.isf is not None:
+                isf = float(data.isf)
+            correction_bolus = glucose_deviation / isf
+            self._log_reason(f"Correction bolus calculated for high glucose (Current: {data.current_glucose:.0f}mg/dL, Target: {self.settings['target_glucose']:.0f}mg/dL, ISF: {isf})", "glucose_correction", correction_bolus)
         else:
             self._log_reason(f"No correction bolus needed (glucose at or below target: {self.settings['target_glucose']:.0f}mg/dL)", "glucose_correction", 0.0)
 

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/core/algorithms/fixed_basal_bolus.py

@@ -32,13 +32,19 @@ class FixedBasalBolus(InsulinAlgorithm):
         Returns:
             Dict[str, Any]: Contains 'basal_insulin' and 'bolus_insulin' for the time step.
         """
-        basal_rate_units_per_minute = self.settings["fixed_basal_rate"] / 60.0
+        basal_rate = self.settings["fixed_basal_rate"]
+        if data.basal_rate_u_per_hr is not None:
+            basal_rate = float(data.basal_rate_u_per_hr)
+        basal_rate_units_per_minute = basal_rate / 60.0
         basal_insulin = basal_rate_units_per_minute * data.time_step
 
         carb_intake = data.carb_intake
         bolus_insulin = 0.0
         if carb_intake > 0:
-            bolus_insulin = carb_intake / self.settings["carb_ratio"]
+            carb_ratio = self.settings["carb_ratio"]
+            if data.icr is not None:
+                carb_ratio = float(data.icr)
+            bolus_insulin = carb_intake / carb_ratio
 
         return {
             "basal_insulin": basal_insulin,

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/core/patient/models.py

@@ -21,7 +21,8 @@ class CustomPatientModel:
                  meal_mismatch_epsilon: float = 1.0, # Factor for meal mismatch
                  dawn_phenomenon_strength: float = 0.0, # mg/dL per hour
                  dawn_start_hour: float = 4.0,
-                 dawn_end_hour: float = 8.0):
+                 dawn_end_hour: float = 8.0,
+                 carb_absorption_duration_minutes: float = 240.0):
         """
         Initializes the patient model with simplified parameters.
 
@@ -48,6 +49,7 @@ class CustomPatientModel:
         self.dawn_phenomenon_strength = dawn_phenomenon_strength
         self.dawn_start_hour = dawn_start_hour
         self.dawn_end_hour = dawn_end_hour
+        self.carb_absorption_duration_minutes = carb_absorption_duration_minutes
 
 
         self.initial_glucose = initial_glucose
@@ -156,12 +158,21 @@ class CustomPatientModel:
             # Simple model: carbs absorb over time, peaking around meal_effect_delay
             # This is a very rough approximation
             absorption_factor = 0.0
-            if carb_event['time_since_intake'] <= 240: # Carbs absorb for ~4 hours
+            if carb_event['time_since_intake'] <= self.carb_absorption_duration_minutes: # Carbs absorb for ~4 hours
                 absorption_factor = self.glucose_absorption_rate * (np.exp(-carb_event['time_since_intake'] / self.meal_effect_delay) - np.exp(-carb_event['time_since_intake'] / (self.meal_effect_delay * 0.5)))
                 carb_effect += carb_event['amount'] * absorption_factor
                 new_active_carb_intakes.append(carb_event)
             # Carbs are "gone" after a while, or their effect is negligible
         self.active_carb_intakes = new_active_carb_intakes
+        # Estimate carbs on board based on remaining absorption window
+        carb_remaining = 0.0
+        for carb_event in self.active_carb_intakes:
+            remaining_fraction = max(
+                0.0,
+                1.0 - (carb_event['time_since_intake'] / self.carb_absorption_duration_minutes),
+            )
+            carb_remaining += carb_event['amount'] * remaining_fraction
+        self.carbs_on_board = carb_remaining
 
 
         # --- Exercise Effect ---
@@ -217,8 +228,36 @@ class CustomPatientModel:
             "current_glucose": self.current_glucose,
             "insulin_on_board": self.insulin_on_board,
             "carbs_on_board": self.carbs_on_board,
+            "basal_rate_u_per_hr": self.basal_insulin_rate,
+            "isf": self.insulin_sensitivity,
+            "icr": self.carb_factor,
+            "dia_minutes": self.insulin_action_duration,
         }
 
+    def get_ratio_state(self) -> Dict[str, float]:
+        return {
+            "basal_rate_u_per_hr": self.basal_insulin_rate,
+            "isf": self.insulin_sensitivity,
+            "icr": self.carb_factor,
+            "dia_minutes": self.insulin_action_duration,
+        }
+
+    def set_ratio_state(
+        self,
+        isf: Optional[float] = None,
+        icr: Optional[float] = None,
+        basal_rate: Optional[float] = None,
+        dia_minutes: Optional[float] = None,
+    ) -> None:
+        if isf is not None:
+            self.insulin_sensitivity = float(isf)
+        if icr is not None:
+            self.carb_factor = float(icr)
+        if basal_rate is not None:
+            self.basal_insulin_rate = float(basal_rate)
+        if dia_minutes is not None:
+            self.insulin_action_duration = float(dia_minutes)
+
     def get_state(self) -> Dict[str, Any]:
         return {
             "current_glucose": self.current_glucose,

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/core/safety/config.py

@@ -23,6 +23,9 @@ class SafetyConfig:
     max_iob: float = 4.0
     trend_stop: float = -2.0
     hypo_cutoff: float = 70.0
+    max_basal_multiplier: float = 3.0
+    predicted_hypoglycemia_threshold: float = 60.0
+    predicted_hypoglycemia_horizon_minutes: int = 30
 
     # Simulation termination limits
     critical_glucose_threshold: float = 40.0

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/core/simulator.py

@@ -25,7 +25,19 @@ class SimulationLimitError(RuntimeError):
 
 class StressEvent:
     """Represents a discrete event that can occur during a simulation for stress testing."""
-    def __init__(self, start_time: int, event_type: str, value: Any = None, reported_value: Any = None, absorption_delay_minutes: int = 0, duration: int = 0) -> None:
+    def __init__(
+        self,
+        start_time: int,
+        event_type: str,
+        value: Any = None,
+        reported_value: Any = None,
+        absorption_delay_minutes: int = 0,
+        duration: int = 0,
+        isf: Optional[float] = None,
+        icr: Optional[float] = None,
+        basal_rate: Optional[float] = None,
+        dia_minutes: Optional[float] = None,
+    ) -> None:
         """
         Args:
             start_time (int): The simulation time (in minutes) when the event should occur.
@@ -41,12 +53,29 @@ class StressEvent:
         self.reported_value = reported_value # New attribute
         self.absorption_delay_minutes = absorption_delay_minutes # New attribute
         self.duration = duration
+        self.isf = isf
+        self.icr = icr
+        self.basal_rate = basal_rate
+        self.dia_minutes = dia_minutes
 
     def __str__(self) -> str:
         reported_str = f", Reported: {self.reported_value}" if self.reported_value is not None else ""
+        ratio_str = ""
+        if self.event_type == "ratio_change":
+            parts = []
+            if self.isf is not None:
+                parts.append(f"ISF={self.isf}")
+            if self.icr is not None:
+                parts.append(f"ICR={self.icr}")
+            if self.basal_rate is not None:
+                parts.append(f"Basal={self.basal_rate}")
+            if self.dia_minutes is not None:
+                parts.append(f"DIA={self.dia_minutes}")
+            if parts:
+                ratio_str = ", " + ", ".join(parts)
         delay_str = f", Delay: {self.absorption_delay_minutes}m" if self.absorption_delay_minutes > 0 else ""
         duration_str = f", Duration: {self.duration}m" if self.duration > 0 else ""
-        return f"Event(Time: {self.start_time}m, Type: {self.event_type}, Value: {self.value}{reported_str}{delay_str}{duration_str})"
+        return f"Event(Time: {self.start_time}m, Type: {self.event_type}, Value: {self.value}{reported_str}{ratio_str}{delay_str}{duration_str})"
 
 class Simulator:
     """
@@ -87,25 +116,27 @@ class Simulator:
         if self.seed is not None:
             np.random.seed(self.seed) # Set numpy seed for reproducibility
             # Potentially set other seeds here if other random modules are used (e.g., random.seed(self.seed))
-        if safety_config is None:
-            safety_config = SafetyConfig()
-        self.supervisor = IndependentSupervisor(safety_config=safety_config)
-        self.input_validator = InputValidator(safety_config=safety_config)
+        self.safety_config = safety_config or SafetyConfig()
+        self.supervisor = IndependentSupervisor(safety_config=self.safety_config)
+        self.input_validator = InputValidator(safety_config=self.safety_config)
         self.sensor_model = sensor_model or SensorModel(seed=seed)
         self.pump_model = pump_model or PumpModel(seed=seed)
         self.on_step = on_step
         self.meal_queue: List[Dict[str, Any]] = [] # Initialize meal queue for delayed absorption
         self.audit_log_path = audit_log_path
         self.enable_profiling = enable_profiling
-        if safety_config is not None:
-            critical_glucose_threshold = safety_config.critical_glucose_threshold
-            critical_glucose_duration_minutes = safety_config.critical_glucose_duration_minutes
+        if self.safety_config is not None:
+            critical_glucose_threshold = self.safety_config.critical_glucose_threshold
+            critical_glucose_duration_minutes = self.safety_config.critical_glucose_duration_minutes
         self.critical_glucose_threshold = critical_glucose_threshold
         self.critical_glucose_duration_minutes = critical_glucose_duration_minutes
         self._critical_low_minutes = 0
         self._current_time = 0
         self._resume_state = False
         self._termination_info: Optional[Dict[str, Any]] = None
+        self._ratio_overrides: List[Dict[str, Any]] = []
+        self._base_ratio_state: Optional[Dict[str, float]] = None
+        self._previous_glucose_for_trend: Optional[float] = None
         self._profiling_samples: Dict[str, List[float]] = {
             "algorithm_latency_ms": [],
             "supervisor_latency_ms": [],
@@ -128,6 +159,67 @@ class Simulator:
             except IOError as e:
                 logger.warning("Could not write to audit log file at %s. Error: %s", self.audit_log_path, e)
 
+    def _apply_ratio_overrides(self, current_time: float) -> Dict[str, float]:
+        if self._base_ratio_state is None:
+            self._base_ratio_state = self.patient_model.get_ratio_state()
+        effective = dict(self._base_ratio_state)
+        active = [
+            override
+            for override in self._ratio_overrides
+            if override["start_time"] <= current_time <= override["end_time"]
+        ]
+        if active:
+            latest = active[-1]
+            if latest.get("isf") is not None:
+                effective["isf"] = latest["isf"]
+            if latest.get("icr") is not None:
+                effective["icr"] = latest["icr"]
+            if latest.get("basal_rate_u_per_hr") is not None:
+                effective["basal_rate_u_per_hr"] = latest["basal_rate_u_per_hr"]
+            if latest.get("dia_minutes") is not None:
+                effective["dia_minutes"] = latest["dia_minutes"]
+
+        self.patient_model.set_ratio_state(
+            isf=effective.get("isf"),
+            icr=effective.get("icr"),
+            basal_rate=effective.get("basal_rate_u_per_hr"),
+            dia_minutes=effective.get("dia_minutes"),
+        )
+        try:
+            if effective.get("isf") is not None:
+                self.algorithm.set_isf(float(effective["isf"]))
+            if effective.get("icr") is not None:
+                self.algorithm.set_icr(float(effective["icr"]))
+        except Exception:
+            # Algorithm may ignore dynamic ratio updates; no hard failure.
+            pass
+        return effective
+
+    def _predict_glucose(
+        self,
+        current_glucose: float,
+        trend_mgdl_min: float,
+        iob_units: float,
+        cob_grams: float,
+        isf: float,
+        icr: float,
+        dia_minutes: float,
+        horizon_minutes: int,
+        carb_absorption_minutes: float,
+    ) -> float:
+        trend_component = trend_mgdl_min * horizon_minutes
+
+        insulin_component = 0.0
+        if dia_minutes > 0:
+            insulin_component = -iob_units * isf * min(horizon_minutes / dia_minutes, 1.0)
+
+        carb_component = 0.0
+        if icr > 0:
+            carb_effect_per_gram = isf / icr
+            carb_component = cob_grams * carb_effect_per_gram * min(horizon_minutes / carb_absorption_minutes, 1.0)
+
+        return current_glucose + trend_component + insulin_component + carb_component
+
     def add_stress_event(self, event: StressEvent) -> None:
         """Adds a stress event to be triggered during the simulation."""
         self.stress_events.append(event)
@@ -244,6 +336,9 @@ class Simulator:
             self._critical_low_minutes = 0
             self._current_time = 0
             self._termination_info = None
+            self._ratio_overrides = []
+            self._base_ratio_state = self.patient_model.get_ratio_state()
+            self._previous_glucose_for_trend = None
         else:
             self._resume_state = False
         if self.enable_profiling:
@@ -292,6 +387,18 @@ class Simulator:
                         self.add_stress_event(end_event)
                     elif event.event_type == 'exercise_end':
                         self.patient_model.stop_exercise()
+                    elif event.event_type == 'ratio_change':
+                        duration = event.duration if event.duration > 0 else float("inf")
+                        self._ratio_overrides.append(
+                            {
+                                "start_time": current_time,
+                                "end_time": current_time + duration,
+                                "isf": event.isf,
+                                "icr": event.icr,
+                                "basal_rate_u_per_hr": event.basal_rate,
+                                "dia_minutes": event.dia_minutes,
+                            }
+                        )
 
                     events_to_process_now.append(event) # Mark for removal from stress_events list
 
@@ -319,12 +426,44 @@ class Simulator:
             # This ensures even sensor error stress events are validated
             glucose_to_algorithm = self.input_validator.validate_glucose(glucose_to_algorithm, float(current_time))
 
+            # Apply dynamic ratio overrides (ISF/ICR/DIA/Basal) if any
+            ratio_state = self._apply_ratio_overrides(float(current_time))
+            effective_isf = float(ratio_state.get("isf", self.patient_model.insulin_sensitivity))
+            effective_icr = float(ratio_state.get("icr", self.patient_model.carb_factor))
+            effective_dia = float(ratio_state.get("dia_minutes", self.patient_model.insulin_action_duration))
+            effective_basal = float(ratio_state.get("basal_rate_u_per_hr", self.patient_model.basal_insulin_rate))
+
+            # Glucose trend (mg/dL per minute) based on sensor value
+            glucose_trend = 0.0
+            if self._previous_glucose_for_trend is not None:
+                glucose_trend = (glucose_to_algorithm - self._previous_glucose_for_trend) / float(self.time_step)
+            self._previous_glucose_for_trend = glucose_to_algorithm
+
+            predicted_glucose_30 = self._predict_glucose(
+                current_glucose=glucose_to_algorithm,
+                trend_mgdl_min=glucose_trend,
+                iob_units=self.patient_model.insulin_on_board,
+                cob_grams=self.patient_model.carbs_on_board,
+                isf=effective_isf,
+                icr=effective_icr,
+                dia_minutes=effective_dia,
+                horizon_minutes=self.safety_config.predicted_hypoglycemia_horizon_minutes,
+                carb_absorption_minutes=self.patient_model.carb_absorption_duration_minutes,
+            )
+
             # --- Algorithm Input ---
             algo_input = AlgorithmInput(
                 current_glucose=glucose_to_algorithm,
                 time_step=self.time_step,
                 insulin_on_board=self.patient_model.insulin_on_board,
                 carb_intake=algo_carb_intake_this_step, # Use algo's perspective of carbs
+                carbs_on_board=self.patient_model.carbs_on_board,
+                isf=effective_isf,
+                icr=effective_icr,
+                dia_minutes=effective_dia,
+                basal_rate_u_per_hr=effective_basal,
+                glucose_trend_mgdl_min=glucose_trend,
+                predicted_glucose_30min=predicted_glucose_30,
                 patient_state=self.patient_model.get_patient_state(),
                 current_time=float(current_time) # Pass current_time
             )
@@ -346,11 +485,17 @@ class Simulator:
 
             # --- Safety Supervision ---
             start_perf_time = time.perf_counter()
+            proposed_basal_units = float(insulin_output.get("basal_insulin", 0.0))
+            basal_limit_u_per_hr = effective_basal * self.safety_config.max_basal_multiplier
+            basal_limit_units = (basal_limit_u_per_hr / 60.0) * float(self.time_step)
             safety_result = self.supervisor.evaluate_safety(
                 current_glucose=glucose_to_algorithm,
                 proposed_insulin=algo_recommended_insulin,
                 current_time=float(current_time),
-                current_iob=self.patient_model.insulin_on_board
+                current_iob=self.patient_model.insulin_on_board,
+                predicted_glucose_30min=predicted_glucose_30,
+                basal_insulin_units=proposed_basal_units,
+                basal_limit_units=basal_limit_units,
             )
             supervisor_latency_ms = (time.perf_counter() - start_perf_time) * 1000
             if self.enable_profiling:
@@ -415,6 +560,8 @@ class Simulator:
                 "time_minutes": current_time,
                 "glucose_actual_mgdl": actual_glucose_reading,
                 "glucose_to_algo_mgdl": glucose_to_algorithm,
+                "glucose_trend_mgdl_min": glucose_trend,
+                "predicted_glucose_30min": predicted_glucose_30,
                 "delivered_insulin_units": delivered_insulin,
                 "algo_recommended_insulin_units": algo_recommended_insulin,
                 "sensor_status": sensor_reading.status,
@@ -426,6 +573,10 @@ class Simulator:
                 "carb_intake_grams": patient_carb_intake_this_step,
                 "patient_iob_units": self.patient_model.insulin_on_board,
                 "patient_cob_grams": self.patient_model.carbs_on_board,
+                "effective_isf": effective_isf,
+                "effective_icr": effective_icr,
+                "effective_basal_rate_u_per_hr": effective_basal,
+                "effective_dia_minutes": effective_dia,
                 "uncertainty": insulin_output.get("uncertainty", 0.0),
                 "fallback_triggered": insulin_output.get("fallback_triggered", False),
                 "safety_level": safety_level.value,

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/core/supervisor.py

@@ -45,6 +45,8 @@ class IndependentSupervisor:
                  max_iob=4.0,                    # Units
                  trend_stop=-2.0,                # mg/dL per minute
                  hypo_cutoff=70.0,               # mg/dL
+                 predicted_hypoglycemia_threshold=60.0,  # mg/dL
+                 predicted_hypoglycemia_horizon_minutes=30,  # minutes
                  safety_config: Optional["SafetyConfig"] = None):
         
         if safety_config is not None:
@@ -57,6 +59,8 @@ class IndependentSupervisor:
             max_iob = safety_config.max_iob
             trend_stop = safety_config.trend_stop
             hypo_cutoff = safety_config.hypo_cutoff
+            predicted_hypoglycemia_threshold = safety_config.predicted_hypoglycemia_threshold
+            predicted_hypoglycemia_horizon_minutes = safety_config.predicted_hypoglycemia_horizon_minutes
 
         self.hypoglycemia_threshold = hypoglycemia_threshold
         self.severe_hypoglycemia_threshold = severe_hypoglycemia_threshold
@@ -67,6 +71,8 @@ class IndependentSupervisor:
         self.max_iob = max_iob
         self.trend_stop = trend_stop
         self.hypo_cutoff = hypo_cutoff
+        self.predicted_hypoglycemia_threshold = predicted_hypoglycemia_threshold
+        self.predicted_hypoglycemia_horizon_minutes = predicted_hypoglycemia_horizon_minutes
         
         # State tracking
         self.glucose_history: List[Tuple[float, float]] = []
@@ -75,8 +81,16 @@ class IndependentSupervisor:
         self.last_iob = 0.0
         self.dose_history: List[tuple] = []
         
-    def evaluate_safety(self, current_glucose: float, proposed_insulin: float, 
-                       current_time: float, current_iob: float = 0.0) -> Dict[str, Any]:
+    def evaluate_safety(
+        self,
+        current_glucose: float,
+        proposed_insulin: float,
+        current_time: float,
+        current_iob: float = 0.0,
+        predicted_glucose_30min: Optional[float] = None,
+        basal_insulin_units: Optional[float] = None,
+        basal_limit_units: Optional[float] = None,
+    ) -> Dict[str, Any]:
         """
         Evaluate safety of proposed insulin dose based on current glucose and IOB.
         Returns modified insulin dose and safety status.
@@ -90,6 +104,28 @@ class IndependentSupervisor:
         self.glucose_history.append((current_time, current_glucose))
         if len(self.glucose_history) > 20:  # Keep last 20 readings
             self.glucose_history.pop(0)
+
+        # Predictive hypo guard (30-min horizon)
+        if predicted_glucose_30min is not None:
+            if predicted_glucose_30min <= self.predicted_hypoglycemia_threshold:
+                safety_status = SafetyLevel.EMERGENCY
+                proposed_insulin = 0
+                actions_taken.append(
+                    f"PREDICTED_HYPO: {predicted_glucose_30min:.1f} mg/dL in "
+                    f"{self.predicted_hypoglycemia_horizon_minutes} min"
+                )
+                self.emergency_mode = True
+
+        # Basal rate limit (relative to patient basal)
+        if basal_insulin_units is not None and basal_limit_units is not None:
+            if basal_insulin_units > basal_limit_units:
+                excess = basal_insulin_units - basal_limit_units
+                proposed_insulin = max(0.0, proposed_insulin - excess)
+                actions_taken.append(
+                    f"BASAL_LIMIT: basal {basal_insulin_units:.2f}U exceeds "
+                    f"limit {basal_limit_units:.2f}U"
+                )
+                safety_status = max(safety_status, SafetyLevel.WARNING, key=lambda x: x.value)
         
         # 1. Hard Hypo Cutoff (absolute stop)
         if current_glucose <= self.hypo_cutoff:

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/validation/__init__.py

@@ -77,6 +77,10 @@ def build_stress_events(payloads: List[Dict[str, Any]]) -> List[StressEvent]:
                 reported_value=event_data.get("reported_value"),
                 absorption_delay_minutes=event_data.get("absorption_delay_minutes", 0),
                 duration=event_data.get("duration", 0),
+                isf=event_data.get("isf"),
+                icr=event_data.get("icr"),
+                basal_rate=event_data.get("basal_rate"),
+                dia_minutes=event_data.get("dia_minutes"),
             )
         )
     return events

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16}/src/iints/validation/schemas.py

@@ -9,11 +9,15 @@ class StressEventModel(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     start_time: int = Field(ge=0)
-    event_type: Literal["meal", "missed_meal", "sensor_error", "exercise", "exercise_end"]
+    event_type: Literal["meal", "missed_meal", "sensor_error", "exercise", "exercise_end", "ratio_change"]
     value: Optional[float] = None
     reported_value: Optional[float] = None
     absorption_delay_minutes: int = Field(default=0, ge=0)
     duration: int = Field(default=0, ge=0)
+    isf: Optional[float] = Field(default=None, gt=0)
+    icr: Optional[float] = Field(default=None, gt=0)
+    basal_rate: Optional[float] = Field(default=None, ge=0)
+    dia_minutes: Optional[float] = Field(default=None, gt=0)
 
     @model_validator(mode="after")
     def _check_required_fields(self) -> "StressEventModel":
@@ -26,6 +30,12 @@ class StressEventModel(BaseModel):
         if self.event_type == "sensor_error":
             if self.value is None:
                 raise ValueError("sensor_error requires a value")
+        if self.event_type == "ratio_change":
+            if all(
+                val is None
+                for val in (self.isf, self.icr, self.basal_rate, self.dia_minutes)
+            ):
+                raise ValueError("ratio_change requires at least one ratio value (isf/icr/basal_rate/dia_minutes)")
         return self
 
 

{iints_sdk_python35-0.1.15 → iints_sdk_python35-0.1.16/src/iints_sdk_python35.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iints-sdk-python35
-Version: 0.1.15
+Version: 0.1.16
 Summary: A pre-clinical Edge-AI SDK for diabetes management validation.
 Author-email: Rune Bobbaers <rune.bobbaers@gmail.com>
 Project-URL: Homepage, https://github.com/python35/IINTS-SDK