paradigma 0.3.2__py3-none-any.whl → 0.4.1__py3-none-any.whl

paradigma/util.py

@@ -1,50 +1,427 @@
+import json
 import os
 import numpy as np
 import pandas as pd
+from pathlib import Path
 from datetime import timedelta
 from dateutil import parser
-from typing import Tuple
+from typing import List, Tuple
 
 import tsdf
 from tsdf import TSDFMetadata
 
+from paradigma.constants import DataColumns, TimeUnit
+
+
 def parse_iso8601_to_datetime(date_str):
     return parser.parse(date_str)
 
+
 def format_datetime_to_iso8601(datetime):
-    return datetime.strftime('%Y-%m-%dT%H:%M:%S') + 'Z'
+    return datetime.strftime("%Y-%m-%dT%H:%M:%S") + "Z"
+
 
 def get_end_iso8601(start_iso8601, window_length_seconds):
     start_date = parser.parse(start_iso8601)
     end_date = start_date + timedelta(seconds=window_length_seconds)
     return format_datetime_to_iso8601(end_date)
 
-def write_data(metadata_time: TSDFMetadata, metadata_samples: TSDFMetadata,
-               output_path: str, output_filename: str, df: pd.DataFrame):
+
+def write_np_data(
+    metadata_time: TSDFMetadata,
+    np_array_time: np.ndarray, 
+    metadata_values: TSDFMetadata,
+    np_array_values: np.ndarray,
+    output_path: str,
+    output_filename: str,
+):
+    """
+    Write the numpy arrays to binary files and store the metadata.
+
+    Parameters
+    ----------
+    metadata_time : TSDFMetadata
+        Metadata for the time column.
+    np_array_time : np.ndarray
+        The numpy array for the time column.
+    metadata_values : TSDFMetadata
+        Metadata for the samples columns.
+    np_array_values : np.ndarray
+        The numpy array for the samples columns.
+    output_path : str
+        The path where the files will be stored.
+    output_filename : str
+        The filename for the metadata.
+
+    """
+    
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+
+    # TODO: improve the way the metadata is stored at a different location
+    metadata_time.file_dir_path = output_path
+    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())
+
+    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)
+
+
+def write_df_data(
+    metadata_time: TSDFMetadata,
+    metadata_values: TSDFMetadata,
+    output_path: str,
+    output_filename: str,
+    df: pd.DataFrame,
+):
+    """
+    Write the Pandas DataFrame to binary files and store the metadata.
+
+    Parameters
+    ----------
+    metadata_time : TSDFMetadata
+        Metadata for the time column.
+    metadata_values : TSDFMetadata
+        Metadata for the samples columns.
+    output_path : str
+        The path where the files will be stored.
+    output_filename : str
+        The filename for the metadata.
+    df : pd.DataFrame
+        The DataFrame to be stored.
+
+    """
     if not os.path.exists(output_path):
         os.makedirs(output_path)
 
     # Make sure the iso8601 format is correctly set
-    #TODO: this should be properly validated in the tsdf library instead
+    # TODO: this should be properly validated in the tsdf library instead
     start_date = parser.parse(metadata_time.start_iso8601)
     metadata_time.start_iso8601 = format_datetime_to_iso8601(start_date)
     end_date = parser.parse(metadata_time.end_iso8601)
     metadata_time.end_iso8601 = format_datetime_to_iso8601(end_date)
-    start_date = parser.parse(metadata_samples.start_iso8601)
-    metadata_samples.start_iso8601 = format_datetime_to_iso8601(start_date)
-    end_date = parser.parse(metadata_samples.end_iso8601)
-    metadata_samples.end_iso8601 = format_datetime_to_iso8601(end_date)
+    start_date = parser.parse(metadata_values.start_iso8601)
+    metadata_values.start_iso8601 = format_datetime_to_iso8601(start_date)
+    end_date = parser.parse(metadata_values.end_iso8601)
+    metadata_values.end_iso8601 = format_datetime_to_iso8601(end_date)
 
     # TODO: improve the way the metadata is stored at a different location
     metadata_time.file_dir_path = output_path
-    metadata_samples.file_dir_path = output_path
+    metadata_values.file_dir_path = output_path
 
     # store binaries and metadata
-    tsdf.write_dataframe_to_binaries(output_path, df, [metadata_time, metadata_samples])
-    tsdf.write_metadata([metadata_time, metadata_samples], output_filename)
+    tsdf.write_dataframe_to_binaries(output_path, df, [metadata_time, metadata_values])
+    tsdf.write_metadata([metadata_time, metadata_values], output_filename)
 
-def read_metadata(input_path: str, meta_filename: str, time_filename: str, values_filename: str) -> Tuple[TSDFMetadata, TSDFMetadata]:
-    metadata_dict = tsdf.load_metadata_from_path(os.path.join(input_path, meta_filename))
+
+def read_metadata(
+    input_path: str, meta_filename: str, time_filename: str, values_filename: str
+) -> Tuple[TSDFMetadata, TSDFMetadata]:
+    metadata_dict = tsdf.load_metadata_from_path(
+        os.path.join(input_path, meta_filename)
+    )
     metadata_time = metadata_dict[time_filename]
-    metadata_samples = metadata_dict[values_filename]
-    return metadata_time, metadata_samples
+    metadata_values = metadata_dict[values_filename]
+    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'):
+    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)
+
+    return df, metadata_time, metadata_values
+
+
+def load_metadata_list(
+    dir_path: str, meta_filename: str, filenames: List[str]
+) -> List[TSDFMetadata]:
+    """
+    Load the metadata objects from a metadata file according to the specified binaries.
+
+    Parameters
+    ----------
+    dir_path : str
+        The dir path where the metadata file is stored.
+    meta_filename : str
+        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_list = []
+    for filename in filenames:
+        metadata_list.append(metadata_dict[filename])
+
+    return metadata_list
+
+
+def transform_time_array(
+    time_array: pd.Series,
+    input_unit_type: str,
+    output_unit_type: str,
+    start_time: float = 0.0,
+) -> np.ndarray:
+    """
+    Transforms the time array to relative time (when defined in delta time) and scales the values.
+
+    Parameters
+    ----------
+    time_array : pd.Series
+        The time array to transform.
+    input_unit_type : str
+        The time unit type of the input time array.
+    output_unit_type : str
+        The time unit type of the output time array. ParaDigMa expects `TimeUnit.RELATIVE_S`.
+    start_time : float, optional
+        The start time of the time array in UNIX seconds (default is 0.0)
+
+    Returns
+    -------
+    np.ndarray
+        The transformed time array in seconds, with the specified time unit type.
+
+    Notes
+    -----
+    - The function handles different time units (`TimeUnit.RELATIVE_MS`, `TimeUnit.RELATIVE_S`, `TimeUnit.ABSOLUTE_MS`, `TimeUnit.ABSOLUTE_S`, `TimeUnit.DIFFERENCE_MS`, `TimeUnit.DIFFERENCE_S`).
+    - 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()
+
+    if input_units == output_units:
+        scale_factor = 1
+    elif input_units == 's' and output_units == 'ms':
+        scale_factor = 1e3
+    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.
+        time_array = np.cumsum(np.double(time_array))
+    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) 
+
+    # 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:
+        # 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:
+        # 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:
+        # The array is already in relative format, do nothing.
+        pass
+
+    return time_array * scale_factor
+
+
+def convert_units_accelerometer(data: np.ndarray, units: str) -> np.ndarray:
+    """
+    Convert acceleration data to g.
+
+    Parameters
+    ----------
+    data : np.ndarray
+        The acceleration data.
+
+    units : str
+        The unit of the data (currently supports g and m/s^2).
+
+    Returns
+    -------
+    np.ndarray
+        The acceleration data in g.
+
+    """
+    if units == "m/s^2":
+        return data / 9.81
+    elif units == "g":
+        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
+    elif units == "rad/s":
+        return np.degrees(data)
+    else:
+        raise ValueError(f"Unsupported unit: {units}")
+    
+
+def invert_watch_side(df: pd.DataFrame, side: str) -> np.ndarray:
+    """
+    Invert the data based on the watch side.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The data.
+    side : str
+        The watch side (left or right).
+
+    Returns
+    -------
+    pd.DataFrame
+        The inverted data.
+
+    """
+    if side not in ["left", "right"]:
+        raise ValueError(f"Unsupported side: {side}")
+    elif side == "right":
+        df[DataColumns.GYROSCOPE_Y] *= -1
+        df[DataColumns.GYROSCOPE_Z] *= -1
+        df[DataColumns.ACCELEROMETER_X] *= -1
+
+    return df
+
+def aggregate_parameter(parameter: np.ndarray, aggregate: str) -> np.ndarray:
+    """
+    Aggregate a parameter based on the specified method.
+    
+    Parameters
+    ----------
+    parameter : np.ndarray
+        The parameter to aggregate.
+        
+    aggregate : str
+        The aggregation method to apply.
+        
+    Returns
+    -------
+    np.ndarray
+        The aggregated parameter.
+    """
+    if aggregate == 'mean':
+        return np.mean(parameter)
+    elif aggregate == 'median':
+        return np.median(parameter)
+    elif aggregate == 'mode':
+        unique_values, counts = np.unique(parameter, return_counts=True)
+        return unique_values[np.argmax(counts)]
+    elif aggregate == '90p':
+        return np.percentile(parameter, 90)
+    elif aggregate == '95p':
+        return np.percentile(parameter, 95)
+    elif aggregate == '99p':
+        return np.percentile(parameter, 99)
+    elif aggregate == 'std':
+        return np.std(parameter)
+    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:
+    """
+    Merges prediction probabilities with timestamps by expanding overlapping windows
+    into individual timestamps and averaging probabilities per unique timestamp.
+
+    Parameters:
+    ----------
+    df_ts : pd.DataFrame
+        DataFrame containing timestamps to be merged with predictions.
+        Must include the timestamp column specified in `DataColumns.TIME`.
+
+    df_predictions : pd.DataFrame
+        DataFrame containing prediction windows with start times and probabilities.
+        Must include:
+        - A column for window start times (defined by `DataColumns.TIME`).
+        - A column for prediction probabilities (defined by `DataColumns.PRED_GAIT_PROBA`).
+
+    pred_proba_colname : str
+        The column name for the prediction probabilities in `df_predictions`.
+
+    window_length_s : float
+        The length of the prediction window in seconds.
+
+    fs : int
+        The sampling frequency of the data.
+        
+    Returns:
+    -------
+    pd.DataFrame
+        Updated `df_ts` with an additional column for averaged prediction probabilities.
+
+    Steps:
+    ------
+    1. Expand prediction windows into individual timestamps using NumPy broadcasting.
+    2. Flatten the timestamps and prediction probabilities into single arrays.
+    3. Aggregate probabilities by unique timestamps using pandas `groupby`.
+    4. Merge the aggregated probabilities with the input `df_ts`.
+
+    Notes:
+    ------
+    - Rounding is applied to timestamps to mitigate floating-point inaccuracies.
+    - Fully vectorized for speed and scalability, avoiding any row-wise operations.
+    """
+    # 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
+    )
+    
+    # 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
+    )
+
+    # Step 2: Create a DataFrame for expanded data
+    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)
+    mean_proba = expanded_df.groupby(DataColumns.TIME, as_index=False).mean()
+
+    # 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 = df_ts.dropna(subset=[pred_proba_colname])
+
+    return df_ts

paradigma-0.4.1.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.3
+Name: paradigma
+Version: 0.4.1
+Summary: Paradigma - a toolbox for Digital Biomarkers for Parkinson's Disease
+License: Apache-2.0
+Author: Erik Post
+Author-email: erik.post@radboudumc.nl
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+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: 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)
+Requires-Dist: scikit-learn (>=1.3.2,<1.6.1)
+Requires-Dist: tsdf (>=0.5.2,<0.6.0)
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/biomarkersParkinson/paradigma/main/docs/source/_static/img/paradigma-logo-banner.png" alt="ParaDigMa logo"/>
+</p>
+
+| Badges | |
+|:----:|----|
+| **Packages and Releases** | [![Latest release](https://img.shields.io/github/release/biomarkersparkinson/paradigma.svg)](https://github.com/biomarkersparkinson/paradigma/releases/latest) [![PyPI](https://img.shields.io/pypi/v/paradigma.svg)](https://pypi.python.org/pypi/paradigma/)  [![Static Badge](https://img.shields.io/badge/RSD-paradigma-lib)](https://research-software-directory.org/software/paradigma) |
+| **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.10+-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) | --> 
+
+## Introduction
+The Parkinsons Disease Digital Markers (ParaDigMa) toolbox is a Python
+software package designed for processing passively collected wrist 
+sensor data to extract digital measures of motor and non-motor signs
+of Parkinson's disease (PD).  
+
+Specifically, the toolbox contains three data processing pipelines: 
+(1) arm swing during gait, (2) tremor, and (3) heart rate analysis.
+Furthermore, the toolbox contains general functionalities for signal
+processing and feature extraction, such as filtering, peak detection,
+and spectral analysis. The toolbox is designed to be user-friendly and
+modular, enabling researchers to easily extend the toolbox with new
+algorithms and functionalities. The toolbox is accompanied by a set of
+example scripts and notebooks for each domain that demonstrate how to use
+the toolbox for processing sensor data and extracting digital measures.
+
+It contains functionalities for processing the following sensor types:
+
+- Inertial Measurement Units (accelerometer, gyroscope)
+- Photoplethysmogram (PPG)
+
+## More about ParaDigMa
+The components of ParaDigMa are visually shown in the diagram below.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/biomarkersParkinson/paradigma/main/docs/source/_static/img/pipeline-architecture.png" alt="Pipeline architeecture"/>
+</p>
+
+#### Processes
+ParaDigMa can best be understood by categorizing the sequential processes:
+
+| Process | Description |
+| ---- | ---- |
+| Preprocessing | Ensuring that the sensor data is ready for further processing | 
+| Feature extraction | Creating features based on windowed views of the timestamps |
+| Classification | Making predictions using developed and validated classifiers | 
+| Quantification | Selecting specific features of interest |
+| Aggregation | Aggregating the features at a specified time-level |
+
+#### Domain requirements
+ParaDigMa can be used to extract aggregations related to a single or multiple domain(s). Each domain has its specific data requirements. Strict requirements for the domain are marked by X, soft requirements (for some additional functionalities) are marked by O.
+
+| | Gait | Tremor | Heart Rate |
+|----------|:-----------:|:-----------:|:-----------:|
+| **Accelerometer** | X | | O | 
+| **Gyroscope** | X | X | | 
+| **PPG** | | | X | 
+
+
+
+## Installation
+
+The package is available in PyPi and requires [Python 3.10](https://www.python.org/downloads/) or higher. It can be installed using:
+
+```bash
+pip install paradigma
+```
+
+## Usage
+
+See our [extended documentation](https://biomarkersparkinson.github.io/paradigma/).
+
+## Development
+
+### Installation
+
+The package requires Python 3.11 or higher. Use [Poetry](https://python-poetry.org/docs/#installation) to set up the environment and install the dependencies:
+
+```bash
+poetry install
+```
+
+### Testing
+
+```bash
+poetry run pytest
+```
+
+### Type checking
+
+```bash
+poetry run pytype .
+```
+
+### Building documentation
+
+```bash
+poetry run make html --directory docs/
+```
+
+## Contributing
+
+Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.
+
+## License
+
+The core team of ParaDigMa consists of Erik Post, Kars Veldkamp, Nienke Timmermans, Diogo Coutinho Soriano, Luc Evers, 
+Peter Kok and Vedran Kasalica. Advisors to the project are Max Little, Jordan Raykov, Twan van Laarhoven, Hayriye Cagnan, and Bas Bloem. It is licensed under the terms of the Apache License 2.0 license.
+
+## Credits
+
+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
+
+For more information or questions about ParaDigMa, please reach out to erik.post@radboudumc.nl.

paradigma-0.4.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+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=bZ7xrqTsCLg0CKBxVejgnnh8hnKSqNsf-bSQG7D2aqY,1613
+paradigma/classification.py,sha256=sBJSePvwHZNPUQuLdx-pncfnDzMq-1naomsCxSJneWY,2921
+paradigma/config.py,sha256=4F6FsY5HI6d-L_vB6zehyTAJK3X-U0F6IrLwxN9M-dw,11102
+paradigma/constants.py,sha256=JlrD4Zx66g7myQALYAc4Gw_y6yW5EipZuvwj9_fjjpI,3543
+paradigma/feature_extraction.py,sha256=pXfVoiuElrMzLCCZu1gj1uYT5v7vb3vULUjkxeJNWXQ,34566
+paradigma/pipelines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+paradigma/pipelines/gait_pipeline.py,sha256=Go0iUmr82v4Vcv2_WBLp5BqRkxKAXImc2N1EHuFYp40,29058
+paradigma/pipelines/heart_rate_pipeline.py,sha256=0-D9KcW9nwE5sgXsWHONkeKrsX6qZ5BYqjDttoffwL8,17726
+paradigma/pipelines/heart_rate_utils.py,sha256=aV2mTMWrFWHZD0KpHqy3IIC1onZykbppyp7_OUWxFTU,26764
+paradigma/pipelines/tremor_pipeline.py,sha256=hPqLf26MRperwlqpNgrwayByoP3aWwnWc-tQMSJNZGw,13314
+paradigma/preprocessing.py,sha256=DQ-lgmta1tng0neuWftwmXG3yesW6dxOsYvjSV2OFRk,13498
+paradigma/segmenting.py,sha256=Jrz2JQX5eSfR9jBfpBhc6QV0SFmPVT5O6T8MyL0sdSw,13874
+paradigma/testing.py,sha256=DSbWeYl5HuZ-bNyOKwgwMHQGG8KlTabvGTR1Yzd-9CY,17955
+paradigma/util.py,sha256=6G-z6OXv8T2PS8RFjkd6IfDywdzTjvSl1pfNwqnT8i0,14431
+paradigma-0.4.1.dist-info/LICENSE,sha256=Lda8kIVC2kbmlSeYaUWwUwV75Q-q31idYvo18HUTfiw,9807
+paradigma-0.4.1.dist-info/METADATA,sha256=ZEXlKrTQX67H7wM5acfEZIUFJZ9FOSuLVAq9yf6DK_A,6416
+paradigma-0.4.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+paradigma-0.4.1.dist-info/RECORD,,

{paradigma-0.3.2.dist-info → paradigma-0.4.1.dist-info}/WHEEL

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