paradigma 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

paradigma/util.py

@@ -1,16 +1,44 @@
+import functools
 import os
-import numpy as np
-import pandas as pd
+import warnings
 from datetime import datetime, timedelta
-from dateutil import parser
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
+import numpy as np
+import pandas as pd
 import tsdf
+from dateutil import parser
+from scipy.stats import gaussian_kde
 from tsdf import TSDFMetadata
 
 from paradigma.constants import DataColumns, TimeUnit
 
 
+def deprecated(reason: str = ""):
+    """
+    Decorator to mark functions as deprecated. It will show a warning when the function is used.
+
+    Parameters
+    ----------
+    reason : str, optional
+        Additional message to explain why it is deprecated and what to use instead.
+    """
+
+    def decorator(func):
+        message = f"Function {func.__name__} is deprecated."
+        if reason:
+            message += f" {reason}"
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            warnings.warn(message, category=DeprecationWarning, stacklevel=2)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
 def parse_iso8601_to_datetime(date_str):
     return parser.parse(date_str)
 
@@ -27,7 +55,7 @@ def get_end_iso8601(start_iso8601, window_length_seconds):
 
 def write_np_data(
     metadata_time: TSDFMetadata,
-    np_array_time: np.ndarray, 
+    np_array_time: np.ndarray,
     metadata_values: TSDFMetadata,
     np_array_values: np.ndarray,
     output_path: str,
@@ -52,7 +80,7 @@ def write_np_data(
         The filename for the metadata.
 
     """
-    
+
     if not os.path.exists(output_path):
         os.makedirs(output_path)
 
@@ -61,9 +89,19 @@ def write_np_data(
     metadata_values.file_dir_path = output_path
 
     # store binaries and metadata
-    time_tsdf = tsdf.write_binary_file(file_dir=output_path, file_name=metadata_time.file_name, data=np_array_time, metadata=metadata_time.get_plain_tsdf_dict_copy())
+    time_tsdf = tsdf.write_binary_file(
+        file_dir=output_path,
+        file_name=metadata_time.file_name,
+        data=np_array_time,
+        metadata=metadata_time.get_plain_tsdf_dict_copy(),
+    )
 
-    samples_tsdf = tsdf.write_binary_file(file_dir=output_path, file_name=metadata_values.file_name, data=np_array_values, metadata=metadata_values.get_plain_tsdf_dict_copy())
+    samples_tsdf = tsdf.write_binary_file(
+        file_dir=output_path,
+        file_name=metadata_values.file_name,
+        data=np_array_values,
+        metadata=metadata_values.get_plain_tsdf_dict_copy(),
+    )
 
     tsdf.write_metadata([time_tsdf, samples_tsdf], output_filename)
 
@@ -126,13 +164,23 @@ def read_metadata(
     return metadata_time, metadata_values
 
 
-def load_tsdf_dataframe(path_to_data, prefix, meta_suffix='meta.json', time_suffix='time.bin', values_suffix='values.bin'):
+def load_tsdf_dataframe(
+    path_to_data,
+    prefix,
+    meta_suffix="meta.json",
+    time_suffix="time.bin",
+    values_suffix="values.bin",
+):
     meta_filename = f"{prefix}_{meta_suffix}"
     time_filename = f"{prefix}_{time_suffix}"
     values_filename = f"{prefix}_{values_suffix}"
 
-    metadata_time, metadata_values = read_metadata(path_to_data, meta_filename, time_filename, values_filename)
-    df = tsdf.load_dataframe_from_binaries([metadata_time, metadata_values], tsdf.constants.ConcatenationType.columns)
+    metadata_time, metadata_values = read_metadata(
+        path_to_data, meta_filename, time_filename, values_filename
+    )
+    df = tsdf.load_dataframe_from_binaries(
+        [metadata_time, metadata_values], tsdf.constants.ConcatenationType.columns
+    )
 
     return df, metadata_time, metadata_values
 
@@ -151,11 +199,9 @@ def load_metadata_list(
         The filename of the metadata file.
     filenames : List[str]
         The list of binary files of which the metadata files need to be loaded
-    
-    """	
-    metadata_dict = tsdf.load_metadata_from_path(
-        os.path.join(dir_path, meta_filename)
-    )
+
+    """
+    metadata_dict = tsdf.load_metadata_from_path(os.path.join(dir_path, meta_filename))
     metadata_list = []
     for filename in filenames:
         metadata_list.append(metadata_dict[filename])
@@ -194,37 +240,54 @@ def transform_time_array(
     - The transformation allows for scaling of the time array, converting between time unit types (e.g., relative, absolute, or difference).
     - When converting to `TimeUnit.RELATIVE_MS`, the function calculates the relative time starting from the provided or default start time.
     """
-    input_units = input_unit_type.split('_')[-1].lower()
-    output_units = output_unit_type.split('_')[-1].lower()
+    input_units = input_unit_type.split("_")[-1].lower()
+    output_units = output_unit_type.split("_")[-1].lower()
 
     if input_units == output_units:
         scale_factor = 1
-    elif input_units == 's' and output_units == 'ms':
+    elif input_units == "s" and output_units == "ms":
         scale_factor = 1e3
-    elif input_units == 'ms' and output_units == 's':
+    elif input_units == "ms" and output_units == "s":
         scale_factor = 1 / 1e3
     else:
-        raise ValueError(f"Unsupported time units conversion: {input_units} to {output_units}")
-    
-    # Transform to relative time (`TimeUnit.RELATIVE_MS`) 
-    if input_unit_type == TimeUnit.DIFFERENCE_MS or input_unit_type == TimeUnit.DIFFERENCE_S:
-    # Convert a series of differences into cumulative sum to reconstruct original time series.
+        raise ValueError(
+            f"Unsupported time units conversion: {input_units} to {output_units}"
+        )
+
+    # Transform to relative time (`TimeUnit.RELATIVE_MS`)
+    if (
+        input_unit_type == TimeUnit.DIFFERENCE_MS
+        or input_unit_type == TimeUnit.DIFFERENCE_S
+    ):
+        # Convert a series of differences into cumulative sum to reconstruct original time series.
         time_array = np.cumsum(np.double(time_array))
-    elif input_unit_type == TimeUnit.ABSOLUTE_MS or input_unit_type == TimeUnit.ABSOLUTE_S:
+    elif (
+        input_unit_type == TimeUnit.ABSOLUTE_MS
+        or input_unit_type == TimeUnit.ABSOLUTE_S
+    ):
         # Set the start time if not provided.
         if np.isclose(start_time, 0.0, rtol=1e-09, atol=1e-09):
             start_time = time_array[0]
         # Convert absolute time stamps into a time series relative to start_time.
-        time_array = (time_array - start_time) 
+        time_array = time_array - start_time
 
     # Transform the time array from `TimeUnit.RELATIVE_MS` to the specified time unit type
-    if output_unit_type == TimeUnit.ABSOLUTE_MS or output_unit_type == TimeUnit.ABSOLUTE_S:
+    if (
+        output_unit_type == TimeUnit.ABSOLUTE_MS
+        or output_unit_type == TimeUnit.ABSOLUTE_S
+    ):
         # Converts time array to absolute time by adding the start time to each element.
         time_array = time_array + start_time
-    elif output_unit_type == TimeUnit.DIFFERENCE_MS or output_unit_type == TimeUnit.DIFFERENCE_S:
+    elif (
+        output_unit_type == TimeUnit.DIFFERENCE_MS
+        or output_unit_type == TimeUnit.DIFFERENCE_S
+    ):
         # Creates a new array starting with 0, followed by the differences between consecutive elements.
         time_array = np.diff(np.insert(time_array, 0, start_time))
-    elif output_unit_type == TimeUnit.RELATIVE_MS or output_unit_type == TimeUnit.RELATIVE_S:
+    elif (
+        output_unit_type == TimeUnit.RELATIVE_MS
+        or output_unit_type == TimeUnit.RELATIVE_S
+    ):
         # The array is already in relative format, do nothing.
         pass
 
@@ -255,25 +318,25 @@ def convert_units_accelerometer(data: np.ndarray, units: str) -> np.ndarray:
         return data
     else:
         raise ValueError(f"Unsupported unit: {units}")
-    
+
 
 def convert_units_gyroscope(data: np.ndarray, units: str) -> np.ndarray:
     """
     Convert gyroscope data to deg/s.
-    
+
     Parameters
     ----------
     data : np.ndarray
         The gyroscope data.
-        
+
     units : str
         The unit of the data (currently supports deg/s and rad/s).
-        
+
     Returns
     -------
     np.ndarray
         The gyroscope data in deg/s.
-        
+
     """
     if units == "deg/s":
         return data
@@ -281,9 +344,9 @@ def convert_units_gyroscope(data: np.ndarray, units: str) -> np.ndarray:
         return np.degrees(data)
     else:
         raise ValueError(f"Unsupported unit: {units}")
-    
 
-def invert_watch_side(df: pd.DataFrame, side: str, sensor='both') -> np.ndarray:
+
+def invert_watch_side(df: pd.DataFrame, side: str, sensor="both") -> np.ndarray:
     """
     Invert the data based on the watch side.
 
@@ -304,60 +367,83 @@ def invert_watch_side(df: pd.DataFrame, side: str, sensor='both') -> np.ndarray:
     """
     if side not in ["left", "right"]:
         raise ValueError(f"Unsupported side: {side}")
-    if sensor not in ['accelerometer', 'gyroscope', 'both']:
+    if sensor not in ["accelerometer", "gyroscope", "both"]:
         raise ValueError(f"Unsupported sensor: {sensor}")
 
     elif side == "right":
-        if sensor in ['gyroscope', 'both']:
+        if sensor in ["gyroscope", "both"]:
             df[DataColumns.GYROSCOPE_Y] *= -1
             df[DataColumns.GYROSCOPE_Z] *= -1
-        if sensor in ['accelerometer', 'both']:
+        if sensor in ["accelerometer", "both"]:
             df[DataColumns.ACCELEROMETER_X] *= -1
 
     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.
-    
+
     Parameters
     ----------
     parameter : np.ndarray
         The parameter to aggregate.
-        
+
     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
         The aggregated parameter.
     """
-    if aggregate == 'mean':
+    if aggregate == "mean":
         return np.mean(parameter)
-    elif aggregate == 'median':
+    elif aggregate == "median":
         return np.median(parameter)
-    elif aggregate == 'mode':
+    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)]
-    elif aggregate == '90p':
+    elif aggregate == "90p":
         return np.percentile(parameter, 90)
-    elif aggregate == '95p':
+    elif aggregate == "95p":
         return np.percentile(parameter, 95)
-    elif aggregate == '99p':
+    elif aggregate == "99p":
         return np.percentile(parameter, 99)
-    elif aggregate == 'std':
+    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}")
 
+
 def merge_predictions_with_timestamps(
-        df_ts: pd.DataFrame, 
-        df_predictions: pd.DataFrame, 
-        pred_proba_colname: str,
-        window_length_s: float, 
-        fs: int
-    ) -> pd.DataFrame:
+    df_ts: pd.DataFrame,
+    df_predictions: pd.DataFrame,
+    pred_proba_colname: str,
+    window_length_s: float,
+    fs: int,
+) -> pd.DataFrame:
     """
     Merges prediction probabilities with timestamps by expanding overlapping windows
     into individual timestamps and averaging probabilities per unique timestamp.
@@ -382,7 +468,7 @@ def merge_predictions_with_timestamps(
 
     fs : int
         The sampling frequency of the data.
-        
+
     Returns:
     -------
     pd.DataFrame
@@ -403,22 +489,18 @@ def merge_predictions_with_timestamps(
     # Step 1: Generate all timestamps for prediction windows using NumPy broadcasting
     window_length = int(window_length_s * fs)
     timestamps = (
-        df_predictions[DataColumns.TIME].values[:, None] +
-        np.arange(0, window_length) / fs
+        df_predictions[DataColumns.TIME].values[:, None]
+        + np.arange(0, window_length) / fs
     )
-    
+
     # Flatten timestamps and probabilities into a single array for efficient processing
     flat_timestamps = timestamps.ravel()
-    flat_proba = np.repeat(
-        df_predictions[pred_proba_colname].values,
-        window_length
-    )
+    flat_proba = np.repeat(df_predictions[pred_proba_colname].values, window_length)
 
     # Step 2: Create a DataFrame for expanded data
-    expanded_df = pd.DataFrame({
-        DataColumns.TIME: flat_timestamps,
-        pred_proba_colname: flat_proba
-    })
+    expanded_df = pd.DataFrame(
+        {DataColumns.TIME: flat_timestamps, pred_proba_colname: flat_proba}
+    )
 
     # Step 3: Round timestamps and aggregate probabilities
     expanded_df[DataColumns.TIME] = expanded_df[DataColumns.TIME].round(2)
@@ -426,14 +508,15 @@ def merge_predictions_with_timestamps(
 
     # Step 4: Round timestamps in `df_ts` and merge
     df_ts[DataColumns.TIME] = df_ts[DataColumns.TIME].round(2)
-    df_ts = pd.merge(df_ts, mean_proba, how='left', on=DataColumns.TIME)
+    df_ts = pd.merge(df_ts, mean_proba, how="left", on=DataColumns.TIME)
     df_ts = df_ts.dropna(subset=[pred_proba_colname])
 
     return df_ts
 
 
-def select_hours(df: pd.DataFrame, select_hours_start: str, select_hours_end: str) -> pd.DataFrame:
-    
+def select_hours(
+    df: pd.DataFrame, select_hours_start: str, select_hours_end: str
+) -> pd.DataFrame:
     """
     Select hours of interest from the data to include in the aggregation step.
 
@@ -444,7 +527,7 @@ def select_hours(df: pd.DataFrame, select_hours_start: str, select_hours_end: st
 
     select_hours_start: str
         The start time of the selected hours in "HH:MM" format.
-    
+
     select_hours_end: str
             The end time of the selected hours in "HH:MM" format.
 
@@ -455,14 +538,18 @@ def select_hours(df: pd.DataFrame, select_hours_start: str, select_hours_end: st
 
     """
 
-    select_hours_start = datetime.strptime(select_hours_start, '%H:%M').time() # convert to time object
-    select_hours_end = datetime.strptime(select_hours_end, '%H:%M').time() 
-    df_subset = df[df['time_dt'].dt.time.between(select_hours_start, select_hours_end)] # select the hours of interest
+    select_hours_start = datetime.strptime(
+        select_hours_start, "%H:%M"
+    ).time()  # convert to time object
+    select_hours_end = datetime.strptime(select_hours_end, "%H:%M").time()
+    df_subset = df[
+        df["time_dt"].dt.time.between(select_hours_start, select_hours_end)
+    ]  # select the hours of interest
 
     return df_subset
 
-def select_days(df: pd.DataFrame, min_hours_per_day: int) -> pd.DataFrame:
 
+def select_days(df: pd.DataFrame, min_hours_per_day: int) -> pd.DataFrame:
     """
     Select days of interest from the data to include in the aggregation step.
 
@@ -483,8 +570,12 @@ 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)
+    df_subset = df.groupby(df["time_dt"].dt.date).filter(
+        lambda x: len(x) >= min_windows_per_day
+    )
 
-    return df_subset
+    return df_subset

{paradigma-1.0.2.dist-info → paradigma-1.0.4.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: paradigma
-Version: 1.0.2
+Version: 1.0.4
 Summary: ParaDigMa - A toolbox for deriving Parkinson's disease Digital Markers from real-life wrist sensor data
 License: Apache-2.0
+License-File: LICENSE
 Author: Erik Post
 Author-email: erik.post@radboudumc.nl
 Requires-Python: >=3.11,<4.0
@@ -11,6 +12,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+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)
@@ -28,25 +31,25 @@ Description-Content-Type: text/markdown
 | **DOI** | [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13838392.svg)](https://doi.org/10.5281/zenodo.13838392) |
 | **Build Status** | [![](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/) [![Build and test](https://github.com/biomarkersParkinson/paradigma/actions/workflows/build-and-test.yml/badge.svg)](https://github.com/biomarkersParkinson/paradigma/actions/workflows/build-and-test.yml) [![pages-build-deployment](https://github.com/biomarkersParkinson/paradigma/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/biomarkersParkinson/paradigma/actions/workflows/pages/pages-build-deployment) |
 | **License** |  [![GitHub license](https://img.shields.io/github/license/biomarkersParkinson/paradigma)](https://github.com/biomarkersparkinson/paradigma/blob/main/LICENSE) |
-<!-- | **Fairness** |  [![fair-software.eu](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F-green)](https://fair-software.eu) [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/8083/badge)](https://www.bestpractices.dev/projects/8083) | --> 
+<!-- | **Fairness** |  [![fair-software.eu](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F-green)](https://fair-software.eu) [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/8083/badge)](https://www.bestpractices.dev/projects/8083) | -->
 
 ## Overview
 The Parkinson's disease Digital Markers (ParaDigMa) toolbox is a Python
 software package designed for processing real-life wrist sensor data
-to extract digital measures of motor and non-motor signs of Parkinson's disease (PD).  
-
-Specifically, the toolbox is designed to process accelerometer, gyroscope and 
-photoplethysmography (PPG) signals, collected during passive monitoring in daily life. 
-It contains three data processing pipelines: (1) arm swing during gait, (2) tremor, 
-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. 
-
-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 
+to extract digital measures of motor and non-motor signs of Parkinson's disease (PD).
+
+Specifically, the toolbox is designed to process accelerometer, gyroscope and
+photoplethysmography (PPG) signals, collected during passive monitoring in daily life.
+It contains three data processing pipelines: (1) arm swing during gait, (2) tremor,
+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.
+
+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
 digital measures. In addition, the toolbox is designed to be modular, enabling
-researchers to easily extend the toolbox with new algorithms and functionalities. 
+researchers to easily extend the toolbox with new algorithms and functionalities.
 
 ## Features
 The components of ParaDigMa are shown in the diagram below.
@@ -59,20 +62,20 @@ ParaDigMa can best be understood by categorizing the sequential processes:
 
 | Process | Description |
 | ---- | ---- |
-| Preprocessing | Preparing raw sensor signals for further processing | 
+| Preprocessing | Preparing raw sensor signals for further processing |
 | Feature extraction | Extracting features based on windowed sensor signals |
-| Classification | Detecting segments of interest using validated classifiers (e.g., gait segments) | 
+| Classification | Detecting segments of interest using validated classifiers (e.g., gait segments) |
 | Quantification | Extracting specific measures from the detected segments (e.g., arm swing measures) |
 | Aggregation | Aggregating the measures over a specific time period (e.g., week-level aggregates) |
 
 <br/>
-ParaDigMa contains the following validated processing pipelines (each using the processes described above): 
+ParaDigMa contains the following validated processing pipelines (each using the processes described above):
 
-| Pipeline | Input | Output classification | Output quantification | Output week-level aggregation | 
+| Pipeline | Input | Output classification | Output quantification | Output week-level aggregation |
 | ---- | ---- | ---- | ---- | ---- |
-| **Arm swing during gait** | Wrist accelerometer and gyroscope data | Gait probability, gait without other arm activities probability | Arm swing range of motion (RoM) | Typical & maximum arm swing RoM | 
-| **Tremor** | Wrist gyroscope data | Tremor probability | Tremor power | % tremor time, typical & maximum tremor power |   
-| **Pulse rate** | Wrist PPG and accelerometer data | PPG signal quality | Pulse rate | Resting & maximum pulse rate | 
+| **Arm swing during gait** | Wrist accelerometer and gyroscope data | Gait probability, gait without other arm activities probability | Arm swing range of motion (RoM) | Typical & maximum arm swing RoM |
+| **Tremor** | Wrist gyroscope data | Tremor probability | Tremor power | % tremor time, typical & maximum tremor power |
+| **Pulse rate** | Wrist PPG and accelerometer data | PPG signal quality | Pulse rate | Resting & maximum pulse rate |
 
 ## Installation
 
@@ -90,9 +93,9 @@ The API reference contains detailed documentation of all toolbox modules and fun
 The user guides provide additional information about specific topics (e.g. the required orientation of the wrist sensor).
 
 ### Sensor data requirements
-The ParaDigMa toolbox is designed for the analysis of passive monitoring data collected using a wrist sensor in persons with PD. 
+The ParaDigMa toolbox is designed for the analysis of passive monitoring data collected using a wrist sensor in persons with PD.
 
-Specific requirements include: 
+Specific requirements include:
 | Pipeline               | Sensor Configuration                                                                                                       | Context of Use                                                                                             |
 |------------------------|--------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------|
 | **All**               | - Sensor position: wrist-band on most or least affected side (validated for both, but different sensitivity for measuring disease progression for tremor and arm swing during gait).  <br> - Sensor orientation: orientation as described in [Coordinate System](https://biomarkersparkinson.github.io/paradigma/guides/coordinate_system.html). <br> - Timeframe: contiguous, strictly increasing timestamps. | - Population: persons with PD. <br> - Data collection protocol: passive monitoring in daily life. |
@@ -100,25 +103,25 @@ Specific requirements include:
 | **Tremor**            | - Gyroscope: minimum sampling rate of 100 Hz, minimum range of ± 1000 degrees/sec. | - Compliance: for weekly measures: at least three compliant days (with ≥10 hours of data between 8 am and 10 pm). |
 | **Pulse rate**        | - PPG*: minimum sampling rate of 30 Hz, green LED. <br> - Accelerometer: minimum sampling rate of 100 Hz, minimum range of ± 4 g. | - Population: no rhythm disorders (e.g. atrial fibrillation, atrial flutter). <br> - Compliance: for weekly measures: minimum average of 12 hours of data per day. |
 
-\* The processing of PPG signals is currently based on the blood volume pulse (arbitrary units) obtained from the Verily Study Watch, and we are currently testing the applicability of the pipeline to other PPG devices.
+\* The processing of PPG signals is currently based on the blood volume pulse (arbitrary units) obtained from the Verily Study Watch. [This](https://biomarkersparkinson.github.io/paradigma/tutorials/_static/pulse_rate_analysis.html#step-3-signal-quality-classification) part of the PPG tutorial provides code and documentation on how to use the pipeline with other PPG devices.
 
 > [!WARNING]
-> While the toolbox is designed to work on any wrist sensor device which fulfills the requirements, 
-we have currently verified its performance on data from the Gait-up Physilog 4 (arm swing during gait & tremor) and the Verily Study Watch (all pipelines). Furthermore, the specifications above are the minimally validated requirements. For example, while ParaDigMa works with accelerometer and gyroscope data sampled at 50 Hz, its effect on subsequent processes has not been empirically validated. 
+> While the toolbox is designed to work on any wrist sensor device which fulfills the requirements,
+we have currently verified its performance on data from the Gait-up Physilog 4 (arm swing during gait & tremor) and the Verily Study Watch (all pipelines). Furthermore, the specifications above are the minimally validated requirements. For example, while ParaDigMa works with accelerometer and gyroscope data sampled at 50 Hz, its effect on subsequent processes has not been empirically validated.
 <br/>
 
 We have included support for [TSDF](https://biomarkersparkinson.github.io/tsdf/) as format for loading and storing sensor data. TSDF enables efficient data storage with added metadata. However, ParaDigMa does not require a particular method of data storage and retrieval. Please see our tutorial [Data preparation](https://biomarkersparkinson.github.io/paradigma/tutorials/data_preparation.html) for examples of loading TSDF and other data formats into memory, and for preparing raw sensor data as input for the processing pipelines.
 
 ## 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
 
-We welcome contributions! Please check out our [contributing guidelines](https://biomarkersparkinson.github.io/paradigma/contributing.html). 
+We welcome contributions! Please check out our [contributing guidelines](https://biomarkersparkinson.github.io/paradigma/contributing.html).
 Please note that this project is released with a [Code of Conduct](https://biomarkersparkinson.github.io/paradigma/conduct.html). By contributing to this project, you agree to abide by its terms.
 
 ## License
@@ -127,11 +130,11 @@ It is licensed under the terms of the Apache License 2.0 license. See [License](
 
 ## Acknowledgements
 
-The core team of ParaDigMa consists of Erik Post, Kars Veldkamp, Nienke Timmermans, Diogo Coutinho Soriano, Peter Kok, Vedran Kasalica and Luc Evers. 
-Advisors to the project are Max Little, Jordan Raykov, Twan van Laarhoven, Hayriye Cagnan, and Bas Bloem. 
+The core team of ParaDigMa consists of Erik Post, Kars Veldkamp, Nienke Timmermans, Diogo Coutinho Soriano, Peter Kok, Vedran Kasalica and Luc Evers.
+Advisors to the project are Max Little, Jordan Raykov, Twan van Laarhoven, Hayriye Cagnan, and Bas Bloem.
 The initial release of ParaDigMa was funded by the Michael J Fox Foundation (grant #020425) and the Dutch Research Council (grant #ASDI.2020.060 & grant #2023.010).
 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.4.dist-info/RECORD

@@ -0,0 +1,23 @@
+paradigma/__init__.py,sha256=vCLqo7vOEgcnYs10gUVYvEFfi8y-jBi7w1YKRoqn95k,127
+paradigma/assets/gait_detection_clf_package.pkl,sha256=8jCbuM_4dkilSjOEk9ss7bJbSppgzXe72y0X4BCnzCU,11497247
+paradigma/assets/gait_filtering_clf_package.pkl,sha256=lAaLyhmXdV4X_drmYt0EM6wGwSo80yhpxtncWGq4RfQ,3915
+paradigma/assets/ppg_quality_clf_package.pkl,sha256=vUcM4v8gZwWAmDVK7E4UcHhVnhlEg27RSB71oPGloSc,1292
+paradigma/assets/tremor_detection_clf_package.pkl,sha256=S-KsK1EcUBJX6oGGBo8GqU0AhNZThA6Qe-cs0QPcWw4,1475
+paradigma/classification.py,sha256=yDTetqTZT0c7G0QtNX_i7SNjevEJeaqr334HyZUE6zw,3302
+paradigma/config.py,sha256=B2a3oCusaxH2vAjNV4ae7IWstVwhMpD5H1uN_7Oz4U4,13924
+paradigma/constants.py,sha256=fbJuZW5VB_hhz9NQYwjOxINOJPAcCgRPYJNL6tMqpTA,3493
+paradigma/feature_extraction.py,sha256=meL8fKmaJd1t7apEzFjt757w7M9EF4lX9w-xK2oRgT8,35686
+paradigma/pipelines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+paradigma/pipelines/gait_pipeline.py,sha256=WkAL6iazYQlze21RLMsEPP5q0XAYlOkkDK74c-A8HnE,29190
+paradigma/pipelines/pulse_rate_pipeline.py,sha256=vktK9C1K-0-MifwJ3t_-gnEmEBFExovGVmgXDjBs2j4,17990
+paradigma/pipelines/pulse_rate_utils.py,sha256=-ixh9aTz_bwqCxpBPJW_L37I5yYuI9u5fJ8TBtDoL8Q,26480
+paradigma/pipelines/tremor_pipeline.py,sha256=Le5DUBMhg7DQaRmS49h3SavoUwKn63bJvlmj2-se7sw,14537
+paradigma/preprocessing.py,sha256=324xRLe_fCwbduSwieFNJOn33AStWpC1eMO1QW6etJQ,17119
+paradigma/segmenting.py,sha256=ccc6gwfXouDi6WGhzuaITKn1FevtNwalmLUqBPxDf8g,14647
+paradigma/testing.py,sha256=DWoq6dUzyg4wnmpv8tyV_2-bN16D5krReeZvurRv5gU,19481
+paradigma/util.py,sha256=L2_fJcGQBpZAqD9ay-sxJBe9ypq0FYsUNIp1-U_x2Jw,18221
+paradigma-1.0.4.dist-info/METADATA,sha256=su0TkJ23wB-qJiqrkn8k-9dLBcoqQ2jPS6oscC3jUzI,12176
+paradigma-1.0.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+paradigma-1.0.4.dist-info/entry_points.txt,sha256=Jiuvl3rCJFdHOVxhC4Uum_jc3qXIj_h5mTo-rALN94E,89
+paradigma-1.0.4.dist-info/licenses/LICENSE,sha256=FErdVJ9zP4I24ElO6xFU5_e8KckvFkpcZdm69ZkaUWI,9806
+paradigma-1.0.4.dist-info/RECORD,,

{paradigma-1.0.2.dist-info → paradigma-1.0.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any

paradigma-1.0.4.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+build-docs=scripts.build_docs:main
+serve-docs=scripts.serve_docs:main
+

{paradigma-1.0.2.dist-info → paradigma-1.0.4.dist-info/licenses}/LICENSE

@@ -189,4 +189,3 @@ distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-