added test files

Author: Sigrid Tofte Thiis

loop_to_python_adaptive/__pycache__/__init__.cpython-310.pyc

@@ -12,29 +12,17 @@
 FIVE_MINUTES = 5
 
 
-# -------------------------
-# Time + schedule utilities
-# -------------------------
-
 def parse_loop_timestamp(iso8601: str) -> datetime:
-    """Parse Loop ISO8601 timestamps like '2023-10-17T20:59:03Z' into tz-aware datetime."""
     return datetime.fromisoformat(iso8601.replace("Z", "+00:00"))
 
 
 def _lookup_schedule_value(at_time: datetime, schedule: list[dict]) -> float:
-    """
-    Look up schedule value at time from Loop schedule segments:
-      [{"startDate","endDate","value"}...]
-    Includes closest-prior fallback.
-    """
-    # exact segment match
     for seg in schedule:
         start = parse_loop_timestamp(seg["startDate"])
         end = parse_loop_timestamp(seg["endDate"])
         if start <= at_time < end:
             return float(seg["value"])
 
-    # closest prior segment
     closest = None
     closest_start = None
     for seg in schedule:
@@ -50,30 +38,18 @@ def _lookup_schedule_value(at_time: datetime, schedule: list[dict]) -> float:
 
 
 def lookup_isf_mgdl_per_u(at_time: datetime, sensitivity_schedule: list[dict]) -> float:
-    """ISF (mg/dL/U) at time."""
     return _lookup_schedule_value(at_time, sensitivity_schedule)
 
 
 def lookup_basal_rate_u_per_hour(at_time: datetime, basal_schedule: list[dict]) -> float:
-    """Basal rate (U/hr) at time."""
     return _lookup_schedule_value(at_time, basal_schedule)
 
 
 def convert_basal_rate_to_microbolus_units(basal_rate_u_per_hour: float, step_minutes: int = FIVE_MINUTES) -> float:
-    """Convert U/hr to U delivered over one timestep."""
     return basal_rate_u_per_hour * (step_minutes / 60.0)
 
 
-# -------------------------
-# Dose event extraction
-# -------------------------
-
 def extract_bolus_events(loop_algorithm_input: dict) -> list[tuple[datetime, float]]:
-    """
-    Extract bolus events from LoopAlgorithmInput doses[]:
-      {"type":"bolus","startDate":...,"volume":...}
-    Returns list[(time, units)].
-    """
     out: list[tuple[datetime, float]] = []
     for dose in loop_algorithm_input.get("doses", []):
         if dose.get("type") != "bolus":
@@ -92,16 +68,12 @@ def build_microbasal_events(
     end_time: datetime,
     step_minutes: int = FIVE_MINUTES,
 ) -> list[tuple[datetime, float]]:
-    """
-    Discretize scheduled basal into micro-doses: one event every step_minutes.
-    Returns list[(time, units_over_step)].
-    """
     basal_schedule = loop_algorithm_input["basal"]
     events: list[tuple[datetime, float]] = []
 
     t = start_time
     while t < end_time:
-        rate = lookup_basal_rate_u_per_hour(t, basal_schedule)  # U/hr
+        rate = lookup_basal_rate_u_per_hour(t, basal_schedule)
         u = convert_basal_rate_to_microbolus_units(rate, step_minutes=step_minutes)
         if u > 0:
             events.append((t, u))
@@ -110,20 +82,14 @@ def build_microbasal_events(
     return events
 
 
-# -------------------------
-# BGI computation
-# -------------------------
-
 @dataclass(frozen=True)
 class BGIConfig:
     action_duration_minutes: int
     peak_activity_minutes: int
     delay_minutes: int
     step_minutes: int = FIVE_MINUTES
     history_hours: int = 16
-
-    # numeric safety
-    min_effect_fraction: float = 0.0  # tune later if needed
+    min_effect_fraction: float = 0.0
 
 
 def _batch_percent_remaining(
@@ -134,9 +100,6 @@ def _batch_percent_remaining(
     peak_activity_minutes: int,
     delay_minutes: int,
 ) -> np.ndarray:
-    """
-    Batch wrapper around insulin_percent_effect_remaining (scalar API).
-    """
     return np.fromiter(
         (
             fn(
@@ -161,18 +124,6 @@ def add_bgi_to_history_df(
     cgm_col: str = "CGM",
     bgi_col: str = "BGI",
 ) -> pd.DataFrame:
-    """
-    Add BGI (mg/dL per step_minutes) aligned to df.index.
-
-    BGI(t) computed oref0-style:
-      units_effect_next_step = sum(dose_units * (R(age) - R(age+step)))
-      BGI = - units_effect_next_step * ISF(t)
-
-    Upstream call policy:
-      - If insulin_percent_effect_remaining is not supplied, this function will
-        use loop_to_python_adaptive.api.insulin_percent_effect_remaining internally.
-      - This keeps upstream usage contained inside loop_bgi.py.
-    """
     if insulin_percent_effect_remaining is None:
         insulin_percent_effect_remaining = api.insulin_percent_effect_remaining
 
@@ -181,6 +132,7 @@ def add_bgi_to_history_df(
     if cgm_col not in df.columns:
         raise ValueError(f"df missing required column {cgm_col!r}.")
 
+    # Normalize to tz-aware UTC index
     idx = df.index
     if idx.tz is None:
         idx = idx.tz_localize("UTC")
@@ -191,7 +143,7 @@ def add_bgi_to_history_df(
     out.index = idx
     out[bgi_col] = np.nan
 
-    # Build event window: include enough history so older doses are negligible
+    # Build event window
     end_time = idx.max().to_pydatetime()
     start_time = (idx.min() - timedelta(hours=config.history_hours)).to_pydatetime()
 
@@ -208,33 +160,37 @@ def add_bgi_to_history_df(
         out[bgi_col] = 0.0
         return out
 
-    event_times = np.array([t for (t, _) in events], dtype="datetime64[ns]")
+    # Convert event times to tz-naive UTC datetime64[ns] (numpy has no tz support)
+    event_times = np.array(
+        [np.datetime64(pd.Timestamp(t).tz_convert("UTC").tz_localize(None).to_datetime64()) for (t, _) in events],
+        dtype="datetime64[ns]",
+    )
     event_units = np.array([u for (_, u) in events], dtype=float)
 
     left = 0
     right = 0
     action_td = np.timedelta64(config.action_duration_minutes, "m")
     step = float(config.step_minutes)
 
-    # main loop
-    for t in out.index.to_pydatetime():
-        t64 = np.datetime64(t)
+    # Iterate over pandas timestamps directly (no pd.Timestamp(t, tz=...) needed)
+    for ts in out.index:
+        # ts is tz-aware UTC pandas Timestamp
+        t64 = ts.tz_convert("UTC").tz_localize(None).to_datetime64()
 
-        # include events <= t
         while right < len(event_times) and event_times[right] <= t64:
             right += 1
 
-        # exclude events < t - action_duration
         cutoff = t64 - action_td
         while left < right and event_times[left] < cutoff:
             left += 1
 
         if left >= right:
-            out.at[pd.Timestamp(t, tz="UTC"), bgi_col] = 0.0
+            out.at[ts, bgi_col] = 0.0
             continue
 
         active_times = event_times[left:right]
         active_units = event_units[left:right]
+
         ages = ((t64 - active_times) / np.timedelta64(1, "m")).astype(float)
 
         r_now = _batch_percent_remaining(
@@ -255,8 +211,9 @@ def add_bgi_to_history_df(
         frac = np.maximum(config.min_effect_fraction, r_now - r_later)
         units_effect_next = float(np.sum(active_units * frac))
 
-        sens = lookup_isf_mgdl_per_u(t, loop_algorithm_input["sensitivity"])
-        out.at[pd.Timestamp(t, tz="UTC"), bgi_col] = -units_effect_next * sens
+        # schedule lookup uses python datetime (tz-aware)
+        sens = lookup_isf_mgdl_per_u(ts.to_pydatetime(), loop_algorithm_input["sensitivity"])
+        out.at[ts, bgi_col] = -units_effect_next * sens
 
     return out
 
@@ -267,15 +224,6 @@ def build_isf_glucose_data_from_df(
     cgm_col: str = "CGM",
     bgi_col: str = "BGI",
 ) -> list[dict]:
-    """
-    Build ISF tuning points for tune_isf_like_oref0().
-
-    Align BGI as "effect over next timestep":
-      avgDelta[i] = CGM[i] - CGM[i-1]
-      deviation[i] = avgDelta[i] - BGI[i-1]
-
-    Returns list of dicts with keys: date, avgDelta, BGI, deviation.
-    """
     if not isinstance(df.index, pd.DatetimeIndex):
         raise ValueError("df must have a DatetimeIndex.")
     if cgm_col not in df.columns:
@@ -299,8 +247,8 @@ def build_isf_glucose_data_from_df(
         if pd.isna(bgi.iat[i - 1]):
             continue
 
-        avg_delta = float(cgm.iat[i] - cgm.iat[i - 1])  # mg/dL per step
-        bgi_step = float(bgi.iat[i - 1])                # mg/dL per step
+        avg_delta = float(cgm.iat[i] - cgm.iat[i - 1])
+        bgi_step = float(bgi.iat[i - 1])
         deviation = float(avg_delta - bgi_step)
 
         ts = idx[i]
@@ -317,14 +265,6 @@ def prepare_isf_glucose_data(
     cgm_col: str = "CGM",
     bgi_col: str = "BGI",
 ) -> tuple[pd.DataFrame, list[dict]]:
-    """
-    Convenience wrapper for autotune_prep:
-      - compute df_with_BGI
-      - build isf_glucose_data list
-
-    Returns:
-      (df_with_BGI, isf_glucose_data)
-    """
     df2 = add_bgi_to_history_df(
         df,
         loop_algorithm_input=loop_algorithm_input,

loop_to_python_adaptive/__pycache__/api.cpython-310.pyc

@@ -1,5 +1,9 @@
-import loop_to_python_adaptive.api as api  # replace with your real import
+from pathlib import Path
+import json
 
-print("has get_glucose_effect_velocity:", hasattr(api, "get_glucose_effect_velocity"))
-print("callable:", callable(getattr(api, "get_glucose_effect_velocity", None)))
-print("module file:", api.__file__)
+HERE = Path(__file__).resolve()
+REPO_ROOT = HERE.parent.parent  # loop_to_python_adaptive/ -> repo root
+
+FIXTURE = REPO_ROOT / "python_tests" / "test_files" / "loop_algorithm_input.json"
+loop_input = json.loads(FIXTURE.read_text(encoding="utf-8"))
+print("Loaded fixture:", FIXTURE)

loop_to_python_adaptive/__pycache__/autotune_isf.cpython-310.pyc

@@ -0,0 +1,61 @@
+{
+  "inputICE": [
+    {
+      "velocity": 0.0,
+      "start_at": "2015-10-15T21:30:12",
+      "end_at": "2015-10-15T21:35:12"
+    },
+    {
+      "velocity": 5.0,
+      "start_at": "2015-10-15T21:35:12",
+      "end_at": "2015-10-15T21:40:12"
+    },
+    {
+      "velocity": 3.0,
+      "start_at": "2015-10-15T21:40:12",
+      "end_at": "2015-10-15T21:45:12"
+    },
+    {
+      "velocity": 2.0,
+      "start_at": "2015-10-15T21:45:12",
+      "end_at": "2015-10-15T21:50:12"
+    },
+    {
+      "velocity": 3.0,
+      "start_at": "2015-10-15T21:50:12",
+      "end_at": "2015-10-15T21:55:12"
+    },
+    {
+      "velocity": 5.0,
+      "start_at": "2015-10-15T21:55:12",
+      "end_at": "2015-10-15T22:00:12"
+    },
+    {
+      "velocity": -2.0,
+      "start_at": "2015-10-15T22:00:12",
+      "end_at": "2015-10-15T22:05:12"
+    }
+  ],
+  "carbEntries": [
+    {
+      "grams": 44,
+      "date": "2015-10-15T21:35:12Z",
+      "absorptionTime": 120,
+      "unit": "g"
+    },
+    {
+      "grams": 30,
+      "date": "2015-10-15T21:55:00Z",
+      "absorptionTime": 120,
+      "unit": "g"
+    },
+    {
+      "grams": 30,
+      "date": "2015-10-15T23:00:00Z",
+      "absorptionTime": 120,
+      "unit": "g"
+    }
+  ],
+  "sensitivity": 63,
+  "carbRatio": 10.0
+}