iints-sdk-python35 0.0.18__py3-none-any.whl

iints/core/algorithms/mock_algorithms.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from typing import Dict, Any, Optional
+
+import numpy as np
+
+from iints.api.base_algorithm import InsulinAlgorithm, AlgorithmInput, AlgorithmMetadata
+
+
+class ConstantDoseAlgorithm(InsulinAlgorithm):
+    """Always returns a fixed insulin dose for CI and smoke testing."""
+
+    def __init__(self, dose: float = 0.5, settings: Optional[Dict[str, Any]] = None):
+        super().__init__(settings)
+        self.dose = max(0.0, float(dose))
+
+    def get_algorithm_metadata(self) -> AlgorithmMetadata:
+        return AlgorithmMetadata(
+            name="ConstantDoseAlgorithm",
+            version="1.0",
+            author="IINTS-AF SDK",
+            algorithm_type="Mock",
+            description="Always delivers a fixed insulin dose for CI testing.",
+            requires_training=False,
+            supported_scenarios=["baseline", "testing"],
+        )
+
+    def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
+        return {
+            "total_insulin_delivered": self.dose,
+            "basal_insulin": self.dose,
+            "bolus_insulin": 0.0,
+            "meal_bolus": 0.0,
+            "correction_bolus": 0.0,
+            "uncertainty": 0.0,
+            "fallback_triggered": False,
+        }
+
+
+class RandomDoseAlgorithm(InsulinAlgorithm):
+    """Returns a random dose within a safe range for stochastic testing."""
+
+    def __init__(self, max_dose: float = 1.0, seed: Optional[int] = None, settings: Optional[Dict[str, Any]] = None):
+        super().__init__(settings)
+        self.max_dose = max(0.0, float(max_dose))
+        self.rng = np.random.default_rng(seed)
+
+    def get_algorithm_metadata(self) -> AlgorithmMetadata:
+        return AlgorithmMetadata(
+            name="RandomDoseAlgorithm",
+            version="1.0",
+            author="IINTS-AF SDK",
+            algorithm_type="Mock",
+            description="Produces randomized doses for stress-testing and CI.",
+            requires_training=False,
+            supported_scenarios=["baseline", "testing"],
+        )
+
+    def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
+        dose = float(self.rng.uniform(0.0, self.max_dose))
+        return {
+            "total_insulin_delivered": dose,
+            "basal_insulin": dose,
+            "bolus_insulin": 0.0,
+            "meal_bolus": 0.0,
+            "correction_bolus": 0.0,
+            "uncertainty": 0.0,
+            "fallback_triggered": False,
+        }
+
+
+class RunawayAIAlgorithm(InsulinAlgorithm):
+    """Delivers a maximal bolus during glucose decline to stress-test supervisor."""
+
+    def __init__(
+        self,
+        max_bolus: float = 5.0,
+        trigger_glucose: float = 140.0,
+        settings: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(settings)
+        self.max_bolus = max(0.0, float(max_bolus))
+        self.trigger_glucose = float(trigger_glucose)
+
+    def get_algorithm_metadata(self) -> AlgorithmMetadata:
+        return AlgorithmMetadata(
+            name="RunawayAIAlgorithm",
+            version="1.0",
+            author="IINTS-AF SDK",
+            algorithm_type="Chaos",
+            description="Forces max bolus during falling glucose to test safety supervisor.",
+            requires_training=False,
+            supported_scenarios=["chaos", "runaway_ai"],
+        )
+
+    def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
+        trend = data.glucose_trend_mgdl_min
+        if data.current_glucose <= self.trigger_glucose or (trend is not None and trend < 0):
+            dose = self.max_bolus
+        else:
+            dose = 0.0
+        return {
+            "total_insulin_delivered": dose,
+            "basal_insulin": 0.0,
+            "bolus_insulin": dose,
+            "meal_bolus": 0.0,
+            "correction_bolus": dose,
+            "uncertainty": 0.0,
+            "fallback_triggered": False,
+        }
+
+
+class StackingAIAlgorithm(InsulinAlgorithm):
+    """Delivers repeated boluses over consecutive steps to simulate stacking."""
+
+    def __init__(
+        self,
+        bolus_units: float = 4.0,
+        stack_steps: int = 3,
+        trigger_glucose: float = 180.0,
+        settings: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(settings)
+        self.bolus_units = max(0.0, float(bolus_units))
+        self.stack_steps = max(1, int(stack_steps))
+        self.trigger_glucose = float(trigger_glucose)
+        self._remaining = 0
+
+    def get_algorithm_metadata(self) -> AlgorithmMetadata:
+        return AlgorithmMetadata(
+            name="StackingAIAlgorithm",
+            version="1.0",
+            author="IINTS-AF SDK",
+            algorithm_type="Chaos",
+            description="Stacks multiple boluses across consecutive steps.",
+            requires_training=False,
+            supported_scenarios=["chaos", "stacking"],
+        )
+
+    def reset(self) -> None:
+        super().reset()
+        self._remaining = 0
+
+    def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
+        if self._remaining <= 0 and data.current_glucose >= self.trigger_glucose:
+            self._remaining = self.stack_steps
+
+        if self._remaining > 0:
+            dose = self.bolus_units
+            self._remaining -= 1
+        else:
+            dose = 0.0
+
+        return {
+            "total_insulin_delivered": dose,
+            "basal_insulin": 0.0,
+            "bolus_insulin": dose,
+            "meal_bolus": 0.0,
+            "correction_bolus": dose,
+            "uncertainty": 0.0,
+            "fallback_triggered": False,
+        }

iints/core/algorithms/pid_controller.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+Industry-Standard PID Controller - IINTS-AF
+Simple PID implementation for algorithm comparison
+"""
+
+import numpy as np
+from iints.api.base_algorithm import InsulinAlgorithm, AlgorithmInput
+
+class PIDController(InsulinAlgorithm):
+    """Industry-standard PID controller for glucose management"""
+    
+    def __init__(self):
+        super().__init__()
+        
+        # PID parameters (tuned for glucose control)
+        self.kp = 0.1   # Proportional gain
+        self.ki = 0.01  # Integral gain  
+        self.kd = 0.05  # Derivative gain
+        
+        # Controller state
+        self.integral = 0
+        self.previous_error = 0
+        self.target_glucose = 120  # mg/dL target
+        
+        # Safety limits
+        self.max_insulin = 5.0  # Maximum insulin dose
+        self.min_insulin = 0.0  # Minimum insulin dose
+        
+    def predict_insulin(self, data: AlgorithmInput):
+        self.why_log = [] # Clear the log for this prediction cycle
+
+        # Calculate error from target
+        error = data.current_glucose - self.target_glucose
+        self._log_reason(f"Glucose error from target ({self.target_glucose} mg/dL)", "glucose_level", error, f"Current glucose: {data.current_glucose:.0f} mg/dL")
+        
+        # Integral term (accumulated error)
+        self.integral += error
+        self._log_reason("Integral term updated", "control_parameter", self.integral)
+        
+        # Derivative term (rate of change)
+        derivative = error - self.previous_error
+        self._log_reason("Derivative term calculated", "control_parameter", derivative)
+        
+        # PID formula
+        insulin_dose = (self.kp * error + 
+                       self.ki * self.integral + 
+                       self.kd * derivative)
+        self._log_reason("Initial insulin dose calculated by PID", "insulin_calculation", insulin_dose)
+        
+        # Update previous error for next iteration
+        self.previous_error = error
+        
+        # Apply safety constraints
+        original_insulin_dose = insulin_dose
+        insulin_dose = max(self.min_insulin, min(insulin_dose, self.max_insulin))
+        if insulin_dose != original_insulin_dose:
+            self._log_reason(f"Insulin dose adjusted due to safety limits (min: {self.min_insulin}, max: {self.max_insulin})", 
+                             "safety_constraint", 
+                             f"Original: {original_insulin_dose:.2f}, Adjusted: {insulin_dose:.2f}")
+        else:
+            self._log_reason("Insulin dose within safety limits", "safety_constraint", insulin_dose)
+        
+        return {
+            'total_insulin_delivered': insulin_dose,
+            'bolus_insulin': insulin_dose,
+            'basal_insulin': 0
+        }
+    
+    def reset(self):
+        """Reset controller state for new patient"""
+        super().reset()
+        self.integral = 0
+        self.previous_error = 0
+    
+    def get_algorithm_info(self):
+        """Return algorithm information"""
+        return {
+            'name': 'Industry PID Controller',
+            'type': 'Classical Control',
+            'parameters': {
+                'kp': self.kp,
+                'ki': self.ki, 
+                'kd': self.kd,
+                'target_glucose': self.target_glucose
+            },
+            'description': 'Industry-standard PID controller for glucose regulation'
+        }

iints/core/algorithms/standard_pump_algo.py

@@ -0,0 +1,64 @@
+from iints import InsulinAlgorithm, AlgorithmInput, AlgorithmMetadata
+from typing import Dict, Any, Optional
+
+class StandardPumpAlgorithm(InsulinAlgorithm):
+    """
+    A simplified algorithm representing a standard insulin pump.
+    It delivers a fixed basal rate and a simple bolus based on carbs,
+    with minimal correction for high glucose.
+    """
+    def __init__(self, settings: Optional[Dict[str, Any]] = None):
+        super().__init__(settings)
+        self.set_algorithm_metadata(AlgorithmMetadata(
+            name="Standard Pump",
+            author="IINTS-AF Team",
+            description="A basic insulin pump algorithm with fixed basal and simple carb/correction bolus.",
+            algorithm_type="rule_based"
+        ))
+        # Default settings for a standard pump
+        self.isf = self.settings.get('isf', 50.0)  # Insulin Sensitivity Factor (mg/dL per Unit)
+        self.icr = self.settings.get('icr', 10.0)  # Insulin to Carb Ratio (grams per Unit)
+        self.basal_rate_per_hour = self.settings.get('basal_rate_per_hour', 0.8) # U/hr
+        self.target_glucose = self.settings.get('target_glucose', 100.0) # mg/dL
+
+    def predict_insulin(self, data: AlgorithmInput) -> Dict[str, Any]:
+        self.why_log = [] # Clear log for each prediction
+
+        total_insulin = 0.0
+        bolus_insulin = 0.0
+        basal_insulin = 0.0
+        correction_bolus = 0.0
+        meal_bolus = 0.0
+
+        # 1. Basal Insulin
+        # Convert hourly basal rate to dose for the current time step
+        basal_insulin = (self.basal_rate_per_hour / 60.0) * data.time_step
+        total_insulin += basal_insulin
+        self._log_reason("Fixed basal insulin", "basal", basal_insulin, f"Delivered {basal_insulin:.2f} units for {data.time_step} min.")
+
+        # 2. Meal Bolus
+        if data.carb_intake > 0:
+            meal_bolus = data.carb_intake / self.icr
+            total_insulin += meal_bolus
+            self._log_reason("Meal bolus for carb intake", "carb_intake", data.carb_intake, f"Delivered {meal_bolus:.2f} units for {data.carb_intake}g carbs.")
+        
+        # 3. Correction Bolus (simple)
+        # Only correct if glucose is significantly above target and not too much IOB
+        if data.current_glucose > self.target_glucose + 20 and data.insulin_on_board < 1.0:
+            correction_bolus = (data.current_glucose - self.target_glucose) / self.isf / 2 # Correct half the difference
+            if correction_bolus > 0:
+                total_insulin += correction_bolus
+                self._log_reason("Correction bolus for high glucose", "glucose_level", data.current_glucose, f"Delivered {correction_bolus:.2f} units to correct {data.current_glucose} mg/dL.")
+        
+        # Ensure no negative insulin delivery
+        total_insulin = max(0.0, total_insulin)
+
+        self._log_reason(f"Final insulin decision: {total_insulin:.2f} units", "decision", total_insulin)
+
+        return {
+            "total_insulin_delivered": total_insulin,
+            "bolus_insulin": bolus_insulin,
+            "basal_insulin": basal_insulin,
+            "correction_bolus": correction_bolus,
+            "meal_bolus": meal_bolus,
+        }

iints/core/device_manager.py

@@ -0,0 +1,64 @@
+import sys
+from typing import Optional
+
+try:
+    import torch  # type: ignore
+    _TORCH_AVAILABLE = True
+except Exception:  # pragma: no cover - handles missing torch in CI
+    torch = None  # type: ignore
+    _TORCH_AVAILABLE = False
+
+
+class _FallbackDevice:
+    def __init__(self, name: str = "cpu") -> None:
+        self.type = name
+
+    def __str__(self) -> str:
+        return self.type
+
+    def __repr__(self) -> str:
+        return f"Device({self.type})"
+
+class DeviceManager:
+    """
+    Manages hardware device detection for cross-platform compatibility.
+    Detects MPS (Apple Silicon), CUDA (NVIDIA GPUs), or falls back to CPU.
+    """
+    def __init__(self):
+        self._device = self._detect_device()
+
+    def _detect_device(self):
+        if not _TORCH_AVAILABLE:
+            print("Torch not available. Falling back to CPU.")
+            return _FallbackDevice("cpu")
+
+        if sys.platform == "darwin" and torch.backends.mps.is_available():
+            print("Detected Apple Silicon (MPS) for accelerated computing.")
+            return torch.device("mps")
+        elif torch.cuda.is_available():
+            print(f"Detected NVIDIA GPU (CUDA) with {torch.cuda.device_count()} device(s) for accelerated computing.")
+            return torch.device("cuda")
+        else:
+            print("No GPU detected. Falling back to CPU for computing.")
+            return torch.device("cpu")
+
+    def get_device(self):
+        """
+        Returns the detected torch.device object.
+        """
+        return self._device
+
+# Example usage (for testing purposes, remove in final SDK if not needed)
+if __name__ == "__main__":
+    device_manager = DeviceManager()
+    device = device_manager.get_device()
+    print(f"Using device: {device}")
+
+    # Small test to ensure device is working
+    try:
+        x = torch.randn(10, 10, device=device)
+        y = torch.randn(10, 10, device=device)
+        z = x @ y
+        print(f"Successfully performed a matrix multiplication on {device}.")
+    except Exception as e:
+        print(f"Error performing test on {device}: {e}")

iints/core/devices/__init__.py

@@ -0,0 +1,3 @@
+from .models import SensorModel, PumpModel
+
+__all__ = ["SensorModel", "PumpModel"]

iints/core/devices/models.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, Tuple
+
+import numpy as np
+
+
+@dataclass
+class SensorReading:
+    value: float
+    status: str
+
+
+class SensorModel:
+    """
+    Sensor error model for CGM readings.
+
+    Supports noise, bias, lag (minutes), and dropout (hold last value).
+    """
+
+    def __init__(
+        self,
+        noise_std: float = 0.0,
+        bias: float = 0.0,
+        lag_minutes: int = 0,
+        dropout_prob: float = 0.0,
+        seed: Optional[int] = None,
+    ) -> None:
+        self.noise_std = noise_std
+        self.bias = bias
+        self.lag_minutes = lag_minutes
+        self.dropout_prob = dropout_prob
+        self._rng = np.random.default_rng(seed)
+        self._history: list[tuple[float, float]] = []
+        self._last_reading: Optional[float] = None
+
+    def reset(self) -> None:
+        self._history = []
+        self._last_reading = None
+
+    def read(self, true_glucose: float, current_time: float) -> SensorReading:
+        self._history.append((current_time, true_glucose))
+        # Keep history window bounded
+        if self.lag_minutes > 0:
+            cutoff = current_time - (self.lag_minutes * 2)
+            self._history = [(t, v) for (t, v) in self._history if t >= cutoff]
+
+        if self.lag_minutes > 0:
+            target_time = current_time - self.lag_minutes
+            candidates = [v for (t, v) in self._history if t <= target_time]
+            base = candidates[-1] if candidates else true_glucose
+        else:
+            base = true_glucose
+
+        reading = base + self.bias
+        if self.noise_std > 0:
+            reading += float(self._rng.normal(0, self.noise_std))
+
+        status = "ok"
+        if self.dropout_prob > 0 and float(self._rng.random()) < self.dropout_prob:
+            status = "dropout_hold"
+            if self._last_reading is not None:
+                reading = self._last_reading
+
+        self._last_reading = reading
+        return SensorReading(value=reading, status=status)
+
+    def get_state(self) -> Dict[str, Any]:
+        return {
+            "noise_std": self.noise_std,
+            "bias": self.bias,
+            "lag_minutes": self.lag_minutes,
+            "dropout_prob": self.dropout_prob,
+            "last_reading": self._last_reading,
+            "history": self._history,
+        }
+
+    def set_state(self, state: Dict[str, Any]) -> None:
+        self.noise_std = state.get("noise_std", self.noise_std)
+        self.bias = state.get("bias", self.bias)
+        self.lag_minutes = state.get("lag_minutes", self.lag_minutes)
+        self.dropout_prob = state.get("dropout_prob", self.dropout_prob)
+        self._last_reading = state.get("last_reading")
+        self._history = state.get("history", [])
+
+
+@dataclass
+class PumpDelivery:
+    delivered_units: float
+    status: str
+    reason: str
+
+
+class PumpModel:
+    """
+    Pump error model for insulin delivery.
+
+    Supports max delivery per step, quantization, and occlusion/dropout.
+    """
+
+    def __init__(
+        self,
+        max_units_per_step: Optional[float] = None,
+        quantization_units: Optional[float] = None,
+        dropout_prob: float = 0.0,
+        delivery_noise_std: float = 0.0,
+        seed: Optional[int] = None,
+    ) -> None:
+        self.max_units_per_step = max_units_per_step
+        self.quantization_units = quantization_units
+        self.dropout_prob = dropout_prob
+        self.delivery_noise_std = delivery_noise_std
+        self._rng = np.random.default_rng(seed)
+
+    def reset(self) -> None:
+        pass
+
+    def deliver(self, requested_units: float, time_step_minutes: float) -> PumpDelivery:
+        delivered = requested_units
+        status = "ok"
+        reason = "approved"
+
+        if delivered < 0.0:
+            delivered = 0.0
+            status = "clamped"
+            reason = "negative_request"
+
+        if self.max_units_per_step is not None and delivered > self.max_units_per_step:
+            delivered = self.max_units_per_step
+            status = "capped"
+            reason = f"max_units_per_step {self.max_units_per_step:.2f}"
+
+        if self.quantization_units:
+            delivered = round(delivered / self.quantization_units) * self.quantization_units
+
+        if self.delivery_noise_std > 0:
+            delivered += float(self._rng.normal(0, self.delivery_noise_std))
+            delivered = max(0.0, delivered)
+
+        if self.dropout_prob > 0 and float(self._rng.random()) < self.dropout_prob:
+            delivered = 0.0
+            status = "occlusion"
+            reason = "pump_dropout"
+
+        return PumpDelivery(delivered_units=delivered, status=status, reason=reason)
+
+    def get_state(self) -> Dict[str, Any]:
+        return {
+            "max_units_per_step": self.max_units_per_step,
+            "quantization_units": self.quantization_units,
+            "dropout_prob": self.dropout_prob,
+            "delivery_noise_std": self.delivery_noise_std,
+        }
+
+    def set_state(self, state: Dict[str, Any]) -> None:
+        self.max_units_per_step = state.get("max_units_per_step", self.max_units_per_step)
+        self.quantization_units = state.get("quantization_units", self.quantization_units)
+        self.dropout_prob = state.get("dropout_prob", self.dropout_prob)
+        self.delivery_noise_std = state.get("delivery_noise_std", self.delivery_noise_std)

iints/core/patient/__init__.py

@@ -0,0 +1,9 @@
+from .profile import PatientProfile
+from .models import PatientModel
+
+try:
+    from .bergman_model import BergmanPatientModel
+except ImportError:  # pragma: no cover - scipy may not be installed
+    BergmanPatientModel = None  # type: ignore[assignment,misc]
+
+__all__ = ["PatientProfile", "PatientModel", "BergmanPatientModel"]