[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

src/wristpy/io/readers/readers.py

@@ -48,8 +48,7 @@ def read_watch_data(
         warnings = data.get("warnings", [])
         if warnings:
             logger.warning(
-                f"Recovered partial data for {file_name} "
-                f"with {len(warnings)} warnings."
+                f"Recovered partial data for {file_name} with {len(warnings)} warnings."
             )
     except Exception as e:
         raise IOError(f"Error reading file: {e}. File type is unsupported.") from e

src/wristpy/processing/metrics.py

@@ -118,7 +118,9 @@ def mean_amplitude_deviation(
     ).set_sorted("time")
 
     mad_df = (
-        mad_lf.group_by_dynamic(index_column="time", every=f"{int(epoch_length*1e9)}ns")
+        mad_lf.group_by_dynamic(
+            index_column="time", every=f"{int(epoch_length * 1e9)}ns"
+        )
         .agg(
             [
                 (

tests/unit/test_analytics.py

@@ -36,9 +36,9 @@ def test_fill_false_blocks() -> None:
 
     result = analytics._fill_false_blocks(sleep_idx_array, gap_block)
 
-    assert np.array_equal(
-        result, expected_result
-    ), f"Expected {expected_result}, but got {result}"
+    assert np.array_equal(result, expected_result), (
+        f"Expected {expected_result}, but got {result}"
+    )
 
 
 def test_compute_abs_diff_mean_anglez(
@@ -55,9 +55,9 @@ def test_compute_abs_diff_mean_anglez(
 
     result = sleep_detection._compute_abs_diff_mean_anglez(sleep_detection.anglez)
 
-    assert np.array_equal(
-        result.measurements, expected_result
-    ), f"Expected {expected_result}, but got {result.measurements}"
+    assert np.array_equal(result.measurements, expected_result), (
+        f"Expected {expected_result}, but got {result.measurements}"
+    )
     assert np.array_equal(len(result.time), expected_length)
 
 
@@ -91,12 +91,12 @@ def test_spt_window(sleep_detection: analytics.GgirSleepDetection) -> None:
 
     result = sleep_detection._spt_window(sleep_detection.anglez)
 
-    assert np.array_equal(
-        result.measurements, expected_result
-    ), f"Expected {expected_result}, but got {result.measurements}"
-    assert np.array_equal(
-        len(result.time), expected_length
-    ), f"Expected {expected_length}, but got {len(result.time)}"
+    assert np.array_equal(result.measurements, expected_result), (
+        f"Expected {expected_result}, but got {result.measurements}"
+    )
+    assert np.array_equal(len(result.time), expected_length), (
+        f"Expected {expected_length}, but got {len(result.time)}"
+    )
 
 
 def test_spt_window_null(sleep_detection: analytics.GgirSleepDetection) -> None:
@@ -106,12 +106,12 @@ def test_spt_window_null(sleep_detection: analytics.GgirSleepDetection) -> None:
 
     result = sleep_detection._spt_window(sleep_detection.anglez)
 
-    assert np.array_equal(
-        result.measurements, expected_result
-    ), f"Expected {expected_result}, but got {result.measurements}"
-    assert np.array_equal(
-        len(result.time), expected_length
-    ), f"Expected {expected_length}, but got {len(result.time)}"
+    assert np.array_equal(result.measurements, expected_result), (
+        f"Expected {expected_result}, but got {result.measurements}"
+    )
+    assert np.array_equal(len(result.time), expected_length), (
+        f"Expected {expected_length}, but got {len(result.time)}"
+    )
 
 
 def test_calculate_sib_periods(sleep_detection: analytics.GgirSleepDetection) -> None:
@@ -121,12 +121,12 @@ def test_calculate_sib_periods(sleep_detection: analytics.GgirSleepDetection) ->
 
     result = sleep_detection._calculate_sib_periods(sleep_detection.anglez, 10)
 
-    assert np.array_equal(
-        result.measurements, expected_result
-    ), f"Expected {expected_result}, but got {result.measurements}"
-    assert (
-        len(result.measurements) == expected_length
-    ), f"Expected {expected_length}, but got {len(result.measurements)}"
+    assert np.array_equal(result.measurements, expected_result), (
+        f"Expected {expected_result}, but got {result.measurements}"
+    )
+    assert len(result.measurements) == expected_length, (
+        f"Expected {expected_length}, but got {len(result.measurements)}"
+    )
 
 
 def test_find_onset_wakeup_times(sleep_detection: analytics.GgirSleepDetection) -> None:

tests/unit/test_calibration.py

@@ -116,12 +116,12 @@ def test_closest_point_fit() -> None:
 
     linear_transform = calibrator._closest_point_fit((unit_sphere * scale) + offset)
 
-    assert np.allclose(
-        linear_transform.scale, expected_scale, atol=1e-3
-    ), f"Scale is {linear_transform.scale} expected {expected_scale}"
-    assert np.allclose(
-        linear_transform.offset, expected_offset, atol=1e-3
-    ), f"Offset is {linear_transform.offset} expected {expected_offset})"
+    assert np.allclose(linear_transform.scale, expected_scale, atol=1e-3), (
+        f"Scale is {linear_transform.scale} expected {expected_scale}"
+    )
+    assert np.allclose(linear_transform.offset, expected_offset, atol=1e-3), (
+        f"Offset is {linear_transform.offset} expected {expected_offset})"
+    )
 
 
 def test_closest_point_fit_constrainedmin() -> None:
@@ -137,12 +137,12 @@ def test_closest_point_fit_constrainedmin() -> None:
 
     linear_transform = calibrator._closest_point_fit((unit_sphere * scale) + offset)
 
-    assert np.allclose(
-        linear_transform.scale, expected_scale, atol=1e-3
-    ), f"Scale is {linear_transform.scale} expected {expected_scale}"
-    assert np.allclose(
-        linear_transform.offset, expected_offset, atol=1e-3
-    ), f"Offset is {linear_transform.offset} expected {expected_offset})"
+    assert np.allclose(linear_transform.scale, expected_scale, atol=1e-3), (
+        f"Scale is {linear_transform.scale} expected {expected_scale}"
+    )
+    assert np.allclose(linear_transform.offset, expected_offset, atol=1e-3), (
+        f"Offset is {linear_transform.offset} expected {expected_offset})"
+    )
 
 
 def test_closest_point_fit_constrainmin_calibration_error() -> None:
@@ -202,12 +202,12 @@ def test_ggir_calibration_successful() -> None:
 
     linear_transform = calibrator._calibrate(dummy_measure)
 
-    assert np.allclose(
-        linear_transform.scale, expected_scale, atol=1e-3
-    ), f"Scale is {linear_transform.scale} expected {expected_scale}"
-    assert np.allclose(
-        linear_transform.offset, expected_offset, atol=1e-3
-    ), f"Offset is {linear_transform.offset} expected {expected_offset}"
+    assert np.allclose(linear_transform.scale, expected_scale, atol=1e-3), (
+        f"Scale is {linear_transform.scale} expected {expected_scale}"
+    )
+    assert np.allclose(linear_transform.offset, expected_offset, atol=1e-3), (
+        f"Offset is {linear_transform.offset} expected {expected_offset}"
+    )
 
 
 @pytest.mark.parametrize(
@@ -276,12 +276,12 @@ def test_run_ggircalibration() -> None:
 
     result = calibrator.run_calibration(dummy_measure)
 
-    assert isinstance(
-        result, models.Measurement
-    ), f"was expecting type models.Measurement, object is of type {type(result)}"
-    assert np.allclose(
-        result.measurements, expected_data.measurements, atol=1e-3
-    ), "Measurement data did not match"
+    assert isinstance(result, models.Measurement), (
+        f"was expecting type models.Measurement, object is of type {type(result)}"
+    )
+    assert np.allclose(result.measurements, expected_data.measurements, atol=1e-3), (
+        "Measurement data did not match"
+    )
     assert result.time.equals(expected_data.time), "Time series are not equal"
 
 
@@ -309,12 +309,12 @@ def test_run_constrainedmincalibration() -> None:
 
     result = calibrator.run_calibration(dummy_measure)
 
-    assert isinstance(
-        result, models.Measurement
-    ), f"was expecting type models.Measurement, object is of type {type(result)}"
-    assert np.allclose(
-        result.measurements, expected_data.measurements, atol=1e-3
-    ), "Measurement data did not match"
+    assert isinstance(result, models.Measurement), (
+        f"was expecting type models.Measurement, object is of type {type(result)}"
+    )
+    assert np.allclose(result.measurements, expected_data.measurements, atol=1e-3), (
+        "Measurement data did not match"
+    )
     assert result.time.equals(expected_data.time), "Time series are not equal"
 
 
@@ -342,12 +342,12 @@ def test_run_chunked_calibration() -> None:
 
     result = calibrator.run_calibration(dummy_measure)
 
-    assert isinstance(
-        result, models.Measurement
-    ), f"was expecting type models.Measurement, object is of type {type(result)}"
-    assert np.allclose(
-        result.measurements, expected_data.measurements, atol=1e-3
-    ), "Measurement data did not match"
+    assert isinstance(result, models.Measurement), (
+        f"was expecting type models.Measurement, object is of type {type(result)}"
+    )
+    assert np.allclose(result.measurements, expected_data.measurements, atol=1e-3), (
+        "Measurement data did not match"
+    )
     assert result.time.equals(expected_data.time), "Time series are not equal"
 
 

tests/unit/test_computations.py

@@ -181,9 +181,9 @@ def test_moving_median(window_size: int, expected_output: np.ndarray) -> None:
         f"measurements array are not the same shape. Expected {expected_output.shape}, "
         f"instead got: {test_result.measurements.shape}"
     )
-    assert np.all(
-        np.isclose(test_result.measurements, expected_output)
-    ), "Test results do not match the expected output"
+    assert np.all(np.isclose(test_result.measurements, expected_output)), (
+        "Test results do not match the expected output"
+    )
 
 
 def test_resample_downsample_simple() -> None:

tests/unit/test_metrics.py

@@ -55,13 +55,13 @@ def test_euclidean_norm_minus_one(
     expected_length = math.ceil(len(test_time) / 5)
     enmo_results = metrics.euclidean_norm_minus_one(test_acceleration)
 
-    assert np.all(
-        np.isclose(enmo_results.measurements, expected_enmo)
-    ), f"Expected {expected_enmo}"
+    assert np.all(np.isclose(enmo_results.measurements, expected_enmo)), (
+        f"Expected {expected_enmo}"
+    )
 
-    assert (
-        len(enmo_results.time) == expected_length
-    ), "Input time attribute does not match output time attribute."
+    assert len(enmo_results.time) == expected_length, (
+        "Input time attribute does not match output time attribute."
+    )
 
 
 @pytest.mark.parametrize(
@@ -91,9 +91,9 @@ def test_angle_relative_to_horizontal(
         np.isclose(angle_z_results.measurements, expected_anglez, equal_nan=True)
     ), f"Expected {expected_anglez}, got: {angle_z_results.measurements}"
 
-    assert (
-        len(angle_z_results.time) == expected_length
-    ), "Input time attribute does not match output time attribute."
+    assert len(angle_z_results.time) == expected_length, (
+        "Input time attribute does not match output time attribute."
+    )
 
 
 @pytest.mark.parametrize(
@@ -115,9 +115,9 @@ def test_cleanup_isolated_ones_nonwear_value(
     """Test the cleanup isolated ones nonwear value function."""
     test_result = metrics._cleanup_isolated_ones_nonwear_value(nonwear_value_array)
 
-    assert np.all(
-        test_result == expected_result
-    ), f"Expected {expected_result}, got: {test_result}"
+    assert np.all(test_result == expected_result), (
+        f"Expected {expected_result}, got: {test_result}"
+    )
 
 
 def test_group_acceleration_data_by_time() -> None:
@@ -158,9 +158,9 @@ def test_compute_nonwear_value_per_axis(
         acceleration_grouped["X"], std_criteria=modifier
     )
 
-    assert (
-        test_resultx == expected_result
-    ), f"Expected {expected_result}, got: {test_resultx}"
+    assert test_resultx == expected_result, (
+        f"Expected {expected_result}, got: {test_resultx}"
+    )
 
 
 def test_compute_nonwear_value_array(create_acceleration: pl.DataFrame) -> None:
@@ -179,12 +179,12 @@ def test_compute_nonwear_value_array(create_acceleration: pl.DataFrame) -> None:
         std_criteria=1,
     )
 
-    assert np.all(
-        test_result == expected_result
-    ), f"Expected {expected_result}, got: {test_result}"
-    assert (
-        len(test_result) == expected_time_length
-    ), f"Expected time to be {expected_time_length}, got: {len(test_result)}"
+    assert np.all(test_result == expected_result), (
+        f"Expected {expected_result}, got: {test_result}"
+    )
+    assert len(test_result) == expected_time_length, (
+        f"Expected time to be {expected_time_length}, got: {len(test_result)}"
+    )
 
 
 @pytest.mark.parametrize(
@@ -214,12 +214,12 @@ def test_detect_nonwear(
         std_criteria=modifier,
     )
 
-    assert np.all(
-        test_result.measurements == modifier
-    ), f"Expected non-wear flag value to be {expected_result}, got: {test_result}"
-    assert (
-        len(test_result.time) == expected_time_length
-    ), f"Expected time to be {expected_time_length}, got: {len(test_result.time)}"
+    assert np.all(test_result.measurements == modifier), (
+        f"Expected non-wear flag value to be {expected_result}, got: {test_result}"
+    )
+    assert len(test_result.time) == expected_time_length, (
+        f"Expected time to be {expected_time_length}, got: {len(test_result.time)}"
+    )
 
 
 def test_mean_amplitude_deviation_function(create_acceleration: pl.DataFrame) -> None:
@@ -230,12 +230,12 @@ def test_mean_amplitude_deviation_function(create_acceleration: pl.DataFrame) ->
 
     test_result = metrics.mean_amplitude_deviation(acceleration)
 
-    assert np.all(
-        test_result.measurements == expected_result
-    ), f"Expected MAD value to be {expected_result}, got: {test_result}"
-    assert (
-        len(test_result.time) == expected_time
-    ), f"Expected time to be {expected_time}, got: {len(test_result.time)}"
+    assert np.all(test_result.measurements == expected_result), (
+        f"Expected MAD value to be {expected_result}, got: {test_result}"
+    )
+    assert len(test_result.time) == expected_time, (
+        f"Expected time to be {expected_time}, got: {len(test_result.time)}"
+    )
 
 
 def test_ag_counts_null(create_acceleration: pl.DataFrame) -> None:
@@ -247,9 +247,9 @@ def test_ag_counts_null(create_acceleration: pl.DataFrame) -> None:
 
     ag_counts = metrics.actigraph_activity_counts(acceleration)
 
-    assert np.all(
-        ag_counts.measurements == expected_result
-    ), f"Expected activity counts to be {expected_result}, got: {ag_counts}"
+    assert np.all(ag_counts.measurements == expected_result), (
+        f"Expected activity counts to be {expected_result}, got: {ag_counts}"
+    )
     assert len(ag_counts.time) == expected_time
 
 
@@ -280,9 +280,9 @@ def test_ag_counts_max() -> None:
 
     ag_counts = metrics.actigraph_activity_counts(acceleration)
 
-    assert np.all(
-        ag_counts.measurements[2:] == expected_result
-    ), f"Expected activity counts to be {expected_result}, got: {ag_counts}"
+    assert np.all(ag_counts.measurements[2:] == expected_result), (
+        f"Expected activity counts to be {expected_result}, got: {ag_counts}"
+    )
 
 
 @pytest.mark.parametrize("temp_length", [498, 500])