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

iints/utils/plotting.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Iterable, List, Optional
+
+
+IINTS_BLUE = "#00798c"
+IINTS_RED = "#d1495b"
+IINTS_ORANGE = "#f4a261"
+IINTS_TEAL = "#2a9d8f"
+IINTS_NAVY = "#264653"
+IINTS_GOLD = "#e9c46a"
+
+
+def apply_plot_style(
+    dpi: int = 150,
+    font_scale: float = 1.1,
+    palette: Optional[Iterable[str]] = None,
+) -> List[str]:
+    """
+    Apply IINTS paper-ready plotting defaults (Matplotlib/Seaborn).
+
+    Returns the palette used.
+    """
+    try:
+        import matplotlib as mpl
+        import seaborn as sns
+    except Exception as exc:  # pragma: no cover - optional dependency
+        raise ImportError("Plot styling requires matplotlib and seaborn.") from exc
+
+    colors = list(
+        palette
+        if palette is not None
+        else [IINTS_BLUE, IINTS_RED, IINTS_ORANGE, IINTS_TEAL, IINTS_NAVY, IINTS_GOLD]
+    )
+
+    sns.set_theme(context="paper", style="whitegrid", palette=colors, font_scale=font_scale)
+    mpl.rcParams.update(
+        {
+            "figure.dpi": dpi,
+            "savefig.dpi": dpi,
+            "axes.titlesize": 14,
+            "axes.labelsize": 12,
+            "legend.fontsize": 10,
+            "xtick.labelsize": 10,
+            "ytick.labelsize": 10,
+            "axes.spines.top": False,
+            "axes.spines.right": False,
+        }
+    )
+    return colors

iints/utils/run_io.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from dataclasses import asdict, is_dataclass
+from datetime import datetime, timezone
+import json
+import hashlib
+import platform
+import random
+import sys
+import uuid
+import subprocess
+import os
+from importlib import metadata as importlib_metadata
+from typing import Mapping, cast
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+try:
+    from importlib.metadata import version as pkg_version
+except Exception:  # pragma: no cover - stdlib fallback
+    pkg_version = None  # type: ignore[assignment]
+
+
+def resolve_seed(seed: Optional[int]) -> int:
+    if seed is None:
+        seed = random.SystemRandom().randint(0, 2**31 - 1)
+    return int(seed)
+
+
+def generate_run_id(seed: int) -> str:
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+    token = uuid.uuid4().hex[:6]
+    return f"{timestamp}-{seed}-{token}"
+
+
+def resolve_output_dir(output_dir: Optional[Union[str, Path]], run_id: str) -> Path:
+    if output_dir is None:
+        output_path = Path.cwd() / "results" / run_id
+    else:
+        output_path = Path(output_dir).expanduser()
+        if not output_path.is_absolute():
+            output_path = (Path.cwd() / output_path).resolve()
+        else:
+            output_path = output_path.resolve()
+    output_path.mkdir(parents=True, exist_ok=True)
+    return output_path
+
+
+def _serialize_payload(payload: Any) -> Any:
+    if is_dataclass(payload) and not isinstance(payload, type):
+        return asdict(payload)
+    if isinstance(payload, Path):
+        return str(payload)
+    return payload
+
+
+def write_json(path: Path, payload: Dict[str, Any]) -> None:
+    safe_payload = {key: _serialize_payload(value) for key, value in payload.items()}
+    path.write_text(json.dumps(safe_payload, indent=2, sort_keys=True))
+
+
+def get_sdk_version(package_name: str = "iints-sdk-python35") -> str:
+    if pkg_version is None:
+        return "unknown"
+    try:
+        return pkg_version(package_name)
+    except Exception:
+        return "unknown"
+
+
+def build_run_metadata(run_id: str, seed: int, config: Dict[str, Any], output_dir: Path) -> Dict[str, Any]:
+    dependencies = []
+    try:
+        for dist in importlib_metadata.distributions():
+            metadata = cast(Mapping[str, str], dist.metadata)
+            name = metadata.get("Name") or metadata.get("Summary") or metadata.get("name")
+            if name:
+                dependencies.append({"name": name, "version": dist.version})
+        dependencies = sorted(dependencies, key=lambda item: item["name"].lower())
+    except Exception:
+        dependencies = []
+
+    git_sha = "unknown"
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            git_sha = result.stdout.strip()
+    except Exception:
+        git_sha = "unknown"
+
+    return {
+        "run_id": run_id,
+        "created_at_utc": datetime.now(timezone.utc).isoformat(),
+        "seed": seed,
+        "output_dir": str(output_dir),
+        "sdk_version": get_sdk_version(),
+        "python_version": sys.version.split()[0],
+        "platform": platform.platform(),
+        "git_sha": git_sha,
+        "dependencies": dependencies,
+        "config": config,
+    }
+
+
+def compute_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8192), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def build_run_manifest(output_dir: Path, files: Dict[str, Path]) -> Dict[str, Any]:
+    manifest: Dict[str, Any] = {
+        "generated_at_utc": datetime.now(timezone.utc).isoformat(),
+        "output_dir": str(output_dir),
+        "files": {},
+    }
+    for label, path in files.items():
+        entry: Dict[str, Any] = {"path": str(path)}
+        if path.exists():
+            entry["sha256"] = compute_sha256(path)
+            entry["size_bytes"] = path.stat().st_size
+        else:
+            entry["missing"] = True
+        manifest["files"][label] = entry
+    return manifest
+
+
+def maybe_sign_manifest(manifest_path: Path) -> Optional[Path]:
+    """Optionally sign a manifest if IINTS_ATTEST_KEY is set."""
+    key_path = os.getenv("IINTS_ATTEST_KEY")
+    if not key_path:
+        return None
+    sig_path = manifest_path.with_suffix(".sig")
+    try:
+        result = subprocess.run(
+            ["openssl", "dgst", "-sha256", "-sign", key_path, "-out", str(sig_path), str(manifest_path)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            return None
+        return sig_path
+    except Exception:
+        return None

iints/validation/__init__.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import yaml
+from pydantic import ValidationError
+
+from iints.core.simulator import StressEvent
+from iints.validation.schemas import ScenarioModel, StressEventModel, PatientConfigModel, LATEST_SCHEMA_VERSION
+
+
+def _convert_legacy_scenario(data: Dict[str, Any]) -> Dict[str, Any]:
+    if "events" in data and "stress_events" not in data:
+        events = []
+        for event in data.get("events", []):
+            event_type = event.get("type")
+            if event_type == "carb_error":
+                event = dict(event)
+                event["reported_value"] = 0
+                event_type = "meal"
+            events.append(
+                {
+                    "start_time": event.get("time"),
+                    "event_type": event_type,
+                    "value": event.get("value"),
+                    "reported_value": event.get("reported_value"),
+                    "absorption_delay_minutes": event.get("absorption_delay_minutes", 0),
+                    "duration": event.get("duration", 0),
+                }
+            )
+        return {
+            "scenario_name": data.get("scenario_name", "Legacy Scenario"),
+            "scenario_version": data.get("scenario_version", "legacy"),
+            "description": data.get("description", ""),
+            "stress_events": events,
+        }
+    return data
+
+
+def migrate_scenario_dict(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalize legacy schemas into the latest scenario schema."""
+    data = _convert_legacy_scenario(data)
+    if "schema_version" not in data or not data.get("schema_version"):
+        data["schema_version"] = LATEST_SCHEMA_VERSION
+    if "scenario_version" not in data or not data.get("scenario_version"):
+        data["scenario_version"] = "1.0"
+    if "scenario_name" not in data or not data.get("scenario_name"):
+        data["scenario_name"] = "Unnamed Scenario"
+    return data
+
+
+def load_scenario(path: Union[str, Path]) -> ScenarioModel:
+    scenario_path = Path(path)
+    data = json.loads(scenario_path.read_text())
+    data = migrate_scenario_dict(data)
+    return ScenarioModel.model_validate(data)
+
+
+def validate_scenario_dict(data: Dict[str, Any]) -> ScenarioModel:
+    data = migrate_scenario_dict(data)
+    return ScenarioModel.model_validate(data)
+
+
+def scenario_warnings(model: ScenarioModel) -> List[str]:
+    warnings: List[str] = []
+    for idx, event in enumerate(model.stress_events):
+        prefix = f"event[{idx}]"
+        if event.event_type in {"meal", "missed_meal"} and event.value is not None:
+            if event.value > 200:
+                warnings.append(f"{prefix}: meal value {event.value}g is unusually high")
+        if event.absorption_delay_minutes > 120:
+            warnings.append(f"{prefix}: absorption_delay_minutes {event.absorption_delay_minutes} is unusual")
+        if event.duration > 240:
+            warnings.append(f"{prefix}: duration {event.duration} is unusual")
+    return warnings
+
+
+def build_stress_events(payloads: List[Dict[str, Any]]) -> List[StressEvent]:
+    events: List[StressEvent] = []
+    for event_data in payloads:
+        events.append(
+            StressEvent(
+                start_time=event_data["start_time"],
+                event_type=event_data["event_type"],
+                value=event_data.get("value"),
+                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
+
+
+def scenario_to_payloads(model: ScenarioModel) -> List[Dict[str, Any]]:
+    return [event.model_dump() for event in model.stress_events]
+
+
+def validate_patient_config_dict(data: Dict[str, Any]) -> PatientConfigModel:
+    return PatientConfigModel.model_validate(data)
+
+
+def load_patient_config(path: Union[str, Path]) -> PatientConfigModel:
+    config_path = Path(path)
+    data = yaml.safe_load(config_path.read_text())
+    return validate_patient_config_dict(data)
+
+
+def load_patient_config_by_name(name: str) -> PatientConfigModel:
+    filename = f"{name}.yaml" if not name.endswith(".yaml") else name
+    if sys.version_info >= (3, 9):
+        from importlib.resources import files
+        content = files("iints.data.virtual_patients").joinpath(filename).read_text()
+    else:
+        from importlib import resources
+        content = resources.read_text("iints.data.virtual_patients", filename)
+    data = yaml.safe_load(content)
+    return validate_patient_config_dict(data)
+
+
+def format_validation_error(error: ValidationError) -> List[str]:
+    lines: List[str] = []
+    for entry in error.errors():
+        loc = ".".join(str(item) for item in entry.get("loc", []))
+        msg = entry.get("msg", "Invalid value")
+        lines.append(f"{loc}: {msg}")
+    return lines

iints/validation/schemas.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Literal
+
+LATEST_SCHEMA_VERSION = "1.1"
+
+from pydantic import BaseModel, Field, ConfigDict, field_validator, model_validator
+
+
+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", "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":
+        if self.event_type in {"meal", "missed_meal"}:
+            if self.value is None or self.value <= 0:
+                raise ValueError("meal value must be > 0 grams")
+        if self.event_type == "exercise":
+            if self.value is None or not (0.0 <= self.value <= 1.0):
+                raise ValueError("exercise value must be between 0.0 and 1.0")
+        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
+
+
+class ScenarioModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    scenario_name: str = Field(min_length=1)
+    schema_version: str = Field(default=LATEST_SCHEMA_VERSION, min_length=1)
+    scenario_version: str = Field(min_length=1)
+    description: Optional[str] = None
+    stress_events: List[StressEventModel] = Field(default_factory=list)
+
+    @field_validator("schema_version", mode="before")
+    @classmethod
+    def _normalize_schema_version(cls, value: Any) -> str:
+        if isinstance(value, (int, float)):
+            return str(value)
+        if value is None:
+            return LATEST_SCHEMA_VERSION
+        return str(value)
+
+    @field_validator("scenario_version", mode="before")
+    @classmethod
+    def _normalize_version(cls, value: Any) -> str:
+        if isinstance(value, (int, float)):
+            return str(value)
+        if value is None:
+            raise ValueError("scenario_version is required")
+        return str(value)
+
+
+class PatientConfigModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    basal_insulin_rate: float = Field(default=0.8, ge=0.0, le=3.0)
+    insulin_sensitivity: float = Field(default=50.0, ge=10.0, le=200.0)
+    carb_factor: float = Field(default=10.0, ge=3.0, le=30.0)
+    glucose_decay_rate: float = Field(default=0.05, ge=0.0, le=0.2)
+    initial_glucose: float = Field(default=120.0, ge=40.0, le=400.0)
+    glucose_absorption_rate: float = Field(default=0.03, ge=0.0, le=0.2)
+    insulin_action_duration: float = Field(default=300.0, ge=60.0, le=720.0)
+    insulin_peak_time: float = Field(default=75.0, ge=15.0, le=240.0)
+    meal_mismatch_epsilon: float = Field(default=1.0, ge=0.5, le=1.5)
+    dawn_phenomenon_strength: float = Field(default=0.0, ge=0.0, le=50.0)
+    dawn_start_hour: float = Field(default=4.0, ge=0.0, le=23.0)
+    dawn_end_hour: float = Field(default=8.0, ge=0.0, le=24.0)
+
+    @model_validator(mode="after")
+    def _check_peak_vs_duration(self) -> "PatientConfigModel":
+        if self.insulin_peak_time >= self.insulin_action_duration:
+            raise ValueError("insulin_peak_time must be less than insulin_action_duration")
+        if self.dawn_end_hour <= self.dawn_start_hour:
+            raise ValueError("dawn_end_hour must be greater than dawn_start_hour")
+        return self

iints/visualization/__init__.py

@@ -0,0 +1,34 @@
+"""
+IINTS-AF Visualization Module
+Professional medical visualizations for diabetes algorithm research.
+
+Includes:
+- Uncertainty Cloud: AI confidence visualization
+- Clinical Cockpit: Full dashboard for research
+- Algorithm comparison charts
+"""
+
+from .uncertainty_cloud import (
+    UncertaintyCloud,
+    UncertaintyData,
+    VisualizationConfig
+)
+
+from .cockpit import (
+    ClinicalCockpit,
+    CockpitConfig,
+    DashboardState
+)
+
+__all__ = [
+    # Uncertainty Cloud
+    'UncertaintyCloud',
+    'UncertaintyData',
+    'VisualizationConfig',
+    
+    # Clinical Cockpit
+    'ClinicalCockpit',
+    'CockpitConfig',
+    'DashboardState'
+]
+