paradigma 1.0.1__tar.gz → 1.0.3__tar.gz

{paradigma-1.0.1 → paradigma-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: paradigma
-Version: 1.0.1
+Version: 1.0.3
 Summary: ParaDigMa - A toolbox for deriving Parkinson's disease Digital Markers from real-life wrist sensor data
 License: Apache-2.0
 Author: Erik Post
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: nbconvert (>=7.16.6,<8.0.0)
 Requires-Dist: pandas (>=2.1.4,<3.0.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: pytype (>=2024.4.11,<2025.0.0)
@@ -41,7 +42,7 @@ It contains three data processing pipelines: (1) arm swing during gait, (2) trem
 and (3) pulse rate. These pipelines are scientifically validated for their 
 use in persons with PD. Furthermore, the toolbox contains general functionalities for 
 signal processing and feature extraction, such as filtering, peak detection, and 
-spectral analysis. 
+spectral analysis.
 
 The toolbox is accompanied by a set of example scripts and notebooks for 
 each processing pipeline that demonstrate how to use the toolbox for extracting 
@@ -111,10 +112,10 @@ We have included support for [TSDF](https://biomarkersparkinson.github.io/tsdf/)
 
 ## Scientific validation
 
-The pipelines were developed and validated using data from the Parkinson@Home Validation study [[Evers et al. 2020]](https://pmc.ncbi.nlm.nih.gov/articles/PMC7584982/) and the Personalized Parkinson Project [[Bloem et al. 2019]](https://pubmed.ncbi.nlm.nih.gov/31315608/). The following publication contains the details and validation of the arm swing during gait pipeline:
-* [Post, E. et al. - Quantifying arm swing in Parkinson's disease: a method account for arm activities during free-living gait](https://doi.org/10.1186/s12984-025-01578-z)
-
-Details and validation of the other pipelines shall be shared in upcoming scientific publications.
+The pipelines were developed and validated using data from the Parkinson@Home Validation study [[Evers et al. (2020)]](https://pmc.ncbi.nlm.nih.gov/articles/PMC7584982/) and the Personalized Parkinson Project [[Bloem et al. (2019)]](https://pubmed.ncbi.nlm.nih.gov/31315608/). The following publications contain details and validation of the pipelines:
+* [Post, E. et al. (2025) - Quantifying arm swing in Parkinson's disease: a method account for arm activities during free-living gait](https://doi.org/10.1186/s12984-025-01578-z)
+* [Timmermans, N.A. et al. (2025) - A generalizable and open-source algorithm for real-life monitoring of tremor in Parkinson's disease](https://doi.org/10.1038/s41531-025-01056-2)
+* [Veldkamp, K.I. et al. (2025) - Heart rate monitoring using wrist photoplethysmography in Parkinson disease: feasibility and relation with autonomic dysfunction](https://doi.org/10.1101/2025.08.15.25333751)
 
 ## Contributing
 
@@ -133,5 +134,5 @@ The initial release of ParaDigMa was funded by the Michael J Fox Foundation (gra
 ParaDigMa was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).
 
 ## Contact
-Questions, issues or suggestions about ParaDigMa? Please reach out to erik.post@radboudumc.nl, or open an issue in the GitHub repository.
+Questions, issues or suggestions about ParaDigMa? Please reach out to paradigma@radboudumc.nl, or open an issue in the GitHub repository.
 

{paradigma-1.0.1 → paradigma-1.0.3}/README.md

@@ -21,7 +21,7 @@ It contains three data processing pipelines: (1) arm swing during gait, (2) trem
 and (3) pulse rate. These pipelines are scientifically validated for their 
 use in persons with PD. Furthermore, the toolbox contains general functionalities for 
 signal processing and feature extraction, such as filtering, peak detection, and 
-spectral analysis. 
+spectral analysis.
 
 The toolbox is accompanied by a set of example scripts and notebooks for 
 each processing pipeline that demonstrate how to use the toolbox for extracting 
@@ -91,10 +91,10 @@ We have included support for [TSDF](https://biomarkersparkinson.github.io/tsdf/)
 
 ## Scientific validation
 
-The pipelines were developed and validated using data from the Parkinson@Home Validation study [[Evers et al. 2020]](https://pmc.ncbi.nlm.nih.gov/articles/PMC7584982/) and the Personalized Parkinson Project [[Bloem et al. 2019]](https://pubmed.ncbi.nlm.nih.gov/31315608/). The following publication contains the details and validation of the arm swing during gait pipeline:
-* [Post, E. et al. - Quantifying arm swing in Parkinson's disease: a method account for arm activities during free-living gait](https://doi.org/10.1186/s12984-025-01578-z)
-
-Details and validation of the other pipelines shall be shared in upcoming scientific publications.
+The pipelines were developed and validated using data from the Parkinson@Home Validation study [[Evers et al. (2020)]](https://pmc.ncbi.nlm.nih.gov/articles/PMC7584982/) and the Personalized Parkinson Project [[Bloem et al. (2019)]](https://pubmed.ncbi.nlm.nih.gov/31315608/). The following publications contain details and validation of the pipelines:
+* [Post, E. et al. (2025) - Quantifying arm swing in Parkinson's disease: a method account for arm activities during free-living gait](https://doi.org/10.1186/s12984-025-01578-z)
+* [Timmermans, N.A. et al. (2025) - A generalizable and open-source algorithm for real-life monitoring of tremor in Parkinson's disease](https://doi.org/10.1038/s41531-025-01056-2)
+* [Veldkamp, K.I. et al. (2025) - Heart rate monitoring using wrist photoplethysmography in Parkinson disease: feasibility and relation with autonomic dysfunction](https://doi.org/10.1101/2025.08.15.25333751)
 
 ## Contributing
 
@@ -113,4 +113,4 @@ The initial release of ParaDigMa was funded by the Michael J Fox Foundation (gra
 ParaDigMa was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).
 
 ## Contact
-Questions, issues or suggestions about ParaDigMa? Please reach out to erik.post@radboudumc.nl, or open an issue in the GitHub repository.
+Questions, issues or suggestions about ParaDigMa? Please reach out to paradigma@radboudumc.nl, or open an issue in the GitHub repository.

{paradigma-1.0.1 → paradigma-1.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "paradigma"
-version = "1.0.1"
+version = "1.0.3"
 description = "ParaDigMa - A toolbox for deriving Parkinson's disease Digital Markers from real-life wrist sensor data"
 authors = [ "Erik Post <erik.post@radboudumc.nl>",
             "Kars Veldkamp <kars.veldkamp@radboudumc.nl>",
@@ -22,6 +22,7 @@ pytype = "^2024.4.11"
 # for the record: pytype was installed directly with pip (in the poetry environment),
 # because poetry didn't handle the install for different CPU architectures
 python-dateutil = "^2.9.0.post0"
+nbconvert = "^7.16.6"
 
 [tool.poetry.group.testing.dependencies]
 ipykernel = "^6.27.1"
@@ -41,6 +42,8 @@ nbsphinx = "^0.9.6"
 
 [tool.poetry.group.dev.dependencies]
 pytype = "^2024.10.11"
+notebook = "^7.4.5"
+ipykernel = "^6.30.1"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{paradigma-1.0.1 → paradigma-1.0.3}/src/paradigma/config.py

@@ -66,6 +66,7 @@ class IMUConfig(BaseConfig):
         self.d_channels_imu = {**self.d_channels_accelerometer, **self.d_channels_gyroscope}
 
         self.sampling_frequency = 100
+        self.resampling_frequency = 100
         self.lower_cutoff_frequency = 0.2
         self.upper_cutoff_frequency = 3.5
         self.filter_order = 4
@@ -222,7 +223,8 @@ class TremorConfig(IMUConfig):
         # -----------
         # Aggregation
         # -----------
-        self.aggregates_tremor_power: List[str] = ['mode', 'median', '90p']
+        self.aggregates_tremor_power: List[str] = ['mode_binned', 'median', '90p']
+        self.evaluation_points_tremor_power: np.ndarray = np.linspace(0, 6, 301) 
 
         # -----------------
         # TSDF data storage

{paradigma-1.0.1 → paradigma-1.0.3}/src/paradigma/pipelines/gait_pipeline.py

@@ -1,3 +1,4 @@
+import logging
 import numpy as np
 import pandas as pd
 from scipy.signal import periodogram
@@ -10,10 +11,16 @@ from paradigma.feature_extraction import pca_transform_gyroscope, compute_angle,
     extract_angle_extremes, compute_range_of_motion, compute_peak_angular_velocity, compute_statistics, \
     compute_std_euclidean_norm, compute_power_in_bandwidth, compute_dominant_frequency, compute_mfccs, \
     compute_total_power
-from paradigma.segmenting import tabulate_windows, create_segments, discard_segments, categorize_segments, WindowedDataExtractor
+from paradigma.segmenting import tabulate_windows, create_segments, discard_segments, WindowedDataExtractor
 from paradigma.util import aggregate_parameter
 
 
+logger = logging.getLogger(__name__)
+
+# Only configure basic logging if no handlers exist
+if not logger.hasHandlers():
+    logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
+
 def extract_gait_features(
         df: pd.DataFrame,
         config: GaitConfig
@@ -351,19 +358,15 @@ def quantify_arm_swing(
     """
     # Group consecutive timestamps into segments, with new segments starting after a pre-specified gap.
     # Segments are made based on predicted gait
-    df[DataColumns.SEGMENT_NR] = create_segments(
+    df['unfiltered_segment_nr'] = create_segments(
         time_array=df[DataColumns.TIME], 
         max_segment_gap_s=max_segment_gap_s
     )
 
-    # Segment category is determined based on predicted gait, hence it is set
-    # before filtering the DataFrame to only include predicted no other arm activity
-    df[DataColumns.SEGMENT_CAT] = categorize_segments(df=df, fs=fs)
-
     # Remove segments that do not meet predetermined criteria
     df = discard_segments(
         df=df,
-        segment_nr_colname=DataColumns.SEGMENT_NR,
+        segment_nr_colname='unfiltered_segment_nr',
         min_segment_length_s=min_segment_length_s,
         fs=fs,
         format='timestamps'
@@ -371,7 +374,10 @@ def quantify_arm_swing(
 
     if df.empty:
         raise ValueError("No segments found in the input data after discarding segments of invalid shape.")
-
+    
+    # Create dictionary of gait segment number and duration
+    gait_segment_duration_dict = {segment_nr: len(group[DataColumns.TIME]) / fs for segment_nr, group in df.groupby('unfiltered_segment_nr', sort=False)}
+    
     # If no arm swing data is remaining, return an empty dictionary
     if filtered and df.loc[df[DataColumns.PRED_NO_OTHER_ARM_ACTIVITY]==1].empty:
         raise ValueError("No gait without other arm activities to quantify.")
@@ -380,7 +386,7 @@ def quantify_arm_swing(
         df = df.loc[df[DataColumns.PRED_NO_OTHER_ARM_ACTIVITY]==1].reset_index(drop=True)
 
         # Group consecutive timestamps into segments of filtered gait
-        df[DataColumns.SEGMENT_NR] = create_segments(
+        df['filtered_segment_nr'] = create_segments(
             time_array=df[DataColumns.TIME], 
             max_segment_gap_s=max_segment_gap_s
         )
@@ -388,13 +394,15 @@ def quantify_arm_swing(
         # Remove segments that do not meet predetermined criteria
         df = discard_segments(
             df=df,
-            segment_nr_colname=DataColumns.SEGMENT_NR,
+            segment_nr_colname='filtered_segment_nr',
             min_segment_length_s=min_segment_length_s,
             fs=fs,
         )
 
         if df.empty:
             raise ValueError("No filtered gait segments found in the input data after discarding segments of invalid shape.")
+        
+    grouping_colname = 'filtered_segment_nr' if filtered else 'unfiltered_segment_nr'
 
     arm_swing_quantified = []
     segment_meta = {
@@ -415,8 +423,22 @@ def quantify_arm_swing(
     )
 
     # Group and process segments
-    for segment_nr, group in df.groupby(DataColumns.SEGMENT_NR, sort=False):
-        segment_cat = group[DataColumns.SEGMENT_CAT].iloc[0]
+    for segment_nr, group in df.groupby(grouping_colname, sort=False):
+        if filtered:
+            gait_segment_nr = group['unfiltered_segment_nr'].iloc[0]  # Each filtered segment is contained within an unfiltered segment
+        else:
+            gait_segment_nr = segment_nr
+
+        try:
+            gait_segment_duration_s = gait_segment_duration_dict[gait_segment_nr]
+        except KeyError:
+            logger.warning(
+                "Segment %s (filtered = %s) not found in gait segment duration dictionary. Skipping this segment.",
+                gait_segment_nr, filtered
+            )
+            logger.debug("Available segments: %s", list(gait_segment_duration_dict.keys()))
+            continue
+
         time_array = group[DataColumns.TIME].to_numpy()
         velocity_array = group[DataColumns.VELOCITY].to_numpy()
 
@@ -435,10 +457,12 @@ def quantify_arm_swing(
         segment_meta['per_segment'][segment_nr] = {
             'start_time_s': time_array.min(),
             'end_time_s': time_array.max(),
-            'duration_s': len(angle_array) / fs,
-            DataColumns.SEGMENT_CAT: segment_cat
+            'duration_unfiltered_segment_s': gait_segment_duration_s,
         }
 
+        if filtered:
+            segment_meta['per_segment'][segment_nr]['duration_filtered_segment_s'] = len(time_array) / fs
+
         if angle_array.size > 0:  
             angle_extrema_indices, _, _ = extract_angle_extremes(
                 angle_array=angle_array,
@@ -469,26 +493,18 @@ def quantify_arm_swing(
 
                 df_params_segment = pd.DataFrame({
                     DataColumns.SEGMENT_NR: segment_nr,
-                    DataColumns.SEGMENT_CAT: segment_cat,
                     DataColumns.RANGE_OF_MOTION: rom,
                     DataColumns.PEAK_VELOCITY: pav
                 })
 
                 arm_swing_quantified.append(df_params_segment)
 
-    # Combine segment categories
-    segment_categories = set([segment_meta['per_segment'][x][DataColumns.SEGMENT_CAT] for x in segment_meta['per_segment'].keys()])
-    for segment_cat in segment_categories:
-        segment_meta['aggregated'][segment_cat] = {
-            'duration_s': sum([segment_meta['per_segment'][x]['duration_s'] for x in segment_meta['per_segment'].keys() if segment_meta['per_segment'][x][DataColumns.SEGMENT_CAT] == segment_cat])
-        }
-
     arm_swing_quantified = pd.concat(arm_swing_quantified, ignore_index=True)
             
     return arm_swing_quantified, segment_meta
 
 
-def aggregate_arm_swing_params(df_arm_swing_params: pd.DataFrame, segment_meta: dict, aggregates: List[str] = ['median']) -> dict:
+def aggregate_arm_swing_params(df_arm_swing_params: pd.DataFrame, segment_meta: dict, segment_cats: List[tuple], aggregates: List[str] = ['median']) -> dict:
     """
     Aggregate the quantification results for arm swing parameters.
     
@@ -499,6 +515,9 @@ def aggregate_arm_swing_params(df_arm_swing_params: pd.DataFrame, segment_meta:
 
     segment_meta : dict
         A dictionary containing metadata for each segment.
+
+    segment_cats : List[tuple]
+        A list of tuples defining the segment categories, where each tuple contains the lower and upper bounds for the segment duration.
         
     aggregates : List[str], optional
         A list of aggregation methods to apply to the quantification results.
@@ -510,29 +529,58 @@ def aggregate_arm_swing_params(df_arm_swing_params: pd.DataFrame, segment_meta:
     """
     arm_swing_parameters = [DataColumns.RANGE_OF_MOTION, DataColumns.PEAK_VELOCITY]
 
-    uq_segment_cats = set([segment_meta[x][DataColumns.SEGMENT_CAT] for x in df_arm_swing_params[DataColumns.SEGMENT_NR].unique()])
-
     aggregated_results = {}
-    for segment_cat in uq_segment_cats:
-        cat_segments = [x for x in segment_meta.keys() if segment_meta[x][DataColumns.SEGMENT_CAT] == segment_cat]
-
-        aggregated_results[segment_cat] = {
-            'duration_s': sum([segment_meta[x]['duration_s'] for x in cat_segments])
-        }
-
-        df_arm_swing_params_cat = df_arm_swing_params[df_arm_swing_params[DataColumns.SEGMENT_NR].isin(cat_segments)]
-        
-        for arm_swing_parameter in arm_swing_parameters:
-            for aggregate in aggregates:
-                aggregated_results[segment_cat][f'{aggregate}_{arm_swing_parameter}'] = aggregate_parameter(df_arm_swing_params_cat[arm_swing_parameter], aggregate)
-
-    aggregated_results['all_segment_categories'] = {
-        'duration_s': sum([segment_meta[x]['duration_s'] for x in segment_meta.keys()])
-    }
-
-    for arm_swing_parameter in arm_swing_parameters:
-        for aggregate in aggregates:
-            aggregated_results['all_segment_categories'][f'{aggregate}_{arm_swing_parameter}'] = aggregate_parameter(df_arm_swing_params[arm_swing_parameter], aggregate)
+    for segment_cat_range in segment_cats:
+        segment_cat_str = f'{segment_cat_range[0]}_{segment_cat_range[1]}'
+        cat_segments = [
+            x for x in segment_meta.keys() 
+            if segment_meta[x]['duration_unfiltered_segment_s'] >= segment_cat_range[0] 
+            and segment_meta[x]['duration_unfiltered_segment_s'] < segment_cat_range[1]
+        ]
+
+        if len(cat_segments) > 0:                
+            # For each segment, use 'duration_filtered_segment_s' if present, else 'duration_unfiltered_segment_s'
+            aggregated_results[segment_cat_str] = {
+                'duration_s': sum(
+                    [
+                        segment_meta[x]['duration_filtered_segment_s']
+                        if 'duration_filtered_segment_s' in segment_meta[x]
+                        else segment_meta[x]['duration_unfiltered_segment_s']
+                        for x in cat_segments
+                    ]
+                )}
+
+            df_arm_swing_params_cat = df_arm_swing_params.loc[df_arm_swing_params[DataColumns.SEGMENT_NR].isin(cat_segments)]
+            
+            # Aggregate across all segments
+            aggregates_per_segment = ['median', 'mean']
+
+            for arm_swing_parameter in arm_swing_parameters:
+                for aggregate in aggregates:
+                    if aggregate in ['std', 'cov']:
+                        per_segment_agg = []
+                        # If the aggregate is 'cov' (coefficient of variation), we also compute the mean and standard deviation per segment
+                        segment_groups = dict(tuple(df_arm_swing_params_cat.groupby(DataColumns.SEGMENT_NR)))
+                        for segment_nr in cat_segments:
+                            segment_df = segment_groups.get(segment_nr)
+                            if segment_df is not None:
+                                per_segment_agg.append(aggregate_parameter(segment_df[arm_swing_parameter], aggregate))
+
+                        # Drop nans
+                        per_segment_agg = np.array(per_segment_agg)
+                        per_segment_agg = per_segment_agg[~np.isnan(per_segment_agg)]
+
+
+                        for segment_level_aggregate in aggregates_per_segment:
+                            aggregated_results[segment_cat_str][f'{segment_level_aggregate}_{aggregate}_{arm_swing_parameter}'] = aggregate_parameter(per_segment_agg, segment_level_aggregate)
+                    else:
+                        aggregated_results[segment_cat_str][f'{aggregate}_{arm_swing_parameter}'] = aggregate_parameter(df_arm_swing_params_cat[arm_swing_parameter], aggregate)
+
+        else:
+            # If no segments are found for this category, initialize with NaN
+            aggregated_results[segment_cat_str] = {
+                'duration_s': 0,
+            }
 
     return aggregated_results
 

{paradigma-1.0.1 → paradigma-1.0.3}/src/paradigma/pipelines/tremor_pipeline.py

@@ -2,7 +2,6 @@ import pandas as pd
 import numpy as np
 from pathlib import Path
 from scipy import signal
-from scipy.stats import gaussian_kde
 
 from paradigma.classification import ClassifierPackage
 from paradigma.constants import DataColumns
@@ -191,7 +190,7 @@ def aggregate_tremor(df: pd.DataFrame, config: TremorConfig):
     if n_windows_tremor == 0: # if no tremor is detected, the tremor power measures are set to NaN
 
         aggregated_tremor_power['median_tremor_power'] = np.nan
-        aggregated_tremor_power['modal_tremor_power'] = np.nan
+        aggregated_tremor_power['mode_binned_tremor_power'] = np.nan
         aggregated_tremor_power['90p_tremor_power'] = np.nan
 
     else:
@@ -202,16 +201,8 @@ def aggregate_tremor(df: pd.DataFrame, config: TremorConfig):
         
         for aggregate in config.aggregates_tremor_power:
             aggregate_name = f"{aggregate}_tremor_power"
-            if aggregate == 'mode':
-                # calculate modal tremor power
-                bin_edges = np.linspace(0, 6, 301)
-                kde = gaussian_kde(tremor_power)
-                kde_values = kde(bin_edges)
-                max_index = np.argmax(kde_values)
-                aggregated_tremor_power['modal_tremor_power'] = bin_edges[max_index]
-            else: # calculate te other aggregates (e.g. median and 90th percentile) of tremor power
-                aggregated_tremor_power[aggregate_name] = aggregate_parameter(tremor_power, aggregate)
-    
+            aggregated_tremor_power[aggregate_name] = aggregate_parameter(tremor_power, aggregate, config.evaluation_points_tremor_power)
+
     # store aggregates in json format
     d_aggregates = {
         'metadata': {
@@ -222,7 +213,7 @@ def aggregate_tremor(df: pd.DataFrame, config: TremorConfig):
         'aggregated_tremor_measures': {
             'perc_windows_tremor': perc_windows_tremor,
             'median_tremor_power': aggregated_tremor_power['median_tremor_power'],
-            'modal_tremor_power': aggregated_tremor_power['modal_tremor_power'],
+            'modal_tremor_power': aggregated_tremor_power['mode_binned_tremor_power'],
             '90p_tremor_power': aggregated_tremor_power['90p_tremor_power']
         }
     }

{paradigma-1.0.1 → paradigma-1.0.3}/src/paradigma/preprocessing.py

@@ -39,7 +39,7 @@ def resample_data(
     tolerance : float, optional
         The tolerance added to the expected difference when checking 
         for contiguous timestamps. If not provided, it defaults to
-        twice the expected interval.
+        three times the expected interval.
 
     Returns
     -------
@@ -57,9 +57,9 @@ def resample_data(
     - Uses cubic interpolation for smooth resampling if there are enough points.
     - If only two timestamps are available, it falls back to linear interpolation.
     """
-    # Set default tolerance if not provided to twice the expected interval
+    # Set default tolerance if not provided to three times the expected interval
     if tolerance is None:
-        tolerance = 2 * 1 / sampling_frequency
+        tolerance = 3 * 1 / sampling_frequency
 
     # Extract time and values
     time_abs_array = np.array(df[time_column])
@@ -208,7 +208,7 @@ def preprocess_imu_data(df: pd.DataFrame, config: IMUConfig, sensor: str, watch_
         time_column=DataColumns.TIME,
         values_column_names=values_colnames,
         sampling_frequency=config.sampling_frequency,
-        resampling_frequency=config.sampling_frequency
+        resampling_frequency=config.resampling_frequency
     )
 
     # Invert the IMU data if the watch was worn on the right wrist

{paradigma-1.0.1 → paradigma-1.0.3}/src/paradigma/util.py

@@ -3,7 +3,8 @@ import numpy as np
 import pandas as pd
 from datetime import datetime, timedelta
 from dateutil import parser
-from typing import List, Tuple
+from typing import List, Tuple, Optional
+from scipy.stats import gaussian_kde
 
 import tsdf
 from tsdf import TSDFMetadata
@@ -316,7 +317,7 @@ def invert_watch_side(df: pd.DataFrame, side: str, sensor='both') -> np.ndarray:
 
     return df
 
-def aggregate_parameter(parameter: np.ndarray, aggregate: str) -> np.ndarray:
+def aggregate_parameter(parameter: np.ndarray, aggregate: str, evaluation_points: Optional[np.ndarray] = None) -> np.ndarray | int:
     """
     Aggregate a parameter based on the specified method.
     
@@ -327,7 +328,11 @@ def aggregate_parameter(parameter: np.ndarray, aggregate: str) -> np.ndarray:
         
     aggregate : str
         The aggregation method to apply.
-        
+
+    evaluation_points : np.ndarray, optional
+        Should be specified if the mode is derived for a continuous parameter. 
+        Defines the evaluation points for the kernel density estimation function, from which the maximum is derived as the mode.
+
     Returns
     -------
     np.ndarray
@@ -337,6 +342,14 @@ def aggregate_parameter(parameter: np.ndarray, aggregate: str) -> np.ndarray:
         return np.mean(parameter)
     elif aggregate == 'median':
         return np.median(parameter)
+    elif aggregate == 'mode_binned':
+        if evaluation_points is None:
+            raise ValueError("evaluation_points must be provided for 'mode_binned' aggregation.")
+        else:
+            kde = gaussian_kde(parameter)
+            kde_values = kde(evaluation_points)
+            max_index = np.argmax(kde_values)
+            return evaluation_points[max_index]
     elif aggregate == 'mode':
         unique_values, counts = np.unique(parameter, return_counts=True)
         return unique_values[np.argmax(counts)]
@@ -348,6 +361,9 @@ def aggregate_parameter(parameter: np.ndarray, aggregate: str) -> np.ndarray:
         return np.percentile(parameter, 99)
     elif aggregate == 'std':
         return np.std(parameter)
+    elif aggregate == 'cov':
+        mean_value = np.mean(parameter)
+        return np.std(parameter) / mean_value if mean_value != 0 else 0
     else:
         raise ValueError(f"Invalid aggregation method: {aggregate}")
 
@@ -483,7 +499,7 @@ def select_days(df: pd.DataFrame, min_hours_per_day: int) -> pd.DataFrame:
     """
 
     min_s_per_day = min_hours_per_day * 3600
-    window_length_s = df['time_dt'].diff().dt.total_seconds()[1] # determine the length of the first window in seconds
+    window_length_s = df['time_dt'].diff().dt.total_seconds().iloc[1] # determine the length of the first window in seconds
     min_windows_per_day = min_s_per_day / window_length_s
     df_subset = df.groupby(df['time_dt'].dt.date).filter(lambda x: len(x) >= min_windows_per_day)