accelerometry-annotator 3.2.2__tar.gz → 3.3.0__tar.gz

{accelerometry_annotator-3.2.2 → accelerometry_annotator-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: accelerometry-annotator
-Version: 3.2.2
+Version: 3.3.0
 Summary: Web-based tool for visualizing and annotating wrist-worn accelerometry data from physical performance assessments.
 Author-email: Manu Murugesan <manorathan@uchicago.edu>
 License: MIT
@@ -33,6 +33,8 @@ Requires-Dist: openpyxl
 Requires-Dist: jinja2
 Provides-Extra: lttb
 Requires-Dist: lttbc; extra == "lttb"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
 Dynamic: license-file
 
 # Accelerometry Annotation Tool

{accelerometry_annotator-3.2.2 → accelerometry_annotator-3.3.0}/accelerometry_annotator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: accelerometry-annotator
-Version: 3.2.2
+Version: 3.3.0
 Summary: Web-based tool for visualizing and annotating wrist-worn accelerometry data from physical performance assessments.
 Author-email: Manu Murugesan <manorathan@uchicago.edu>
 License: MIT
@@ -33,6 +33,8 @@ Requires-Dist: openpyxl
 Requires-Dist: jinja2
 Provides-Extra: lttb
 Requires-Dist: lttbc; extra == "lttb"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
 Dynamic: license-file
 
 # Accelerometry Annotation Tool

{accelerometry_annotator-3.2.2 → accelerometry_annotator-3.3.0}/accelerometry_annotator.egg-info/SOURCES.txt

@@ -6,6 +6,9 @@ accelerometry_annotator.egg-info/SOURCES.txt
 accelerometry_annotator.egg-info/dependency_links.txt
 accelerometry_annotator.egg-info/requires.txt
 accelerometry_annotator.egg-info/top_level.txt
+tests/test_data_loading.py
+tests/test_plotting.py
+tests/test_state.py
 visualize_accelerometry/__init__.py
 visualize_accelerometry/app.py
 visualize_accelerometry/callbacks.py

{accelerometry_annotator-3.2.2 → accelerometry_annotator-3.3.0}/accelerometry_annotator.egg-info/requires.txt

@@ -8,3 +8,6 @@ jinja2
 
 [lttb]
 lttbc
+
+[test]
+pytest>=7.0

{accelerometry_annotator-3.2.2 → accelerometry_annotator-3.3.0}/pyproject.toml

@@ -48,6 +48,7 @@ dependencies = [
 
 [project.optional-dependencies]
 lttb = ["lttbc"]
+test = ["pytest>=7.0"]
 
 [project.urls]
 Homepage = "https://github.com/TavoloPerUno/py_visualize_accelerometry"

accelerometry_annotator-3.3.0/tests/test_data_loading.py

@@ -0,0 +1,212 @@
+"""Tests for visualize_accelerometry.data_loading."""
+
+import os
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from visualize_accelerometry.config import ANNOTATION_COLUMNS, TIME_FMT
+from visualize_accelerometry.data_loading import (
+    clamp_anchor,
+    cleanup_annotations,
+    get_annotations_from_files,
+    get_filedata,
+    get_filenames,
+    save_annotations,
+)
+
+
+class TestGetFilenames:
+    """Tests for file discovery and user assignment."""
+
+    def test_discovers_h5_files(self, patch_config, sample_h5):
+        fnames = get_filenames()
+        assert len(fnames) == 1
+        assert "900001-20230315093000" in fnames[0]
+
+    def test_deterministic_assignment(self, patch_config, sample_h5, second_h5):
+        """Same seed produces same assignment across calls."""
+        first = get_filenames()
+        second = get_filenames()
+        assert first == second
+
+    def test_assigns_all_files(self, patch_config, sample_h5, second_h5):
+        fnames = get_filenames()
+        assert len(fnames) == 2
+        basenames = [f.split("--")[1] for f in fnames]
+        assert "900001-20230315093000" in basenames
+        assert "900002-20230316140000" in basenames
+
+    def test_format_is_user_dash_dash_filename(self, patch_config, sample_h5):
+        from visualize_accelerometry.config import ANNOTATOR_USERS
+        fnames = get_filenames()
+        for f in fnames:
+            parts = f.split("--")
+            assert len(parts) == 2
+            assert parts[0] in ANNOTATOR_USERS
+
+    def test_ignores_non_h5_files(self, patch_config, tmp_data_dir):
+        readings = tmp_data_dir / "readings"
+        (readings / "not_a_data_file.csv").write_text("x,y,z")
+        fnames = get_filenames()
+        assert len(fnames) == 0
+
+    def test_no_global_rng_pollution(self, patch_config, sample_h5):
+        """Ensure get_filenames doesn't pollute global numpy random state."""
+        np.random.seed(123)
+        before = np.random.random()
+        np.random.seed(123)
+        get_filenames()
+        after = np.random.random()
+        assert before == after
+
+
+class TestGetFiledata:
+    """Tests for HDF5 time-window loading."""
+
+    def test_first_load_returns_bounds(self, sample_h5):
+        fname = str(sample_h5).replace(".h5", "")
+        anchor, start, end, pdf = get_filedata(fname, None, 3600)
+        assert anchor is not None
+        assert start is not None
+        assert end is not None
+        assert len(pdf) > 0
+
+    def test_subsequent_load_no_bounds(self, sample_h5):
+        fname = str(sample_h5).replace(".h5", "")
+        anchor, start, end, pdf = get_filedata(fname, None, 3600)
+        anchor2, start2, end2, pdf2 = get_filedata(fname, anchor, 3600)
+        assert start2 is None
+        assert end2 is None
+
+    def test_returns_expected_columns(self, sample_h5):
+        fname = str(sample_h5).replace(".h5", "")
+        _, _, _, pdf = get_filedata(fname, None, 3600)
+        assert "timestamp" in pdf.columns
+        assert "x" in pdf.columns
+        assert "y" in pdf.columns
+        assert "z" in pdf.columns
+
+    def test_windowed_query(self, sample_h5):
+        """Small window should return fewer rows than the full file."""
+        fname = str(sample_h5).replace(".h5", "")
+        _, _, _, pdf_full = get_filedata(fname, None, 3600)
+        anchor = pdf_full["timestamp"].iloc[len(pdf_full) // 2].strftime(TIME_FMT)
+        _, _, _, pdf_small = get_filedata(fname, anchor, 1)
+        assert len(pdf_small) <= len(pdf_full)
+
+
+class TestClampAnchor:
+    """Tests for anchor clamping logic."""
+
+    def test_anchor_within_bounds_unchanged(self):
+        start = "Mar 15 2023 09:00 AM"
+        end = "Mar 15 2023 10:00 AM"
+        anchor = "Mar 15 2023 09:30 AM"
+        result = clamp_anchor(anchor, start, end, 600)
+        assert result == anchor
+
+    def test_anchor_past_end_clamped(self):
+        start = "Mar 15 2023 09:00 AM"
+        end = "Mar 15 2023 10:00 AM"
+        anchor = "Mar 15 2023 10:30 AM"
+        result = clamp_anchor(anchor, start, end, 600)
+        from datetime import datetime
+        result_dt = datetime.strptime(result, TIME_FMT)
+        end_dt = datetime.strptime(end, TIME_FMT)
+        assert result_dt < end_dt
+
+    def test_anchor_before_start_clamped(self):
+        start = "Mar 15 2023 09:00 AM"
+        end = "Mar 15 2023 10:00 AM"
+        anchor = "Mar 15 2023 08:00 AM"
+        result = clamp_anchor(anchor, start, end, 600)
+        from datetime import datetime
+        result_dt = datetime.strptime(result, TIME_FMT)
+        start_dt = datetime.strptime(start, TIME_FMT)
+        assert result_dt > start_dt
+
+
+class TestAnnotations:
+    """Tests for annotation I/O and cleanup."""
+
+    def test_load_annotations(self, patch_config, sample_annotations):
+        pdf = get_annotations_from_files()
+        assert len(pdf) == 2
+        assert set(pdf["artifact"]) == {"chair_stand", "tug"}
+
+    def test_load_empty_returns_empty_df(self, patch_config):
+        pdf = get_annotations_from_files()
+        assert len(pdf) == 0
+        assert list(pdf.columns) == ANNOTATION_COLUMNS
+
+    def test_cleanup_sorts_and_fills(self):
+        pdf = pd.DataFrame({
+            "fname": ["f1", "f2"],
+            "artifact": ["tug", "chair_stand"],
+            "segment": [1, np.nan],
+            "scoring": [np.nan, 1],
+            "review": [0, np.nan],
+            "start_epoch": [100, np.nan],
+            "end_epoch": [200, np.nan],
+            "start_time": pd.to_datetime(["2023-01-01", None]),
+            "end_time": pd.to_datetime(["2023-01-02", None]),
+            "annotated_at": pd.to_datetime(["2023-01-01", "2023-01-01"]),
+            "user": ["a", "b"],
+            "notes": [None, "test"],
+        })
+        result = cleanup_annotations(pdf)
+        assert result["segment"].isna().sum() == 0
+        assert result["scoring"].isna().sum() == 0
+        assert result["review"].isna().sum() == 0
+        assert result["notes"].dtype == object
+
+    def test_cleanup_adds_notes_column(self):
+        pdf = pd.DataFrame({
+            "fname": ["f1"],
+            "artifact": ["tug"],
+            "segment": [0], "scoring": [0], "review": [0],
+            "start_epoch": [100], "end_epoch": [200],
+            "start_time": pd.to_datetime(["2023-01-01"]),
+            "end_time": pd.to_datetime(["2023-01-02"]),
+            "annotated_at": pd.to_datetime(["2023-01-01"]),
+            "user": ["a"],
+        })
+        result = cleanup_annotations(pdf)
+        assert "notes" in result.columns
+
+    def test_save_and_reload(self, patch_config, sample_annotations):
+        pdf = get_annotations_from_files()
+        pdf = cleanup_annotations(pdf)
+
+        # Add a new annotation
+        new_row = pd.DataFrame({
+            "fname": ["900001-20230315093000"],
+            "artifact": ["3m_walk"],
+            "segment": [0], "scoring": [0], "review": [0],
+            "start_epoch": [1678872700.0], "end_epoch": [1678872720.0],
+            "start_time": pd.to_datetime(["2023-03-15 09:31:40"]),
+            "end_time": pd.to_datetime(["2023-03-15 09:32:00"]),
+            "annotated_at": pd.to_datetime(["2023-03-17 11:00:00"]),
+            "user": ["test_user"],
+            "notes": [""],
+        })
+        pdf = pd.concat([pdf, new_row], ignore_index=True)
+
+        result = save_annotations(
+            pdf, "test_user", "900001-20230315093000",
+        )
+        assert len(result) == 3
+        assert "3m_walk" in result["artifact"].values
+
+    def test_save_preserves_other_files(self, patch_config, sample_annotations):
+        """Saving annotations for one file shouldn't delete annotations for other files."""
+        pdf = get_annotations_from_files()
+        pdf = cleanup_annotations(pdf)
+
+        # Save with only one file's annotations modified
+        result = save_annotations(
+            pdf, "test_user", "900001-20230315093000",
+        )
+        assert len(result) == 2

accelerometry_annotator-3.3.0/tests/test_plotting.py

@@ -0,0 +1,88 @@
+"""Tests for visualize_accelerometry.plotting."""
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from bokeh.models import ColumnDataSource
+
+from visualize_accelerometry.plotting import _downsample, make_plot, MAX_POINTS
+
+
+class TestDownsample:
+    """Tests for the LTTB downsampling function."""
+
+    def test_passthrough_when_short(self):
+        ts = np.arange(100, dtype=np.float64)
+        vals = np.random.randn(100)
+        ds_ts, ds_vals = _downsample(ts, vals, 200)
+        np.testing.assert_array_equal(ds_ts, ts)
+        np.testing.assert_array_equal(ds_vals, vals)
+
+    def test_reduces_to_target(self):
+        n = 50000
+        ts = np.arange(n, dtype=np.float64)
+        vals = np.sin(np.linspace(0, 10 * np.pi, n))
+        ds_ts, ds_vals = _downsample(ts, vals, 1000)
+        assert len(ds_ts) <= 1000 + 10  # allow small tolerance
+        assert len(ds_ts) > 0
+
+    def test_preserves_dtype(self):
+        ts = np.arange(
+            np.datetime64("2023-01-01"),
+            np.datetime64("2023-01-01") + np.timedelta64(10000, "ms"),
+            np.timedelta64(1, "ms"),
+        )
+        vals = np.random.randn(len(ts)).astype(np.float64)
+        ds_ts, ds_vals = _downsample(ts, vals, 100)
+        assert ds_ts.dtype == ts.dtype
+
+
+class TestMakePlot:
+    """Tests for the main plot creation function."""
+
+    def _make_annotation_cds(self):
+        empty = dict(start_time=[], end_time=[])
+        return {
+            "chair_stand": ColumnDataSource(data=dict(**empty)),
+            "3m_walk": ColumnDataSource(data=dict(**empty)),
+            "6min_walk": ColumnDataSource(data=dict(**empty)),
+            "tug": ColumnDataSource(data=dict(**empty)),
+            "segment": ColumnDataSource(data=dict(**empty)),
+            "scoring": ColumnDataSource(data=dict(**empty)),
+            "review": ColumnDataSource(data=dict(**empty)),
+        }
+
+    def test_returns_four_elements(self):
+        n = 2000
+        pdf = pd.DataFrame({
+            "timestamp": pd.date_range("2023-01-01", periods=n, freq="12ms"),
+            "x": np.random.randn(n),
+            "y": np.random.randn(n),
+            "z": np.random.randn(n),
+        })
+        result = make_plot(pdf, self._make_annotation_cds())
+        assert len(result) == 4
+
+    def test_empty_data_returns_placeholders(self):
+        result = make_plot(None, self._make_annotation_cds())
+        assert len(result) == 4
+
+    def test_empty_dataframe_returns_placeholders(self):
+        pdf = pd.DataFrame(columns=["timestamp", "x", "y", "z"])
+        result = make_plot(pdf, self._make_annotation_cds())
+        assert len(result) == 4
+
+    def test_signal_cds_has_expected_keys(self):
+        n = 2000
+        pdf = pd.DataFrame({
+            "timestamp": pd.date_range("2023-01-01", periods=n, freq="12ms"),
+            "x": np.random.randn(n),
+            "y": np.random.randn(n),
+            "z": np.random.randn(n),
+        })
+        _, _, _, signal_cds = make_plot(pdf, self._make_annotation_cds())
+        assert "timestamp" in signal_cds.data
+        assert "x" in signal_cds.data
+        assert "y" in signal_cds.data
+        assert "z" in signal_cds.data

accelerometry_annotator-3.3.0/tests/test_state.py

@@ -0,0 +1,93 @@
+"""Tests for visualize_accelerometry.state."""
+
+import os
+
+import pandas as pd
+import pytest
+
+from visualize_accelerometry.state import AppState
+
+
+class TestAppStateInit:
+    """Tests for AppState initialization."""
+
+    def test_creates_with_username(self, patch_config, sample_h5):
+        state = AppState("test_user")
+        assert state.username == "test_user"
+
+    def test_discovers_files(self, patch_config, sample_h5):
+        state = AppState("test_user")
+        assert len(state.lst_fnames) == 1
+
+    def test_sets_initial_fname(self, patch_config, sample_h5):
+        state = AppState("test_user")
+        assert "900001-20230315093000" in state.fname
+
+    def test_default_windowsize(self, patch_config, sample_h5):
+        state = AppState("test_user")
+        assert state.windowsize == 3600
+
+    def test_annotation_cds_keys(self, patch_config, sample_h5):
+        state = AppState("test_user")
+        expected = {"chair_stand", "3m_walk", "6min_walk", "tug",
+                    "segment", "scoring", "review"}
+        assert set(state.annotation_cds.keys()) == expected
+
+    def test_initial_selection_bounds_none(self, patch_config, sample_h5):
+        state = AppState("test_user")
+        assert state.selection_bounds is None
+
+
+class TestAppStateLoadFile:
+    """Tests for loading signal data."""
+
+    def test_load_file_data(self, patch_config, sample_h5):
+        state = AppState("test_user")
+        pdf = state.load_file_data()
+        assert pdf is not None
+        assert len(pdf) > 0
+        assert "timestamp" in pdf.columns
+
+    def test_sets_anchor_and_bounds(self, patch_config, sample_h5):
+        state = AppState("test_user")
+        state.load_file_data()
+        assert state.anchor_timestamp is not None
+        assert state.file_start_timestamp is not None
+        assert state.file_end_timestamp is not None
+
+    def test_stores_signal_data(self, patch_config, sample_h5):
+        state = AppState("test_user")
+        pdf = state.load_file_data()
+        assert state.pdf_signal_to_display is pdf
+
+
+class TestAppStateAnnotations:
+    """Tests for annotation management in AppState."""
+
+    def test_loads_annotations(self, patch_config, sample_h5, sample_annotations):
+        state = AppState("test_user")
+        assert len(state.pdf_annotations) == 2
+
+    def test_refresh_annotations(self, patch_config, sample_h5, sample_annotations):
+        state = AppState("test_user")
+        state.refresh_annotations()
+        assert len(state.pdf_annotations) == 2
+
+    def test_get_displayed_annotations_filters(
+        self, patch_config, sample_h5, sample_annotations,
+    ):
+        state = AppState("test_user")
+        displayed = state.get_displayed_annotations()
+        assert all(displayed["user"] == "test_user")
+        assert all(
+            displayed["fname"] == os.path.basename(state.fname)
+        )
+
+    def test_update_annotation_sources(
+        self, patch_config, sample_h5, sample_annotations,
+    ):
+        state = AppState("test_user")
+        state.update_annotation_sources()
+        # chair_stand annotation should appear in the CDS
+        cs_data = state.annotation_cds["chair_stand"].data
+        assert len(cs_data["start_time"]) == 1

accelerometry_annotator-3.3.0/visualize_accelerometry/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.3.0"

{accelerometry_annotator-3.2.2 → accelerometry_annotator-3.3.0}/visualize_accelerometry/data_loading.py

@@ -30,10 +30,11 @@ def get_filenames():
         uses a fixed random seed so every server restart produces the
         same mapping, distributing files evenly across annotators.
     """
-    # Fixed seed ensures the same user-to-file assignment across restarts
-    np.random.seed(2020)
+    # Fixed seed ensures the same user-to-file assignment across restarts.
+    # Use a local Generator to avoid polluting global NumPy random state.
+    rng = np.random.default_rng(2020)
     users_to_assign = list(ANNOTATOR_USERS)
-    np.random.shuffle(users_to_assign)
+    rng.shuffle(users_to_assign)
     users_cycle = cycle(users_to_assign)
     lst_files = sorted(
         next(users_cycle) + "--" + os.path.splitext(f)[0]
@@ -70,7 +71,9 @@ def get_filedata(fname, anchor_timestamp, windowsize):
     if anchor_timestamp is None:
         # First load: read the first and last rows to determine file bounds
         first_row = pd.read_hdf(file_path, "readings", start=0, stop=1)
-        last_row = pd.read_hdf(file_path, "readings", start=-1)
+        with pd.HDFStore(file_path, mode="r") as store:
+            nrows = store.get_storer("readings").nrows
+        last_row = pd.read_hdf(file_path, "readings", start=nrows - 1, stop=nrows)
         anchor_timestamp = first_row["timestamp"].dt.strftime(TIME_FMT).values[0]
         file_start = first_row["timestamp"].dt.strftime(TIME_FMT).values[0]
         file_end = last_row["timestamp"].dt.strftime(TIME_FMT).values[0]

accelerometry_annotator-3.2.2/visualize_accelerometry/__init__.py

@@ -1 +0,0 @@
-__version__ = "3.2.2"