Merge pull request #2 from staskh/fix_warning

Fix runtime warning and episode_calculation support lv1/lv2 exclusion

Author: staskh

README.md

@@ -33,7 +33,7 @@ Unless noted, iglu-r test is considered successful if it achieves precision of 0
 | cv_glu | ✅ |
 | cv_measures | ✅ |
 | ea1c | ✅ |
-| episode_calculation |  🟡  need fix in excl| || no match in lv1_hypo_excl and lv1_hyper_excl|
+| episode_calculation |  ✅| || no match in lv1_hypo_excl and lv1_hyper_excl|
 | gmi | ✅ |
 | grade_eugly | ✅ |
 | grade_hyper | ✅ |

iglu_python/conga.py

@@ -77,6 +77,12 @@ def conga_single(data: pd.DataFrame, hours: int = 1, tz: str = "") -> float:
         lag = hourly_readings * hours
         diffs = gl_vector[lag:] - gl_vector[:-lag]
 
+        # Check if we have sufficient data for std calculation
+        # Need at least 2 non-NaN values for ddof=1
+        valid_diffs = diffs[~np.isnan(diffs)]
+        if len(valid_diffs) < 2:
+            return np.nan
+        
         return float(np.nanstd(diffs, ddof=1))
 
     # Handle Series input

iglu_python/episode_calculation.py

@@ -168,8 +168,15 @@ def episode_calculation(
         subject_episode_data['id'] = subject_id
 
         # Append to main dataframes
-        episode_data_df = pd.concat([episode_data_df, subject_episode_data], ignore_index=True)
-        episode_summary_df = pd.concat([episode_summary_df, subject_summary], ignore_index=True)
+        if episode_data_df.empty:
+            episode_data_df = subject_episode_data
+        else:
+            episode_data_df = pd.concat([episode_data_df, subject_episode_data], ignore_index=True)
+        
+        if episode_summary_df.empty:
+            episode_summary_df = subject_summary
+        else:
+            episode_summary_df = pd.concat([episode_summary_df, subject_summary], ignore_index=True)
 
 
 
@@ -238,7 +245,7 @@ def episode_single(
             day_one = day_one.tz_convert(local_tz)
         ndays = len(gd2d_tuple[1])
         # generate grid times by starting from day one and cumulatively summing
-        time_ip =  pd.date_range(start=day_one + pd.Timedelta(minutes=dt0), periods=ndays * 24 * 60 /dt0, freq=f"{dt0}min")
+        time_ip =  pd.date_range(start=day_one + pd.Timedelta(minutes=dt0), periods=int(ndays * 24 * 60 /dt0), freq=f"{dt0}min")
         data_ip = gd2d_tuple[0].flatten().tolist()
         new_data = pd.DataFrame({
             "time": time_ip,
@@ -297,29 +304,25 @@ def episode_single(
                         x, "hypo", lv1_hypo, int(120 / dt0) + 1, end_idx
                     ),
                 }
-            )
+            ),
+            include_groups=False
         )
         .reset_index()
         .drop(columns=['level_1'])
     )
 
 
-    # Add exclusive labels
-    def hypo_exclusion_logic(group_df):
-        # group_df is a DataFrame with all columns for the current group
-        if (group_df['lv2_hypo'] > 0).any():
-            return pd.Series([0] * len(group_df), index=group_df.index)
-        else:
-            return group_df['lv1_hypo']
-    ep_per_seg['lv1_hypo_excl'] = ep_per_seg.groupby(['segment', 'lv1_hypo']).apply(hypo_exclusion_logic).reset_index(level=[0,1], drop=True).values.flatten()
-
-    def hyper_exclusion_logic(group_df):
-        # group_df is a DataFrame with all columns for the current group
-        if (group_df['lv2_hyper'] > 0).any():
-            return pd.Series([0] * len(group_df), index=group_df.index)
-        else:
-            return group_df['lv1_hyper']
-    ep_per_seg['lv1_hyper_excl'] = ep_per_seg.groupby(['segment', 'lv1_hyper']).apply(hyper_exclusion_logic).reset_index(level=[0,1], drop=True).values.flatten()
+    # Add exclusive labels using the correct original logic without DeprecationWarning
+    # For hypo exclusion: group by both segment and lv1_hypo, set to 0 if any lv2_hypo > 0 in that group
+    def calculate_exclusion(df, lv1_col, lv2_col):
+        """Calculate exclusion labels for lv1 episodes based on lv2 episodes in same group"""
+        df = df.copy()
+        df['group_id'] = df.groupby(['segment', lv1_col]).ngroup()
+        group_has_lv2 = df.groupby('group_id')[lv2_col].transform(lambda x: (x > 0).any())
+        return df[lv1_col].where(~group_has_lv2, 0)
+    
+    ep_per_seg['lv1_hypo_excl'] = calculate_exclusion(ep_per_seg, 'lv1_hypo', 'lv2_hypo')
+    ep_per_seg['lv1_hyper_excl'] = calculate_exclusion(ep_per_seg, 'lv1_hyper', 'lv2_hyper')
 
     full_segment_df = pd.concat([segment_data, ep_per_seg.drop(["segment"], axis=1)], axis=1)
 
@@ -402,7 +405,8 @@ def event_class(
                         else None] + [None]*(len(x)-1)
                     ),
                 }
-            )
+            ),
+            include_groups=False
         )
         .reset_index()
         .drop(columns=['level_1'])
@@ -471,7 +475,8 @@ def lv1_excl(data: pd.DataFrame) -> np.ndarray:
         lambda x: pd.DataFrame(
                 {
                     "excl":[0 if (x[lv2_first].values > 0).any() else x[lv1_first].iloc[0]]*len(x)
-                })
+                }),
+        include_groups=False
     )
 
     excl = excl.reset_index()

iglu_python/grade.py

@@ -79,7 +79,7 @@ def grade(data: Union[pd.DataFrame, pd.Series]) -> pd.DataFrame:
     # Calculate GRADE score for each subject
     result = (
         data.groupby("id")
-        .apply(lambda x: np.mean(_grade_formula(x["gl"].dropna())))
+        .apply(lambda x: np.mean(_grade_formula(x["gl"].dropna())), include_groups=False)
         .reset_index()
     )
     result.columns = ["id", "GRADE"]

iglu_python/lbgi.py

@@ -109,14 +109,11 @@ def lbgi(data: Union[pd.DataFrame, pd.Series]) -> pd.DataFrame:
         raise ValueError("Empty DataFrame provided")
 
     # Calculate LBGI for each subject
-    result = pd.DataFrame(columns=["id", "LBGI"])
+    results = []
 
     for subject_id in data["id"].unique():
         subject_data = data[data["id"] == subject_id]["gl"]
         lbgi_value = calculate_lbgi(subject_data)
-        result = pd.concat(
-            [result, pd.DataFrame({"id": [subject_id], "LBGI": [lbgi_value]})],
-            ignore_index=True,
-        )
+        results.append({"id": subject_id, "LBGI": lbgi_value})
 
-    return result
+    return pd.DataFrame(results)

iglu_python/m_value.py

@@ -71,7 +71,7 @@ def m_value(data: Union[pd.DataFrame, pd.Series], r: float = 90) -> pd.DataFrame
     # Calculate M-value for each subject
     result = (
         data.groupby("id")
-        .apply(lambda x: 1000 * np.mean(np.abs(np.log10(x["gl"] / r)) ** 3))
+        .apply(lambda x: 1000 * np.mean(np.abs(np.log10(x["gl"] / r)) ** 3), include_groups=False)
         .reset_index()
     )
     result.columns = ["id", "M_value"]

iglu_python/mage.py

@@ -180,7 +180,10 @@ def mage_ma_single(data: pd.DataFrame, short_ma: int, long_ma: int,
         return_val = pd.DataFrame(columns=["start", "end", "mage", "plus_or_minus", "first_excursion"])
         for segment in dfs:
             ret = mage_atomic(segment,short_ma,long_ma)
-            return_val = pd.concat([return_val, ret], ignore_index=True)
+            if return_val.empty:
+                return_val = ret
+            else:
+                return_val = pd.concat([return_val, ret], ignore_index=True)
 
         if return_type == 'df':
             return return_val
@@ -195,9 +198,8 @@ def mage_ma_single(data: pd.DataFrame, short_ma: int, long_ma: int,
             res = return_val[return_val['MAGE'].notna()].copy()
         elif direction == 'max':
             # Group by start,end and keep max mage in each group
-            res = (return_val.groupby(['start', 'end'])
-                .apply(lambda x: x[x['MAGE'] == x['MAGE'].max()])
-                .reset_index(drop=True))
+            idx = return_val.groupby(['start', 'end'])['MAGE'].idxmax()
+            res = return_val.loc[idx].reset_index(drop=True)
         else:  # default: first excursions only
             res = return_val[return_val['first_excursion'] == True].copy()
 
@@ -220,13 +222,13 @@ def mage_atomic(data, short_ma,long_ma):
         data["MA_Long"] = data["gl"].rolling(window=long_ma, min_periods=1).mean()
         # Fill leading NAs (forward fill first valid value)
         if short_ma > len(data): 
-            data['MA_Short'].iloc[:short_ma] = data['MA_Short'].iloc[-1]
+            data.loc[data.index[:short_ma], 'MA_Short'] = data['MA_Short'].iloc[-1]
         else:
-            data['MA_Short'].iloc[:short_ma] = data['MA_Short'].iloc[short_ma-1]
+            data.loc[data.index[:short_ma], 'MA_Short'] = data['MA_Short'].iloc[short_ma-1]
         if long_ma > len(data):
-            data['MA_Long'].iloc[:long_ma] = data['MA_Long'].iloc[-1]
+            data.loc[data.index[:long_ma], 'MA_Long'] = data['MA_Long'].iloc[-1]
         else:
-            data['MA_Long'].iloc[:long_ma] = data['MA_Long'].iloc[long_ma-1]
+            data.loc[data.index[:long_ma], 'MA_Long'] = data['MA_Long'].iloc[long_ma-1]
         # Calculate difference
         data['DELTA_SHORT_LONG'] = data['MA_Short'] - data['MA_Long']
         data = data.reset_index(drop=True)

iglu_python/modd.py

@@ -72,7 +72,10 @@ def modd_single(data: pd.DataFrame) -> float:
         abs_diffs = abs_diffs[~np.isnan(abs_diffs)]  # Remove NaNs
 
         # Calculate mean of absolute differences, ignoring NaN values
-        modd_val = np.nanmean(abs_diffs)
+        if len(abs_diffs) == 0:
+            modd_val = np.nan
+        else:
+            modd_val = np.nanmean(abs_diffs)
 
         return float(modd_val) if not pd.isna(modd_val) else np.nan
 

iglu_python/pgs.py

@@ -127,8 +127,12 @@ def pgs_single(subj_data: pd.DataFrame) -> float:
 
         return pgs_score
 
-    # Calculate PGS for each subject
-    result = data.groupby("id").apply(lambda x: pgs_single(x)).reset_index()
-    result.columns = ["id", "PGS"]
 
-    return result
+    # Calculate PGS for each subject
+    results = []
+    for subject_id in data["id"].unique():
+        subject_data = data[data["id"] == subject_id].copy()
+        pgs_value = pgs_single(subject_data)
+        results.append({"id": subject_id, "PGS": pgs_value})
+    
+    return pd.DataFrame(results)

iglu_python/roc.py

@@ -123,7 +123,7 @@ def roc_single(data: pd.DataFrame, timelag: int, dt0: int = None , inter_gap: in
             {
                 "id": ["subject1"] * len(data),
                 "time": pd.date_range(
-                    start="2020-01-01", periods=len(data), freq=f"{dt0}T"
+                    start="2020-01-01", periods=len(data), freq=f"{dt0}min"
                 ),
                 "gl": data.values,
             }