iints-sdk-python35 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

iints/__init__.py

@@ -3,7 +3,15 @@
 import pandas as pd # Required for type hints like pd.DataFrame
 from typing import Optional
 
-__version__ = "0.1.22"
+try:
+    from importlib.metadata import PackageNotFoundError, version
+except ImportError:  # pragma: no cover - Python < 3.8 fallback
+    from importlib_metadata import PackageNotFoundError, version  # type: ignore
+
+try:
+    __version__ = version("iints-sdk-python35")
+except PackageNotFoundError:  # pragma: no cover - source tree fallback
+    __version__ = "1.1.2"
 
 # 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/__init__.py

@@ -1,6 +1,8 @@
 from .assistant import AIResponse, IINTSAssistant
 from .backends import DEFAULT_MINISTRAL_MODEL, DEFAULT_OLLAMA_HOST, OllamaBackend
 from .mdmp_guard import GuardResult, MDMPGuard
+from .model_catalog import LocalMistralModelProfile, list_local_mistral_models
+from .prepare import prepare_ai_ready_artifacts
 
 __all__ = [
     "AIResponse",
@@ -10,4 +12,7 @@ __all__ = [
     "OllamaBackend",
     "GuardResult",
     "MDMPGuard",
+    "LocalMistralModelProfile",
+    "list_local_mistral_models",
+    "prepare_ai_ready_artifacts",
 ]

iints/ai/backends/mistral_api.py

@@ -13,5 +13,5 @@ class MistralAPIBackend:
     def complete(self, *, system_prompt: str, user_prompt: str) -> str:
         raise RuntimeError(
             "Cloud fallback is not enabled in this SDK build yet. "
-            "Use mode='local' with Ollama for Ministral."
+            "Use mode='local' with Ollama for the open Ministral 3 model."
         )

iints/ai/backends/ollama.py

@@ -6,12 +6,19 @@ from urllib import error, request
 
 
 DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434"
-DEFAULT_MINISTRAL_MODEL = "mistral/ministral-8b-instruct"
+DEFAULT_MINISTRAL_MODEL = "ministral-3:8b"
+LEGACY_MINISTRAL_MODEL = "mistral/ministral-8b-instruct"
+MIN_OLLAMA_VERSION_FOR_MINISTRAL_3 = (0, 13, 1)
 MINISTRAL_MODEL_ALIASES = (
     DEFAULT_MINISTRAL_MODEL,
+    "ministral-3",
+    "ministral-3:latest",
+    "ministral-3:8b",
+    "ministral-3:8b-instruct",
     "ministral",
     "ministral-8b",
     "ministral-8b-instruct",
+    LEGACY_MINISTRAL_MODEL,
 )
 
 
@@ -23,7 +30,7 @@ class OllamaBackend:
         *,
         model_name: str = DEFAULT_MINISTRAL_MODEL,
         base_url: str | None = None,
-        timeout_seconds: float = 60.0,
+        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("/")
@@ -33,6 +40,28 @@ class OllamaBackend:
     def _pull_hint(self) -> str:
         return f"ollama pull {self.model_name}"
 
+    def _requires_ministral_3_runtime(self) -> bool:
+        requested = self.model_name.strip().lower()
+        return requested.startswith("ministral-3") or requested == "ministral"
+
+    @staticmethod
+    def _parse_version(raw_version: str) -> tuple[int, ...] | None:
+        value = raw_version.strip().lower().lstrip("v")
+        numeric_parts: list[int] = []
+        for part in value.split("."):
+            digits = ""
+            for char in part:
+                if char.isdigit():
+                    digits += char
+                else:
+                    break
+            if not digits:
+                break
+            numeric_parts.append(int(digits))
+        if not numeric_parts:
+            return None
+        return tuple(numeric_parts)
+
     def _request_json(
         self,
         path: str,
@@ -79,6 +108,27 @@ class OllamaBackend:
             return False
         return True
 
+    def server_version(self) -> str | None:
+        try:
+            response = self._request_json("/api/version", method="GET")
+        except Exception:
+            return None
+        raw_version = response.get("version")
+        if isinstance(raw_version, str) and raw_version.strip():
+            return raw_version.strip()
+        return None
+
+    def version_supported(self) -> tuple[bool | None, str | None]:
+        version = self.server_version()
+        if version is None:
+            return None, None
+        if not self._requires_ministral_3_runtime():
+            return True, version
+        parsed = self._parse_version(version)
+        if parsed is None:
+            return None, version
+        return parsed >= MIN_OLLAMA_VERSION_FOR_MINISTRAL_3, version
+
     def list_models(self) -> list[str]:
         response = self._request_json("/api/tags", method="GET")
         raw_models = response.get("models", [])
@@ -102,12 +152,24 @@ class OllamaBackend:
             return installed_lookup[self.model_name.lower()]
 
         requested = self.model_name.strip().lower()
-        if requested in {"ministral", "ministral-8b", "ministral-8b-instruct"}:
+        if requested in {
+            "ministral",
+            "ministral-3",
+            "ministral-3:latest",
+            "ministral-3:8b",
+            "ministral-3:8b-instruct",
+            "ministral-8b",
+            "ministral-8b-instruct",
+        }:
             for alias in MINISTRAL_MODEL_ALIASES:
                 resolved = installed_lookup.get(alias.lower())
                 if resolved is not None:
                     return resolved
 
+        for installed_name in installed:
+            lowered = installed_name.lower()
+            if "ministral-3" in lowered and "8b" in lowered:
+                return installed_name
         for installed_name in installed:
             lowered = installed_name.lower()
             if "ministral" in lowered and "8b" in lowered:
@@ -116,6 +178,14 @@ class OllamaBackend:
         return None
 
     def ensure_model_ready(self) -> str:
+        version_ok, version = self.version_supported()
+        if version_ok is False:
+            required_version = ".".join(str(part) for part in MIN_OLLAMA_VERSION_FOR_MINISTRAL_3)
+            raise RuntimeError(
+                "The open Ministral 3 local model requires a newer Ollama runtime.\n"
+                f"Detected Ollama: {version}\n"
+                f"Required Ollama: >= {required_version}"
+            )
         try:
             resolved = self.resolve_model_name()
         except RuntimeError:
@@ -137,6 +207,7 @@ class OllamaBackend:
         return resolved
 
     def healthcheck(self) -> dict[str, object]:
+        version_ok, version = self.version_supported()
         installed = self.list_models()
         resolved = self.resolve_model_name() if installed else None
         return {
@@ -148,6 +219,8 @@ class OllamaBackend:
             "ready": resolved is not None,
             "pull_command": None if resolved is not None else self._pull_hint(),
             "timeout_seconds": self.timeout_seconds,
+            "server_version": version,
+            "version_ok": version_ok,
         }
 
     def complete(self, *, system_prompt: str, user_prompt: str) -> str:

iints/ai/cli.py

@@ -7,10 +7,13 @@ from typing import Any, Optional
 import typer
 from rich.console import Console
 from rich.panel import Panel
+from rich.table import Table
 from typing_extensions import Annotated
 
 from .assistant import AIResponse, IINTSAssistant
 from .backends import DEFAULT_MINISTRAL_MODEL, OllamaBackend
+from .model_catalog import list_local_mistral_models
+from .prepare import prepare_ai_ready_artifacts
 
 
 app = typer.Typer(help="Research-only AI assistant commands gated by MDMP certification.")
@@ -34,6 +37,57 @@ def _load_json_payload(path: Path, label: str) -> Any:
     return payload
 
 
+def _default_prepared_payload(task: str, ai_dir: Path) -> Path:
+    candidates = {
+        "explain": ["step_riskiest.json", "step_latest.json"],
+        "trends": ["trends_payload.json"],
+        "anomalies": ["anomalies_payload.json"],
+        "report": ["report_payload.json"],
+    }.get(task, [])
+    for filename in candidates:
+        candidate = ai_dir / filename
+        if candidate.is_file():
+            return candidate
+    expected = ", ".join(candidates) if candidates else "prepared payload"
+    raise typer.BadParameter(
+        f"No prepared AI payload found in {ai_dir}. Expected one of: {expected}. "
+        "Run `iints ai prepare <run_dir>` first."
+    )
+
+
+def _resolve_cli_inputs(
+    *,
+    task: str,
+    input_path: Path,
+    mdmp_cert: Path | None,
+    public_key: Path | None,
+    trust_store: Path | None,
+) -> tuple[Path, Path, Path | None]:
+    resolved_input = input_path
+    resolved_cert = mdmp_cert
+    resolved_public_key = public_key
+
+    if input_path.is_dir():
+        ai_dir = input_path / "ai"
+        resolved_input = _default_prepared_payload(task, ai_dir)
+        if resolved_cert is None:
+            candidate_cert = ai_dir / "report.signed.mdmp"
+            if candidate_cert.is_file():
+                resolved_cert = candidate_cert
+        if resolved_public_key is None and trust_store is None:
+            candidate_public_key = ai_dir / "keys" / "mdmp_pub_v1.pem"
+            if candidate_public_key.is_file():
+                resolved_public_key = candidate_public_key
+
+    if resolved_cert is None:
+        raise typer.BadParameter(
+            "No MDMP certificate provided. Pass --mdmp-cert or run "
+            "`iints ai prepare <run_dir>` to generate a local development certificate."
+        )
+
+    return resolved_input, resolved_cert, resolved_public_key
+
+
 def _write_output(path: Path | None, response: AIResponse) -> None:
     if path is None:
         return
@@ -64,6 +118,7 @@ def _render_local_check(console: Console, status: dict[str, object]) -> None:
                     f"Endpoint: {status.get('base_url')}",
                     f"Requested model: {status.get('requested_model')}",
                     f"Resolved local model: {resolved_model}",
+                    f"Server version: {status.get('server_version') or 'unknown'}",
                     f"Timeout (s): {status.get('timeout_seconds')}",
                     f"Installed models: {installed_text}",
                     (
@@ -78,9 +133,81 @@ def _render_local_check(console: Console, status: dict[str, object]) -> None:
         )
     )
     if ready:
-        console.print("[green]Local Ollama backend is ready for Ministral inference.[/green]")
+        console.print("[green]Local Ollama backend is ready for open Ministral 3 inference.[/green]")
     else:
         console.print("[bold red]Local Ollama backend is reachable, but the requested model is missing.[/bold red]")
+    if status.get("version_ok") is False:
+        console.print("[bold red]Ollama is too old for the open Ministral 3 runtime.[/bold red]")
+
+
+@app.command("models")
+def models() -> None:
+    console = Console()
+    table = Table(title="IINTS AI Local Mistral Model Guide")
+    table.add_column("Model Tag", style="cyan", no_wrap=True)
+    table.add_column("Best For", style="green")
+    table.add_column("Approx Download")
+    table.add_column("System RAM")
+    table.add_column("GPU VRAM")
+    table.add_column("Notes", overflow="fold")
+
+    for profile in list_local_mistral_models():
+        vram = f"{profile.recommended_vram_gb}+ GB" if profile.recommended_vram_gb is not None else "CPU-only"
+        table.add_row(
+            profile.tag,
+            profile.fit,
+            f"{profile.approx_download_gb:.1f} GB",
+            f"{profile.recommended_system_ram_gb}+ GB",
+            vram,
+            profile.notes,
+        )
+
+    console.print(table)
+    console.print(
+        "[dim]Tip:[/dim] start with "
+        f"`{DEFAULT_MINISTRAL_MODEL}` unless you know your hardware can comfortably run a larger local model."
+    )
+
+
+@app.command("prepare")
+def prepare(
+    run_dir: Annotated[Path, typer.Argument(help="Run output directory containing results.csv and run_metadata.json.")],
+    create_dev_mdmp_cert: Annotated[
+        bool,
+        typer.Option(
+            "--create-dev-mdmp-cert/--no-create-dev-mdmp-cert",
+            help="Generate a local development MDMP certificate and keypair for AI commands.",
+        ),
+    ] = True,
+    grade: Annotated[str, typer.Option(help="Grade to embed in the local development MDMP certificate.")] = "research_grade",
+    expires_days: Annotated[int, typer.Option(help="Certificate expiry window in days for local development certs.")] = 30,
+    key_dir: Annotated[Optional[Path], typer.Option(help="Optional directory to store the generated local MDMP keypair.")] = None,
+) -> None:
+    console = Console()
+    try:
+        outputs = prepare_ai_ready_artifacts(
+            run_dir,
+            create_dev_mdmp_cert=create_dev_mdmp_cert,
+            grade=grade,
+            expires_days=expires_days,
+            key_dir=key_dir,
+        )
+    except Exception as exc:
+        console.print(f"[bold red]Error:[/bold red] {exc}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="IINTS AI Prepared Artifacts")
+    table.add_column("Artifact", style="cyan")
+    table.add_column("Path", overflow="fold")
+    for key, value in outputs.items():
+        table.add_row(key, value)
+    console.print(table)
+    console.print("[green]Prepared AI payloads are ready.[/green]")
+    if "mdmp_cert" in outputs:
+        console.print(
+            "[green]You can now run:[/green] "
+            f"`iints ai report {run_dir}` or `iints ai explain {run_dir}`"
+        )
 
 
 def _build_assistant(
@@ -135,8 +262,8 @@ def local_check(
 
 @app.command("explain")
 def explain(
-    input_json: Annotated[Path, typer.Argument(help="JSON file with a single simulation step or decision context.")],
-    mdmp_cert: Annotated[Path, typer.Option(help="Signed MDMP artifact required before AI analysis can run.")],
+    input_json: Annotated[Path, typer.Argument(help="Prepared run directory or JSON file with a single simulation step or decision context.")],
+    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",
@@ -148,13 +275,20 @@ def explain(
 ) -> None:
     console = Console()
     try:
-        payload = _load_json_payload(input_json, "Input JSON")
-        assistant = _build_assistant(
+        resolved_input, resolved_cert, resolved_public_key = _resolve_cli_inputs(
+            task="explain",
+            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=public_key,
+            public_key=resolved_public_key,
             trust_store=trust_store,
             ollama_host=ollama_host,
             timeout_seconds=timeout_seconds,
@@ -169,8 +303,8 @@ def explain(
 
 @app.command("trends")
 def trends(
-    input_json: Annotated[Path, typer.Argument(help="JSON file with glucose trace data or a run payload.")],
-    mdmp_cert: Annotated[Path, typer.Option(help="Signed MDMP artifact required before AI analysis can run.")],
+    input_json: Annotated[Path, typer.Argument(help="Prepared run directory or JSON file with glucose trace data or a run payload.")],
+    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",
@@ -182,13 +316,20 @@ def trends(
 ) -> None:
     console = Console()
     try:
-        payload = _load_json_payload(input_json, "Input JSON")
-        assistant = _build_assistant(
+        resolved_input, resolved_cert, resolved_public_key = _resolve_cli_inputs(
+            task="trends",
+            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=public_key,
+            public_key=resolved_public_key,
             trust_store=trust_store,
             ollama_host=ollama_host,
             timeout_seconds=timeout_seconds,
@@ -203,8 +344,8 @@ def trends(
 
 @app.command("anomalies")
 def anomalies(
-    input_json: Annotated[Path, typer.Argument(help="JSON file with simulation results or run summary.")],
-    mdmp_cert: Annotated[Path, typer.Option(help="Signed MDMP artifact required before AI analysis can run.")],
+    input_json: Annotated[Path, typer.Argument(help="Prepared run directory or JSON file with simulation results or run summary.")],
+    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",
@@ -216,13 +357,20 @@ def anomalies(
 ) -> None:
     console = Console()
     try:
-        payload = _load_json_payload(input_json, "Input JSON")
-        assistant = _build_assistant(
+        resolved_input, resolved_cert, resolved_public_key = _resolve_cli_inputs(
+            task="anomalies",
+            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=public_key,
+            public_key=resolved_public_key,
             trust_store=trust_store,
             ollama_host=ollama_host,
             timeout_seconds=timeout_seconds,
@@ -237,8 +385,8 @@ def anomalies(
 
 @app.command("report")
 def report(
-    input_json: Annotated[Path, typer.Argument(help="JSON file with run-level simulation outputs.")],
-    mdmp_cert: Annotated[Path, typer.Option(help="Signed MDMP artifact required before AI analysis can run.")],
+    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",
@@ -250,13 +398,20 @@ def report(
 ) -> None:
     console = Console()
     try:
-        payload = _load_json_payload(input_json, "Input JSON")
-        assistant = _build_assistant(
+        resolved_input, resolved_cert, resolved_public_key = _resolve_cli_inputs(
+            task="report",
+            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=public_key,
+            public_key=resolved_public_key,
             trust_store=trust_store,
             ollama_host=ollama_host,
             timeout_seconds=timeout_seconds,

iints/ai/model_catalog.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .backends.ollama import DEFAULT_MINISTRAL_MODEL
+
+
+@dataclass(frozen=True)
+class LocalMistralModelProfile:
+    tag: str
+    label: str
+    approx_download_gb: float
+    recommended_system_ram_gb: int
+    recommended_vram_gb: int | None
+    fit: str
+    notes: str
+    aliases: tuple[str, ...] = ()
+
+
+LOCAL_MISTRAL_MODEL_PROFILES: tuple[LocalMistralModelProfile, ...] = (
+    LocalMistralModelProfile(
+        tag="ministral-3:3b",
+        label="Ministral 3 3B",
+        approx_download_gb=3.0,
+        recommended_system_ram_gb=16,
+        recommended_vram_gb=6,
+        fit="Entry-level laptop / small edge box",
+        notes="Best starting point for CPU-only systems or modest GPUs. Fastest option, lowest memory pressure.",
+        aliases=("ministral-3:3b",),
+    ),
+    LocalMistralModelProfile(
+        tag=DEFAULT_MINISTRAL_MODEL,
+        label="Ministral 3 8B",
+        approx_download_gb=6.0,
+        recommended_system_ram_gb=24,
+        recommended_vram_gb=10,
+        fit="Balanced desktop / strong laptop",
+        notes="Recommended default for most users. Best trade-off between quality, speed, and local memory footprint.",
+        aliases=("ministral", "ministral-3", "ministral-3:8b"),
+    ),
+    LocalMistralModelProfile(
+        tag="ministral-3:14b",
+        label="Ministral 3 14B",
+        approx_download_gb=10.0,
+        recommended_system_ram_gb=32,
+        recommended_vram_gb=16,
+        fit="High-end workstation",
+        notes="Use when you have plenty of RAM or a strong GPU and want better reasoning depth at the cost of latency.",
+        aliases=("ministral-3:14b",),
+    ),
+)
+
+
+def list_local_mistral_models() -> list[LocalMistralModelProfile]:
+    return list(LOCAL_MISTRAL_MODEL_PROFILES)

iints/ai/prepare.py

@@ -0,0 +1,342 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+import importlib
+import json
+import math
+
+import pandas as pd
+
+from iints.utils.run_io import compute_sha256
+
+
+def _now_utc() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError(f"Expected JSON object in {path}")
+    return payload
+
+
+def _normalize_value(value: Any) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, (str, bool, int)):
+        return value
+    if isinstance(value, float):
+        if math.isnan(value) or math.isinf(value):
+            return None
+        return round(value, 4)
+    if hasattr(value, "item"):
+        return _normalize_value(value.item())
+    return value
+
+
+def _normalize_record(record: dict[str, Any]) -> dict[str, Any]:
+    return {key: _normalize_value(value) for key, value in record.items()}
+
+
+def _normalize_series_record(record: Any) -> dict[str, Any]:
+    if not isinstance(record, dict):
+        return {}
+    return {str(key): _normalize_value(value) for key, value in record.items()}
+
+
+def _glucose_column(df: pd.DataFrame) -> str:
+    for candidate in ("glucose_actual_mgdl", "glucose_to_algo_mgdl", "cgm"):
+        if candidate in df.columns:
+            return candidate
+    raise ValueError("Results CSV does not contain a supported glucose column.")
+
+
+def _bool_sum(df: pd.DataFrame, column: str) -> int:
+    if column not in df.columns:
+        return 0
+    return int(df[column].fillna(False).astype(bool).sum())
+
+
+def _safe_sum(df: pd.DataFrame, column: str) -> float:
+    if column not in df.columns:
+        return 0.0
+    return float(pd.to_numeric(df[column], errors="coerce").fillna(0.0).sum())
+
+
+def _time_in_band_pct(series: pd.Series, low: float, high: float) -> float:
+    clean = pd.to_numeric(series, errors="coerce").dropna()
+    if clean.empty:
+        return 0.0
+    mask = (clean >= low) & (clean <= high)
+    return float(mask.mean() * 100.0)
+
+
+def _sample_trace(df: pd.DataFrame, *, max_rows: int = 48) -> list[dict[str, Any]]:
+    interesting_columns = [
+        "time_minutes",
+        "glucose_actual_mgdl",
+        "glucose_to_algo_mgdl",
+        "glucose_trend_mgdl_min",
+        "predicted_glucose_30min",
+        "algo_recommended_insulin_units",
+        "delivered_insulin_units",
+        "safety_triggered",
+        "safety_reason",
+    ]
+    present = [column for column in interesting_columns if column in df.columns]
+    if not present:
+        return []
+    if len(df) <= max_rows:
+        sampled = df[present]
+    else:
+        step = max(1, len(df) // max_rows)
+        sampled = df.iloc[::step][present].head(max_rows)
+    return [_normalize_series_record(record) for record in sampled.to_dict(orient="records")]
+
+
+def _position_for_label(df: pd.DataFrame, label: Any) -> int:
+    location = df.index.get_loc(label)
+    if isinstance(location, int):
+        return location
+    raise ValueError(f"Could not resolve row position for label: {label!r}")
+
+
+def _select_step_payload(df: pd.DataFrame) -> tuple[dict[str, Any], dict[str, Any]]:
+    if df.empty:
+        raise ValueError("Results CSV is empty.")
+
+    glucose_column = _glucose_column(df)
+    risk_position = len(df.index) - 1
+    selection_reason = "latest_step"
+
+    if "safety_triggered" in df.columns and df["safety_triggered"].fillna(False).astype(bool).any():
+        safety_rows = df[df["safety_triggered"].fillna(False).astype(bool)]
+        risk_position = _position_for_label(df, safety_rows.index[0])
+        selection_reason = "first_safety_trigger"
+    else:
+        glucose_values = pd.to_numeric(df[glucose_column], errors="coerce")
+        if (glucose_values < 70).any():
+            risk_label = glucose_values.idxmin()
+            risk_position = _position_for_label(df, risk_label)
+            selection_reason = "lowest_glucose"
+        elif "predicted_glucose_30min" in df.columns:
+            predicted = pd.to_numeric(df["predicted_glucose_30min"], errors="coerce")
+            if (predicted > 180).any():
+                risk_label = predicted.idxmax()
+                risk_position = _position_for_label(df, risk_label)
+                selection_reason = "highest_predicted_glucose_30min"
+    latest_position = len(df.index) - 1
+
+    def _row_at(position: int) -> Optional[dict[str, Any]]:
+        if position < 0 or position >= len(df.index):
+            return None
+        return _normalize_series_record(df.iloc[position].to_dict())
+
+    risk_payload = {
+        "selection_reason": selection_reason,
+        "selected_step": _row_at(risk_position),
+        "previous_step": _row_at(risk_position - 1),
+        "next_step": _row_at(risk_position + 1),
+    }
+    latest_payload = {
+        "selection_reason": "latest_step",
+        "selected_step": _row_at(latest_position),
+        "previous_step": _row_at(latest_position - 1),
+        "next_step": None,
+    }
+    return risk_payload, latest_payload
+
+
+def _build_summary(df: pd.DataFrame, run_metadata: dict[str, Any], audit_summary: dict[str, Any]) -> dict[str, Any]:
+    glucose_column = _glucose_column(df)
+    glucose = pd.to_numeric(df[glucose_column], errors="coerce").dropna()
+    if glucose.empty:
+        raise ValueError("Results CSV glucose series is empty.")
+
+    duration_minutes = run_metadata.get("config", {}).get("duration_minutes")
+    if duration_minutes is None and "time_minutes" in df.columns:
+        duration_minutes = _normalize_value(pd.to_numeric(df["time_minutes"], errors="coerce").max())
+
+    return {
+        "steps": int(len(df)),
+        "duration_minutes": _normalize_value(duration_minutes),
+        "mean_glucose_mgdl": _normalize_value(float(glucose.mean())),
+        "min_glucose_mgdl": _normalize_value(float(glucose.min())),
+        "max_glucose_mgdl": _normalize_value(float(glucose.max())),
+        "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_above_180_pct": _normalize_value(float((glucose > 180.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"),
+        "audit_override_count": int(audit_summary.get("total_overrides", 0)),
+    }
+
+
+def _build_payloads(
+    *,
+    run_dir: Path,
+    results_df: pd.DataFrame,
+    run_metadata: dict[str, Any],
+    run_manifest: dict[str, Any],
+    audit_summary: dict[str, Any],
+    baseline_comparison: dict[str, Any] | None,
+) -> dict[str, dict[str, Any]]:
+    summary = _build_summary(results_df, run_metadata, audit_summary)
+    risk_payload, latest_payload = _select_step_payload(results_df)
+    trace_sample = _sample_trace(results_df)
+
+    common = {
+        "generated_at_utc": _now_utc(),
+        "run_dir": str(run_dir),
+        "run_id": run_metadata.get("run_id"),
+        "sdk_version": run_metadata.get("sdk_version"),
+        "algorithm": run_metadata.get("config", {}).get("algorithm", {}),
+        "scenario": run_metadata.get("config", {}).get("scenario"),
+        "summary": summary,
+    }
+
+    payloads: dict[str, dict[str, Any]] = {
+        "report_payload.json": {
+            **common,
+            "artifacts": {
+                "run_metadata": str(run_dir / "run_metadata.json"),
+                "run_manifest": str(run_dir / "run_manifest.json"),
+                "results_csv": str(run_dir / "results.csv"),
+                "audit_summary": str(run_dir / "audit" / "audit_summary.json"),
+                "baseline_comparison": str(run_dir / "baseline" / "baseline_comparison.json"),
+            },
+            "audit_summary": audit_summary,
+            "baseline_comparison": baseline_comparison,
+            "trace_sample": trace_sample,
+            "run_manifest": run_manifest,
+        },
+        "anomalies_payload.json": {
+            **common,
+            "audit_summary": audit_summary,
+            "safety_events": [
+                record
+                for record in trace_sample
+                if bool(record.get("safety_triggered"))
+            ],
+        },
+        "trends_payload.json": {
+            **common,
+            "trace_sample": trace_sample,
+            "baseline_comparison": baseline_comparison,
+        },
+        "step_riskiest.json": {
+            **common,
+            **risk_payload,
+        },
+        "step_latest.json": {
+            **common,
+            **latest_payload,
+        },
+    }
+    return payloads
+
+
+def _load_mdmp_signer_tools() -> tuple[type[Any], Any]:
+    try:
+        module = importlib.import_module("mdmp_core")
+    except Exception as exc:
+        raise ImportError(
+            "Local AI certification requires the optional standalone MDMP package.\n"
+            "Install with: pip install 'iints-sdk-python35[mdmp]'"
+        ) from exc
+
+    signer_cls = getattr(module, "MDMPSigner", None)
+    keygen_fn = getattr(module, "generate_keypair", None)
+    if signer_cls is None or keygen_fn is None:
+        raise ImportError("mdmp_core is installed but does not expose MDMPSigner/generate_keypair.")
+    return signer_cls, keygen_fn
+
+
+def _write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def prepare_ai_ready_artifacts(
+    run_dir: str | Path,
+    *,
+    create_dev_mdmp_cert: bool = True,
+    grade: str = "research_grade",
+    expires_days: int = 30,
+    key_dir: str | Path | None = None,
+) -> dict[str, str]:
+    bundle_dir = Path(run_dir).expanduser().resolve()
+    if not bundle_dir.is_dir():
+        raise FileNotFoundError(f"Run directory not found: {bundle_dir}")
+
+    results_csv = bundle_dir / "results.csv"
+    run_metadata_path = bundle_dir / "run_metadata.json"
+    run_manifest_path = bundle_dir / "run_manifest.json"
+
+    for required in (results_csv, run_metadata_path, run_manifest_path):
+        if not required.is_file():
+            raise FileNotFoundError(f"Required run artifact missing: {required}")
+
+    results_df = pd.read_csv(results_csv)
+    run_metadata = _read_json(run_metadata_path)
+    run_manifest = _read_json(run_manifest_path)
+
+    audit_summary_path = bundle_dir / "audit" / "audit_summary.json"
+    baseline_path = bundle_dir / "baseline" / "baseline_comparison.json"
+    audit_summary = _read_json(audit_summary_path) if audit_summary_path.is_file() else {}
+    baseline_comparison = _read_json(baseline_path) if baseline_path.is_file() else None
+
+    ai_dir = bundle_dir / "ai"
+    payloads = _build_payloads(
+        run_dir=bundle_dir,
+        results_df=results_df,
+        run_metadata=run_metadata,
+        run_manifest=run_manifest,
+        audit_summary=audit_summary,
+        baseline_comparison=baseline_comparison,
+    )
+
+    written: dict[str, str] = {}
+    for filename, payload in payloads.items():
+        target = ai_dir / filename
+        _write_json(target, payload)
+        written[filename.removesuffix(".json")] = str(target)
+
+    if create_dev_mdmp_cert:
+        signer_cls, keygen_fn = _load_mdmp_signer_tools()
+        resolved_key_dir = Path(key_dir).expanduser().resolve() if key_dir else ai_dir / "keys"
+        private_key_path = resolved_key_dir / "mdmp_private_v1.pem"
+        public_key_path = resolved_key_dir / "mdmp_pub_v1.pem"
+        if not private_key_path.is_file() or not public_key_path.is_file():
+            keygen_fn(output_dir=resolved_key_dir)
+
+        cert_payload = {
+            "mdmp_object": "iints_ai_local_cert",
+            "spec_version": "1.0",
+            "grade": grade,
+            "generated_at_utc": _now_utc(),
+            "run_id": run_metadata.get("run_id"),
+            "run_dir": str(bundle_dir),
+            "sdk_version": run_metadata.get("sdk_version"),
+            "purpose": "local_research_ai",
+            "results_csv_sha256": f"sha256:{compute_sha256(results_csv)}",
+            "run_manifest_sha256": f"sha256:{compute_sha256(run_manifest_path)}",
+            "notes": "Local development certificate generated by IINTS AI prepare.",
+        }
+        signer = signer_cls(
+            private_key_path=private_key_path,
+            signed_by="IINTS-Local-AI",
+            key_id="iints_local_ai_v1",
+        )
+        signed_cert = signer.sign_card(cert_payload, expires_days=expires_days)
+        cert_path = ai_dir / "report.signed.mdmp"
+        _write_json(cert_path, signed_cert)
+        written["mdmp_cert"] = str(cert_path)
+        written["mdmp_public_key"] = str(public_key_path)
+        written["mdmp_private_key"] = str(private_key_path)
+
+    return written

iints/cli/cli.py

@@ -22,6 +22,7 @@ from rich.table import Table  # type: ignore # For comparison table
 from rich.panel import Panel  # type: ignore # For nicer auto-doc output
 
 import iints # Import the top-level SDK package
+from iints.ai import prepare_ai_ready_artifacts
 from iints.ai.cli import app as ai_app
 from iints.analysis.baseline import run_baseline_comparison, write_baseline_comparison
 from iints.api.registry import list_algorithm_plugins
@@ -278,6 +279,30 @@ def _write_certification_summary(
     return summary_path
 
 
+def _maybe_prepare_ai_artifacts(output_dir: Path, console: Console) -> None:
+    try:
+        outputs = prepare_ai_ready_artifacts(output_dir, create_dev_mdmp_cert=True)
+        console.print(f"[green]AI-ready artifacts:[/green] {output_dir / 'ai'}")
+        if "mdmp_cert" in outputs:
+            console.print(f"[green]AI quick start:[/green] iints ai report {output_dir}")
+        return
+    except ImportError as exc:
+        console.print(f"[yellow]AI dev certificate skipped:[/yellow] {exc}")
+    except Exception as exc:
+        console.print(f"[yellow]AI-ready export skipped:[/yellow] {exc}")
+        return
+
+    try:
+        prepare_ai_ready_artifacts(output_dir, create_dev_mdmp_cert=False)
+        console.print(f"[green]AI-ready payloads:[/green] {output_dir / 'ai'}")
+        console.print(
+            "[yellow]Tip:[/yellow] Install the MDMP extra or rerun "
+            f"`iints ai prepare {output_dir}` to generate a local development certificate."
+        )
+    except Exception as exc:
+        console.print(f"[yellow]AI-ready payload export skipped:[/yellow] {exc}")
+
+
 def _get_preset(name: str) -> Dict[str, Any]:
     presets = _load_presets()
     for preset in presets:
@@ -1698,9 +1723,11 @@ def presets_run(
     run_manifest_path = output_dir / "run_manifest.json"
     write_json(run_manifest_path, run_manifest)
     console.print(f"Run manifest: {run_manifest_path}")
+    _maybe_prepare_ai_artifacts(output_dir, console)
     signature_path = maybe_sign_manifest(run_manifest_path)
     if signature_path:
         console.print(f"Run manifest signature: {signature_path}")
+    _maybe_prepare_ai_artifacts(output_dir, console)
 
 
 @presets_app.command("create")
@@ -2295,6 +2322,8 @@ def run_full(
         console.print(f"Profiling report: {outputs['profiling_path']}")
     if "run_manifest_signature" in outputs:
         console.print(f"Run manifest signature: {outputs['run_manifest_signature']}")
+    if "output_dir" in outputs:
+        _maybe_prepare_ai_artifacts(Path(outputs["output_dir"]), console)
 
 
 @app.command("run-parallel")

{iints_sdk_python35-1.1.0.dist-info → iints_sdk_python35-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iints-sdk-python35
-Version: 1.1.0
+Version: 1.1.2
 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
@@ -81,7 +81,7 @@ cd iints_quickstart
 iints presets run --name baseline_t1d --algo algorithms/example_algorithm.py
 ```
 
-## AI Assistant (Ministral via Ollama)
+## AI Assistant (Ministral 3 Open-Weight via Ollama)
 
 The SDK now includes a research-only AI assistant layer for explanations and run summaries.
 It is gated by MDMP verification before any LLM call is allowed.
@@ -95,30 +95,59 @@ python -m pip install -U pip
 python -m pip install -e ".[mdmp]"
 ```
 
-Run Ministral locally with Ollama:
+Run the open local Mistral model locally with Ollama:
 
 ```bash
-ollama pull mistral/ministral-8b-instruct
-iints ai local-check --model ministral
+python -m pip install -e ".[mdmp]"
+ollama pull ministral-3:8b
+iints ai models
+```
+
+Recommended first-time setup:
+
+```bash
+ollama pull ministral-3:8b
+iints ai local-check --model ministral-3:8b
 ```
 
-Example commands:
+Recommended flow:
+
+```bash
+iints quickstart --project-name iints_quickstart
+cd iints_quickstart
+iints presets run --name baseline_t1d --algo algorithms/example_algorithm.py
+iints ai prepare results/<run_id>
+iints ai report results/<run_id>
+```
+
+Direct JSON mode still works if you already have your own payloads and signed MDMP artifact:
 
 ```bash
 iints ai explain results/step.json \
   --mdmp-cert results/report.signed.mdmp
-
-iints ai report results/simulation_run.json \
-  --mdmp-cert results/report.signed.mdmp \
-  --output results/ai_report.md
 ```
 
 Notes:
 - AI analysis is blocked if the MDMP artifact is invalid.
 - Minimum required MDMP grade defaults to `research_grade`.
+- The SDK now targets the open local `Ministral 3` Ollama model by default.
+- Users can choose a larger or smaller local Mistral-family model with `--model ...`.
 - Large JSON payloads are clipped automatically before prompt generation to keep local inference stable.
+- `iints ai prepare <run_dir>` now creates AI-ready JSON payloads and, when MDMP is installed, a local development certificate plus keypair in `<run_dir>/ai/`.
+- After `iints ai prepare`, you can point `iints ai explain|trends|anomalies|report` directly at the run directory.
 - Output is research-only and not medical advice.
 
+Troubleshooting:
+- If `iints ai ...` says `No such command 'ai'`, your environment usually still has a legacy `iints` package installed alongside `iints-sdk-python35`.
+- Run `iints-sdk-doctor` first.
+- If it reports a conflict, repair the environment with:
+
+```bash
+python -m pip uninstall -y iints iints-sdk-python35
+python -m pip install -U "iints-sdk-python35[mdmp]==1.1.2"
+hash -r
+```
+
 ## MDMP (Short)
 MDMP is the data-quality protocol used by IINTS.
 

{iints_sdk_python35-1.1.0.dist-info → iints_sdk_python35-1.1.2.dist-info}/RECORD

@@ -1,15 +1,17 @@
-iints/__init__.py,sha256=XsWIyn-Zkw9S0NMRJA0BpUTAxHtXAdU4Te4BBEox-_I,6047
+iints/__init__.py,sha256=wfAcfS7htgnV4JD-R8_WyKZHOwR8Z98vy-oLYxu0-rE,6391
 iints/highlevel.py,sha256=DX12LRmL6YaYY99P0c_P93xfHe4mZjqyLhTYuS6L6hI,20491
 iints/metrics.py,sha256=O9hqOqJpUhUJDqsbfuqRMS9dkV97gzcgh3Y2jYUqHzg,907
-iints/ai/__init__.py,sha256=Yg0XPOBnABwGgAx5ZJK6ycYOKx8tiCy72Nn6CCiY-gg,349
+iints/ai/__init__.py,sha256=nyRDcFfSHI4a3NbTvySipFc3_inqRMEsr6xIEipWuyo,575
 iints/ai/assistant.py,sha256=0Ye1IaWEYg2rZnk3ny8f0GMoYqOWIa7U_GsV-sWrxtU,4346
-iints/ai/cli.py,sha256=Tds-d8IENa4lwNiFZODA1NL-9nSCs8GlhQTC-4zjjog,12202
+iints/ai/cli.py,sha256=_1ogEAb36BAt7sZ2CQSRKIJSpdn5xrlM7nNTtBIqfRo,18345
 iints/ai/mdmp_guard.py,sha256=BpFQX0oyP9WMCUZbFhhoBzomNeVKuI1HY1EFH9cG8EE,4249
+iints/ai/model_catalog.py,sha256=gRW-i4eaXkrjX3mIKJlGzHqzU75lpIulEFKQsCX11CI,1804
+iints/ai/prepare.py,sha256=z3y5elCAMv0p_aNq4gQfZA1uIT7_cX3FGRdzmoZoKho,12967
 iints/ai/prompts.py,sha256=pGp9tC1wBZXGG5duxfktaJEF4p_cvmR0zEIxmMTEAyE,2812
 iints/ai/backends/__init__.py,sha256=EAJRZS8G0DK7fffw_LHio9DkyYHwtzvz2Jo7AXk7pk4,303
 iints/ai/backends/base.py,sha256=BLgP03X-jebYkF9D5n5crawoPBmy3RSh4q3jaT8a9XM,274
-iints/ai/backends/mistral_api.py,sha256=CUFwyymCmaY_lTN0cP6ONpYGUT0us5rjfZS4v1hv2KE,490
-iints/ai/backends/ollama.py,sha256=dgSbKpG8fnLQczKbzqQExYMW1c48uStki8B5Dhm1baI,6067
+iints/ai/backends/mistral_api.py,sha256=dousHnzgzuik49822H8nCclYv5NoxHpTMLwtZPVj_TM,507
+iints/ai/backends/ollama.py,sha256=pH_UkrCmm6jI4_Hl-NM_7W4tXOwHZdZ0heeKph72NUk,8739
 iints/analysis/__init__.py,sha256=Qx49KDy0deoxSnVORJB10_BsdezZXKsuoXTR0KZRcqg,411
 iints/analysis/algorithm_xray.py,sha256=-AtXkZsgnsiFQ_K-IozjIDWkq-dDn0i0zmqWVMhINP4,15952
 iints/analysis/baseline.py,sha256=PCFVb5vX0lYKChZvVk-8I_B5NLQQwGyx7Y6M3XjpIEY,3458
@@ -34,7 +36,7 @@ iints/api/registry.py,sha256=h2syJwacFbgrtgnVK20JwlXivvVO31zeJ_Ez4KBkn1g,3240
 iints/api/template_algorithm.py,sha256=AFs9AymL3ddWAjgpOkF1Oa3TeOSg56siyDt_BmsAND8,9195
 iints/assets/iints_logo.png,sha256=rWzP8XqIYDrPCTp378w73zA1snKCUHrZ76vwslro-uk,700372
 iints/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-iints/cli/cli.py,sha256=bTYXVneLUBKBr4p1jSwg0aNKT2ECLZA-PwJ9UggYIVg,208838
+iints/cli/cli.py,sha256=oDg0rkD_zXu83oQHb6kTzjKzQBr7ETJA9-C5diPASg0,210187
 iints/core/__init__.py,sha256=rRH2lTmikavR7BgeJCUla0ZmPbZxATR6rEcSSv_tet4,28
 iints/core/device.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 iints/core/device_manager.py,sha256=479_CNn6YescDLWDE7w1BbwuLwRUmCUOColAVTEWQc8,2078
@@ -140,9 +142,9 @@ iints/validation/schemas.py,sha256=uXhiPxyfyvOgCA83ZPBIzlITOu663fWctYxOMXUyf1I,4
 iints/visualization/__init__.py,sha256=OdxVHDpY-9bDt8DTWWd-dspn1p0O9T908Cck-IGFaiM,640
 iints/visualization/cockpit.py,sha256=Y7hoJXcTEWQ8yLiU5X5abT58uqGGsQllftXJwqerG1E,25057
 iints/visualization/uncertainty_cloud.py,sha256=I5nNzSitgai21rkul31YNtJriSEmCeTsW0GWW2HUskY,19848
-iints_sdk_python35-1.1.0.dist-info/licenses/LICENSE,sha256=b1luljj2mWWDW10t_qFIqd9Z6euXAcDBmIXowWuUlm4,1417
-iints_sdk_python35-1.1.0.dist-info/METADATA,sha256=TkfRZkb2KCZBvjdUCRMCY6OTGF7bJRDixc04rdIdCoU,7716
-iints_sdk_python35-1.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-iints_sdk_python35-1.1.0.dist-info/entry_points.txt,sha256=ZlC9C1-rhefU6t-Wr7tT05LI5agdKnpsDJgXKxDO350,528
-iints_sdk_python35-1.1.0.dist-info/top_level.txt,sha256=7Usr6NQKiC9SpNFyCis81MmgXy71lDCr5unR8BNXZ0E,6
-iints_sdk_python35-1.1.0.dist-info/RECORD,,
+iints_sdk_python35-1.1.2.dist-info/licenses/LICENSE,sha256=b1luljj2mWWDW10t_qFIqd9Z6euXAcDBmIXowWuUlm4,1417
+iints_sdk_python35-1.1.2.dist-info/METADATA,sha256=F-4k2b--KpKAGQpS6Kw8LP_AW3A1zzqATS7lgs_Mx8I,8887
+iints_sdk_python35-1.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+iints_sdk_python35-1.1.2.dist-info/entry_points.txt,sha256=aVioeLytTHG7WM7L3LIZ6XDJCKiSfqG-nVUQDVHPpQk,578
+iints_sdk_python35-1.1.2.dist-info/top_level.txt,sha256=7Usr6NQKiC9SpNFyCis81MmgXy71lDCr5unR8BNXZ0E,6
+iints_sdk_python35-1.1.2.dist-info/RECORD,,

{iints_sdk_python35-1.1.0.dist-info → iints_sdk_python35-1.1.2.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 iints = iints.cli.cli:app
+iints-sdk-doctor = iints_sdk_python35_doctor:main
 
 [iints.algorithms]
 Correction Bolus = iints.core.algorithms.correction_bolus:CorrectionBolusAlgorithm