paradigma 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

paradigma/gait_analysis_config.py

@@ -1,106 +1,150 @@
 from typing import Dict, List
 
-from paradigma.constants import DataColumns
+from paradigma.constants import DataColumns, DataUnits
 
 
-class GaitFeatureExtractionConfig:
+
+class IMUConfig:
+    """
+    Base class for Gait feature extraction and Gait detection configurations, based on the IMU data (accelerometer, gyroscope).
+    """
+    def __init__(self):
+
+        self.time_colname = DataColumns.TIME
+
+        self.l_accelerometer_cols: List[str] = [
+            DataColumns.ACCELEROMETER_X,
+            DataColumns.ACCELEROMETER_Y,
+            DataColumns.ACCELEROMETER_Z,
+        ]
+        self.l_gyroscope_cols: List[str] = [
+            DataColumns.GYROSCOPE_X,
+            DataColumns.GYROSCOPE_Y,
+            DataColumns.GYROSCOPE_Z,
+        ]
+
+        self.l_gravity_cols: List[str] = [
+            DataColumns.GRAV_ACCELEROMETER_X,
+            DataColumns.GRAV_ACCELEROMETER_Y,
+            DataColumns.GRAV_ACCELEROMETER_Z,
+        ]
+
+    def set_sensor(self, sensor: str) -> None:
+        """Sets the sensor and derived filenames"""
+        self.sensor: str = sensor
+        self.set_filenames(sensor)
+
+    def set_filenames(self, prefix: str) -> None:
+        """Sets the filenames based on the prefix,
+        
+        Parameters
+        ----------
+        prefix : str
+            The prefix for the filenames.
+        """
+        self.meta_filename = f"{prefix}_meta.json"
+        self.time_filename = f"{prefix}_time.bin"
+        self.values_filename = f"{prefix}_samples.bin"
+
+    def set_filenames_values(self, prefix: str) -> None:
+        """Sets the filenames based on the prefix,
+        
+        Parameters
+        ----------
+        prefix : str
+            The prefix for the filenames.
+        """
+        self.meta_filename = f"{prefix}_meta.json"
+        self.time_filename = f"{prefix}_time.bin"
+        self.values_filename = f"{prefix}_values.bin"
+
+
+class GaitFeatureExtractionConfig (IMUConfig):
 
     def __init__(self) -> None:
-        self.set_sensor('accelerometer')
+        super().__init__()
+        self.set_sensor("accelerometer")
         self.set_sampling_frequency(100)
 
-        self.window_type: str = 'hann'
+        self.window_type: str = "hann"
         self.verbose: int = 0
-        
+
         self.window_length_s: int = 6
         self.window_step_size_s: int = 1
 
         # cepstral coefficients
-        self.cc_low_frequency = 0
-        self.cc_high_frequency = 25
+        self.cc_low_frequency: int = 0
+        self.cc_high_frequency: int = 25
         self.n_dct_filters_cc: int = 20
         self.n_coefficients_cc: int = 12
-        
+
         self.d_frequency_bandwidths: Dict[str, List[float]] = {
-            'power_below_gait': [0.3, 0.7],
-            'power_gait': [0.7, 3.5],
-            'power_tremor': [3.5, 8],
-            'power_above_tremor': [8, self.sampling_frequency]
+            "power_below_gait": [0.3, 0.7],
+            "power_gait": [0.7, 3.5],
+            "power_tremor": [3.5, 8],
+            "power_above_tremor": [8, self.sampling_frequency],
         }
 
-        self.time_colname = 'time'
-        
-        self.l_accelerometer_cols: List[str] = [
-            DataColumns.ACCELEROMETER_X, 
-            DataColumns.ACCELEROMETER_Y, 
-            DataColumns.ACCELEROMETER_Z
+
+        self.l_window_level_cols: List[str] = [
+            "id",
+            "window_nr",
+            "window_start",
+            "window_end",
         ]
+        self.l_data_point_level_cols: List[str] = (
+            self.l_accelerometer_cols + self.l_gravity_cols
+        )
 
-        self.l_gravity_cols: List[str] = [f'grav_{x}' for x in self.l_accelerometer_cols]
-        self.l_window_level_cols: List[str] = ['id', 'window_nr', 'window_start', 'window_end']
-        self.l_data_point_level_cols: List[str] = self.l_accelerometer_cols + self.l_gravity_cols
-        
         # TODO: generate this dictionary using object attributes (self.X) and parameters (e.g., n_dct_filters for cc)
         self.d_channels_values: Dict[str, str] = {
-            f'grav_{self.sensor}_x_mean': 'g',
-            f'grav_{self.sensor}_y_mean': 'g',
-            f'grav_{self.sensor}_z_mean': 'g',
-            f'grav_{self.sensor}_x_std': 'g',
-            f'grav_{self.sensor}_y_std': 'g',
-            f'grav_{self.sensor}_z_std': 'g',
-            f'{self.sensor}_x_power_below_gait': 'g^2/Hz',
-            f'{self.sensor}_y_power_below_gait': 'g^2/Hz',
-            f'{self.sensor}_z_power_below_gait': 'g^2/Hz',
-            f'{self.sensor}_x_power_gait': 'g^2/Hz',
-            f'{self.sensor}_y_power_gait': 'g^2/Hz',
-            f'{self.sensor}_z_power_gait': 'g^2/Hz',
-            f'{self.sensor}_x_power_tremor': 'g^2/Hz',
-            f'{self.sensor}_y_power_tremor': 'g^2/Hz',
-            f'{self.sensor}_z_power_tremor': 'g^2/Hz',
-            f'{self.sensor}_x_power_above_tremor': 'g^2/Hz',
-            f'{self.sensor}_y_power_above_tremor': 'g^2/Hz',
-            f'{self.sensor}_z_power_above_tremor': 'g^2/Hz',
-            f'{self.sensor}_x_dominant_frequency': 'Hz',
-            f'{self.sensor}_y_dominant_frequency': 'Hz',
-            f'{self.sensor}_z_dominant_frequency': 'Hz',
-            f'std_norm_acc': 'g',
+            f"grav_{self.sensor}_x_mean": DataUnits.GRAVITY,
+            f"grav_{self.sensor}_y_mean": DataUnits.GRAVITY,
+            f"grav_{self.sensor}_z_mean": DataUnits.GRAVITY,
+            f"grav_{self.sensor}_x_std": DataUnits.GRAVITY,
+            f"grav_{self.sensor}_y_std": DataUnits.GRAVITY,
+            f"grav_{self.sensor}_z_std": DataUnits.GRAVITY,
+            f"{self.sensor}_x_power_below_gait": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_y_power_below_gait": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_z_power_below_gait": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_x_power_gait": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_y_power_gait": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_z_power_gait": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_x_power_tremor": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_y_power_tremor": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_z_power_tremor": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_x_power_above_tremor": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_y_power_above_tremor": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_z_power_above_tremor": DataUnits.POWER_SPECTRAL_DENSITY,
+            f"{self.sensor}_x_dominant_frequency": DataUnits.FREQUENCY,
+            f"{self.sensor}_y_dominant_frequency": DataUnits.FREQUENCY,
+            f"{self.sensor}_z_dominant_frequency": DataUnits.FREQUENCY,
+            "std_norm_acc": DataUnits.GRAVITY,
         }
 
-        for cc_coef in range(1, self.n_coefficients_cc+1):
-            self.d_channels_values[f'cc_{cc_coef}_{self.sensor}'] = 'g'
-
-    # TODO: move to higher level config class (duplicate in armswing feature extraction)
-    def set_sensor(self, sensor: str) -> None:
-        """ Sets the sensor and derived filenames """
-        self.sensor: str = sensor
-        self.meta_filename: str = f'{self.sensor}_meta.json'
-        self.values_filename: str = f'{self.sensor}_samples.bin'
-        self.time_filename: str = f'{self.sensor}_time.bin'
+        for cc_coef in range(1, self.n_coefficients_cc + 1):
+            self.d_channels_values[f"cc_{cc_coef}_{self.sensor}"] = "g"
 
     def set_sampling_frequency(self, sampling_frequency: int) -> None:
-        """ Sets the sampling frequency and derived variables """
+        """Sets the sampling frequency and derived variables"""
         self.sampling_frequency: int = sampling_frequency
         self.spectrum_low_frequency: int = 0  # Hz
         self.spectrum_high_frequency: int = int(self.sampling_frequency / 2)  # Hz
         self.filter_length: int = self.spectrum_high_frequency - 1
 
 
-class GaitDetectionConfig:
+class GaitDetectionConfig(IMUConfig):
 
     def __init__(self) -> None:
-        self.classifier_file_name = 'gd_classifier.pkl'
-        self.thresholds_file_name = 'gd_threshold.txt'
-
-        self.meta_filename = 'gait_meta.json'
-        self.time_filename = 'gait_time.bin'
-        self.values_filename = 'gait_values.bin'
+        super().__init__()
+        self.classifier_file_name = "gd_classifier.pkl"
+        self.thresholds_file_name = "gd_threshold.txt"
 
-        self.l_accel_cols = [DataColumns.ACCELEROMETER_X, DataColumns.ACCELEROMETER_Y, DataColumns.ACCELEROMETER_Z]
+        self.set_filenames_values("gait")
 
-        self.time_colname = 'time'
 
 
-class ArmSwingFeatureExtractionConfig:
+class ArmSwingFeatureExtractionConfig(IMUConfig):
 
     def initialize_window_length_fields(self, window_length_s: int) -> None:
         self.window_length_s = window_length_s
@@ -117,10 +161,10 @@ class ArmSwingFeatureExtractionConfig:
         self.spectrum_high_frequency = int(sampling_frequency / 2)
 
         self.d_frequency_bandwidths = {
-            'power_below_gait': [0.3, 0.7],
-            'power_gait': [0.7, 3.5],
-            'power_tremor': [3.5, 8],
-            'power_above_tremor': [8, sampling_frequency]
+            "power_below_gait": [0.3, 0.7],
+            "power_gait": [0.7, 3.5],
+            "power_tremor": [3.5, 8],
+            "power_above_tremor": [8, sampling_frequency],
         }
 
         # cepstral coefficients
@@ -129,41 +173,32 @@ class ArmSwingFeatureExtractionConfig:
         self.n_dct_filters_cc: int = 20
         self.n_coefficients_cc: int = 12
 
-    def initialize_column_names(self, time_colname='time', pred_gait_colname='pred_gait',
-                         angle_smooth_colname='angle_smooth', angle_colname='angle',
-                         velocity_colname='velocity', segment_nr_colname='segment_nr') -> None:
-        self.time_colname = time_colname
-        self.pred_gait_colname = pred_gait_colname
-        self.angle_smooth_colname = angle_smooth_colname
-        self.angle_colname = angle_colname
-        self.velocity_colname = velocity_colname
-        self.segment_nr_colname = segment_nr_colname
+    def initialize_column_names(
+        self
+    ) -> None:
 
-        self.l_accelerometer_cols: List[str] = [
-            DataColumns.ACCELEROMETER_X, 
-            DataColumns.ACCELEROMETER_Y, 
-            DataColumns.ACCELEROMETER_Z
-        ]
+        self.pred_gait_colname=DataColumns.PRED_GAIT
+        self.angle_smooth_colname: str = DataColumns.ANGLE_SMOOTH
+        self.angle_colname=DataColumns.ANGLE
+        self.velocity_colname=DataColumns.VELOCITY
+        self.segment_nr_colname=DataColumns.SEGMENT_NR
 
-        self.l_gyroscope_cols: List[str] = [
-            DataColumns.GYROSCOPE_X, 
-            DataColumns.GYROSCOPE_Y, 
-            DataColumns.GYROSCOPE_Z
-        ]
-        
-        self.l_gravity_cols: List[str] = [f'grav_{x}' for x in self.l_accelerometer_cols]
 
-        self.l_data_point_level_cols = self.l_accelerometer_cols + self.l_gyroscope_cols + self.l_gravity_cols + [
-            angle_smooth_colname, velocity_colname
-        ]
+        self.l_data_point_level_cols: List[str] = (
+            self.l_accelerometer_cols
+            + self.l_gyroscope_cols
+            + self.l_gravity_cols
+            + [self.angle_smooth_colname, self.velocity_colname]
+        )
 
     def __init__(self) -> None:
+        super().__init__()
         # general
-        self.sensor = 'IMU'
-        self.units = 'degrees'
+        self.sensor = "IMU"
+        self.units = "degrees"
 
         # windowing
-        self.window_type = 'hann'
+        self.window_type = "hann"
         self.initialize_window_length_fields(3)
 
         self.initialize_sampling_frequency_fields(100)
@@ -171,72 +206,59 @@ class ArmSwingFeatureExtractionConfig:
         self.initialize_column_names()
 
         self.d_channels_values = {
-            'angle_perc_power': 'proportion',
-            'range_of_motion': 'deg',
-            'forward_peak_ang_vel_mean': 'deg/s',
-            'forward_peak_ang_vel_std': 'deg/s',
-            'backward_peak_ang_vel_mean': 'deg/s',
-            'backward_peak_ang_vel_std': 'deg/s',
-            'std_norm_acc': 'g',
-            'grav_accelerometer_x_mean': 'g',
-            'grav_accelerometer_x_std': 'g',
-            'grav_accelerometer_y_mean': 'g',
-            'grav_accelerometer_y_std': 'g',
-            'grav_accelerometer_z_mean': 'g',
-            'grav_accelerometer_z_std': 'g',
-            'accelerometer_x_power_below_gait': 'X', 
-            'accelerometer_x_power_gait': 'X',
-            'accelerometer_x_power_tremor': 'X',
-            'accelerometer_x_power_above_tremor': 'X',
-            'accelerometer_x_dominant_frequency': 'Hz',
-            'accelerometer_y_power_below_gait': 'X',
-            'accelerometer_y_power_gait': 'X',
-            'accelerometer_y_power_tremor': 'X',
-            'accelerometer_y_power_above_tremor': 'X',
-            'accelerometer_y_dominant_frequency': 'Hz',
-            'accelerometer_z_power_below_gait': 'X',
-            'accelerometer_z_power_gait': 'X',
-            'accelerometer_z_power_tremor': 'X',
-            'accelerometer_z_power_above_tremor': 'X',
-            'accelerometer_z_dominant_frequency': 'Hz',
-            'angle_dominant_frequency': 'Hz',
+            "angle_perc_power": "proportion",
+            "range_of_motion": "deg",
+            "forward_peak_ang_vel_mean": DataUnits.ROTATION,
+            "forward_peak_ang_vel_std": DataUnits.ROTATION,
+            "backward_peak_ang_vel_mean": DataUnits.ROTATION,
+            "backward_peak_ang_vel_std": DataUnits.ROTATION,
+            "std_norm_acc": DataUnits.GRAVITY,
+            "grav_accelerometer_x_mean": DataUnits.GRAVITY,
+            "grav_accelerometer_x_std": DataUnits.GRAVITY,
+            "grav_accelerometer_y_mean": DataUnits.GRAVITY,
+            "grav_accelerometer_y_std": DataUnits.GRAVITY,
+            "grav_accelerometer_z_mean": DataUnits.GRAVITY,
+            "grav_accelerometer_z_std": DataUnits.GRAVITY,
+            "accelerometer_x_power_below_gait": "X",
+            "accelerometer_x_power_gait": "X",
+            "accelerometer_x_power_tremor": "X",
+            "accelerometer_x_power_above_tremor": "X",
+            "accelerometer_x_dominant_frequency": DataUnits.FREQUENCY,
+            "accelerometer_y_power_below_gait": "X",
+            "accelerometer_y_power_gait": "X",
+            "accelerometer_y_power_tremor": "X",
+            "accelerometer_y_power_above_tremor": "X",
+            "accelerometer_y_dominant_frequency": DataUnits.FREQUENCY,
+            "accelerometer_z_power_below_gait": "X",
+            "accelerometer_z_power_gait": "X",
+            "accelerometer_z_power_tremor": "X",
+            "accelerometer_z_power_above_tremor": "X",
+            "accelerometer_z_dominant_frequency": DataUnits.FREQUENCY,
+            "angle_dominant_frequency": DataUnits.FREQUENCY,
         }
 
-        for sensor in ['accelerometer', 'gyroscope']:
-            for cc_coef in range(1, self.n_coefficients_cc+1):
-                self.d_channels_values[f'cc_{cc_coef}_{sensor}'] = 'g'
-
-
-    # TODO: move to higher level config class (duplicate in gait feature extraction)
-    def set_sensor(self, sensor: str) -> None:
-        """ Sets the sensor and derived filenames """
-        self.sensor: str = sensor
-        self.meta_filename: str = f'{self.sensor}_meta.json'
-        self.values_filename: str = f'{self.sensor}_samples.bin'
-        self.time_filename: str = f'{self.sensor}_time.bin'
+        for sensor in ["accelerometer", "gyroscope"]:
+            for cc_coef in range(1, self.n_coefficients_cc + 1):
+                self.d_channels_values[f"cc_{cc_coef}_{sensor}"] = DataUnits.GRAVITY
 
 
-class ArmSwingDetectionConfig:
+class ArmSwingDetectionConfig(IMUConfig):
 
     def __init__(self) -> None:
-        self.classifier_file_name = 'asd_classifier.pkl'
+        super().__init__()
+        self.classifier_file_name = "asd_classifier.pkl"
 
-        self.meta_filename = 'arm_swing_meta.json'
-        self.time_filename = 'arm_swing_time.bin'
-        self.values_filename = 'arm_swing_values.bin'
+        self.set_filenames_values("arm_swing")
 
-        self.l_accel_cols = [DataColumns.ACCELEROMETER_X, DataColumns.ACCELEROMETER_Y, DataColumns.ACCELEROMETER_Z]
-        self.l_gyro_cols = [DataColumns.GYROSCOPE_X, DataColumns.GYROSCOPE_Y, DataColumns.GYROSCOPE_Z]
 
 
-class ArmSwingQuantificationConfig:
+class ArmSwingQuantificationConfig(IMUConfig):
 
     def __init__(self) -> None:
-        self.meta_filename = 'arm_swing_meta.json'
-        self.time_filename = 'arm_swing_time.bin'
-        self.values_filename = 'arm_swing_values.bin'
+        super().__init__()
+        self.set_filenames_values("arm_swing")
 
-        self.pred_arm_swing_colname = 'pred_arm_swing'
+        self.pred_arm_swing_colname = DataColumns.PRED_ARM_SWING
 
         self.window_length_s = 3
         self.window_step_size = 0.75

paradigma/heart_rate_util.py

@@ -1,4 +1,4 @@
-from typing import List, Tuple
+from typing import List, Tuple, Union
 import pickle
 import pandas as pd
 import numpy as np
@@ -72,7 +72,7 @@ def extract_ppg_features(arr_ppg: np.ndarray, sampling_frequency: int) -> np.nda
 # print(features_df)
 
 
-def peakdet(v: np.ndarray, delta, x: np.ndarray=None) -> Tuple[List[Tuple[int, float]], List[Tuple[int, float]]]:
+def peakdet(v: np.ndarray, delta, x: Union[np.ndarray, None]=None) -> Tuple[List[Tuple[int, float]], List[Tuple[int, float]]]:
     """
     Detect peaks in a vector.
     

paradigma/imu_preprocessing.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from typing import List, Union
 import numpy as np
 import pandas as pd
@@ -10,10 +11,11 @@ from paradigma.util import write_data, read_metadata
 from paradigma.preprocessing_config import IMUPreprocessingConfig
 
 
-def preprocess_imu_data(input_path: str, output_path: str, config: IMUPreprocessingConfig) -> None:
+def preprocess_imu_data(input_path: Union[str, Path], output_path: Union[str, Path], config: IMUPreprocessingConfig) -> None:
 
     # Load data
-    metadata_time, metadata_samples = read_metadata(input_path, config.meta_filename, config.time_filename, config.values_filename)
+    metadata_time, metadata_samples = read_metadata(str(input_path), str(config.meta_filename),
+                                                    str(config.time_filename), str(config.values_filename))
     df = tsdf.load_dataframe_from_binaries([metadata_time, metadata_samples], tsdf.constants.ConcatenationType.columns)
 
     # Rename columns
@@ -24,14 +26,14 @@ def preprocess_imu_data(input_path: str, output_path: str, config: IMUPreprocess
     df[config.time_colname] = transform_time_array(
         time_array=df[config.time_colname],
         scale_factor=1000, 
-        input_unit_type = TimeUnit.difference_ms,
-        output_unit_type = TimeUnit.relative_ms)
+        input_unit_type = TimeUnit.DIFFERENCE_MS,
+        output_unit_type = TimeUnit.RELATIVE_MS)
     
 
     df = resample_data(
         df=df,
         time_column=config.time_colname,
-        time_unit_type=TimeUnit.relative_ms,
+        time_unit_type=TimeUnit.RELATIVE_MS,
         unscaled_column_names = list(config.d_channels_imu.keys()),
         scale_factors=metadata_samples.scale_factors,
         resampling_frequency=config.sampling_frequency)
@@ -71,10 +73,10 @@ def preprocess_imu_data(input_path: str, output_path: str, config: IMUPreprocess
         write_data(metadata_time, metadata_samples, output_path, f'{sensor}_meta.json', df_sensor)
 
 def transform_time_array(
-    time_array: np.ndarray,
+    time_array: pd.Series,
     scale_factor: float,
-    input_unit_type: TimeUnit,
-    output_unit_type: TimeUnit,
+    input_unit_type: str,
+    output_unit_type: str,
     start_time: float = 0.0,
 ) -> np.ndarray:
     """
@@ -82,14 +84,14 @@ def transform_time_array(
 
     Parameters
     ----------
-    time_array : np.ndarray
+    time_array : pd.Series
         The time array in milliseconds to transform.
     scale_factor : float
         The scale factor to apply to the time array.
-    input_unit_type : TimeUnit
-        The time unit type of the input time array. Raw PPP data was in `TimeUnit.difference_ms`.
-    output_unit_type : TimeUnit
-        The time unit type of the output time array. The processing is often done in `TimeUnit.relative_ms`.
+    input_unit_type : str
+        The time unit type of the input time array. Raw PPP data was in `TimeUnit.DIFFERENCE_MS`.
+    output_unit_type : str
+        The time unit type of the output time array. The processing is often done in `TimeUnit.RELATIVE_MS`.
     start_time : float, optional
         The start time of the time array in UNIX milliseconds (default is 0.0)
 
@@ -98,28 +100,28 @@ def transform_time_array(
     time_array
         The transformed time array in milliseconds, with the specified time unit type.
     """
-    # Scale time array and transform to relative time (`TimeUnit.relative_ms`) 
-    if input_unit_type == TimeUnit.difference_ms:
+    # Scale time array and transform to relative time (`TimeUnit.RELATIVE_MS`) 
+    if input_unit_type == TimeUnit.DIFFERENCE_MS:
     # Convert a series of differences into cumulative sum to reconstruct original time series.
         time_array = np.cumsum(np.double(time_array)) / scale_factor
-    elif input_unit_type == TimeUnit.absolute_ms:
+    elif input_unit_type == TimeUnit.ABSOLUTE_MS:
         # 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) / scale_factor
-    elif input_unit_type == TimeUnit.relative_ms:
+    elif input_unit_type == TimeUnit.RELATIVE_MS:
         # Scale the relative time series as per the scale_factor.
         time_array = time_array / scale_factor
 
-    # Transform the time array from `TimeUnit.relative_ms` to the specified time unit type
-    if output_unit_type == TimeUnit.absolute_ms:
+    # Transform the time array from `TimeUnit.RELATIVE_MS` to the specified time unit type
+    if output_unit_type == TimeUnit.ABSOLUTE_MS:
         # 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:
+    elif output_unit_type == TimeUnit.DIFFERENCE_MS:
         # 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:
+    elif output_unit_type == TimeUnit.RELATIVE_MS:
         # The array is already in relative format, do nothing.
         pass
     return time_array
@@ -127,11 +129,11 @@ def transform_time_array(
 
 def resample_data(
     df: pd.DataFrame,
-    time_column : DataColumns,
-    time_unit_type: TimeUnit,
-    unscaled_column_names: list,
+    time_column : str,
+    time_unit_type: str,
+    unscaled_column_names: List[str],
     resampling_frequency: int,
-    scale_factors: list = [],
+    scale_factors: List[float] = [],
     start_time: float = 0.0,
 ) -> pd.DataFrame:
     """
@@ -143,9 +145,9 @@ def resample_data(
         The data to resample.
     time_column : str
         The name of the time column.
-    time_unit_type : TimeUnit
-        The time unit type of the time array. The method currently works only for `TimeUnit.relative_ms`.
-    unscaled_column_names : list
+    time_unit_type : str
+        The time unit type of the time array. The method currently works only for `TimeUnit.RELATIVE_MS`.
+    unscaled_column_names : List[str]
         The names of the columns to resample.
     resampling_frequency : int
         The frequency to resample the data to.
@@ -160,7 +162,7 @@ def resample_data(
         The resampled data.
     """
     # We need a start_time if the time is in absolute time format
-    if time_unit_type == TimeUnit.absolute_ms and start_time == 0.0:
+    if time_unit_type == TimeUnit.ABSOLUTE_MS and start_time == 0.0:
         raise ValueError("start_time is required for absolute time format")
 
     # get time and values
@@ -183,6 +185,7 @@ def resample_data(
             raise ValueError("time_abs_array is not strictly increasing")
 
         cs = CubicSpline(time_abs_array, scaled_values.T[j])
+        #TODO: isn't sensor_col of type DataColumns?
         df[sensor_col] = cs(df[time_column])
 
     return df