formatting with ruff

Author: staskh

.github/workflows/ci.yml

@@ -38,10 +38,10 @@ jobs:
         pip install -e .
         pip install -r requirements-dev.txt
 
-    # - name: Lint with ruff
-    #   run: |
-    #     ruff check .
-    #     ruff format --check .
+    - name: Lint with ruff
+      run: |
+        ruff check .
+        ruff format --check .
 
     - name: Test with pytest
       run: |

iglu_python/above_percent.py

@@ -7,9 +7,9 @@
 
 
 def above_percent(
-    data: Union[pd.DataFrame, pd.Series, list,np.ndarray],
+    data: Union[pd.DataFrame, pd.Series, list, np.ndarray],
     targets_above: List[int] = None,
-) -> pd.DataFrame|dict[str:float]:
+) -> pd.DataFrame | dict[str:float]:
     """
     Calculate percentage of values above target thresholds.
 
@@ -61,12 +61,11 @@ def above_percent(
     # Handle Series input
     if targets_above is None:
         targets_above = [140, 180, 250]
-    if isinstance(data, (pd.Series, list,np.ndarray)):
+    if isinstance(data, (pd.Series, list, np.ndarray)):
         if isinstance(data, (list, np.ndarray)):
             data = pd.Series(data)
         return above_percent_single(data, targets_above)
 
-
     # Handle DataFrame input
     data = check_data_columns(data)
     targets_above = [int(t) for t in targets_above]
@@ -83,9 +82,10 @@ def above_percent(
 
     # Convert to DataFrame
     df = pd.DataFrame(result)
-    df = df[['id'] + [col for col in df.columns if col != 'id']]
+    df = df[["id"] + [col for col in df.columns if col != "id"]]
     return df
 
+
 def above_percent_single(data: pd.Series, targets_above: List[int] = None) -> dict[str:float]:
     """
     Calculate percentage of values above target thresholds for a single series/subject.

iglu_python/active_percent.py

@@ -14,7 +14,7 @@ def active_percent(
     range_type: str = "automatic",
     ndays: int = 14,
     consistent_end_date: Optional[Union[str, datetime]] = None,
-) -> pd.DataFrame|dict[str:float]:
+) -> pd.DataFrame | dict[str:float]:
     """
     Calculate percentage of time CGM was active.
 
@@ -86,21 +86,16 @@ def active_percent(
     # Process each subject
     for subject in data["id"].unique():
         # Filter data for current subject and remove NA values
-        sub_data = (
-            data[data["id"] == subject]
-            .dropna(subset=["gl", "time"])
-            .sort_values("time")
-        )
+        sub_data = data[data["id"] == subject].dropna(subset=["gl", "time"]).sort_values("time")
 
         timeseries = sub_data.set_index("time")["gl"]
         active_percent_dict = active_percent_single(timeseries, dt0, tz, range_type, ndays, consistent_end_date)
         active_percent_dict["id"] = subject
         active_perc_data.append(active_percent_dict)
 
-
     # Convert to DataFrame
     df = pd.DataFrame(active_perc_data)
-    df = df[['id'] + [col for col in df.columns if col != 'id']]
+    df = df[["id"] + [col for col in df.columns if col != "id"]]
     return df
 
 
@@ -127,9 +122,7 @@ def active_percent_single(
         return {"active_percent": 0, "ndays": 0, "start_date": None, "end_date": None}
 
     # Calculate time differences between consecutive measurements
-    time_diffs = np.array(
-        data.index.diff().total_seconds() / 60
-    )  # Convert to minutes
+    time_diffs = np.array(data.index.diff().total_seconds() / 60)  # Convert to minutes
 
     # Automatically determine dt0 if not provided
     if dt0 is None:
@@ -154,9 +147,7 @@ def active_percent_single(
         ndays = (max_time - min_time).total_seconds() / (24 * 3600)
 
         # Calculate active percentage
-        active_percent = (
-            (theoretical_gl_vals - missing_gl_vals) / theoretical_gl_vals
-        ) * 100
+        active_percent = ((theoretical_gl_vals - missing_gl_vals) / theoretical_gl_vals) * 100
     elif range_type == "manual":
         # Handle consistent end date if provided
         if consistent_end_date is not None:
@@ -178,6 +169,3 @@ def active_percent_single(
         raise ValueError(f"Invalid range_type: {range_type}")
 
     return {"active_percent": active_percent, "ndays": round(ndays, 1), "start_date": min_time, "end_date": max_time}
-
-
-

iglu_python/adrr.py

@@ -1,11 +1,10 @@
-
 import numpy as np
 import pandas as pd
 
 from .utils import check_data_columns
 
 
-def adrr(data: pd.DataFrame|pd.Series) -> pd.DataFrame|float:
+def adrr(data: pd.DataFrame | pd.Series) -> pd.DataFrame | float:
     """
     Calculate average daily risk range (ADRR)
 
@@ -52,7 +51,6 @@ def adrr(data: pd.DataFrame|pd.Series) -> pd.DataFrame|float:
     >>> iglu.adrr(data)
     """
 
-
     # Validate input
     if isinstance(data, pd.Series):
         if not isinstance(data.index, pd.DatetimeIndex):
@@ -61,15 +59,13 @@ def adrr(data: pd.DataFrame|pd.Series) -> pd.DataFrame|float:
 
     data = check_data_columns(data)
 
-    data.set_index("time", inplace=True,drop=True)
-    out = data.groupby("id").agg(
-        ADRR = ("gl", lambda x: adrr_single(x))
-    ).reset_index()
+    data.set_index("time", inplace=True, drop=True)
+    out = data.groupby("id").agg(ADRR=("gl", lambda x: adrr_single(x))).reset_index()
 
     return out
 
 
-def adrr_single(data: pd.DataFrame|pd.Series) -> float:
+def adrr_single(data: pd.DataFrame | pd.Series) -> float:
     """Internal function to calculate ADRR for a single subject or timeseries of glucose values"""
 
     if isinstance(data, pd.Series):
@@ -85,11 +81,10 @@ def adrr_single(data: pd.DataFrame|pd.Series) -> float:
         return np.nan
 
     # Group by date and calculate daily risk for each day
-    daily_risks = data_filtered.groupby(data_filtered.index.date).apply(
-        lambda x: _calculate_daily_risk(x)
-    )
+    daily_risks = data_filtered.groupby(data_filtered.index.date).apply(lambda x: _calculate_daily_risk(x))
     return daily_risks.mean()
 
+
 def _calculate_daily_risk(gl: pd.Series) -> float:
     """Calculate daily risk range for a single day and subject"""
 

iglu_python/auc.py

@@ -1,4 +1,3 @@
-
 import numpy as np
 import pandas as pd
 
@@ -60,7 +59,7 @@ def auc(data: pd.DataFrame, tz: str = "") -> pd.DataFrame:
         if not isinstance(data.index, pd.DatetimeIndex):
             raise ValueError("Series must have a DatetimeIndex")
 
-        auc = auc_single(data,tz=tz)
+        auc = auc_single(data, tz=tz)
         return auc
 
     # Check data format and convert time to datetime
@@ -70,46 +69,41 @@ def auc(data: pd.DataFrame, tz: str = "") -> pd.DataFrame:
     result = []
     for subject in data["id"].unique():
         subject_data = data[data["id"] == subject]
-        hourly_auc = auc_single(subject_data,tz=tz)
+        hourly_auc = auc_single(subject_data, tz=tz)
         result.append({"id": subject, "hourly_auc": hourly_auc})
 
     # Convert to DataFrame
     return pd.DataFrame(result)
 
-def auc_single(subject_data: pd.DataFrame|pd.Series,tz:str = "") -> float:
+
+def auc_single(subject_data: pd.DataFrame | pd.Series, tz: str = "") -> float:
     """Calculate AUC for a single subject"""
     # Get interpolated data using CGMS2DayByDay
     gd2d, actual_dates, dt0 = CGMS2DayByDay(subject_data, tz=tz)
 
     # Convert gd2d to DataFrame
     input_data = gd2d_to_df(gd2d, actual_dates, dt0)
     if is_iglu_r_compatible():
-        input_data['day'] = input_data['time'].dt.floor('d')
-        input_data['gl_next'] = input_data['gl'].shift(-1)
+        input_data["day"] = input_data["time"].dt.floor("d")
+        input_data["gl_next"] = input_data["gl"].shift(-1)
         each_day_area = input_data.groupby("day").apply(
-            lambda x: np.nansum(
-                (dt0/60)*(x["gl"].values + x["gl_next"].values) / 2
-            ),
-            include_groups=False
+            lambda x: np.nansum((dt0 / 60) * (x["gl"].values + x["gl_next"].values) / 2), include_groups=False
         )
         # calculate number of not nan trapezoids in total (number of not nan gl and gl_next)
         n_trapezoids = (~np.isnan(input_data["gl"]) & ~np.isnan(input_data["gl_next"])).sum()
-        hours = dt0/60 * n_trapezoids
+        hours = dt0 / 60 * n_trapezoids
         daily_area = each_day_area.sum()
-        hourly_avg = daily_area/hours
+        hourly_avg = daily_area / hours
         return hourly_avg
     else:
         # Add hour column by rounding time to nearest hour
-        input_data['hour'] = input_data['time'].dt.floor('h')
+        input_data["hour"] = input_data["time"].dt.floor("h")
 
-        input_data['gl_next'] = input_data['gl'].shift(-1)
+        input_data["gl_next"] = input_data["gl"].shift(-1)
 
         # Calculate AUC for each hour using trapezoidal rule (mg*min/dL)
         hourly_auc = input_data.groupby("hour").apply(
-            lambda x: np.nansum(
-                (dt0/60)*(x["gl"].values + x["gl_next"].values) / 2
-            ),
-            include_groups=False
+            lambda x: np.nansum((dt0 / 60) * (x["gl"].values + x["gl_next"].values) / 2), include_groups=False
         )
         # 0 mean no data in this hour, replace with nan
         hourly_auc = hourly_auc.replace(0, np.nan)

iglu_python/below_percent.py

@@ -7,8 +7,8 @@
 
 
 def below_percent(
-    data: Union[pd.DataFrame, pd.Series, list,np.ndarray], targets_below: List[int] = None
-) -> pd.DataFrame|dict[str:float]:
+    data: Union[pd.DataFrame, pd.Series, list, np.ndarray], targets_below: List[int] = None
+) -> pd.DataFrame | dict[str:float]:
     """
     Calculate percentage of values below target thresholds.
 
@@ -60,12 +60,11 @@ def below_percent(
     # Handle Series input
     if targets_below is None:
         targets_below = [54, 70]
-    if isinstance(data, (pd.Series, list,np.ndarray)):
+    if isinstance(data, (pd.Series, list, np.ndarray)):
         if isinstance(data, (list, np.ndarray)):
             data = pd.Series(data)
         return below_percent_single(data, targets_below)
 
-
     # Handle DataFrame input
     data = check_data_columns(data)
 
@@ -82,9 +81,10 @@ def below_percent(
 
     # Convert to DataFrame
     df = pd.DataFrame(result)
-    df = df[['id'] + [col for col in df.columns if col != 'id']]
+    df = df[["id"] + [col for col in df.columns if col != "id"]]
     return df
 
+
 def below_percent_single(data: pd.Series, targets_below: List[int] = None) -> dict[str:float]:
     """
     Calculate percentage of values below target thresholds for a single series/subject.
@@ -106,4 +106,3 @@ def below_percent_single(data: pd.Series, targets_below: List[int] = None) -> di
         percentages[f"below_{target}"] = (below_count / total_readings) * 100
 
     return percentages
-

iglu_python/cogi.py

@@ -10,10 +10,10 @@
 
 
 def cogi(
-    data: Union[pd.DataFrame, pd.Series, list,np.ndarray],
+    data: Union[pd.DataFrame, pd.Series, list, np.ndarray],
     targets: List[int] = None,
     weights: List[float] = None,
-) -> pd.DataFrame|float:
+) -> pd.DataFrame | float:
     """
     Calculate Coefficient of Glucose Irregularity (COGI).
 
@@ -81,12 +81,11 @@ def cogi(
 
     data = check_data_columns(data)
 
-    out = data.groupby("id").agg(
-        COGI=('gl', lambda x: cogi_single(x, targets, weights))
-    ).reset_index()
+    out = data.groupby("id").agg(COGI=("gl", lambda x: cogi_single(x, targets, weights))).reset_index()
 
     return out
 
+
 def cogi_single(data: pd.Series, targets: List[int] = None, weights: List[float] = None) -> float:
     """Calculate COGI for a single subject"""
     # Calculate components
@@ -110,7 +109,6 @@ def cogi_single(data: pd.Series, targets: List[int] = None, weights: List[float]
     return weighted_features * 100  # Convert to percentage
 
 
-
 def weight_features(
     feature: Union[float, pd.Series, list],
     scale_range: List[float],
@@ -122,26 +120,19 @@ def weight_features(
     with the same number of rows (or length) as the input, with values clipped
     (or "inverse" clipped) so that they are between 0 and 1."""
     if isinstance(feature, pd.Series):
-        scaled = (feature - min(scale_range)) / (
-            max(scale_range) - min(scale_range)
-        )
+        scaled = (feature - min(scale_range)) / (max(scale_range) - min(scale_range))
         if increasing:
             out = scaled.clip(lower=0, upper=1)
         else:
             out = (1 - scaled).clip(lower=0, upper=1)
     elif isinstance(feature, list):
-        scaled = [
-            (x - min(scale_range)) / (max(scale_range) - min(scale_range))
-            for x in feature
-        ]
+        scaled = [(x - min(scale_range)) / (max(scale_range) - min(scale_range)) for x in feature]
         if increasing:
             out = [min(1, max(0, x)) for x in scaled]
         else:
             out = [min(1, max(0, 1 - x)) for x in scaled]
     else:
-        scaled = (feature - min(scale_range)) / (
-            max(scale_range) - min(scale_range)
-        )
+        scaled = (feature - min(scale_range)) / (max(scale_range) - min(scale_range))
         if increasing:
             out = min(1, max(0, scaled))
         else:

iglu_python/conga.py

@@ -6,9 +6,7 @@
 from .utils import CGMS2DayByDay, check_data_columns
 
 
-def conga(
-    data: Union[pd.DataFrame, pd.Series], n: int = 24, tz: str = ""
-) -> pd.DataFrame|float:
+def conga(data: Union[pd.DataFrame, pd.Series], n: int = 24, tz: str = "") -> pd.DataFrame | float:
     """
     Calculate Continuous Overall Net Glycemic Action (CONGA).
 
@@ -69,14 +67,13 @@ def conga(
     data = check_data_columns(data)
 
     # Calculate CONGA for each subject
-    data.set_index("time", inplace=True,drop=True)
-    out = data.groupby('id').agg(
-        CONGA = ("gl", lambda x: conga_single(x, hours=n, tz=tz))
-    ).reset_index()
+    data.set_index("time", inplace=True, drop=True)
+    out = data.groupby("id").agg(CONGA=("gl", lambda x: conga_single(x, hours=n, tz=tz))).reset_index()
 
     return out
 
-def conga_single(data: pd.DataFrame|pd.Series, hours: int = 1, tz: str = "") -> float:
+
+def conga_single(data: pd.DataFrame | pd.Series, hours: int = 1, tz: str = "") -> float:
     """Calculate CONGA for a single subject"""
     # Convert data to day-by-day format
     # Missing values will be linearly interpolated when close enough to non-missing values.

iglu_python/cv_glu.py

@@ -56,8 +56,6 @@ def cv_glu(data: Union[pd.DataFrame, pd.Series, list, np.ndarray]) -> Union[pd.D
 
     data = data.dropna()
     # Calculate CV for each subject
-    out = data.groupby('id').agg(
-        CV=('gl', lambda x: 100 * x.std() / x.mean())
-    ).reset_index()
+    out = data.groupby("id").agg(CV=("gl", lambda x: 100 * x.std() / x.mean())).reset_index()
 
     return out