glucose360 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

glucose360/__init__.py

@@ -1 +1,6 @@
+"""
+Glucose360: A Python package that provides Continuous Glucose Monitoring (CGM) data preprocessing, feature extraction, event detection, and plotting utilities.
+"""
+
+__version__ = "0.0.1"
 __all__ = ["preprocessing", "features", "events", "plots"]

glucose360/config.ini

@@ -0,0 +1,10 @@
+[variables]
+id = ID
+glucose = Glucose
+time = Timestamp
+before = Before
+after = After
+type = Type
+description = Description
+interval = 5
+

glucose360/event_colors.json

@@ -0,0 +1,47 @@
+{
+   "gold": "#ffd700",
+   "red": "#ff0000",
+   "limegreen": "#32cd32",
+   "hotpink": "#ff69b4",
+   "dodgerblue": "#1e90ff",
+   "darkolivegreen": "#556b2f",
+   "sienna": "#a0522d",
+   "seagreen": "#2e8b57",
+   "maroon2": "#7f0000",
+   "darkgreen": "#006400",
+   "slategray": "#708090",
+   "olive": "#808000",
+   "rosybrown": "#bc8f8f",
+   "peru": "#cd853f",
+   "yellowgreen": "#9acd32",
+   "lightseagreen": "#20b2aa",
+   "indianred": "#cd5c5c",
+   "goldenrod": "#daa520",
+   "darkseagreen": "#8fbc8f",
+   "purple": "#800080",
+   "darkorchid": "#9932cc",
+   "darkorange": "#ff8c00",
+   "slateblue": "#6a5acd",
+   "lime": "#00ff00",
+   "mediumspringgreen": "#00fa9a",
+   "darksalmon": "#e9967a",
+   "crimson": "#dc143c",
+   "aqua": "#00ffff",
+   "deepskyblue": "#00bfff",
+   "purple3": "#a020f0",
+   "greenyellow": "#adff2f",
+   "tomato": "#ff6347",
+   "thistle": "#d8bfd8",
+   "fuchsia": "#ff00ff",
+   "palevioletred": "#db7093",
+   "khaki": "#f0e68c",
+   "laserlemon": "#ffff54",
+   "plum": "#dda0dd",
+   "lightgreen": "#90ee90",
+   "deeppink": "#ff1493",
+   "paleturquoise": "#afeeee",
+   "violet": "#ee82ee",
+   "aquamarine": "#7fffd4",
+   "peachpuff": "#ffdab9",
+   "darkslategray": "#2f4f4f"
+}

glucose360/events.py

@@ -4,11 +4,12 @@ from scipy.integrate import trapezoid
 import configparser
 import glob, os, zipfile, tempfile
 import math
+from importlib import resources
+from glucose360.preprocessing import load_config
 
-dir_path = os.path.dirname(os.path.realpath(__file__))
-config_path = os.path.join(dir_path, "config.ini")
-config = configparser.ConfigParser()
-config.read(config_path)
+# Initialize config at module level
+config = load_config()
+INTERVAL = int(config["variables"]["interval"])
 ID = config['variables']['id']
 GLUCOSE = config['variables']['glucose']
 TIME = config['variables']['time']
@@ -23,8 +24,8 @@ def import_events(
    name: str = None,
    day_col: str = "Day",
    time_col: str = "Time",
-   before: int = 60,
-   after: int = 60,
+   before: int = 30,
+   after: int = 180,
    type: str = "imported event"
 ) -> pd.DataFrame:
    """Bulk imports events from standalone .csv files or from those within a given directory or .zip file
@@ -37,9 +38,9 @@ def import_events(
    :type day_col: str, optional
    :param time_col: the name of the column specifying what time during the day the event occurred, defaults to 'Time'
    :type time_col: str, optional
-   :param before: the amount of minutes to also look at before the event timestamp, defaults to 60
+   :param before: the amount of minutes to also look at before the event timestamp, defaults to 30
    :type before: int, optional
-   :param after: the amount of minutes to also look at after the event timestamp, defaults to 60
+   :param after: the amount of minutes to also look at after the event timestamp, defaults to 180
    :type after: int, optional
    :param type: the type of event to classify all the imported events as, defaults to 'imported event'
    :type type: str, optional
@@ -79,8 +80,8 @@ def import_events_directory(
    id: str,
    day_col: str = "Day",
    time_col: str = "Time",
-   before: int = 60,
-   after: int = 60,
+   before: int = 30,
+   after: int = 180,
    type: str = "imported event"
 ) -> pd.DataFrame:
     """Bulk imports events from .csv files within a given directory
@@ -93,9 +94,9 @@ def import_events_directory(
    :type day_col: str, optional
    :param time_col: the name of the column specifying what time during the day the event occurred, defaults to 'Time'
    :type time_col: str, optional
-   :param before: the amount of minutes to also look at before the event timestamp, defaults to 60
+   :param before: the amount of minutes to also look at before the event timestamp, defaults to 30
    :type before: int, optional
-   :param after: the amount of minutes to also look at after the event timestamp, defaults to 60
+   :param after: the amount of minutes to also look at after the event timestamp, defaults to 180
    :type after: int, optional
    :param type: the type of event to classify all the imported events as, defaults to 'imported event'
    :type type: str, optional
@@ -114,8 +115,8 @@ def import_events_csv(
    id: str,
    day_col: str = "Day",
    time_col: str = "Time",
-   before: int = 60,
-   after: int = 60,
+   before: int = 30,
+   after: int = 180,
    type: str = "imported event"
 ) -> pd.DataFrame:
    """Bulk imports events from a single .csv file
@@ -128,9 +129,9 @@ def import_events_csv(
    :type day_col: str, optional
    :param time_col: the name of the column specifying what time during the day the event occurred, defaults to 'Time'
    :type time_col: str, optional
-   :param before: the amount of minutes to also look at before the event timestamp, defaults to 60
+   :param before: the amount of minutes to also look at before the event timestamp, defaults to 30
    :type before: int, optional
-   :param after: the amount of minutes to also look at after the event timestamp, defaults to 60
+   :param after: the amount of minutes to also look at after the event timestamp, defaults to 180
    :type after: int, optional
    :param type: the type of event to classify all the imported events as, defaults to 'imported event'
    :type type: str, optional
@@ -263,10 +264,11 @@ def get_episodes(
                             _episodes_helper(data, id, "hypo", hypo_lvl1, 1, min_length, end_length),
                             _episodes_helper(data, id, "hypo", hypo_lvl2, 2, min_length, end_length)])
       
-      episodes.sort_values(by=[TIME], inplace=True)
+      if not episodes.empty:
+          episodes = episodes.sort_values(by=[TIME])
       output = pd.concat([output, episodes])
 
-   return output 
+   return output
 
 def get_excursions(
    df: pd.DataFrame, 
@@ -388,7 +390,7 @@ def retrieve_event_data(
          final = datetime + pd.Timedelta(row[AFTER], "m")
 
          patient_data = df.loc[id]
-         data = patient_data[(patient_data[TIME] >= initial) & (patient_data[TIME] <= final)].copy()
+         data = patient_data[(patient_data[TIME] >= initial) & (patient_data[TIME] <= final)].copy().reset_index(drop=True)
 
          data[ID] = id
          data[DESCRIPTION] = row[DESCRIPTION]
@@ -562,7 +564,7 @@ def event_metrics(
    final = datetime + pd.Timedelta(event[AFTER], "m")
 
    patient_data = df.loc[id]
-   data = patient_data[(patient_data[TIME] >= initial) & (patient_data[TIME] <= final)].copy()
+   data = patient_data[(patient_data[TIME] >= initial) & (patient_data[TIME] <= final)].copy().reset_index(drop=True)
 
    metrics = pd.Series()
    metrics["Baseline"] = baseline(data)
@@ -610,8 +612,8 @@ def create_event_features(
    event_features = {}
    for id in df.index.unique():
       sub_features = {}
-      for type, sub_events in events[events[ID] == id].groupby(TYPE):
-         sub_features.update(create_event_features_helper(df.loc[id], sub_events, type))
+      for event_type, sub_events in events[events[ID] == id].groupby(TYPE):
+         sub_features.update(create_event_features_helper(df.loc[id], sub_events, event_type))
       event_features[id] = sub_features
 
    return pd.DataFrame(event_features).T
@@ -619,7 +621,7 @@ def create_event_features(
 def create_event_features_helper(
    df: pd.DataFrame,
    sub_events: pd.DataFrame,
-   type: str,     
+   event_type: str,
 ) -> dict[str, float]:
    """Calculates aggregate event-based metrics for a single patient and type of event. Helper method for 'create_event_features()'.
 
@@ -627,32 +629,32 @@ def create_event_features_helper(
    :type df: 'pandas.DataFrame'
    :param sub_events: Pandas DataFrame containing events of only one type solely for the patient whose CGM trace is also given
    :type sub_events: 'pandas.DataFrame'
-   :param type: the type of event that 'sub_events' contains
-   :type type: str
+   :param event_type: the type of event that 'sub_events' contains
+   :type event_type: str
    :return: a dictionary with str-type keys that refer to the name of the calculated features and float-type values
    :rtype: dict[str, float]
    """
    
    features = {
-      f"Mean {type} Duration": [],
-      f"Mean Glucose During {type}s": [],
-      f"Mean Upwards Slope of {type}s (mg/dL per min)": [],
-      f"Mean Downwards Slope of {type}s (mg/dL per min)": [],
-      f"Mean Minimum Glucose of {type}s": [],
-      f"Mean Maximum Glucose of {type}s": [],
-      f"Mean Amplitude of {type}s": [],
-      f"Mean iAUC of {type}s": []
+      f"Mean {event_type} Duration": [],
+      f"Mean Glucose During {event_type}s": [],
+      f"Mean Upwards Slope of {event_type}s (mg/dL per min)": [],
+      f"Mean Downwards Slope of {event_type}s (mg/dL per min)": [],
+      f"Mean Minimum Glucose of {event_type}s": [],
+      f"Mean Maximum Glucose of {event_type}s": [],
+      f"Mean Amplitude of {event_type}s": [],
+      f"Mean iAUC of {event_type}s": []
    }
    
    for _, event in sub_events.iterrows():
       event_data = retrieve_event_data(df, event)
 
-      duration = event[AFTER] - event[BEFORE]
-      features[f"Mean {type} Duration"].append(duration)
+      duration = event[AFTER] + event[BEFORE]
+      features[f"Mean {event_type} Duration"].append(duration)
 
-      features[f"Mean Glucose During {type}s"].append(event_data[GLUCOSE].mean())
-      features[f"Mean Minimum Glucose of {type}s"] = nadir(event_data)
-      features[f"Mean Maximum Glucose of {type}s"] = peak(event_data)
+      features[f"Mean Glucose During {event_type}s"].append(event_data[GLUCOSE].mean())
+      features[f"Mean Minimum Glucose of {event_type}s"].append(nadir(event_data))
+      features[f"Mean Maximum Glucose of {event_type}s"].append(peak(event_data))
 
       event_time = event[TIME]
       closest_idx = (event_data[TIME] - event_time).abs().idxmin()
@@ -661,20 +663,20 @@ def create_event_features_helper(
       peak_glucose = peak(event_data)
       peak_time = event_data.loc[event_data[GLUCOSE].idxmax(), TIME]
       amplitude = peak_glucose - event_glucose
-      features[f"Mean Amplitude of {type}s"].append(abs(amplitude))
+      features[f"Mean Amplitude of {event_type}s"].append(abs(amplitude))
 
       time_diff_to_peak = (peak_time - event_time).total_seconds() / 60.0
       slope_to_peak = (peak_glucose - event_glucose) / time_diff_to_peak if time_diff_to_peak != 0 else np.nan
-      features[f"Mean Upwards Slope of {type}s (mg/dL per min)"].append(slope_to_peak)
+      features[f"Mean Upwards Slope of {event_type}s (mg/dL per min)"].append(slope_to_peak)
 
       end_time = event_data[TIME].iloc[-1]
       end_glucose = event_data[GLUCOSE].iloc[-1]
       time_diff_peak_to_end = (end_time - peak_time).total_seconds() / 60.0
       slope_peak_to_end = (end_glucose - peak_glucose) / time_diff_peak_to_end if time_diff_peak_to_end != 0 else np.nan
-      features[f"Mean Downwards Slope of {type}s (mg/dL per min)"].append(slope_peak_to_end)
+      features[f"Mean Downwards Slope of {event_type}s (mg/dL per min)"].append(slope_peak_to_end)
 
-      features[f"Mean iAUC of {type}s"].append(iAUC(event_data, event_glucose))
+      features[f"Mean iAUC of {event_type}s"].append(iAUC(event_data, event_glucose))
 
    features = {k: np.mean(v) for k, v in features.items()}
-   features[f"Mean # of {type}s per day"] = sub_events.shape[0] / len(df[TIME].dt.date.unique())
+   features[f"Mean # of {event_type}s per day"] = sub_events.shape[0] / len(df[TIME].dt.date.unique())
    return features