iints-sdk-python35 1.5.19__py3-none-any.whl → 1.5.22__py3-none-any.whl

iints/__init__.py

@@ -11,7 +11,7 @@ except ImportError:  # pragma: no cover - Python < 3.8 fallback
 try:
     __version__ = version("iints-sdk-python35")
 except PackageNotFoundError:  # pragma: no cover - source tree fallback
-    __version__ = "1.5.19"
+    __version__ = "1.5.22"
 
 # 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/analysis/reporting.py

@@ -854,9 +854,15 @@ class ClinicalReportGenerator:
         ax.set_ylabel("Sensor glucose (mg/dL)")
         ax.grid(True, alpha=0.22)
         ax.legend(loc="upper left", fontsize=7, frameon=True)
-        fig.tight_layout()
-        fig.savefig(output_path, dpi=260, bbox_inches="tight")
-        plt.close(fig)
+        try:
+            fig.tight_layout()
+            fig.savefig(output_path, dpi=260, bbox_inches="tight")
+        except ValueError as exc:
+            logger.warning("Clinical validation plot layout failed; saving fallback layout: %s", exc)
+            fig.subplots_adjust(left=0.08, right=0.98, top=0.9, bottom=0.12)
+            fig.savefig(output_path, dpi=260)
+        finally:
+            plt.close(fig)
 
     @staticmethod
     def _metric_delta(current: float, target: float, higher_is_better: bool = True) -> str:

iints/core/simulator.py

@@ -724,12 +724,13 @@ class Simulator:
         """Alias for run_batch to ensure backward compatibility."""
         return self.run_batch(duration_minutes)
 
-    def run_batch(self, duration_minutes: int) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    def run_batch(self, duration_minutes: int, step_callback: Optional[Callable[[int, int, float], None]] = None) -> Tuple[pd.DataFrame, Dict[str, Any]]:
         """
         Runs the entire simulation and returns the results as a single DataFrame.
 
         Args:
             duration_minutes (int): Total simulation duration in minutes.
+            step_callback (Callable): Optional callback for live telemetry (time, duration, glucose).
 
         Returns:
             pd.DataFrame: A DataFrame containing the complete simulation results.
@@ -740,6 +741,8 @@ class Simulator:
         try:
             for record in self.run_live(duration_minutes):
                 all_records.append(record)
+                if step_callback:
+                    step_callback(record["time"], duration_minutes, record["glucose"])
         except SimulationLimitError as err:
             logger.error("Simulation terminated early: %s", err)
             self._termination_info = {

iints/highlevel.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from pathlib import Path
 from dataclasses import asdict
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional, Union, Callable
 
 import pandas as pd
 import yaml
@@ -296,6 +296,7 @@ def run_full(
     enable_profiling: bool = True,
     safety_config: Optional[SafetyConfig] = None,
     predictor: Optional[object] = None,
+    step_callback: Optional[Callable[[int, int, float], None]] = None,
 ) -> Dict[str, Any]:
     """
     One-line runner that always exports results + audit + PDF + baseline comparison.
@@ -341,7 +342,7 @@ def run_full(
     for event in build_stress_events(stress_event_payloads):
         simulator.add_stress_event(event)
 
-    results_df, safety_report = simulator.run_batch(duration_minutes)
+    results_df, safety_report = simulator.run_batch(duration_minutes, step_callback=step_callback)
 
     outputs: Dict[str, Any] = {
         "results": results_df,

iints/research/alphafold_engine.py

@@ -0,0 +1,91 @@
+import urllib.request
+import json
+from typing import Dict, Any
+
+class AlphaFoldGenomicsEngine:
+    """
+    Bridges deep 3D structural AI (AlphaFold) to physiological equations.
+    """
+
+    @staticmethod
+    def evaluate_plddt_impact(uniprot_id: str, residue_index: int) -> Dict[str, Any]:
+        """
+        Fetches AlphaFold structure, finds the pLDDT for the residue,
+        and mathematically translates it into a molecular_affinity_scalar.
+        """
+        api_url = f"https://alphafold.ebi.ac.uk/api/prediction/{uniprot_id}"
+        
+        try:
+            req = urllib.request.Request(api_url, headers={'User-Agent': 'IINTS-AF-SDK/1.0'})
+            with urllib.request.urlopen(req) as response:
+                if response.status != 200:
+                    return {"error": f"Failed to query AlphaFold API for {uniprot_id} (Status {response.status})"}
+                data = json.loads(response.read().decode())
+        except Exception as e:
+            return {"error": f"AlphaFold API request failed: {e}"}
+
+        if not data:
+            return {"error": f"No AlphaFold prediction found for {uniprot_id}"}
+            
+        # Find the correct fragment for large proteins
+        target_fragment = None
+        for frag in data:
+            start = frag.get("uniprotStart", 1)
+            end = frag.get("uniprotEnd", 999999)
+            if start <= residue_index <= end:
+                target_fragment = frag
+                break
+                
+        if not target_fragment:
+            return {"error": f"Residue {residue_index} is out of bounds for {uniprot_id}."}
+            
+        pdb_url = target_fragment.get("pdbUrl")
+        if not pdb_url:
+            return {"error": "PDB file not available in AlphaFold DB for this protein."}
+            
+        try:
+            pdb_req = urllib.request.Request(pdb_url, headers={'User-Agent': 'IINTS-AF-SDK/1.0'})
+            with urllib.request.urlopen(pdb_req) as response:
+                pdb_text = response.read().decode()
+        except Exception as e:
+            return {"error": f"Failed to download PDB file: {e}"}
+            
+        # Parse PDB text to find pLDDT (B-factor is in columns 61-66)
+        plddt_values = []
+        for line in pdb_text.split("\n"):
+            if line.startswith("ATOM  "):
+                try:
+                    res_num = int(line[22:26].strip())
+                    if res_num == residue_index:
+                        b_factor = float(line[60:66].strip())
+                        plddt_values.append(b_factor)
+                except ValueError:
+                    pass
+                    
+        if not plddt_values:
+            return {"error": f"Residue {residue_index} not found in AlphaFold structure."}
+            
+        avg_plddt = sum(plddt_values) / len(plddt_values)
+        
+        # Mathematical translation
+        if avg_plddt >= 90:
+            scalar = 0.15
+            conclusion = "Highly structured core domain. Mutation is likely catastrophic."
+        elif avg_plddt >= 70:
+            scalar = 0.40
+            conclusion = "Structured domain. Mutation likely impairs function."
+        elif avg_plddt >= 50:
+            scalar = 0.75
+            conclusion = "Moderate flexibility. Mutation partially tolerated."
+        else:
+            scalar = 0.95
+            conclusion = "Intrinsically disordered/flexible region. Mutation is highly tolerated."
+            
+        return {
+            "uniprot_id": uniprot_id,
+            "residue_index": residue_index,
+            "plddt": round(avg_plddt, 2),
+            "scalar": scalar,
+            "conclusion": conclusion,
+            "pdb_url": pdb_url
+        }

iints/research/genomics_engine.py

@@ -57,14 +57,33 @@ class GenomicsEngine:
 
     @staticmethod
     def evaluate_mutation(gene: str, variant: str) -> dict[str, Any]:
-        """Translate a variant such as ``INSR V938M`` into a functional scalar."""
+        """Translate a variant such as ``INSR V938M`` into a functional scalar using AlphaFold."""
+        import re
+        from iints.research.alphafold_engine import AlphaFoldGenomicsEngine
 
         variant = variant.upper().strip()
-        if gene.upper() != "INSR":
-            return {"scalar": 1.0, "desc": f"Gene {gene} not supported yet.", "residue": None}
-        if variant in KNOWN_MUTATIONS:
+        
+        # Check known mutations first for fast/offline execution
+        if gene.upper() == "INSR" and variant in KNOWN_MUTATIONS:
             return dict(KNOWN_MUTATIONS[variant])
-        return {"scalar": 0.5, "desc": "Unknown mutation (assumed 50% loss of function)", "residue": None}
+            
+        # Determine UniProt ID (INSR -> P06213)
+        uniprot_id = "P06213" if gene.upper() == "INSR" else gene.strip()
+        
+        # Extract residue index from variant (e.g. V938M -> 938)
+        match = re.search(r'\d+', variant)
+        if not match:
+            return {"scalar": 0.5, "desc": "Unknown mutation format (assumed 50% loss of function)", "residue": None}
+            
+        residue_idx = int(match.group())
+        
+        # Query AlphaFold
+        af_result = AlphaFoldGenomicsEngine.evaluate_plddt_impact(uniprot_id, residue_idx)
+        if "error" in af_result:
+            return {"scalar": 0.5, "desc": f"AlphaFold fallback (50% loss): {af_result['error']}", "residue": residue_idx}
+            
+        desc = f"AlphaFold pLDDT: {af_result['plddt']}. {af_result['conclusion']}"
+        return {"scalar": af_result['scalar'], "desc": desc, "residue": residue_idx}
 
     @staticmethod
     def run_multi_scale_simulation(

iints/utils/plotting.py

@@ -54,6 +54,11 @@ def apply_plot_style(
             "ytick.labelsize": 10,
             "axes.spines.top": False,
             "axes.spines.right": False,
+            # Scientific styles can enable mathtext tick formatting. Some
+            # Matplotlib/macOS combinations then try to parse empty ticklabels
+            # during tight_layout(), which can abort report generation.
+            "axes.formatter.use_mathtext": False,
+            "text.usetex": False,
         }
     )
     return colors

iints_desktop/engine.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from importlib import metadata
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 
 @dataclass(frozen=True)
@@ -174,6 +174,7 @@ def run_demo_preset(
     desktop_preset_key: str = DEFAULT_DESKTOP_PRESET_KEY,
     preset_name: str | None = None,
     seed: int = 42,
+    step_callback: Callable[[int, int, float], None] | None = None,
 ) -> DesktopRunResult:
     """Run one deterministic demo preset through the normal SDK engine.
 
@@ -205,6 +206,7 @@ def run_demo_preset(
         time_step=int(preset["time_step_minutes"]),
         seed=seed,
         output_dir=target,
+        step_callback=step_callback,
     )
 
     results_csv = _optional_path(outputs.get("results_csv"))
@@ -243,6 +245,71 @@ def run_demo_preset(
     return result
 
 
+def run_custom_preset(
+    *,
+    output_dir: str | Path,
+    custom_preset: dict[str, Any],
+    seed: int = 42,
+    step_callback: Callable[[int, int, float], None] | None = None,
+) -> DesktopRunResult:
+    """Run a dynamically constructed scenario from the UI."""
+    base_output = Path(output_dir).expanduser().resolve()
+    mpl_cache = base_output / ".cache" / "matplotlib"
+    mpl_cache.mkdir(parents=True, exist_ok=True)
+    os.environ.setdefault("MPLCONFIGDIR", str(mpl_cache))
+
+    from iints.core.algorithms.clinical_baseline import ClinicalBaselineAlgorithm
+    from iints.highlevel import run_full
+
+    resolved_preset_name = custom_preset.get("name", "custom_scenario")
+    folder_name = _safe_slug(f"custom-{resolved_preset_name}-{seed}")
+    target = base_output / folder_name
+    outputs: dict[str, Any] = run_full(
+        algorithm=ClinicalBaselineAlgorithm(),
+        scenario=custom_preset.get("scenario", {}),
+        patient_config=custom_preset.get("patient_config", {}),
+        duration_minutes=int(custom_preset.get("duration_minutes", 1440)),
+        time_step=int(custom_preset.get("time_step_minutes", 5)),
+        seed=seed,
+        output_dir=target,
+        step_callback=step_callback,
+    )
+
+    results_csv = _optional_path(outputs.get("results_csv"))
+    report_pdf = _optional_path(outputs.get("report_pdf"))
+    config_path = _optional_path(outputs.get("config_path"))
+    run_id = str(outputs.get("run_id", "unknown-run"))
+    summary = "\n".join(
+        line
+        for line in [
+            "Workflow: Custom Scenario Builder",
+            f"SDK preset: {resolved_preset_name}",
+            f"Seed: {seed}",
+            f"Run completed: {run_id}",
+            f"Output folder: {target}",
+            f"Results CSV: {results_csv}" if results_csv else "Results CSV: not generated",
+            f"Clinical report: {report_pdf}" if report_pdf else "Clinical report: not generated",
+            "Research only: not a medical device and not for treatment decisions.",
+        ]
+    )
+    result = DesktopRunResult(
+        run_id=run_id,
+        workflow_title="Custom Scenario",
+        preset_name=resolved_preset_name,
+        seed=seed,
+        output_dir=target,
+        results_csv=results_csv,
+        report_pdf=report_pdf,
+        config_path=config_path,
+        summary=summary,
+    )
+    try:
+        append_run_history(base_output, result)
+    except OSError:
+        pass
+    return result
+
+
 def _optional_path(value: object) -> Path | None:
     if value is None:
         return None

iints_desktop/local_ai.py

@@ -19,6 +19,7 @@ RECOMMENDED_OLLAMA_MODELS = (
     "llama3.1:8b",
     "qwen2.5:7b",
     "gemma3:4b",
+    "hf.co/devanshamin/PubMedDiabetes-LLM-Predictions",
 )
 
 
@@ -45,22 +46,19 @@ class LocalAIStartResult:
     pulled_model: bool = False
 
 
-SYSTEM_PROMPT = """You are the local IINTS-AF desktop research assistant.
-
-Rules:
-- Research and education only.
-- Not a medical device.
-- Do not provide diagnosis, insulin dosing, treatment instructions, or real-time patient care advice.
-- Be critical about simulation limitations, data quality, uncertainty, and physiology.
-- If the user asks for dosing/treatment decisions, refuse briefly and redirect to safe research interpretation.
-- Prefer clear, plain-language explanations over hype.
-- If result-summary context is provided, explain what it suggests without pretending it is clinically validated.
-- Use this exact readable structure:
-  Summary
-  Key observations
-  Limitations
-  Next checks
-- Use short paragraphs or numbered points. Do not use markdown tables, decorative separators, or long raw bullet lists.
+SYSTEM_PROMPT = """You are a highly advanced Medical Data Scientist and Computational Biologist analyzing output from the IINTS-AF closed-loop insulin simulator.
+
+CRITICAL INSTRUCTIONS:
+1. Speak with absolute professional authority and scientific rigor. Do NOT sound like an AI assistant. Do NOT use vague conversational filler.
+2. Analyze the provided clinical simulation data. Extract meaningful physiological insights, glycemic control patterns (Time in Range, Coefficient of Variation), and algorithmic behaviors (e.g. basal suspension aggressiveness, insulin resistance masking).
+3. Do not include boilerplate legal disclaimers at the beginning of your text. If necessary, include a single sentence limitation at the very end.
+4. Structure your response explicitly using these exact headers:
+  Clinical Overview
+  Biomathematical Observations
+  Algorithmic Behavior
+  Conclusions
+5. Use highly specific scientific terminology (e.g., exogenous insulin kinetics, hepatic glucose production, PI3K/AKT pathway attenuation).
+6. Acknowledge that the IINTS-AF simulator is for research and education only. It is Not a medical device. Do not provide diagnosis, insulin dosing, or treatment advice.
 """
 
 
@@ -280,7 +278,12 @@ def format_ai_answer(text: str) -> str:
             line = "• " + line[2:].strip()
         if line.startswith(("---", "___", "***")):
             continue
-        if line.lower().rstrip(":") in {"summary", "key observations", "limitations", "next checks"}:
+        if line.lower().rstrip(":") in {
+            "clinical overview", 
+            "biomathematical observations", 
+            "algorithmic behavior", 
+            "conclusions"
+        }:
             line = line.rstrip(":").title()
         lines.append(line)
     return "\n".join(lines).strip()
@@ -309,8 +312,8 @@ def ask_local_ai(
     user_prompt = (
         f"Result context:\n{context}\n\n"
         f"User question:\n{question.strip()}\n\n"
-        "Answer as a critical SDK research assistant. Mention limitations and avoid treatment advice. "
-        "Make the response readable in a desktop app text panel."
+        "Perform a highly technical, rigorous analysis based purely on the data. "
+        "Do not offer generic advice. Structure the response perfectly."
     )
     answer = backend.complete(system_prompt=SYSTEM_PROMPT, user_prompt=user_prompt)
     resolved = backend.resolved_model_name or model