diff --git a/.flake8 b/.flake8 new file mode 100644 index 0000000..2f9ba5c --- /dev/null +++ b/.flake8 @@ -0,0 +1,3 @@ +[flake8] +extend-ignore = E501 +exclude = .git,.venv,.direnv,__pycache__,.pytest_cache diff --git a/.github/workflows/pr-testing-suite.yml b/.github/workflows/pr-testing-suite.yml new file mode 100644 index 0000000..955cf66 --- /dev/null +++ b/.github/workflows/pr-testing-suite.yml @@ -0,0 +1,61 @@ +name: PR Testing Suite + +on: + pull_request: + branches: + - main + +jobs: + lint: + name: Lint + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + + - name: Install Dependencies + run: pip install -r act/requirements.txt + + - name: Run Flake8 + run: flake8 act/tests act/main.py act/utils/pipe.py act/utils/comparison_utils.py + + test: + name: Tests and Coverage + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + + - name: Install Dependencies + run: pip install -r act/requirements.txt + + - name: Run Pytest with Coverage + run: pytest -q --cov=act.utils.pipe --cov-report=term-missing --cov-fail-under=90 + + smoke-e2e: + name: Smoke E2E + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + + - name: Install Dependencies + run: pip install -r act/requirements.txt + + - name: Run Smoke Integration Test + run: pytest -q act/tests/test_pipeline_smoke.py::test_pipeline_smoke_mocked_dependencies diff --git a/.gitignore b/.gitignore index 6bfc0b5..32cc661 100644 --- a/.gitignore +++ b/.gitignore @@ -1,9 +1,9 @@ .direnv/ .envrc.local -code/tests/dsmc/ -code/tests/gt3x/ -code/tests/sleep/ -code/tests/non-wear/ +act/tests/dsmc/ +act/tests/gt3x/ +act/tests/sleep/ +act/tests/non-wear/ # Python bytecode and caches __pycache__/ diff --git a/AGENTS.md b/AGENTS.md index 2e838c5..319440f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,30 +1,30 @@ # Repository Guidelines ## Project Structure & Module Organization -- Primary code lives in `code/`; `main.py` orchestrates the pipeline via `utils.pipe.Pipe`. -- `code/utils/` contains data movement, QC, and plotting helpers; keep new helpers modular and reuse logging. -- `code/core/` houses GGIR-facing R scripts and the `GG` Python wrapper; treat these as the source of truth for summary metrics. -- `code/tests/` stores QA notebooks, sample CSVs, and plotting scripts grouped by study focus; add new fixtures beside the notebooks they support. -- Artifacts land in `code/res/data.json` and repo-level `logs/`; avoid committing large raw exports. +- Primary code lives in `act/`; `main.py` orchestrates the pipeline via `utils.pipe.Pipe`. +- `act/utils/` contains data movement, QC, and plotting helpers; keep new helpers modular and reuse logging. +- `act/core/` houses GGIR-facing R scripts and the `GG` Python wrapper; treat these as the source of truth for summary metrics. +- `act/tests/` stores QA notebooks, sample CSVs, and plotting scripts grouped by study focus; add new fixtures beside the notebooks they support. +- Artifacts land in `act/res/data.json` and repo-level `logs/`; avoid committing large raw exports. ## Build, Test, and Development Commands - `python -m venv .venv && source .venv/bin/activate` – create a local env (Python 3.11). -- `pip install -r code/requirements.txt` – install runtime deps; add extras here only when they are runtime-critical. +- `pip install -r act/requirements.txt` – install runtime deps; add extras here only when they are runtime-critical. - `python -m code.main 1 "$BOOST_TOKEN" vosslnx` – run the ingest + GGIR pipeline; system flag may be `vosslnxft`, `local`, or `argon`. -- `python code/tests/gt3x/plots.py` – regenerate GT3X diagnostic plots and CSV summaries; confirm paths before running. +- `python act/tests/gt3x/plots.py` – regenerate GT3X diagnostic plots and CSV summaries; confirm paths before running. - `bash cron.sh` – mirrors production cron behaviour; ensure credentials and git remotes are safe before invoking. ## Coding Style & Naming Conventions - Follow PEP 8 (4-space indents, snake_case for modules/functions, PascalCase for classes). -- Use `logging` (see `code/main.py`) instead of print for new runtime diagnostics. +- Use `logging` (see `act/main.py`) instead of print for new runtime diagnostics. - File outputs should match `sub-####_ses-#_accel.csv` naming as enforced in `Save._determine_location`. - Keep tokens and secrets in environment variables; never hard-code inside scripts or configs. ## Testing Guidelines -- Prefer pytest modules named `test_*.py` under `code/tests/`; reuse the existing subfolders to group by modality. +- Prefer pytest modules named `test_*.py` under `act/tests/`; reuse the existing subfolders to group by modality. - Lightweight assertions should mock filesystem paths rather than writing to `/mnt`; see `utils.save` for patterns to isolate. -- For manual QA, refresh notebooks (`code/tests/*/*.ipynb`) after dataset changes and export key figures to git-tracked PNG/CSV in the same folder. -- Before submitting, run the pipeline in dry-run mode (use a low `daysago` and a sandbox token) and inspect `code/res/data.json`. +- For manual QA, refresh notebooks (`act/tests/*/*.ipynb`) after dataset changes and export key figures to git-tracked PNG/CSV in the same folder. +- Before submitting, run the pipeline in dry-run mode (use a low `daysago` and a sandbox token) and inspect `act/res/data.json`. ## Commit & Pull Request Guidelines - Use short, present-tense commit subjects (for example: `Sync GGIR exports`, `Harden RDSS sync error handling`); history (`3c432e9`) favours concise summaries. diff --git a/README.md b/README.md index d3121f2..e4ce131 100644 --- a/README.md +++ b/README.md @@ -3,29 +3,31 @@ An automation stack for synchronizing raw actigraphy exports, routing them through GGIR, and publishing QC plots for the BOOST observational and intervention studies. The service pulls IDs from REDCap, reconciles them with RDSS file drops, mirrors curated files to the LSS project hierarchy, and runs the GGIR + QC suite end to end. ## Table of Contents -- [Features](#features) -- [Repository Layout](#repository-layout) -- [Prerequisites](#prerequisites) -- [Quick Start](#quick-start) -- [Running the Pipeline](#running-the-pipeline) -- [Configuration](#configuration) -- [Testing & QA](#testing--qa) -- [Automation & Cron Support](#automation--cron-support) -- [Troubleshooting Tips](#troubleshooting-tips) -- [Contributing](#contributing) -- [Roadmap](#roadmap) -- [License](#license) +- [Boost Actigraphy Processing Pipeline](#boost-actigraphy-processing-pipeline) + - [Table of Contents](#table-of-contents) + - [Features](#features) + - [Repository Layout](#repository-layout) + - [Prerequisites](#prerequisites) + - [Quick Start](#quick-start) + - [Running the Pipeline](#running-the-pipeline) + - [Configuration](#configuration) + - [Testing \& QA](#testing--qa) + - [Automation \& Cron Support](#automation--cron-support) + - [Troubleshooting Tips](#troubleshooting-tips) + - [Contributing](#contributing) + - [Roadmap](#roadmap) + - [License](#license) ## Features - Mirrors RDSS accelerometer files into LSS study folders using deterministic naming (`sub-####_ses-#_accel.csv`). - Executes GGIR (3.2.6) via bundled R scripts and captures QC metrics per subject/session. - Generates interactive activity composition plots (Plotly/Matplotlib) and summary tables for downstream dashboards. -- Exposes a Python CLI (`code/main.py`) that orchestrates symlink creation, ingest, GGIR, QC, and group visualizations. +- Exposes a Python CLI (`act/main.py`) that orchestrates symlink creation, ingest, GGIR, QC, and group visualizations. - Provides cron wrappers to keep remote environments synchronized with `main` and to ship new outputs automatically. ## Repository Layout ``` -code/ +act/ core/ # GGIR-facing R scripts and conda env spec utils/ # ingest, QC, plotting, symlink helpers tests/ # QA notebooks, sample fixtures, exploratory plots @@ -37,7 +39,7 @@ AGENTS.md # contributor workflow guide ## Prerequisites - Python 3.11 (see `pyproject.toml`). -- R 4.3 with GGIR 3.0+; `code/core/environment.yml` captures a conda environment that works on VossLab Linux. +- R 4.3 with GGIR 3.0+; `act/core/environment.yml` captures a conda environment that works on VossLab Linux. - Access to RDSS (`/mnt/nfs/rdss/vosslab/Repositories/Accelerometer_Data`) and LSS project mounts. - REDCap API token with access to report `43327` (store in an environment variable, e.g. `BOOST_TOKEN`). - Git credentials for fetching/pushing when using the cron wrappers. @@ -51,10 +53,10 @@ cd boost-act # 2. Python environment python -m venv .venv source .venv/bin/activate -pip install -r code/requirements.txt +pip install -r act/requirements.txt # 3. Optional: create R/GGIR env (Linux) -conda env create -f code/core/environment.yml +conda env create -f act/core/environment.yml conda activate act-newer ``` @@ -70,21 +72,26 @@ python -m code.main $BOOST_TOKEN 2. Match REDCap IDs to RDSS filenames (`utils.comparison_utils`). 3. Copy curated CSVs into the correct LSS project folders (`utils.save`). 4. Call GGIR through `core/acc_new.R` and execute QC/plotting (`utils.qc`, `utils.group`). - 5. Write a subject manifest to `code/res/data.json`. + 5. Write a subject manifest to `act/res/data.json`. -For ad-hoc diagnostics, re-run plot generation with `python code/tests/gt3x/plots.py` (requires adjusting the hard-coded file path). +For ad-hoc diagnostics, re-run plot generation with `python act/tests/gt3x/plots.py` (requires adjusting the hard-coded file path). ## Configuration -- Edit `code/utils/pipe.py` if new deployment targets or mounts are added. -- Update `code/core/acc_new.R` to tweak GGIR parameters or derivative paths. +- Edit `act/utils/pipe.py` if new deployment targets or mounts are added. +- Update `act/core/acc_new.R` to tweak GGIR parameters or derivative paths. - Place credentials in the environment or a secure secrets manager; never commit tokens. -- Logging defaults to INFO via `logging.basicConfig` in `code/main.py`; adjust the level for verbose runs. +- Logging defaults to INFO via `logging.basicConfig` in `act/main.py`; adjust the level for verbose runs. ## Testing & QA -- Lightweight Python tests can be added under `code/tests//test_*.py` and executed with `pytest`. -- QA notebooks in `code/tests/*/*.ipynb` document exploratory checks; rerun them after major data or script changes. +- Run local checks with the same commands used by CI: + - `flake8 act/tests act/main.py act/utils/pipe.py act/utils/comparison_utils.py` + - `pytest -q --cov=act.utils.pipe --cov-report=term-missing --cov-fail-under=90` + - `pytest -q act/tests/test_pipeline_smoke.py::test_pipeline_smoke_mocked_dependencies` +- CI runs on pull requests targeting `main` and fails when lint, tests, coverage (`< 90%` for scoped modules), or smoke integration checks fail. +- Add or update tests under `act/tests/test_*.py` for Python-only validation; keep QA notebooks in `act/tests/*/*.ipynb` for manual exploratory checks. - `utils.qc` aggregates results into `logs/GGIR_QC_errs.csv`; inspect this file to confirm expected wear-time and calibration checks. -- Use sandbox tokens and the `local` system flag to validate changes without touching production mounts. +- Use sandbox tokens and mocked/local paths for tests; do not require `/mnt` mounts or real secrets. +- Detailed testing contributor guidance lives in `act/docs/TESTING.md`. ## Automation & Cron Support - `cron.sh` bootstraps the conda env, pulls latest `main`, runs the pipeline (`daysago=1`, production token), and pushes any resulting artifacts. @@ -93,7 +100,7 @@ For ad-hoc diagnostics, re-run plot generation with `python code/tests/gt3x/plot ## Troubleshooting Tips - **Missing symlinks:** run `python -c "from code.utils.mnt import create_symlinks; create_symlinks('../mnt', system='argon')"` (swap `system` as needed) and confirm mount availability. -- **GGIR failures:** check the console output and logs under `code/core/` or R’s stderr; ensure the conda env includes GGIR dependencies. +- **GGIR failures:** check the console output and logs under `act/core/` or R’s stderr; ensure the conda env includes GGIR dependencies. - **REDCap mismatches:** `utils.comparison_utils.ID_COMPARISONS` logs duplicate IDs; review its stdout and `AGENTS.md` for remediation steps. - **Permission errors:** verify the executing user can read RDSS and write to the LSS target directories. @@ -107,17 +114,3 @@ Contributions are welcome! Start by reviewing `AGENTS.md` for code style, testin ## License No license has been specified yet. Until a license is published, usage is limited to collaborators with explicit permission from the maintainers. - -<<<<<<< HEAD -/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/derivatives/GGIR-3.2.6/sub-8020/accel/ses-3/output_ses-3/results/part5_personsummary_MM_L44.8M100.6V428.8_T5A5.csv -/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6/sub-7168/accel/ses-1/output_ses-1/results/part5_personsummary_MM_L44.8M100.6V428.8_T5A5.csv -======= -/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/derivatives/GGIR-3.2.6-test-ncp-sleep2/sub-8020/accel/ses-3/output_ses-3/results/part5_personsummary_MM_L44.8M100.6V428.8_T5A5.csv -/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6-test-ncp-sleep2/sub-7168/accel/ses-1/output_ses-1/results/part5_personsummary_MM_L44.8M100.6V428.8_T5A5.csv - -```sh -cp /mnt/rdss/VossLab/Repositories/Accelerometer_Data/1168\ \(2025-08-14\)RAW.csv \ - /mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/sub-8019/accel/ses-3 -``` - ->>>>>>> 77463126661d2d8dd46654410d811d2b3d50bf5f diff --git a/code/__init__.py b/act/__init__.py similarity index 100% rename from code/__init__.py rename to act/__init__.py diff --git a/code/core/R_requirements.R b/act/core/R_requirements.R similarity index 100% rename from code/core/R_requirements.R rename to act/core/R_requirements.R diff --git a/code/core/acc.R b/act/core/acc.R similarity index 100% rename from code/core/acc.R rename to act/core/acc.R diff --git a/code/core/acc_new.R b/act/core/acc_new.R similarity index 100% rename from code/core/acc_new.R rename to act/core/acc_new.R diff --git a/code/core/accel.R b/act/core/accel.R similarity index 99% rename from code/core/accel.R rename to act/core/accel.R index 3642db7..765244d 100644 --- a/code/core/accel.R +++ b/act/core/accel.R @@ -1,7 +1,7 @@ #!/usr/bin/env rscript #usage: -# cd /path/to/code/func/ +# cd /path/to/act/func/ # chmod +x accel.r # ./accel.r --project_dir="path/to/project" --project_deriv_dir="path/to/derivatives" --files="file1.csv, file2.csv, file3.csv" --verbose diff --git a/code/core/basic_accel.R b/act/core/basic_accel.R similarity index 100% rename from code/core/basic_accel.R rename to act/core/basic_accel.R diff --git a/code/core/environment.yml b/act/core/environment.yml similarity index 100% rename from code/core/environment.yml rename to act/core/environment.yml diff --git a/code/core/gg.py b/act/core/gg.py similarity index 86% rename from code/core/gg.py rename to act/core/gg.py index b5778b8..999ce08 100644 --- a/code/core/gg.py +++ b/act/core/gg.py @@ -3,6 +3,7 @@ logger = logging.getLogger(__name__) + class GG: """ Class to execute GGIR processing for matched subject records. @@ -18,8 +19,8 @@ def __init__(self, matched, intdir, obsdir, system): obsdir (str): Path to the observational directory. """ self.matched = matched - self.INTDIR = intdir.rstrip('/') + '/' - self.OBSDIR = obsdir.rstrip('/') + '/' + self.INTDIR = intdir.rstrip("/") + "/" + self.OBSDIR = obsdir.rstrip("/") + "/" self.DERIVATIVES = "derivatives/GGIR-3.2.6/" # Defined within the class self.system = system @@ -32,7 +33,7 @@ def run_gg(self): from code.utils.qc import QC for project_dir in [self.INTDIR, self.OBSDIR]: - command = f"Rscript code/core/acc_new.R --project_dir {project_dir} --deriv_dir {self.DERIVATIVES}" + command = f"Rscript act/core/acc_new.R --project_dir {project_dir} --deriv_dir {self.DERIVATIVES}" try: # Execute the command in a new subprocess @@ -43,7 +44,7 @@ def run_gg(self): stdout=subprocess.PIPE, stderr=subprocess.STDOUT, bufsize=1, - universal_newlines=True + universal_newlines=True, ) # Stream output line-by-line @@ -59,10 +60,10 @@ def run_gg(self): logger.info("GGIR completed successfully for %s.", project_dir) # Determine project type for QC ('int' for internal, 'obs' for observational) - if project_dir.rstrip('/') == self.INTDIR.rstrip('/'): - project_type = 'int' + if project_dir.rstrip("/") == self.INTDIR.rstrip("/"): + project_type = "int" else: - project_type = 'obs' + project_type = "obs" # Run QC for this project logger.info("Starting QC pipeline for %s project.", project_type) diff --git a/code/core/gt3x_test.R b/act/core/gt3x_test.R similarity index 100% rename from code/core/gt3x_test.R rename to act/core/gt3x_test.R diff --git a/code/core/remainder.R b/act/core/remainder.R similarity index 100% rename from code/core/remainder.R rename to act/core/remainder.R diff --git a/code/data.json b/act/data.json similarity index 100% rename from code/data.json rename to act/data.json diff --git a/code/docs/.gitkeeper b/act/docs/.gitkeeper similarity index 100% rename from code/docs/.gitkeeper rename to act/docs/.gitkeeper diff --git a/act/docs/TESTING.md b/act/docs/TESTING.md new file mode 100644 index 0000000..3a8f580 --- /dev/null +++ b/act/docs/TESTING.md @@ -0,0 +1,78 @@ +# TESTING.md + +Testing guidance for BOOST Actigraphy Python changes. + +## Scope +- Primary automated coverage targets Python orchestration and utility paths in `act/`. +- GGIR/R is not required for PR smoke checks and should be mocked/stubbed in tests. +- CI-safe tests must avoid live mounts, production data paths, and real API tokens. + +## Local Commands +Run these from repo root: + +```bash +flake8 act/tests act/main.py act/utils/pipe.py act/utils/comparison_utils.py +pytest -q --cov=act.utils.pipe --cov-report=term-missing --cov-fail-under=90 +pytest -q act/tests/test_pipeline_smoke.py::test_pipeline_smoke_mocked_dependencies +``` + +If you use the local nix environment: + +```bash +nix develop +flake8 act/tests act/main.py act/utils/pipe.py act/utils/comparison_utils.py +pytest -q --cov=act.utils.pipe --cov-report=term-missing --cov-fail-under=90 +pytest -q act/tests/test_pipeline_smoke.py::test_pipeline_smoke_mocked_dependencies +``` + +## CI Expectations +- Workflow file: `.github/workflows/pr-testing-suite.yml`. +- Trigger: `pull_request` to `main` only. +- Required jobs: + - `lint` + - `test` (coverage fail-under 90 on scoped modules) + - `smoke-e2e` + +## Test Layout +- Put tests in `act/tests/` and name files `test_*.py`. +- Prefer deterministic unit/integration tests over notebook-driven checks for CI. +- Keep test data small and explicit. + +## Shared Fixtures +- Shared fixtures live in `act/tests/conftest.py`. +- Current fixture groups: + - Temporary roots for `int`, `obs`, and `rdss` paths. + - Filename/path factories for `sub-####_ses-#_accel.csv`. + - Signature example fixtures for known-good and mismatch cases. +- Reuse existing fixtures before creating new ones to reduce duplication. + +## Save Edge Cases +When adding save logic tests: +- Use temporary directories (`tmp_path`) and local fixture roots. +- Cover both path styles: + - intervention (`int`) + - observational (`obs`) +- Validate deterministic session outputs: + - session numbers stay contiguous for the tested scenario + - generated file names follow `sub-####_ses-#_accel.csv` + - destination paths include expected `accel/ses-#` structure +- For error paths, mock file operations (for example `shutil.copy`) and assert graceful continuation or expected failure semantics. + +## Smoke E2E Constraints +- Smoke tests must stay Python-only and fast. +- Mock external boundaries: + - REDCap-dependent ingest calls + - GGIR/R invocation paths + - filesystem cleanup paths when needed +- Do not require: + - `/mnt` or network storage mounts + - real REDCap tokens + - full GGIR execution + +## Contributor Notes +AGENTS-aligned expectations: +- Keep commit subjects short and present tense. +- Keep test commits focused by checkpoint or behavior slice. +- Name tests by behavior (`test__`). +- Add one clear assertion group per behavior being guarded. +- Run local lint/tests before opening a PR to keep CI feedback focused on regressions. diff --git a/code/logs/GGIR_QC_errs.csv b/act/logs/GGIR_QC_errs.csv similarity index 100% rename from code/logs/GGIR_QC_errs.csv rename to act/logs/GGIR_QC_errs.csv diff --git a/code/main.py b/act/main.py similarity index 75% rename from code/main.py rename to act/main.py index 9675d2d..297f3bd 100644 --- a/code/main.py +++ b/act/main.py @@ -1,38 +1,41 @@ import logging import os import sys - from code.utils.group import Group -from code.core.gg import GG from code.utils.pipe import Pipe -import logging + def _configure_logging() -> None: + log_file = os.getenv("LOG_FILE") handlers = [] + if log_file: + log_dir = os.path.dirname(log_file) if log_dir: os.makedirs(log_dir, exist_ok=True) handlers.append(logging.FileHandler(log_file)) + else: handlers.append(logging.StreamHandler()) logging.basicConfig( level=logging.INFO, - format='[%(levelname)s] %(message)s', + format="[%(levelname)s] %(message)s", handlers=handlers, ) - -if __name__ == '__main__': +if __name__ == "__main__": _configure_logging() # Expect at least 2 arguments: daysago (integer) and token (string) if len(sys.argv) < 3: print("Usage: python main.py [system]") print(" must be an integer, must be a non-empty string.") - print(" [system] optional values: 'vosslnx', 'vosslnxft', 'argon', 'local' (default 'vosslnx').") + print( + " [system] optional values: 'vosslnx', 'vosslnxft', 'argon', 'local' (default 'vosslnx')." + ) sys.exit(1) # Parse daysago @@ -49,13 +52,16 @@ def _configure_logging() -> None: sys.exit(1) # Parse system - if len(sys.argv)>3: + if len(sys.argv) > 3: system = sys.argv[3] - else: system = None + else: + system = None if not system: print("System not specified, defaulting to 'vosslnx'.") - elif system not in ['vosslnx', 'vosslnxft', 'argon', 'local']: - print("Error: must be one of 'vosslnx', 'vosslnxft', 'argon', or 'local'.") + elif system not in ["vosslnx", "vosslnxft", "argon", "local"]: + print( + "Error: must be one of 'vosslnx', 'vosslnxft', 'argon', or 'local'." + ) sys.exit(1) p = Pipe(token, daysago, system) diff --git a/act/requirements.txt b/act/requirements.txt new file mode 100644 index 0000000..41f9c62 --- /dev/null +++ b/act/requirements.txt @@ -0,0 +1,6 @@ +pandas +psycopg +requests +pytest +pytest-cov +flake8 diff --git a/code/res/data.json b/act/res/data.json similarity index 100% rename from code/res/data.json rename to act/res/data.json diff --git a/act/tests/conftest.py b/act/tests/conftest.py new file mode 100644 index 0000000..c59c6a0 --- /dev/null +++ b/act/tests/conftest.py @@ -0,0 +1,110 @@ +from __future__ import annotations + +import importlib +from pathlib import Path +import sys +import types + +import pytest + +PROJECT_ROOT = Path(__file__).resolve().parents[2] +if str(PROJECT_ROOT) not in sys.path: + sys.path.insert(0, str(PROJECT_ROOT)) + +_comparison_utils = importlib.import_module("act.utils.comparison_utils") +_stdlib_code = importlib.import_module("code") +_code_utils = types.ModuleType("code.utils") +_code_utils.comparison_utils = _comparison_utils +_stdlib_code.utils = _code_utils +sys.modules["code.utils"] = _code_utils +sys.modules["code.utils.comparison_utils"] = _comparison_utils + + +@pytest.fixture +def temp_study_roots(tmp_path: Path) -> dict[str, Path]: + """Create local-only roots used by filesystem-facing tests.""" + roots = { + "int": tmp_path / "act-int-test", + "obs": tmp_path / "act-obs-test", + "rdss": tmp_path / "rdss", + } + for root in roots.values(): + root.mkdir(parents=True, exist_ok=True) + return roots + + +@pytest.fixture +def accel_filename_factory(): + """Build deterministic accel filenames with project naming conventions.""" + + def _factory(subject_id: str | int, session: int) -> str: + subject = str(subject_id) + return f"sub-{subject}_ses-{session}_accel.csv" + + return _factory + + +@pytest.fixture +def accel_path_factory(temp_study_roots: dict[str, Path], accel_filename_factory): + """Build deterministic file paths for both supported study types.""" + + def _factory(study: str, subject_id: str | int, session: int) -> Path: + study_key = study.lower() + if study_key not in {"int", "obs"}: + raise ValueError(f"Unknown study type: {study}") + + subject = str(subject_id) + filename = accel_filename_factory(subject, session) + return ( + temp_study_roots[study_key] + / f"sub-{subject}" + / "accel" + / f"ses-{session}" + / filename + ) + + return _factory + + +@pytest.fixture +def signature_known_good() -> dict[str, list[dict[str, str]]]: + """Signature fixture where report and RDSS file IDs fully align.""" + report_rows = [ + {"lab_id": "1101", "boost_id": "8001"}, + {"lab_id": "1102", "boost_id": "7012"}, + ] + rdss_files = [ + { + "ID": "1101", + "filename": "1101 (2025-01-01)RAW.csv", + "Date": "2025-01-01", + }, + { + "ID": "1102", + "filename": "1102 (2025-01-02)RAW.csv", + "Date": "2025-01-02", + }, + ] + return {"report_rows": report_rows, "rdss_files": rdss_files} + + +@pytest.fixture +def signature_mismatch() -> dict[str, list[dict[str, str]]]: + """Signature fixture where one report ID is intentionally unmatched.""" + report_rows = [ + {"lab_id": "1201", "boost_id": "8009"}, + {"lab_id": "1202", "boost_id": "7050"}, + ] + rdss_files = [ + { + "ID": "1201", + "filename": "1201 (2025-01-11)RAW.csv", + "Date": "2025-01-11", + }, + { + "ID": "9999", + "filename": "9999 (2025-01-12)RAW.csv", + "Date": "2025-01-12", + }, + ] + return {"report_rows": report_rows, "rdss_files": rdss_files} diff --git a/act/tests/test_baseline.py b/act/tests/test_baseline.py new file mode 100644 index 0000000..4e766d1 --- /dev/null +++ b/act/tests/test_baseline.py @@ -0,0 +1,6 @@ +"""Baseline tests for initial pytest wiring.""" + + +def test_pytest_wiring_baseline(): + """Ensure pytest discovery and execution are wired correctly.""" + assert True diff --git a/act/tests/test_fixtures.py b/act/tests/test_fixtures.py new file mode 100644 index 0000000..b907486 --- /dev/null +++ b/act/tests/test_fixtures.py @@ -0,0 +1,43 @@ +from pathlib import Path + + +def _matched_lab_ids( + signature_fixture: dict[str, list[dict[str, str]]], +) -> set[str]: + report_ids = {row["lab_id"] for row in signature_fixture["report_rows"]} + rdss_ids = {row["ID"] for row in signature_fixture["rdss_files"]} + return report_ids & rdss_ids + + +def test_temp_study_roots_are_local(temp_study_roots): + for root in temp_study_roots.values(): + assert root.exists() + assert root.is_dir() + assert str(root).startswith("/tmp/") + + +def test_accel_filename_factory(accel_filename_factory): + assert accel_filename_factory("8001", 3) == "sub-8001_ses-3_accel.csv" + + +def test_accel_path_factory_is_deterministic(accel_path_factory): + first = accel_path_factory("int", "8001", 2) + second = accel_path_factory("int", "8001", 2) + + assert isinstance(first, Path) + assert first == second + assert first.name == "sub-8001_ses-2_accel.csv" + assert first.parts[-4:] == ( + "sub-8001", + "accel", + "ses-2", + "sub-8001_ses-2_accel.csv", + ) + + +def test_signature_known_good_fixture(signature_known_good): + assert _matched_lab_ids(signature_known_good) == {"1101", "1102"} + + +def test_signature_mismatch_fixture(signature_mismatch): + assert _matched_lab_ids(signature_mismatch) == {"1201"} diff --git a/act/tests/test_pipeline_smoke.py b/act/tests/test_pipeline_smoke.py new file mode 100644 index 0000000..d1bd3e3 --- /dev/null +++ b/act/tests/test_pipeline_smoke.py @@ -0,0 +1,128 @@ +import importlib +import json +import runpy +import sys +import types + + +def _install_module(monkeypatch, name, module): + monkeypatch.setitem(sys.modules, name, module) + + +def _ensure_package(monkeypatch, name): + package = sys.modules.get(name) + if package is None: + package = types.ModuleType(name) + _install_module(monkeypatch, name, package) + return package + + +def test_pipeline_smoke_mocked_dependencies(tmp_path, monkeypatch): + save_state = {"init_kwargs": None, "remove_calls": []} + gg_state = {"init_kwargs": None, "ran": False} + + class FakeSave: + def __init__(self, **kwargs): + save_state["init_kwargs"] = kwargs + + def save(self): + return {"8001": [{"filename": "1001 (2025-01-01)RAW.csv"}]} + + @staticmethod + def remove_symlink_directories(study_dirs): + save_state["remove_calls"].append(study_dirs) + + class FakeGG: + def __init__(self, **kwargs): + gg_state["init_kwargs"] = kwargs + + def run_gg(self): + gg_state["ran"] = True + + code_pkg = _ensure_package(monkeypatch, "code") + utils_pkg = _ensure_package(monkeypatch, "code.utils") + core_pkg = _ensure_package(monkeypatch, "code.core") + + save_mod = types.ModuleType("code.utils.save") + save_mod.Save = FakeSave + gg_mod = types.ModuleType("code.core.gg") + gg_mod.GG = FakeGG + + utils_pkg.save = save_mod + core_pkg.gg = gg_mod + code_pkg.utils = utils_pkg + code_pkg.core = core_pkg + + _install_module(monkeypatch, "code.utils.save", save_mod) + _install_module(monkeypatch, "code.core.gg", gg_mod) + + pipe_mod = importlib.import_module("act.utils.pipe") + pipe_mod = importlib.reload(pipe_mod) + monkeypatch.chdir(tmp_path) + pipe_mod.Pipe._SYSTEM_PATHS["local"] = { + "INT_DIR": str(tmp_path / "int"), + "OBS_DIR": str(tmp_path / "obs"), + "RDSS_DIR": str(tmp_path / "rdss"), + } + + pipe = pipe_mod.Pipe(token="token", daysago=1, system="local") + pipe.run_pipe() + + written_manifest = tmp_path / "res" / "data.json" + assert written_manifest.exists() + payload = json.loads(written_manifest.read_text(encoding="utf-8")) + assert payload == {"8001": [{"filename": "1001 (2025-01-01)RAW.csv"}]} + + assert save_state["init_kwargs"]["symlink"] is False + assert save_state["init_kwargs"]["token"] == "token" + assert gg_state["ran"] is True + assert gg_state["init_kwargs"]["matched"] == payload + assert save_state["remove_calls"] == [ + [str(tmp_path / "int"), str(tmp_path / "obs")] + ] + + +def test_main_smoke_invokes_pipe_and_group(monkeypatch): + call_state = {"pipe_args": None, "run_pipe": 0, "group_systems": []} + + class FakePipe: + def __init__(self, token, daysago, system): + call_state["pipe_args"] = (token, daysago, system) + + def run_pipe(self): + call_state["run_pipe"] += 1 + + class FakeGroup: + def __init__(self, system): + call_state["group_systems"].append(system) + + def plot_person(self): + call_state["group_systems"].append("person") + + def plot_session(self): + call_state["group_systems"].append("session") + + code_pkg = _ensure_package(monkeypatch, "code") + utils_pkg = _ensure_package(monkeypatch, "code.utils") + pipe_mod = types.ModuleType("code.utils.pipe") + group_mod = types.ModuleType("code.utils.group") + pipe_mod.Pipe = FakePipe + group_mod.Group = FakeGroup + utils_pkg.pipe = pipe_mod + utils_pkg.group = group_mod + code_pkg.utils = utils_pkg + + _install_module(monkeypatch, "code.utils.pipe", pipe_mod) + _install_module(monkeypatch, "code.utils.group", group_mod) + + monkeypatch.setattr( + sys, + "argv", + ["main.py", "2", "token-value", "local"], + ) + + runpy.run_module("act.main", run_name="__main__") + + assert call_state["pipe_args"] == ("token-value", 2, "local") + assert call_state["run_pipe"] == 1 + assert call_state["group_systems"] == ["local", "person", "local", "session"] diff --git a/act/tests/test_save_edge_cases.py b/act/tests/test_save_edge_cases.py new file mode 100644 index 0000000..b8f1477 --- /dev/null +++ b/act/tests/test_save_edge_cases.py @@ -0,0 +1,139 @@ +import os +import shutil + +import pytest + +from act.utils.save import Save + + +def _make_save(temp_study_roots): + save = Save.__new__(Save) + save.INT_DIR = os.fspath(temp_study_roots["int"]) + save.OBS_DIR = os.fspath(temp_study_roots["obs"]) + save.RDSS_DIR = os.fspath(temp_study_roots["rdss"]) + save.symlink = False + save.matches = {} + save.dupes = [] + return save + + +@pytest.mark.parametrize( + "subject_id,expected_study,edge_case", + [ + ("8001", "int", "duplicate_date"), + ("7001", "obs", "duplicate_date"), + ("8002", "int", "noop_existing"), + ("7002", "obs", "noop_existing"), + ], +) +def test_save_edge_cases_matrix( + temp_study_roots, subject_id, expected_study, edge_case +): + save = _make_save(temp_study_roots) + + matches = { + subject_id: [ + { + "filename": "1001 (2025-01-01)RAW.csv", + "labID": "1001", + "date": "2025-01-01", + }, + { + "filename": "1002 (2025-01-01)RAW.csv", + "labID": "1002", + "date": "2025-01-01", + }, + ] + } + + save._determine_run(matches) + save._determine_study(matches) + save._determine_location(matches) + + runs = [record["run"] for record in matches[subject_id]] + studies = {record["study"] for record in matches[subject_id]} + paths = [record["file_path"] for record in matches[subject_id]] + + assert runs == [1, 2] + assert studies == {expected_study} + assert any("/ses-1/" in path for path in paths) + assert any("/ses-2/" in path for path in paths) + + root = os.fspath(temp_study_roots[expected_study]) + for path in paths: + assert path.startswith(root) + assert os.path.basename(path).startswith(f"sub-{subject_id}_ses-") + assert path.endswith("_accel.csv") + + # Duplicate dates should be deterministic and stable on re-run. + save._determine_run(matches) + assert [record["run"] for record in matches[subject_id]] == [1, 2] + + if edge_case == "noop_existing": + first_record = matches[subject_id][0] + source = os.path.join(save.RDSS_DIR, first_record["filename"]) + destination = first_record["file_path"] + os.makedirs(os.path.dirname(source), exist_ok=True) + os.makedirs(os.path.dirname(destination), exist_ok=True) + with open(source, "w", encoding="utf-8") as handle: + handle.write("new") + with open(destination, "w", encoding="utf-8") as handle: + handle.write("existing") + + save._move_files({subject_id: [first_record]}) + + with open(destination, "r", encoding="utf-8") as handle: + assert handle.read() == "existing" + + +def test_move_files_partial_copy_failure_continues(temp_study_roots, monkeypatch): + save = _make_save(temp_study_roots) + subject_id = "8009" + first_name = "2001 (2025-02-01)RAW.csv" + second_name = "2002 (2025-02-02)RAW.csv" + + first_source = os.path.join(save.RDSS_DIR, first_name) + second_source = os.path.join(save.RDSS_DIR, second_name) + os.makedirs(save.RDSS_DIR, exist_ok=True) + with open(first_source, "w", encoding="utf-8") as handle: + handle.write("first") + with open(second_source, "w", encoding="utf-8") as handle: + handle.write("second") + + first_dest = os.path.join( + save.INT_DIR, + f"sub-{subject_id}", + "accel", + "ses-1", + f"sub-{subject_id}_ses-1_accel.csv", + ) + second_dest = os.path.join( + save.INT_DIR, + f"sub-{subject_id}", + "accel", + "ses-2", + f"sub-{subject_id}_ses-2_accel.csv", + ) + + matches = { + subject_id: [ + {"filename": first_name, "file_path": first_dest}, + {"filename": second_name, "file_path": second_dest}, + ] + } + + original_copy = shutil.copy + + def flaky_copy(src, dst): + if src == first_source: + raise OSError("simulated copy failure") + return original_copy(src, dst) + + monkeypatch.setattr("act.utils.save.shutil.copy", flaky_copy) + + save._move_files(matches) + + assert not os.path.exists(first_dest) + assert os.path.exists(second_dest) + with open(second_dest, "r", encoding="utf-8") as handle: + assert handle.read() == "second" diff --git a/code/utils/comparison_utils.py b/act/utils/comparison_utils.py similarity index 75% rename from code/utils/comparison_utils.py rename to act/utils/comparison_utils.py index 34f5f4a..c07b448 100644 --- a/code/utils/comparison_utils.py +++ b/act/utils/comparison_utils.py @@ -8,6 +8,7 @@ logger = logging.getLogger(__name__) + class ID_COMPARISONS: def __init__(self, rdss_dir, token, daysago=None) -> None: @@ -16,6 +17,7 @@ def __init__(self, rdss_dir, token, daysago=None) -> None: if not self.rdss_dir: raise ValueError("RDSS directory is required to compare IDs.") self.daysago = daysago + def compare_ids(self): """ Pulls all files from RDSS @@ -34,37 +36,41 @@ def compare_ids(self): # Iterate over the rows in the cleaned RedCap report for _, row in report.iterrows(): - boost_id = str(row['boost_id']) - lab_id = str(row['lab_id']) - + boost_id = str(row["boost_id"]) + lab_id = str(row["lab_id"]) + # Find matching files in the RDSS list - rdss_matches = rdss[rdss['ID'] == lab_id] + rdss_matches = rdss[rdss["ID"] == lab_id] if not rdss_matches.empty: if boost_id not in result: result[boost_id] = [] for _, match_row in rdss_matches.iterrows(): - result[boost_id].append({ - 'filename': match_row['filename'], - 'labID': lab_id, - 'date': match_row['Date'] - }) - + result[boost_id].append( + { + "filename": match_row["filename"], + "labID": lab_id, + "date": match_row["Date"], + } + ) + # Process duplicates into the desired structure. duplicates_dict = [] if not file_duplicates.empty: # Group by lab_id and boost_id; each group represents one duplicate combination. - grouped = file_duplicates.groupby(['lab_id', 'boost_id']) + grouped = file_duplicates.groupby(["lab_id", "boost_id"]) for (lab_id, boost_id), group in grouped: - duplicates_dict.append({ - 'lab_id': lab_id, - 'boost_id': boost_id, - 'filenames': group['filename'].tolist(), - 'dates': group['Date'].tolist() - }) + duplicates_dict.append( + { + "lab_id": lab_id, + "boost_id": boost_id, + "filenames": group["filename"].tolist(), + "dates": group["Date"].tolist(), + } + ) else: logger.info("Found no duplicates.") - return {'matches': result, 'duplicates': duplicates_dict} + return {"matches": result, "duplicates": duplicates_dict} def _return_report(self): """ @@ -73,57 +79,57 @@ def _return_report(self): checks for boost_ids that are associated with multiple lab_ids, logs a critical error, and removes these rows from the dataframe. separates duplicate rows (based on any column) from the cleaned data. - + returns: df_cleaned: dataframe with duplicates removed and problematic boost_ids excluded duplicate_rows: dataframe of duplicate rows """ - url = 'https://redcap.icts.uiowa.edu/redcap/api/' + url = "https://redcap.icts.uiowa.edu/redcap/api/" data = { - 'token': self.token, - 'content': 'report', - 'report_id': 43327, - 'format': 'csv' + "token": self.token, + "content": "report", + "report_id": 43327, + "format": "csv", } r = requests.post(url, data=data) if r.status_code != 200: print(f"error! status code is {r.status_code}") sys.exit(1) - + df = pd.read_csv(StringIO(r.text)) - + # identify boost_ids associated with multiple lab_ids. - boost_id_counts = df.groupby('boost_id')['lab_id'].nunique() + boost_id_counts = df.groupby("boost_id")["lab_id"].nunique() problematic_boost_ids = boost_id_counts[boost_id_counts > 1].index.tolist() - + if problematic_boost_ids: logger.critical( "found boost_id(s) with multiple lab_ids: %s. these entries will be removed from processing.", ", ".join(map(str, problematic_boost_ids)), ) - df = df[~df['boost_id'].isin(problematic_boost_ids)] + df = df[~df["boost_id"].isin(problematic_boost_ids)] print(df) - + # identify and separate duplicate rows based on any column. duplicate_rows = df[df.duplicated(keep=False)] df_cleaned = df.drop_duplicates(keep=False) - + if not duplicate_rows.empty: logger.info("duplicate rows found:\n%s", duplicate_rows) if df_cleaned.empty: logger.warning("no unique rows remain after removing duplicates.") else: print(df_cleaned.head(), len(df_cleaned)) - + return df_cleaned, duplicate_rows def _rdss_file_list(self, duplicates, daysago=None): """ extracts the first string before the space and the date from filenames ending with .csv in the specified folder and stores them in a dataframe. - + Also, merges the file list with duplicate report entries based on lab_id. - + Returns: df: DataFrame of all file entries merged_df: DataFrame of file entries that match duplicate lab_ids from the report @@ -136,11 +142,13 @@ def _rdss_file_list(self, duplicates, daysago=None): raise FileNotFoundError(f"RDSS directory not found: {rdss_dir}") for filename in os.listdir(rdss_dir): print(filename) - if filename.endswith('.csv'): + if filename.endswith(".csv"): try: - base_name = filename.split(' ')[0] # Extract lab_id - date_part = filename.split('(')[1].split(')')[0] # Extract date - extracted_data.append({'ID': base_name, 'Date': date_part, 'filename': filename}) + base_name = filename.split(" ")[0] # Extract lab_id + date_part = filename.split("(")[1].split(")")[0] # Extract date + extracted_data.append( + {"ID": base_name, "Date": date_part, "filename": filename} + ) except IndexError: print(f"Skipping file with unexpected format: {filename}") @@ -148,28 +156,31 @@ def _rdss_file_list(self, duplicates, daysago=None): print(f"EXTRACTED: {extracted_data}") if not df.empty: - df['Date'] = pd.to_datetime(df['Date'], errors='coerce') + df["Date"] = pd.to_datetime(df["Date"], errors="coerce") print(f"DATE CONVERTED: {df['Date']}") if daysago: print(f"DAYS AGO: {daysago}") cutoff_date = datetime.today() - timedelta(days=daysago) print(f"CUTOFF DATE: {cutoff_date}") - df = df[df['Date'] >= cutoff_date] # Filter files within the last `daysago` days + df = df[ + df["Date"] >= cutoff_date + ] # Filter files within the last `daysago` days else: - df = df[df['Date'] >= '2024-08-05'] # Filter out rows before the threshold date + df = df[ + df["Date"] >= "2024-08-05" + ] # Filter out rows before the threshold date # Filter the file list to only include rows where ID is in the duplicate report (if any) if not duplicates.empty: - matched_df = df[df['ID'].isin(duplicates['lab_id'])] + matched_df = df[df["ID"].isin(duplicates["lab_id"])] # Merge with the duplicates to bring in boost_id information from the report - merged_df = matched_df.merge(duplicates, left_on='ID', right_on='lab_id') + merged_df = matched_df.merge(duplicates, left_on="ID", right_on="lab_id") else: merged_df = pd.DataFrame() if df.empty: logger.info("No RDSS files found after filtering.") print(f"MERGED: {merged_df}") - return df, merged_df diff --git a/code/utils/group.py b/act/utils/group.py similarity index 70% rename from code/utils/group.py rename to act/utils/group.py index 54bfb2d..5ea4deb 100644 --- a/code/utils/group.py +++ b/act/utils/group.py @@ -9,30 +9,22 @@ class Group: - def __init__(self, system: str = 'vosslnx'): + def __init__(self, system: str = "vosslnx"): Pipe.configure(system) self.system = system - self.obs_path = Pipe.OBS_DIR + self.obs_path = Pipe.OBS_DIR self.int_path = Pipe.INT_DIR self.paths = [ - os.path.join(self.obs_path, 'derivatives', 'GGIR-3.2.6'), - os.path.join(self.int_path, 'derivatives', 'GGIR-3.2.6'), + os.path.join(self.obs_path, "derivatives", "GGIR-3.2.6"), + os.path.join(self.int_path, "derivatives", "GGIR-3.2.6"), ] - self.path = './plots/group' + self.path = "./plots/group" - ''' + """ New person logic: GGIR with ncp and sleep no longer are outputting the output_accel files for all sessions (may be premature) - New goal is to iterate through the folders and grab the metrics, then average - ''' - - def _parse_person_files(self, subject, study): - person_path = "/output_accel/part5_personsummary_MM_L40M100V400_T5A5.csv" - if study == 'int': - base_path = os.path.join(self.path[1], subject) - elif study == 'obs': - base_path = os.path.join(self.path[0], subject) - + New goal is to iterate through the folders and grab the metrics, then average + """ def _parse_person_file(self, file_path): try: @@ -44,26 +36,33 @@ def _parse_person_file(self, file_path): vig = df["dur_day_total_VIG_min_pla"].iloc[0] mvpa = mod + vig total = sleep + inactivity + light + mvpa - logger.debug(f"Parsed {file_path}: sleep={sleep}, inactivity={inactivity}, light={light}, mvpa={mvpa}, total={total}") + logger.debug( + f"Parsed {file_path}: sleep={sleep}, inactivity={inactivity}, light={light}, mvpa={mvpa}, total={total}" + ) if total == 0: - logger.warning(f"Total was 0 for {file_path}. Columns found: {df.columns.tolist()}") + logger.warning( + f"Total was 0 for {file_path}. Columns found: {df.columns.tolist()}" + ) return None if df.empty: logger.warning(f"{file_path} is empty.") return None - session = df.get("filename", [""])[0].split("_")[-2] if "filename" in df else "unknown" + session = ( + df.get("filename", [""])[0].split("_")[-2] + if "filename" in df + else "unknown" + ) return { "Sleep": sleep / total * 1440, "Inactivity": inactivity / total * 1440, "Light": light / total * 1440, "MVPA": mvpa / total * 1440, - "Session": session + "Session": session, } except Exception as e: logger.warning(f"Error reading file {file_path}: {e}") return None - def plot_person(self): durations = [] @@ -73,16 +72,19 @@ def plot_person(self): continue results_dir = os.path.join( - base_dir, entry, - "accel", "output_accel", "results" + base_dir, entry, "accel", "output_accel", "results" ) if not os.path.isdir(results_dir): - logger.debug("Results directory missing for %s: %s", entry, results_dir) + logger.debug( + "Results directory missing for %s: %s", entry, results_dir + ) continue pattern = os.path.join(results_dir, "part5_personsummary_MM*.csv") matches = glob.glob(pattern) if not matches: - logger.debug(f"No matching files in {results_dir}, skipping {entry}") + logger.debug( + f"No matching files in {results_dir}, skipping {entry}" + ) continue for person_file in matches: @@ -95,7 +97,9 @@ def plot_person(self): df_all = pd.DataFrame(durations) if not df_all.empty and "Subject" in df_all.columns: - df_all = df_all[~df_all["Subject"].str.startswith("sub-6")].reset_index(drop=True) + df_all = df_all[~df_all["Subject"].str.startswith("sub-6")].reset_index( + drop=True + ) df_all = df_all.sort_values("Subject").reset_index(drop=True) else: logger.warning("No valid data found — skipping Subject filtering.") @@ -103,10 +107,9 @@ def plot_person(self): self._plot_stacked_bar( df_all, title="Normalized Average Activity Composition by Subject (All Sessions)", - filename="avg_plot_all.html" + filename="avg_plot_all.html", ) - def plot_session(self): durations = [] @@ -127,15 +130,22 @@ def plot_session(self): subject_path, session_folder, f"output_{session_folder}", - "results" + "results", ) if not os.path.isdir(results_dir): - logger.debug("Results directory missing for %s/%s: %s", entry, session_folder, results_dir) + logger.debug( + "Results directory missing for %s/%s: %s", + entry, + session_folder, + results_dir, + ) continue pattern = os.path.join(results_dir, "part5_personsummary_MM*.csv") matches = glob.glob(pattern) if not matches: - logger.debug(f"No matching files in {results_dir}, skipping {entry}/{session_folder}") + logger.debug( + f"No matching files in {results_dir}, skipping {entry}/{session_folder}" + ) continue for person_file in matches: @@ -149,7 +159,9 @@ def plot_session(self): df_all = pd.DataFrame(durations) if not df_all.empty and {"Subject", "Session"}.issubset(df_all.columns): - df_all = df_all[~df_all["Subject"].str.startswith("sub-6")].reset_index(drop=True) + df_all = df_all[~df_all["Subject"].str.startswith("sub-6")].reset_index( + drop=True + ) df_all = df_all.sort_values(["Session", "Subject"]).reset_index(drop=True) else: logger.warning("No valid data found — skipping Subject/Session filtering.") @@ -159,7 +171,7 @@ def plot_session(self): group_df, title=f"Average Activity Composition — Session {session.upper()}", y_key="Subject", - filename=f"avg_plot_{session}.html" + filename=f"avg_plot_{session}.html", ) def _plot_stacked_bar(self, df, title, filename, y_key="Subject"): @@ -172,30 +184,34 @@ def _plot_stacked_bar(self, df, title, filename, y_key="Subject"): "Sleep": "#A8DADC", "Inactivity": "#F1FAEE", "Light": "#FFD6A5", - "MVPA": "#FF9F1C" + "MVPA": "#FF9F1C", } fig = go.Figure() for activity in activities: - fig.add_trace(go.Bar( - y=df[y_key], - x=df[activity], - name=activity, - orientation='h', - marker_color=colors[activity], - hovertemplate=df[y_key] + f" - {activity} = " + - (df[activity] / 60).round(2).astype(str) + " hr" - )) + fig.add_trace( + go.Bar( + y=df[y_key], + x=df[activity], + name=activity, + orientation="h", + marker_color=colors[activity], + hovertemplate=df[y_key] + + f" - {activity} = " + + (df[activity] / 60).round(2).astype(str) + + " hr", + ) + ) fig.update_layout( - barmode='stack', + barmode="stack", title=title, xaxis=dict(title="Hours (normalized to 24)"), yaxis=dict(title=y_key), height=30 * len(df), margin=dict(l=20, r=20, t=40, b=20), showlegend=True, - autosize=True + autosize=True, ) os.makedirs(self.path, exist_ok=True) fig.write_html(os.path.join(self.path, filename)) diff --git a/code/utils/mnt.py b/act/utils/mnt.py similarity index 73% rename from code/utils/mnt.py rename to act/utils/mnt.py index a48afa3..629b9c0 100644 --- a/code/utils/mnt.py +++ b/act/utils/mnt.py @@ -5,7 +5,7 @@ """ -def create_symlinks(target_dir='../mnt', system='vosslnx'): +def create_symlinks(target_dir="../mnt", system="vosslnx"): """ Create symlinks to the system-specific mount points defined on Pipe. """ @@ -13,7 +13,7 @@ def create_symlinks(target_dir='../mnt', system='vosslnx'): os.makedirs(target_dir, exist_ok=True) - system = system or 'vosslnx' + system = system or "vosslnx" try: paths = Pipe.system_paths(system) except ValueError as exc: @@ -22,14 +22,16 @@ def create_symlinks(target_dir='../mnt', system='vosslnx'): ) from exc symlinks = { - 'int_dir': paths.get('INT_DIR'), - 'obs_dir': paths.get('OBS_DIR'), - 'rdss_dir': paths.get('RDSS_DIR') + "int_dir": paths.get("INT_DIR"), + "obs_dir": paths.get("OBS_DIR"), + "rdss_dir": paths.get("RDSS_DIR"), } for link_name, target_path in symlinks.items(): if not target_path: - print(f"Skipping symlink for {link_name}: no path configured for system '{system}'.") + print( + f"Skipping symlink for {link_name}: no path configured for system '{system}'." + ) continue link_path = os.path.join(target_dir, link_name) diff --git a/code/utils/pipe.py b/act/utils/pipe.py similarity index 94% rename from code/utils/pipe.py rename to act/utils/pipe.py index be7a921..f2021b6 100644 --- a/code/utils/pipe.py +++ b/act/utils/pipe.py @@ -1,9 +1,7 @@ -from pathlib import Path from code.utils.save import Save from code.core.gg import GG - class Pipe: # class-level "exported" attributes INT_DIR: str = "" @@ -51,7 +49,7 @@ def configure(cls, system: str = "vosslnx") -> None: cls.OBS_DIR = paths["OBS_DIR"] cls.RDSS_DIR = paths["RDSS_DIR"] - def __init__(self, token, daysago, system='vosslnx'): + def __init__(self, token, daysago, system="vosslnx"): # ensure class attrs are set for everyone (Pipe.INT_DIR etc.) type(self).configure(system) self.token = token @@ -65,16 +63,18 @@ def run_pipe(self): rdssdir=type(self).RDSS_DIR, token=self.token, daysago=self.daysago, - symlink=False + symlink=False, ) try: matched = save_instance.save() # (side note: your JSON writing was invalid; use json.dump) - import json, pathlib + import json + import pathlib + pathlib.Path("res").mkdir(exist_ok=True) - with open('res/data.json', 'w') as f: + with open("res/data.json", "w") as f: json.dump(matched, f, indent=2) GG( diff --git a/code/utils/plots.py b/act/utils/plots.py similarity index 63% rename from code/utils/plots.py rename to act/utils/plots.py index 3af435a..c2f8378 100644 --- a/code/utils/plots.py +++ b/act/utils/plots.py @@ -5,10 +5,10 @@ import seaborn as sns # TODO -# - look at the large comment sections and implement changes +# - look at the large comment sections and implement changes -#TODO +# TODO # - change the summary plots to use summaries by session as they come in? # - change the indices for daily plots to have date as index - not day number @@ -16,79 +16,81 @@ class ACT_PLOTS: def __init__(self, sub, ses, person, day): - self.df_person = pd.read_csv(person) - self.df_day = pd.read_csv(day) - self.sub = str(sub).split('-')[1] - self.ses = str(ses).split('-')[1] + self.df_person = pd.read_csv(person) + self.df_day = pd.read_csv(day) + self.sub = str(sub).split("-")[1] + self.ses = str(ses).split("-")[1] self.create_paths() - def create_paths(self): - if str(self.sub).startswith('9'): - proj = 'int' - site = 'NE' - path = os.path.join('plots', proj, site, str(self.sub)) - elif str(self.sub).startswith('8'): - proj = 'int' - site = 'UI' - path = os.path.join('plots', proj, site, str(self.sub)) - elif str(self.sub).startswith('7'): - proj = 'obs' - site = 'UI' - path = os.path.join('plots', proj, site, str(self.sub)) + if str(self.sub).startswith("9"): + proj = "int" + site = "NE" + path = os.path.join("plots", proj, site, str(self.sub)) + elif str(self.sub).startswith("8"): + proj = "int" + site = "UI" + path = os.path.join("plots", proj, site, str(self.sub)) + elif str(self.sub).startswith("7"): + proj = "obs" + site = "UI" + path = os.path.join("plots", proj, site, str(self.sub)) else: print("stupid NE and their dumb tests god...") - proj = 'junk' - path = os.path.join('plots', 'junk', str(self.sub)) + proj = "junk" + path = os.path.join("plots", "junk", str(self.sub)) self.path = path os.makedirs(self.path, exist_ok=True) return None - - - ''' + """ below plot needs to change to be multiple bar graphs (one for each session) - this should now be calculated by session iterating through the session folder + this should now be calculated by session iterating through the session folder logic for create_paths needs to change for this -> should be a list of person files by session - ''' + """ - def summary_plot(self, - act_cycles=['IN', 'LIG', 'MOD', 'VIG'], - sleep_col='dur_spt_min_pla'): + def summary_plot( + self, act_cycles=["IN", "LIG", "MOD", "VIG"], sleep_col="dur_spt_min_pla" + ): """ Plots a horizontal stacked bar of daily activity composition: Sleep, Inactivity, Light activity, MVPA, and Unidentified time (if any). """ # Collect durations - durations = {cycle: self.df_person[f'dur_day_total_{cycle}_min_pla'].iloc[0] for cycle in act_cycles} - mvpa = durations.pop('MOD') + durations.pop('VIG') durations = { - 'Sleep': self.df_person[sleep_col].iloc[0], - 'Inactivity': durations['IN'], - 'Light': durations['LIG'], - 'MVPA': mvpa + cycle: self.df_person[f"dur_day_total_{cycle}_min_pla"].iloc[0] + for cycle in act_cycles + } + mvpa = durations.pop("MOD") + durations.pop("VIG") + durations = { + "Sleep": self.df_person[sleep_col].iloc[0], + "Inactivity": durations["IN"], + "Light": durations["LIG"], + "MVPA": mvpa, } total_minutes = 24 * 60 identified = sum(durations.values()) unidentified = total_minutes - identified if unidentified > 0: - durations['Unidentified'] = unidentified + durations["Unidentified"] = unidentified # Order of segments - segments = ['Sleep', 'Inactivity', 'Light', 'MVPA'] - if 'Unidentified' in durations: - segments.append('Unidentified') + segments = ["Sleep", "Inactivity", "Light", "MVPA"] + if "Unidentified" in durations: + segments.append("Unidentified") values = [durations[s] for s in segments] # Styling - sns.set_theme(style='whitegrid', rc={'axes.facecolor': 'white'}) + sns.set_theme(style="whitegrid", rc={"axes.facecolor": "white"}) fig, ax = plt.subplots(figsize=(10, 3)) - palette = sns.color_palette('pastel', n_colors=len(segments)) + palette = sns.color_palette("pastel", n_colors=len(segments)) y_max = max(0.6 + 0.3, 0.5) # max text_y + padding ax.set_ylim(-1, y_max) - ax.set_xlim(0, 1440 + 200) # Add padding to the right (or whatever consistent total you want) + ax.set_xlim( + 0, 1440 + 200 + ) # Add padding to the right (or whatever consistent total you want) left = 0 min_width_for_inside_label = 40 # in minutes @@ -101,8 +103,8 @@ def summary_plot(self, left=left, height=0.5, color=color, - edgecolor='black', - linewidth=0.8 + edgecolor="black", + linewidth=0.8, ) center_x = left + val / 2 @@ -115,18 +117,18 @@ def summary_plot(self, center_x, text_y, seg, - ha='center', - va='bottom' if val < min_width_for_inside_label else 'top', + ha="center", + va="bottom" if val < min_width_for_inside_label else "top", fontsize=10, - fontweight='bold' + fontweight="bold", ) ax.text( center_x, text_y + (0.12 if val < min_width_for_inside_label else -0.12), f"{val/60:.1f} h", - ha='center', - va='bottom' if val < min_width_for_inside_label else 'top', - fontsize=9 + ha="center", + va="bottom" if val < min_width_for_inside_label else "top", + fontsize=9, ) left += val @@ -135,23 +137,24 @@ def summary_plot(self, ax.grid(False) # ← disables gridlines ax.set_yticks([]) ax.set_xticks([]) - ax.set_title('Average Daily Activity Composition (over the wear period)', fontsize=14, pad=12) - ax.spines[['top', 'left', 'right', 'bottom']].set_visible(False) + ax.set_title( + "Average Daily Activity Composition (over the wear period)", + fontsize=14, + pad=12, + ) + ax.spines[["top", "left", "right", "bottom"]].set_visible(False) plt.tight_layout() - plt.savefig(os.path.join(self.path, 'summary_plot'), bbox_inches='tight') + plt.savefig(os.path.join(self.path, "summary_plot"), bbox_inches="tight") plt.close() return None - - ''' + + """ new logic needs to create these day plots by combining all sessions each new session gets the dashed line indices for the y-axis on the graph needs to be dates, not days - ''' - + """ - def day_plots(self, - sleep_col='dur_spt_sleep_min', - dates_col='calendar_date'): + def day_plots(self, sleep_col="dur_spt_sleep_min", dates_col="calendar_date"): """ Plots a horizontal stacked bar of daily activity composition: Sleep, Inactivity, Light, MVPA, and Unidentified time. @@ -165,28 +168,22 @@ def day_plots(self, # Define colors colors = { - "Sleep": "#782D73", # Soft blue - "Inactivity": "#E57A44", # Neutral light gray - "Light": "#95D075", # Muted green - "MVPA": "#7A89C2", # Soft coral red - "Unidentified": "#B0B0B0" # Medium gray + "Sleep": "#782D73", # Soft blue + "Inactivity": "#E57A44", # Neutral light gray + "Light": "#95D075", # Muted green + "MVPA": "#7A89C2", # Soft coral red + "Unidentified": "#B0B0B0", # Medium gray } sns.set_theme(style="white") total_minutes = 24 * 60 bar_height = 0.4 - fig, ax = plt.subplots( - figsize=(10, 3 + 0.3 * len(df_day)) - ) + fig, ax = plt.subplots(figsize=(10, 3 + 0.3 * len(df_day))) # --- 1) Compute custom y-positions with extra space between sessions --- # extract session numbers from filename - session_nums = ( - df_day['filename'] - .str.extract(r'ses-(\d+)')[0] - .astype(int) - ) + session_nums = df_day["filename"].str.extract(r"ses-(\d+)")[0].astype(int) default_space = 1.9 extra_space = 0.8 y_positions = [] @@ -215,15 +212,15 @@ def day_plots(self, y_val = y_positions[i] # build durations durations = { - 'Sleep': row[sleep_col], - 'Inactivity': row['dur_day_total_IN_min'], - 'Light': row['dur_day_total_LIG_min'], - 'MVPA': row['dur_day_total_MOD_min'] + row['dur_day_total_VIG_min'] + "Sleep": row[sleep_col], + "Inactivity": row["dur_day_total_IN_min"], + "Light": row["dur_day_total_LIG_min"], + "MVPA": row["dur_day_total_MOD_min"] + row["dur_day_total_VIG_min"], } identified = sum(durations.values()) unidentified = total_minutes - identified if unidentified > 0: - durations['Unidentified'] = unidentified + durations["Unidentified"] = unidentified left = 0.0 above_toggle = False @@ -234,20 +231,20 @@ def day_plots(self, left=left, height=bar_height, color=colors[cat], - edgecolor='none' + edgecolor="none", ) center_x = left + val / 2 # choose label position if val >= min_width_for_inside_label: text_y = y_val - bar_height / 2 - 0.1 - va = 'top' + va = "top" else: if above_toggle: text_y = y_val + bar_height / 2 + 0.05 - va = 'bottom' + va = "bottom" else: text_y = y_val - bar_height / 2 - 0.25 - va = 'top' + va = "top" above_toggle = not above_toggle if val > 1: @@ -255,50 +252,55 @@ def day_plots(self, center_x, text_y, f"{val/60:.1f} h", - ha='center', + ha="center", va=va, - fontsize=8 + fontsize=8, ) left += val # Day labels on y-axis ax.set_yticks(y_positions) - date_labels = df_day[dates_col].astype(str).str.replace(r'\s*00:00:00$', '', regex=True) + date_labels = ( + df_day[dates_col].astype(str).str.replace(r"\s*00:00:00$", "", regex=True) + ) ax.set_yticklabels(date_labels) # Add dotted lines between sessions for b in boundary_ys: - ax.axhline(y=b, color='black', linestyle='--', linewidth=0.7) + ax.axhline(y=b, color="black", linestyle="--", linewidth=0.7) # Clean up x-axis - ax.set_xticks([0, total_minutes/2, total_minutes]) + ax.set_xticks([0, total_minutes / 2, total_minutes]) ax.set_xticklabels(["0 h", "12 h", "24 h"], fontsize=9) - ax.spines[['top', 'right', 'left', 'bottom']].set_visible(False) - ax.tick_params(axis='y', length=0) + ax.spines[["top", "right", "left", "bottom"]].set_visible(False) + ax.tick_params(axis="y", length=0) ax.set_xlim(0, total_minutes) # Legend handles = [plt.Rectangle((0, 0), 1, 1, color=colors[k]) for k in colors] - ax.legend(handles, list(colors.keys()), - bbox_to_anchor=(1.01, 1), - loc='upper left', - frameon=False) + ax.legend( + handles, + list(colors.keys()), + bbox_to_anchor=(1.01, 1), + loc="upper left", + frameon=False, + ) fig.suptitle("Daily Activity Composition", fontsize=14, y=0.95) plt.tight_layout() - plt.savefig(os.path.join(self.path, 'daily_plot')) + plt.savefig(os.path.join(self.path, "daily_plot")) plt.close() return None -def create_json(data_folder, out_file='data.json'): +def create_json(data_folder, out_file="data.json"): """ Constructs a JSON of PNG files organized by project, site, and subject, assuming each subject folder contains exactly two PNG files. Only scans 'int' and 'obs' folders at the top level. """ master_data = {} - projects = ['int', 'obs'] + projects = ["int", "obs"] for project in projects: project_path = os.path.join(data_folder, project) @@ -320,9 +322,9 @@ def create_json(data_folder, out_file='data.json'): continue png_files = [ - os.path.join(subject_path, fname).replace('plots/', 'data/', 1) + os.path.join(subject_path, fname).replace("plots/", "data/", 1) for fname in os.listdir(subject_path) - if fname.endswith('.png') + if fname.endswith(".png") ] png_files.sort() @@ -330,7 +332,7 @@ def create_json(data_folder, out_file='data.json'): if len(png_files) == 2: master_data[project][site][subject] = png_files - with open(out_file, 'w') as f: + with open(out_file, "w") as f: json.dump(master_data, f, indent=2) return master_data diff --git a/code/utils/qc.py b/act/utils/qc.py similarity index 71% rename from code/utils/qc.py rename to act/utils/qc.py index b18d519..5881a4e 100644 --- a/code/utils/qc.py +++ b/act/utils/qc.py @@ -6,7 +6,7 @@ class QC: - def __init__(self, project: str, system: str = 'vosslnx'): + def __init__(self, project: str, system: str = "vosslnx"): """ Initialize a QC instance. @@ -31,19 +31,17 @@ def __init__(self, project: str, system: str = 'vosslnx'): self.system = system # Determine the expected days worn based on project type - if project == 'obs': - self.base_dir = os.path.join(Pipe.OBS_DIR, 'derivatives', 'GGIR-3.2.6') + if project == "obs": + self.base_dir = os.path.join(Pipe.OBS_DIR, "derivatives", "GGIR-3.2.6") self.n_days_worn = 7 - elif project == 'int': + elif project == "int": self.n_days_worn = 9 - self.base_dir = os.path.join(Pipe.INT_DIR, 'derivatives', 'GGIR-3.2.6') + self.base_dir = os.path.join(Pipe.INT_DIR, "derivatives", "GGIR-3.2.6") else: raise ValueError("Project must be 'obs' or 'int'") - # Path to the master CSV that accumulates QC errors/warnings - self.csv_path = "./code/logs/GGIR_QC_errs.csv" - + self.csv_path = "./act/logs/GGIR_QC_errs.csv" def qc(self) -> None: """ @@ -88,9 +86,10 @@ def qc(self) -> None: if not os.path.isdir(ses_path): continue - # Now construct path to results - results_dir = os.path.join(ses_path, f"output_{session_folder}", "results") # new design needs to use output_{session_folder} instead of output_accel + results_dir = os.path.join( + ses_path, f"output_{session_folder}", "results" + ) # new design needs to use output_{session_folder} instead of output_accel if not os.path.isdir(results_dir): continue @@ -100,19 +99,17 @@ def qc(self) -> None: continue # 2. Locate the person summary using glob for MM - person_matches = glob.glob(os.path.join( - results_dir, - "part5_personsummary_MM*.csv" - )) + person_matches = glob.glob( + os.path.join(results_dir, "part5_personsummary_MM*.csv") + ) if not person_matches: continue person_file = person_matches[0] # 3. Locate the day summary using glob for MM - day_matches = glob.glob(os.path.join( - results_dir, - "part5_daysummary_MM*.csv" - )) + day_matches = glob.glob( + os.path.join(results_dir, "part5_daysummary_MM*.csv") + ) if not day_matches: continue day_file = day_matches[0] @@ -120,7 +117,9 @@ def qc(self) -> None: # Extract subject/session and metrics dfs = [qc_file, person_file, day_file] metrics, sub, ses = self.extract_metrics(dfs) - cal_err, h_considered, valid_days, clean_code_series, calendar_date = metrics + cal_err, h_considered, valid_days, clean_code_series, calendar_date = ( + metrics + ) # Run QC checks self.cal_error_check(cal_err, sub, ses) @@ -129,12 +128,14 @@ def qc(self) -> None: self.cleaning_code_check(clean_code_series, calendar_date, sub, ses) # Store session-level MM files for fallback plotting - session_records.append({ - "sub": sub, - "ses": ses, - "person": person_file, - "day": day_file, - }) + session_records.append( + { + "sub": sub, + "ses": ses, + "person": person_file, + "day": day_file, + } + ) # Clean up try: @@ -145,7 +146,9 @@ def qc(self) -> None: # After per‐session QC, make summary plots using the MM files all_ses_dir = os.path.join(sub_path, "accel", "output_accel", "results") - agg_person = glob.glob(os.path.join(all_ses_dir, "part5_personsummary_MM*.csv")) + agg_person = glob.glob( + os.path.join(all_ses_dir, "part5_personsummary_MM*.csv") + ) agg_day = glob.glob(os.path.join(all_ses_dir, "part5_daysummary_MM*.csv")) if agg_person and agg_day: @@ -168,9 +171,8 @@ def qc(self) -> None: plotter.day_plots() # create the json file used in the application - create_json('plots') - # End of qc loop - + create_json("plots") + # End of qc loop def extract_metrics(self, dfs: list) -> tuple: """ @@ -215,9 +217,9 @@ def extract_metrics(self, dfs: list) -> tuple: # Split on '_' to get subject and session identifiers file_id = qc_df["filename"].iloc[0] parts = file_id.split("_") - sub = parts[0] # e.g., 'sub-7001' + sub = parts[0] # e.g., 'sub-7001' print(f"Processing subject: {sub}") - ses = parts[1] # e.g., 'ses-1' + ses = parts[1] # e.g., 'ses-1' print(f"Processing session: {ses}") # Extract metrics from each DataFrame: @@ -236,12 +238,13 @@ def extract_metrics(self, dfs: list) -> tuple: self.df_day = day_df return metrics, sub, ses - # ───────────────────────────────────────────────────────────────────── # #2: Append/Update Master QC CSV with human-readable messages # ───────────────────────────────────────────────────────────────────── - def create_and_return_csv(self, check: str, code: int, sub: str, ses: str, date=None, clean_code=None) -> None: + def create_and_return_csv( + self, check: str, code: int, sub: str, ses: str, date=None, clean_code=None + ) -> None: """ Appends or updates a row in self.csv_path for (sub, ses), setting the human-readable interpretation for the specified QC check. @@ -251,44 +254,46 @@ def create_and_return_csv(self, check: str, code: int, sub: str, ses: str, date= """ # Map internal check names to CSV column names name_map = { - 'cal_err': 'Calibration_Error', - 'h_considered': 'Hours_Considered', - 'clean_code': 'Cleaning_Code', - 'val_days': 'Valid_Days' + "cal_err": "Calibration_Error", + "h_considered": "Hours_Considered", + "clean_code": "Cleaning_Code", + "val_days": "Valid_Days", } col = name_map.get(check, check) # Human-readable interpretations for each check / response code meanings = { - 'Calibration_Error': { - 0: 'Pass', - 1: 'ERROR: Calibration error too high', - 3: 'ERROR: Calibration error missing' + "Calibration_Error": { + 0: "Pass", + 1: "ERROR: Calibration error too high", + 3: "ERROR: Calibration error missing", }, - 'Hours_Considered': { - 0: 'Pass', - 1: 'ERROR: Too few hours considered', - 2: 'WARNING: Exceeds expected hours (possible worn-day mismatch)', - 3: 'ERROR: Hours considered missing' + "Hours_Considered": { + 0: "Pass", + 1: "ERROR: Too few hours considered", + 2: "WARNING: Exceeds expected hours (possible worn-day mismatch)", + 3: "ERROR: Hours considered missing", }, - 'Cleaning_Code': { - 0: 'Pass', - 1: 'ERROR: Invalid cleaning code found', - 2: 'WARNING: Missing (NaN) cleaning codes present', - 3: 'ERROR: Cleaning code missing' + "Cleaning_Code": { + 0: "Pass", + 1: "ERROR: Invalid cleaning code found", + 2: "WARNING: Missing (NaN) cleaning codes present", + 3: "ERROR: Cleaning code missing", + }, + "Valid_Days": { + 0: "Pass: ≥2 weekend days and ≥3 weekdays", + 1: "ERROR: Fewer than 2 weekend days for at least one session", + 2: "ERROR: Fewer than 3 weekdays for at least one session", + 3: "ERROR: No valid-days data found for at least one session", }, - 'Valid_Days': { - 0: 'Pass: ≥2 weekend days and ≥3 weekdays', - 1: 'ERROR: Fewer than 2 weekend days for at least one session', - 2: 'ERROR: Fewer than 3 weekdays for at least one session', - 3: 'ERROR: No valid-days data found for at least one session' - } } - interpretation = meanings[col].get(code, 'ERROR: Unknown code') + interpretation = meanings[col].get(code, "ERROR: Unknown code") # Append the actual cleaning codes and dates if applicable - if check == 'clean_code' and code == 1 and clean_code is not None: - invalids = clean_code[~clean_code.isin([0, 1]) & clean_code.notna()].unique() + if check == "clean_code" and code == 1 and clean_code is not None: + invalids = clean_code[ + ~clean_code.isin([0, 1]) & clean_code.notna() + ].unique() if len(invalids) > 0: interpretation += f" — Invalid codes: {', '.join(map(str, invalids))}" if date is not None and len(date) > 0: @@ -298,32 +303,35 @@ def create_and_return_csv(self, check: str, code: int, sub: str, ses: str, date= if os.path.exists(self.csv_path): master_df = pd.read_csv(self.csv_path) else: - cols = ['Subject', 'Session'] + list(name_map.values()) + cols = ["Subject", "Session"] + list(name_map.values()) master_df = pd.DataFrame(columns=cols) # Check if a row for this (sub, ses) already exists - mask = (master_df['Subject'] == sub) & (master_df['Session'] == ses) + mask = (master_df["Subject"] == sub) & (master_df["Session"] == ses) if mask.any(): # Overwrite only this column’s value master_df.loc[mask, col] = interpretation else: # Create a new row, with blanks in all QC columns except this one - new_row = {c: '' for c in master_df.columns} - new_row['Subject'] = sub - new_row['Session'] = ses + new_row = {c: "" for c in master_df.columns} + new_row["Subject"] = sub + new_row["Session"] = ses new_row[col] = interpretation - master_df = pd.concat([master_df, pd.DataFrame([new_row])], ignore_index=True) + master_df = pd.concat( + [master_df, pd.DataFrame([new_row])], ignore_index=True + ) # Write back to CSV (index=False to avoid an extra column) master_df.to_csv(self.csv_path, index=False) - # ───────────────────────────────────────────────────────────────────── # #3: Individual QC Check Methods (append to CSV via create_and_return_csv) # Modified to catch “variable not set” and report code = 3 # ───────────────────────────────────────────────────────────────────── - def cal_error_check(self, cal_error: float, sub: str, ses: str, threshold: float = 0.03) -> int: + def cal_error_check( + self, cal_error: float, sub: str, ses: str, threshold: float = 0.03 + ) -> int: """ Check calibration error against a threshold. @@ -335,23 +343,26 @@ def cal_error_check(self, cal_error: float, sub: str, ses: str, threshold: float """ try: # If cal_error is None or NaN, treat as missing - if cal_error is None or (isinstance(cal_error, float) and pd.isna(cal_error)): + if cal_error is None or ( + isinstance(cal_error, float) and pd.isna(cal_error) + ): raise ValueError("cal_error is missing") if cal_error > threshold: - self.create_and_return_csv('cal_err', 1, sub, ses) + self.create_and_return_csv("cal_err", 1, sub, ses) return 1 else: - self.create_and_return_csv('cal_err', 0, sub, ses) + self.create_and_return_csv("cal_err", 0, sub, ses) return 0 except Exception: # Any exception (NameError, ValueError, etc.) means variable not set - self.create_and_return_csv('cal_err', 3, sub, ses) + self.create_and_return_csv("cal_err", 3, sub, ses) return 3 - - def h_considered_check(self, h_considered: int, sub: str, ses: str, tolerance: int = 5) -> int: + def h_considered_check( + self, h_considered: int, sub: str, ses: str, tolerance: int = 5 + ) -> int: """ Check if the number of hours considered is within the expected window. @@ -364,25 +375,26 @@ def h_considered_check(self, h_considered: int, sub: str, ses: str, tolerance: i """ try: # If h_considered is None or NaN, treat as missing - if h_considered is None or (isinstance(h_considered, (int, float)) and pd.isna(h_considered)): + if h_considered is None or ( + isinstance(h_considered, (int, float)) and pd.isna(h_considered) + ): raise ValueError("h_considered is missing") expected_hours = self.n_days_worn * 24 if h_considered < (expected_hours - tolerance): - self.create_and_return_csv('h_considered', 1, sub, ses) + self.create_and_return_csv("h_considered", 1, sub, ses) return 1 elif h_considered > expected_hours: - self.create_and_return_csv('h_considered', 2, sub, ses) + self.create_and_return_csv("h_considered", 2, sub, ses) return 2 else: - self.create_and_return_csv('h_considered', 0, sub, ses) + self.create_and_return_csv("h_considered", 0, sub, ses) return 0 except Exception: - self.create_and_return_csv('h_considered', 3, sub, ses) + self.create_and_return_csv("h_considered", 3, sub, ses) return 3 - def valid_days_check(self, sub: str, ses: str) -> int: """ QC: ensure that for this session (ses) we have at least @@ -399,7 +411,7 @@ def valid_days_check(self, sub: str, ses: str) -> int: print(f"Valid Days - Checking session {ses} for subject {sub}") # select only the rows for this session - mask = self.df_day['filename'].str.contains(f"{ses}_") + mask = self.df_day["filename"].str.contains(f"{ses}_") session_df = self.df_day[mask] if session_df.empty: @@ -407,31 +419,32 @@ def valid_days_check(self, sub: str, ses: str) -> int: raise ValueError("No data for session") # count weekends vs weekdays - is_weekend = session_df['weekday'].isin(['Saturday', 'Sunday']) + is_weekend = session_df["weekday"].isin(["Saturday", "Sunday"]) weekend_count = is_weekend.sum() weekday_count = (~is_weekend).sum() # QC rules if weekend_count < 2: - self.create_and_return_csv('val_days', 1, sub, ses) + self.create_and_return_csv("val_days", 1, sub, ses) return 1 if weekday_count < 3: - self.create_and_return_csv('val_days', 2, sub, ses) + self.create_and_return_csv("val_days", 2, sub, ses) return 2 # all good - self.create_and_return_csv('val_days', 0, sub, ses) + self.create_and_return_csv("val_days", 0, sub, ses) return 0 except Exception as e: # anything else counts as “missing” print(str(e)) - self.create_and_return_csv('val_days', 3, sub, ses) + self.create_and_return_csv("val_days", 3, sub, ses) return 3 - - def cleaning_code_check(self, clean_code: pd.Series, calendar_dates: pd.Series, sub: str, ses: str) -> int: + def cleaning_code_check( + self, clean_code: pd.Series, calendar_dates: pd.Series, sub: str, ses: str + ) -> int: """ Inspect the 'cleaningcode' column from the day summary. @@ -451,22 +464,34 @@ def cleaning_code_check(self, clean_code: pd.Series, calendar_dates: pd.Series, invalid_codes = clean_code[invalid_mask].unique() if len(invalid_codes) > 0: - invalid_dates = calendar_dates[invalid_mask].dt.strftime('%Y-%m-%d').unique() - print(f"Found invalid cleaning codes: {invalid_codes} on dates: {invalid_dates}") + invalid_dates = ( + calendar_dates[invalid_mask].dt.strftime("%Y-%m-%d").unique() + ) + print( + f"Found invalid cleaning codes: {invalid_codes} on dates: {invalid_dates}" + ) self.create_and_return_csv( - 'clean_code', 1, sub, ses, + "clean_code", + 1, + sub, + ses, clean_code=clean_code, - date=invalid_dates # Pass the list of dates to include in interpretation + date=invalid_dates, # Pass the list of dates to include in interpretation ) return 1 # If all values are NaN → warning (no cleaning codes present) elif clean_code.isna().all(): - self.create_and_return_csv('clean_code', 2, sub, ses,) + self.create_and_return_csv( + "clean_code", + 2, + sub, + ses, + ) return 2 else: - self.create_and_return_csv('clean_code', 0, sub, ses) + self.create_and_return_csv("clean_code", 0, sub, ses) return 0 except Exception: - self.create_and_return_csv('clean_code', 3, sub, ses) + self.create_and_return_csv("clean_code", 3, sub, ses) return 3 diff --git a/code/utils/save.py b/act/utils/save.py similarity index 74% rename from code/utils/save.py rename to act/utils/save.py index d5b017b..569e187 100644 --- a/code/utils/save.py +++ b/act/utils/save.py @@ -10,16 +10,20 @@ class Save: def __init__(self, intdir, obsdir, rdssdir, token, daysago=None, symlink=True): if not rdssdir: - raise ValueError("RDSS directory is not configured for this system; cannot ingest files.") - - results = ID_COMPARISONS(rdss_dir=rdssdir, token=token, daysago=daysago).compare_ids() - self.matches = results['matches'] - self.matches.pop('6022, 7143', None) - self.matches.pop('7178, 8066', None) - self.matches.pop('8057, 7219', None) + raise ValueError( + "RDSS directory is not configured for this system; cannot ingest files." + ) + + results = ID_COMPARISONS( + rdss_dir=rdssdir, token=token, daysago=daysago + ).compare_ids() + self.matches = results["matches"] + self.matches.pop("6022, 7143", None) + self.matches.pop("7178, 8066", None) + self.matches.pop("8057, 7219", None) print(self.matches) - self.dupes = results['duplicates'] + self.dupes = results["duplicates"] print(f"Type of Dupes: {type(self.dupes)}") self.INT_DIR = intdir self.OBS_DIR = obsdir @@ -31,7 +35,7 @@ def save(self): matches = self._determine_run(matches=self.matches) matches = self._determine_study(matches=matches) matches = self._determine_location(matches=matches) - + # If duplicates exist, process and merge them. if not len(self.dupes) == 0: matches = self._handle_and_merge_duplicates(self.dupes) @@ -45,11 +49,11 @@ def _move_files_test(self, matches): Moves only one file per study category ('int' and 'obs') from RDSS_DIR to the determined file_path. If the destination file already exists, it skips the move. """ - selected_files = {'int': None, 'obs': None} + selected_files = {"int": None, "obs": None} for subject_id, records in matches.items(): for record in records: - study = record.get('study') + study = record.get("study") if study in selected_files and selected_files[study] is None: selected_files[study] = record # Store first occurrence @@ -61,8 +65,8 @@ def _move_files_test(self, matches): for study, record in selected_files.items(): if record: - source_path = os.path.join(self.RDSS_DIR, record['filename']) - destination_path = record['file_path'] + source_path = os.path.join(self.RDSS_DIR, record["filename"]) + destination_path = record["file_path"] if not os.path.exists(source_path): print(f"Source file not found: {source_path}. Skipping.") @@ -72,7 +76,9 @@ def _move_files_test(self, matches): os.makedirs(destination_dir, exist_ok=True) if os.path.exists(destination_path): - print(f"File already exists at destination: {destination_path}. Skipping.") + print( + f"File already exists at destination: {destination_path}. Skipping." + ) else: try: shutil.copy(source_path, destination_path) @@ -80,7 +86,7 @@ def _move_files_test(self, matches): except Exception as e: print(f"Error moving {source_path} to {destination_path}: {e}") continue - if self.symlink: + if self.symlink: self._refresh_subject_symlinks(destination_path) def _move_files(self, matches): @@ -97,8 +103,8 @@ def _move_files(self, matches): """ for subject_id, records in matches.items(): for record in records: - source_path = os.path.join(self.RDSS_DIR, record['filename']) - destination_path = record['file_path'] + source_path = os.path.join(self.RDSS_DIR, record["filename"]) + destination_path = record["file_path"] if not os.path.exists(source_path): print(f"Source file not found: {source_path}. Skipping.") @@ -109,7 +115,9 @@ def _move_files(self, matches): os.makedirs(destination_dir, exist_ok=True) if os.path.exists(destination_path): - print(f"File already exists at destination: {destination_path}. Skipping.") + print( + f"File already exists at destination: {destination_path}. Skipping." + ) if self.symlink: self._refresh_subject_symlinks(destination_path) continue @@ -157,7 +165,9 @@ def _refresh_subject_symlinks(self, csv_path): use_symlinks = True for src, rel_path in csv_records: rel_dir = os.path.dirname(rel_path) - target_dir = all_dir if rel_dir in ("", ".") else os.path.join(all_dir, rel_dir) + target_dir = ( + all_dir if rel_dir in ("", ".") else os.path.join(all_dir, rel_dir) + ) os.makedirs(target_dir, exist_ok=True) link_path = os.path.join(target_dir, os.path.basename(rel_path)) @@ -201,11 +211,11 @@ def _determine_run(self, matches): print(f"Value of matches: {matches}") # Debugging line for boost_id, match_list in matches.items(): # Sort the match_list by date in ascending order - match_list.sort(key=lambda x: x['date']) + match_list.sort(key=lambda x: x["date"]) # Assign a 'run' value to each entry based on its position in the sorted list for idx, match in enumerate(match_list, start=1): - match['run'] = idx + match["run"] = idx return matches @@ -219,7 +229,7 @@ def _determine_study(self, matches): - If boost_id >= 8000, 'study' = 'int' Args: - matches (dict): Dictionary with keys as boost_ids and values as lists of dictionaries + matches (dict): Dictionary with keys as boost_ids and values as lists of dictionaries containing 'filename', 'labID', and 'date'. Returns: @@ -234,19 +244,18 @@ def _determine_study(self, matches): # Determine the study type based on the boost_id if 6000 < boost_id_int < 8000: - study = 'obs' + study = "obs" elif boost_id_int >= 8000: - study = 'int' + study = "int" else: study = None # Or a default value if needed # Append the study type to each match dictionary for match in match_list: - match['study'] = study + match["study"] = study return matches - def _determine_location(self, matches): """ STRUCTURE OF DIRECTORIES @@ -259,19 +268,27 @@ def _determine_location(self, matches): for subject_id, records in matches.items(): try: for record in records: - if record['study'] is None: + if record["study"] is None: raise TypeError(f"study is None for {subject_id}") - study_dir = self.INT_DIR if record['study'].lower() == 'int' else self.OBS_DIR + study_dir = ( + self.INT_DIR + if record["study"].lower() == "int" + else self.OBS_DIR + ) subject_folder = f"sub-{subject_id}" - session = record['run'] # 'run' is synonymous with 'session' or 'set' + session = record[ + "run" + ] # 'run' is synonymous with 'session' or 'set' filename = f"sub-{subject_id}_ses-{session}_accel.csv" # Construct full path - file_path = f"{study_dir}/{subject_folder}/accel/ses-{session}/{filename}" + file_path = ( + f"{study_dir}/{subject_folder}/accel/ses-{session}/{filename}" + ) # Append file path to record - record['file_path'] = file_path + record["file_path"] = file_path except TypeError as e: print(f"Skipping subject {subject_id} due to error: {e}") @@ -279,18 +296,17 @@ def _determine_location(self, matches): return matches - def _prepare_for_json(self, matches): """Convert non-serializable values (e.g., pandas Timestamps) to strings.""" for records in matches.values(): for record in records: - date_value = record.get('date') + date_value = record.get("date") if date_value is None or isinstance(date_value, str): continue if hasattr(date_value, "isoformat"): - record['date'] = date_value.isoformat() + record["date"] = date_value.isoformat() else: - record['date'] = str(date_value) + record["date"] = str(date_value) return matches @staticmethod @@ -326,15 +342,14 @@ def remove_symlink_directories(study_dirs): except OSError as exc: print(f"Unable to remove directory {accel_all_dir}: {exc}") - def _handle_and_merge_duplicates(self, duplicates): """ Processes duplicate entries and merges them into the main matches dictionary. - - For each lab_id group in the duplicates (each group is expected to contain two entries: - one with a boost_id < 8000 for the observational study and one with a boost_id >= 8000 for + + For each lab_id group in the duplicates (each group is expected to contain two entries: + one with a boost_id < 8000 for the observational study and one with a boost_id >= 8000 for the interventional study): - + 1. Combine the filenames and dates from both entries and sort them chronologically. 2. Pre-build the expected observational study session-1 path: OBS_DIR/sub-/accel/sub-_ses-1_accel.csv @@ -349,23 +364,23 @@ def _handle_and_merge_duplicates(self, duplicates): starting at 1, using the int boost_id. 4. Merge these processed duplicate entries into the main matches dictionary. Each entry is stored under the key equal to its subject_id. - + If an expected observational (<8000) or interventional (>=8000) ID is missing for a group, an error is raised and processing is stopped. - + Args: duplicates (list): A list of dictionaries with keys 'lab_id', 'boost_id', 'filenames', and 'dates' representing duplicate records. - + Returns: dict: The updated matches dictionary with processed duplicates merged in. """ # Group duplicates by lab_id. grouped = {} for dup in duplicates: - lab_id = dup['lab_id'] + lab_id = dup["lab_id"] grouped.setdefault(lab_id, []).append(dup) - + # Process each group. for lab_id, dup_list in grouped.items(): # Identify the observational and interventional entries. @@ -373,87 +388,111 @@ def _handle_and_merge_duplicates(self, duplicates): int_entry = None for entry in dup_list: try: - boost_val = int(entry['boost_id']) + boost_val = int(entry["boost_id"]) except ValueError: - raise ValueError(f"Invalid boost_id in duplicates for lab_id {lab_id}: {entry['boost_id']}") + raise ValueError( + f"Invalid boost_id in duplicates for lab_id {lab_id}: {entry['boost_id']}" + ) if boost_val < 8000: obs_entry = entry elif boost_val >= 8000: int_entry = entry if obs_entry is None: - raise ValueError(f"Missing observational study ID (boost_id < 8000) for lab_id {lab_id}.") + raise ValueError( + f"Missing observational study ID (boost_id < 8000) for lab_id {lab_id}." + ) if int_entry is None: - raise ValueError(f"Missing interventional study ID (boost_id >= 8000) for lab_id {lab_id}.") + raise ValueError( + f"Missing interventional study ID (boost_id >= 8000) for lab_id {lab_id}." + ) # Combine filenames and dates from both entries. combined = [] - for fname, fdate in zip(obs_entry['filenames'], obs_entry['dates']): + for fname, fdate in zip(obs_entry["filenames"], obs_entry["dates"]): combined.append((fname, fdate)) - for fname, fdate in zip(int_entry['filenames'], int_entry['dates']): + for fname, fdate in zip(int_entry["filenames"], int_entry["dates"]): combined.append((fname, fdate)) # Sort by date (assuming dates are comparable) combined.sort(key=lambda x: x[1]) - + # Determine subject IDs from the entries. - obs_boost_id = str(obs_entry['boost_id']) - int_boost_id = str(int_entry['boost_id']) - + obs_boost_id = str(obs_entry["boost_id"]) + int_boost_id = str(int_entry["boost_id"]) + # Build the expected OBS session 1 path. subject_folder_obs = f"sub-{obs_boost_id}" - obs_session1_path = os.path.join(self.OBS_DIR, subject_folder_obs, "accel", - f"sub-{obs_boost_id}_ses-1_accel.csv") - + obs_session1_path = os.path.join( + self.OBS_DIR, + subject_folder_obs, + "accel", + f"sub-{obs_boost_id}_ses-1_accel.csv", + ) + new_entries = [] if not os.path.exists(obs_session1_path): # OBS session 1 does not exist. # The first (oldest) file becomes observational. first_fname, first_date = combined[0] - new_entries.append({ - 'filename': first_fname, - 'labID': lab_id, - 'date': first_date, - 'study': 'obs', - 'run': 1, - 'file_path': obs_session1_path, - 'subject_id': obs_boost_id - }) + new_entries.append( + { + "filename": first_fname, + "labID": lab_id, + "date": first_date, + "study": "obs", + "run": 1, + "file_path": obs_session1_path, + "subject_id": obs_boost_id, + } + ) # All remaining files become interventional (run numbers start at 2). for idx, (fname, fdate) in enumerate(combined[1:], start=1): subject_folder_int = f"sub-{int_boost_id}" - int_file_path = os.path.join(self.INT_DIR, subject_folder_int, "accel", - f"sub-{int_boost_id}_ses-{idx}_accel.csv") - new_entries.append({ - 'filename': fname, - 'labID': lab_id, - 'date': fdate, - 'study': 'int', - 'run': idx, - 'file_path': int_file_path, - 'subject_id': int_boost_id - }) + int_file_path = os.path.join( + self.INT_DIR, + subject_folder_int, + "accel", + f"sub-{int_boost_id}_ses-{idx}_accel.csv", + ) + new_entries.append( + { + "filename": fname, + "labID": lab_id, + "date": fdate, + "study": "int", + "run": idx, + "file_path": int_file_path, + "subject_id": int_boost_id, + } + ) else: # OBS session 1 exists; assign all duplicate files as interventional. for idx, (fname, fdate) in enumerate(combined, start=1): subject_folder_int = f"sub-{int_boost_id}" - int_file_path = os.path.join(self.INT_DIR, subject_folder_int, "accel", - f"sub-{int_boost_id}_ses-{idx}_accel.csv") - new_entries.append({ - 'filename': fname, - 'labID': lab_id, - 'date': fdate, - 'study': 'int', - 'run': idx, - 'file_path': int_file_path, - 'subject_id': int_boost_id - }) - + int_file_path = os.path.join( + self.INT_DIR, + subject_folder_int, + "accel", + f"sub-{int_boost_id}_ses-{idx}_accel.csv", + ) + new_entries.append( + { + "filename": fname, + "labID": lab_id, + "date": fdate, + "study": "int", + "run": idx, + "file_path": int_file_path, + "subject_id": int_boost_id, + } + ) + # Merge the processed duplicate entries into the main matches dictionary. for entry in new_entries: - subject_key = entry['subject_id'] + subject_key = entry["subject_id"] if subject_key in self.matches: self.matches[subject_key].append(entry) else: self.matches[subject_key] = [entry] - + return self.matches diff --git a/code/requirements.txt b/code/requirements.txt deleted file mode 100644 index 9c67652..0000000 --- a/code/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -pandas -psycopg -requests diff --git a/code/run_gg_temp.py b/code/run_gg_temp.py deleted file mode 100644 index 8d3f64e..0000000 --- a/code/run_gg_temp.py +++ /dev/null @@ -1,128 +0,0 @@ -from core.gg import GG - - -# this function needs to read the LSS temp dirs and run GGIR on all files -INT_DIR = '/Volumes/vosslabhpc/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test' -OBS_DIR = '/Volumes/vosslabhpc/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test' - - -def find_files(): - return None #return the files as a dictionary with correct metadata - -# run the GGIR script using the GG class -def run_gg(): - return None - - - -''' -EXAMPLE DICT -> CAN LEAVE VALUES FOR KEY 'filename' as string 'BLANK' -{ - "8022": "[{'filename': '1023 (2022-06-15)RAW.csv', 'labID': '1023', 'date': '2022-06-15', 'run': 1, 'study': 'int', 'file_path': '/Volumes/vosslabhpc/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/sub-8022/accel/sub-8022_ses-1_accel.csv'}]", - "8002": "[{'filename': '1124 (2024-11-07)RAW.csv', 'labID': '1124', 'date': '2024-11-07', 'run': 1, 'study': 'int', 'file_path': '/Volumes/vosslabhpc/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/sub-8002/accel/sub-8002_ses-1_accel.csv'}]", - "8018": "[{'filename': '1167 (2025-01-22)RAW.csv', 'labID': '1167', 'date': '2025-01-22', 'run': 1, 'study': 'int', 'file_path': '/Volumes/vosslabhpc/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/sub-8018/accel/sub-8018_ses-1_accel.csv'}]", - "7043": "[{'filename': '1174 (2025-01-28)RAW.csv', 'labID': '1174', 'date': '2025-01-28', 'run': 1, 'study': 'obs', 'file_path': '/Volumes/vosslabhpc/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/sub-7043/accel/sub-7043_ses-1_accel.csv'}]" -} -''' - - - -import os -import re -import json -from collections import defaultdict - -# Define your directory paths -INT_DIR = "/Volumes/vosslabhpc/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test" -OBS_DIR = "/Volumes/vosslabhpc/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test" - -def extract_info_from_filename(filename): - """ - Extracts labID and date from the filename pattern: '#### (YYYY-MM-DD)RAW.csv' - """ - match = re.match(r"(\d+) \((\d{4}-\d{2}-\d{2})\)RAW\.csv", filename) - if match: - labID, date = match.groups() - return labID, date - return None, None - -def find_csv_files(directory): - """ - Recursively find all CSV files in the given directory. - Returns a list of full file paths. - """ - csv_files = [] - for root, _, files in os.walk(directory): - for file in files: - if file.endswith(".csv"): - csv_files.append(os.path.join(root, file)) - return csv_files - -def recreate_matches(int_dir, obs_dir): - """ - Searches through INT_DIR and OBS_DIR for CSV files and reconstructs the matches dictionary. - """ - matches = defaultdict(list) - - # Search both directories - for directory, study in [(int_dir, "int"), (obs_dir, "obs")]: - for file_path in find_csv_files(directory): - filename = os.path.basename(file_path) - subject_match = re.search(r"sub-(\d+)", file_path) # Extract subject ID - if not subject_match: - continue - - subject_id = subject_match.group(1) - labID, date = extract_info_from_filename(filename) - if not labID or not date: - rdss=None # Skip files that don't match expected pattern - - matches[subject_id].append({ - "filename": "BLANK", - "labID": "blank", - "date": "blank", - "study": study, - "file_path": file_path - }) - - # Assign 'run' values - matches = _determine_run(matches) - - # Reconstruct file paths using the study type and session/run numbers - matches = _determine_location(matches) - - return matches - -# Helper functions reused from provided code -def _determine_run(matches): - """Assigns 'run' values based on chronological order of entries per subject.""" - for subject_id, match_list in matches.items(): - match_list.sort(key=lambda x: x['date']) # Sort by date - for idx, match in enumerate(match_list, start=1): - match['run'] = idx # Assign run number - return matches - -def _determine_location(matches): - """Reconstructs the expected file path based on study and run number.""" - for subject_id, records in matches.items(): - for record in records: - study_dir = INT_DIR if record['study'].lower() == 'int' else OBS_DIR - subject_folder = f"sub-{subject_id}" - session = record['run'] - filename = f"sub-{subject_id}_ses-{session}_accel.csv" - - # Construct full path - record['file_path'] = f"{study_dir}/{subject_folder}/accel/{filename}" - - return matches - -# Execute function and print output as JSON -matches_dict = recreate_matches(INT_DIR, OBS_DIR) -print(json.dumps(matches_dict, indent=4)) -GG(matches_dict, INT_DIR, OBS_DIR).run_gg() - - - - - - diff --git a/code/tests/.gitkeeper b/code/tests/.gitkeeper deleted file mode 100644 index e69de29..0000000 diff --git a/code/tests/.ipynb_checkpoints/gt3x-checkpoint.ipynb b/code/tests/.ipynb_checkpoints/gt3x-checkpoint.ipynb deleted file mode 100644 index 6451d30..0000000 --- a/code/tests/.ipynb_checkpoints/gt3x-checkpoint.ipynb +++ /dev/null @@ -1,100 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "b0951ddb-0d6b-4ac5-a801-821b030f9fd5", - "metadata": {}, - "source": [ - "# gt3x implementation of ggir\n", - "\n", - "## Goals \n", - "- provide a rough implementation of using gt3x in ggir\n", - "- allow for this to be run on argon" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "431867ff-c214-4b11-930b-77a045648ffd", - "metadata": {}, - "outputs": [], - "source": [ - "# imports\n", - "import os\n", - "import shutil" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "bd833fd5-7c65-4194-86ff-b0d0e4e43923", - "metadata": {}, - "outputs": [], - "source": [ - "# create a test environment on lss to add gt3x files\n", - "# initial variables\n", - "test_dir = \"/mnt/lss/Users/zak/ggir\"\n", - "example_files = [\"/mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/hinklin (2025-08-18).gt3x\", \"/mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/Andersen (2025-08-18).gt3x\", \"/mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/Voss (2025-08-18).gt3x\"]\n", - "subjects = [\"1\", \"2\", \"3\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "4ef5da28-42a3-43d8-8b1e-b3ecb148cb55", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "copying /mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/hinklin (2025-08-18).gt3x to /mnt/lss/Users/zak/ggir/sub-1_ses-#_accel.gt3x\n", - "copying /mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/Andersen (2025-08-18).gt3x to /mnt/lss/Users/zak/ggir/sub-2_ses-#_accel.gt3x\n", - "copying /mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/Voss (2025-08-18).gt3x to /mnt/lss/Users/zak/ggir/sub-3_ses-#_accel.gt3x\n" - ] - } - ], - "source": [ - "# copy the gt3x files from rdss to lss while renaming\n", - "new_files = []\n", - "counter = 0\n", - "while counter < 3:\n", - " for file in example_files:\n", - " new_files.append([file, f\"sub-{subjects[counter]}_ses-#_accel.gt3x\"])\n", - " counter += 1\n", - "for pair in new_files:\n", - " shutil.copy(pair[0], os.path.join(test_dir, pair[1]))\n", - " print(f\"copying {pair[0]} to {os.path.join(test_dir, pair[1])}\") " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2d17d6e9-8236-4145-ae31-75706b4874fa", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/code_tests/test_save_session.py b/code/tests/code_tests/test_save_session.py deleted file mode 100644 index 720c284..0000000 --- a/code/tests/code_tests/test_save_session.py +++ /dev/null @@ -1,167 +0,0 @@ -import datetime as dt -import sys -from pathlib import Path - -PROJECT_ROOT = Path(__file__).resolve().parents[3] -if str(PROJECT_ROOT) not in sys.path: - # Assumption: repository root is three levels above this file; append so stdlib modules (like 'code') stay ahead. - sys.path.append(str(PROJECT_ROOT)) - -import importlib -import types - -# Combine the stdlib `code` module with the project's `code/` package so we can import submodules -# without breaking tooling that expects pdb's InteractiveConsole, etc. -stdlib_code = importlib.import_module("code") -project_code_path = PROJECT_ROOT / "code" -merged_code = types.ModuleType("code") -merged_code.__dict__.update(stdlib_code.__dict__) -merged_code.__path__ = [str(project_code_path)] -sys.modules["code"] = merged_code - -import pytest - -from code.utils.save import Save - - -def _make_save(tmp_path: Path) -> Save: - """ - Construct a Save instance without invoking its __init__, wiring in temp directories. - """ - save = Save.__new__(Save) # Bypass __init__ to avoid RDSS/network side effects. - int_dir = tmp_path / "int" - obs_dir = tmp_path / "obs" - rdss_dir = tmp_path / "rdss" - for directory in (int_dir, obs_dir, rdss_dir): - directory.mkdir(parents=True, exist_ok=True) - - save.INT_DIR = str(int_dir) - save.OBS_DIR = str(obs_dir) - save.RDSS_DIR = str(rdss_dir) - save.matches = {} - save.dupes = [] - return save - - -def _touch_session_file(root: Path, subject_id: str, session: int) -> Path: - """ - Create a canonical session file for the given subject/session pair. - """ - file_path = ( - root - / f"sub-{subject_id}" - / "accel" - / f"ses-{session}" - / f"sub-{subject_id}_ses-{session}_accel.csv" - ) - file_path.parent.mkdir(parents=True, exist_ok=True) - file_path.touch() - return file_path - - -def test_determine_location_appends_after_existing_sessions(tmp_path: Path): - save = _make_save(tmp_path) - existing = _touch_session_file(Path(save.INT_DIR), "8001", 1) - assert existing.exists() - - matches = { - "8001": [ - {"study": "int", "run": 1, "date": dt.datetime(2024, 1, 1), "filename": "first.gt3x"}, - {"study": "int", "run": 2, "date": dt.datetime(2024, 1, 2), "filename": "second.gt3x"}, - ] - } - - updated = save._determine_location(matches) - sessions = {record["run"] for record in updated["8001"]} - # Expect the new sessions to start after the existing one. - assert sessions == {2, 3} - for record in updated["8001"]: - assert record["file_path"].endswith(f"ses-{record['run']}/sub-8001_ses-{record['run']}_accel.csv") - - -def test_determine_location_reuses_missing_session_numbers(tmp_path: Path): - save = _make_save(tmp_path) - # Pre-create session 2 only; session 1 should be reassigned to the first new run. - _touch_session_file(Path(save.INT_DIR), "8002", 2) - - matches = { - "8002": [ - {"study": "int", "run": 1, "date": dt.datetime(2024, 2, 1), "filename": "gap.gt3x"}, - ] - } - - updated = save._determine_location(matches) - record = updated["8002"][0] - assert record["run"] == 1 # Smallest available session should be reused. - assert record["file_path"].endswith("ses-1/sub-8002_ses-1_accel.csv") - - -def test_duplicate_merge_respects_existing_sessions(tmp_path: Path): - save = _make_save(tmp_path) - # Existing observational session 1 is missing; interventional already has session 1. - _touch_session_file(Path(save.INT_DIR), "8100", 1) - - duplicates = [ - { - "lab_id": "LAB-1", - "boost_id": "7005", - "filenames": ["obs_raw.gt3x"], - "dates": [dt.datetime(2024, 3, 1)], - }, - { - "lab_id": "LAB-1", - "boost_id": "8100", - "filenames": ["int_first.gt3x", "int_second.gt3x"], - "dates": [dt.datetime(2024, 3, 2), dt.datetime(2024, 3, 3)], - }, - ] - - merged = save._handle_and_merge_duplicates(duplicates) - - obs_records = merged["7005"] - int_records = merged["8100"] - - assert len(obs_records) == 1 - assert obs_records[0]["run"] == 1 - assert obs_records[0]["file_path"].endswith("ses-1/sub-7005_ses-1_accel.csv") - - # Interventional subject already had session 1; ensure we keep appending. - runs = sorted(record["run"] for record in int_records) - assert runs == [2, 3] - for record in int_records: - assert record["file_path"].endswith(f"ses-{record['run']}/sub-8100_ses-{record['run']}_accel.csv") - - -def test_duplicate_merge_when_observational_session_exists(tmp_path: Path): - save = _make_save(tmp_path) - # Pre-create both observational and interventional sessions to force all new files into INT. - _touch_session_file(Path(save.OBS_DIR), "7006", 1) - _touch_session_file(Path(save.INT_DIR), "8200", 1) - - duplicates = [ - { - "lab_id": "LAB-2", - "boost_id": "7006", - "filenames": ["existing_obs.gt3x"], - "dates": [dt.datetime(2024, 4, 1)], - }, - { - "lab_id": "LAB-2", - "boost_id": "8200", - "filenames": ["int_new.gt3x"], - "dates": [dt.datetime(2024, 4, 2)], - }, - ] - - merged = save._handle_and_merge_duplicates(duplicates) - - # No new observational records should be added because ses-1 exists. - assert "7006" not in merged or not merged["7006"] - - int_records = merged["8200"] - assert len(int_records) == 2 - runs = sorted(record["run"] for record in int_records) - # Existing INT session 1 should push the new runs to sessions 2 and 3. - assert runs == [2, 3] - for record in int_records: - assert record["file_path"].endswith(f"ses-{record['run']}/sub-8200_ses-{record['run']}_accel.csv") diff --git a/code/tests/conftest.py b/code/tests/conftest.py deleted file mode 100644 index 91d22d9..0000000 --- a/code/tests/conftest.py +++ /dev/null @@ -1,6 +0,0 @@ -import sys -from pathlib import Path - -REPO_ROOT = Path(__file__).resolve().parents[2] -if str(REPO_ROOT) not in sys.path: - sys.path.insert(0, str(REPO_ROOT)) diff --git a/code/tests/dsmc/.ipynb_checkpoints/dsmc-checkpoint.ipynb b/code/tests/dsmc/.ipynb_checkpoints/dsmc-checkpoint.ipynb deleted file mode 100644 index 363fcab..0000000 --- a/code/tests/dsmc/.ipynb_checkpoints/dsmc-checkpoint.ipynb +++ /dev/null @@ -1,6 +0,0 @@ -{ - "cells": [], - "metadata": {}, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/dsmc/.ipynb_checkpoints/int-checkpoint.csv b/code/tests/dsmc/.ipynb_checkpoints/int-checkpoint.csv deleted file mode 100644 index c1913fc..0000000 --- a/code/tests/dsmc/.ipynb_checkpoints/int-checkpoint.csv +++ /dev/null @@ -1,5 +0,0 @@ -,sub-8019,sub-8021,sub-8026,sub-8014,sub-8035,sub-8003,sub-8022,sub-8036,sub-8004,sub-8006,sub-8015,sub-8018,sub-8037,sub-8005,sub-8024,sub-8016,sub-8011,sub-8023,sub-8008 -sessions,2,1,2,1,1,2,4,1,2,2,1,2,1,2,1,2,2,1,2 -total_days,18,6,18,9,9,15,32,9,12,18,9,18,9,18,9,18,18,9,16 -weekdays,14,5,13,7,7,9,23,7,6,11,7,14,6,14,5,14,12,7,13 -weekends,4,1,5,2,2,6,9,2,6,7,2,4,3,4,4,4,6,2,3 diff --git a/code/tests/dsmc/.ipynb_checkpoints/obs-checkpoint.csv b/code/tests/dsmc/.ipynb_checkpoints/obs-checkpoint.csv deleted file mode 100644 index 2367932..0000000 --- a/code/tests/dsmc/.ipynb_checkpoints/obs-checkpoint.csv +++ /dev/null @@ -1,5 +0,0 @@ -,sub-7085,sub-7016,sub-7061,sub-7059,sub-7129,sub-7024,sub-7072,sub-7078,sub-7102,sub-7096,sub-6016,sub-7040,sub-7037,sub-7030,sub-7047,sub-7137,sub-6011,sub-7075,sub-7002,sub-7091,sub-7105,sub-7029,sub-7124,sub-7054,sub-7082,sub-7116,sub-7088,sub-7062,sub-7015,sub-7086,sub-7068,sub-7027,sub-7050,sub-7120,sub-7006,sub-7049,sub-7133,sub-7034,sub-7043,sub-6015,sub-6012,sub-6018,sub-7134,sub-7039,sub-7033,sub-6020,sub-7092,sub-7106,sub-7001,sub-7076,sub-7057,sub-7020,sub-7012,sub-7115,sub-7022,sub-7028,sub-7125,sub-7010,sub-7067,sub-7083,sub-7031,sub-6010,sub-7090,sub-7009,sub-7003,sub-6022,sub-7097,sub-7073,sub-7004,sub-6017,sub-7041,sub-7017,sub-7110,sub-7084,sub-7025,sub-7052,sub-7122,sub-7058,sub-7021,sub-7056,sub-7019,sub-7080,sub-7114,sub-7064,sub-6013,sub-7032,sub-7099,sub-7107,sub-7094,sub-7042,sub-7035,sub-7048,sub-7113,sub-7087,sub-7069,sub-7063,sub-7026 -sessions,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1 -total_days,7,7,7,7,7,6,7,7,7,7,7,7,5,7,7,6,18,7,7,7,7,5,7,7,7,7,7,7,7,8,6,7,7,7,7,7,7,7,14,6,7,7,7,6,7,7,7,7,6,7,5,7,7,7,7,7,7,7,7,8,7,7,7,7,7,6,7,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,14,6,8,7,7,6,7,7,7,8,7,7,7 -weekdays,5,5,5,5,4,5,5,5,4,4,5,5,3,5,5,5,12,5,5,5,4,3,5,5,5,5,5,5,5,6,5,5,5,4,5,5,5,5,10,4,5,5,5,4,5,5,4,4,5,5,5,5,5,5,5,5,5,5,5,6,5,5,4,5,5,4,4,4,4,5,5,5,4,4,5,5,4,5,5,5,5,5,4,5,10,4,5,4,5,4,5,5,4,6,5,5,5 -weekends,2,2,2,2,3,1,2,2,3,3,2,2,2,2,2,1,6,2,2,2,3,2,2,2,2,2,2,2,2,2,1,2,2,3,2,2,2,2,4,2,2,2,2,2,2,2,3,3,1,2,0,2,2,2,2,2,2,2,2,2,2,2,3,2,2,2,3,2,2,2,2,2,3,3,2,2,3,2,2,2,2,2,3,2,4,2,3,3,2,2,2,2,3,2,2,2,2 diff --git a/code/tests/dsmc/.ipynb_checkpoints/redcap-check-checkpoint.ipynb b/code/tests/dsmc/.ipynb_checkpoints/redcap-check-checkpoint.ipynb deleted file mode 100644 index 363fcab..0000000 --- a/code/tests/dsmc/.ipynb_checkpoints/redcap-check-checkpoint.ipynb +++ /dev/null @@ -1,6 +0,0 @@ -{ - "cells": [], - "metadata": {}, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/dsmc/.ipynb_checkpoints/test_rdss-checkpoint.py b/code/tests/dsmc/.ipynb_checkpoints/test_rdss-checkpoint.py deleted file mode 100644 index e69de29..0000000 diff --git a/code/tests/dsmc/dsmc.ipynb b/code/tests/dsmc/dsmc.ipynb deleted file mode 100644 index b4c6229..0000000 --- a/code/tests/dsmc/dsmc.ipynb +++ /dev/null @@ -1,292 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "41516cc1-a9ea-483c-afa3-4ac009fcf7dd", - "metadata": {}, - "source": [ - "# dsmc report for tuesday 07-something\n", - "\n", - "## requirements \n", - "- each subject and session\n", - "- calibration error\n", - "- total number of days\n", - "- total numbers of days and weekdays" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "d85fbf45-b14c-4b64-af55-baade17fb421", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd \n", - "import numpy as np\n", - "import os " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "587c5a88-c78a-4d55-8236-449f44b15cfc", - "metadata": {}, - "outputs": [], - "source": [ - "def extract_all_subjects(project):\n", - " file_appendage = 'accel/output_accel/results/part5_personsummary_MM_L44.8M100.6V428.8_T5A5.csv'\n", - " \n", - " if project == 'int':\n", - " base_path = '/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/derivatives/GGIR-3.2.6'\n", - " elif project == 'obs':\n", - " base_path = '/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6'\n", - " else:\n", - " raise ValueError(\"Invalid project; use 'int' or 'obs'.\")\n", - "\n", - " subject_data = {}\n", - "\n", - " for subject in os.listdir(base_path):\n", - " subject_path = os.path.join(base_path, subject, file_appendage)\n", - " if not os.path.isfile(subject_path):\n", - " continue\n", - "\n", - " try:\n", - " df = pd.read_csv(subject_path)\n", - " subject_data[subject] = {\n", - " 'sessions': len(df),\n", - " 'total_days': int(df['Nvaliddays'].sum()),\n", - " 'weekdays': int(df['Nvaliddays_WD'].sum()),\n", - " 'weekends': int(df['Nvaliddays_WE'].sum())\n", - " }\n", - " except Exception as e:\n", - " print(f\"Skipping {subject} due to error: {e}\")\n", - " continue\n", - "\n", - " return subject_data" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "02378f88-2eea-4019-bc4b-de46255b922f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'sub-8024': {'sessions': 1, 'total_days': 9, 'weekdays': 5, 'weekends': 4},\n", - " 'sub-8016': {'sessions': 2, 'total_days': 18, 'weekdays': 14, 'weekends': 4},\n", - " 'sub-8037': {'sessions': 1, 'total_days': 9, 'weekdays': 6, 'weekends': 3},\n", - " 'sub-8005': {'sessions': 2, 'total_days': 18, 'weekdays': 14, 'weekends': 4},\n", - " 'sub-8008': {'sessions': 2, 'total_days': 16, 'weekdays': 13, 'weekends': 3},\n", - " 'sub-8011': {'sessions': 2, 'total_days': 18, 'weekdays': 12, 'weekends': 6},\n", - " 'sub-8023': {'sessions': 1, 'total_days': 9, 'weekdays': 7, 'weekends': 2},\n", - " 'sub-8015': {'sessions': 1, 'total_days': 9, 'weekdays': 7, 'weekends': 2},\n", - " 'sub-8006': {'sessions': 2, 'total_days': 18, 'weekdays': 11, 'weekends': 7},\n", - " 'sub-8018': {'sessions': 2, 'total_days': 18, 'weekdays': 14, 'weekends': 4},\n", - " 'sub-8003': {'sessions': 2, 'total_days': 15, 'weekdays': 9, 'weekends': 6},\n", - " 'sub-8036': {'sessions': 1, 'total_days': 9, 'weekdays': 7, 'weekends': 2},\n", - " 'sub-8004': {'sessions': 2, 'total_days': 12, 'weekdays': 6, 'weekends': 6},\n", - " 'sub-8019': {'sessions': 2, 'total_days': 18, 'weekdays': 14, 'weekends': 4},\n", - " 'sub-8021': {'sessions': 1, 'total_days': 8, 'weekdays': 7, 'weekends': 1},\n", - " 'sub-8035': {'sessions': 1, 'total_days': 9, 'weekdays': 7, 'weekends': 2},\n", - " 'sub-8026': {'sessions': 2, 'total_days': 18, 'weekdays': 13, 'weekends': 5},\n", - " 'sub-8014': {'sessions': 1, 'total_days': 9, 'weekdays': 7, 'weekends': 2}}" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "int_result = extract_all_subjects('int')\n", - "int_result" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9dbde937-9872-4d32-b218-2bc65ae9d6c3", - "metadata": {}, - "outputs": [], - "source": [ - "obs_result = extract_all_subjects('obs')\n", - "obs_result" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "67e66df2-5678-4e8a-be23-846d903bea05", - "metadata": {}, - "outputs": [], - "source": [ - "int_result_df = pd.DataFrame(int_result)\n", - "obs_result_df = pd.DataFrame(obs_result)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a1ce77a7-1019-4e03-aa95-76712cb77c6a", - "metadata": {}, - "outputs": [], - "source": [ - "int_result_df.to_csv('./int.csv')\n", - "obs_result_df.to_csv('./obs.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c0aad536-c681-4b6a-a4d5-456e96a25874", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "def extract_all_subjects(project):\n", - " file_appendage = 'accel/output_accel/results/part5_personsummary_MM_L44.8M100.6V428.8_T5A5.csv'\n", - " \n", - " if project == 'int':\n", - " base_path = '/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/derivatives/GGIR-3.2.6'\n", - " elif project == 'obs':\n", - " base_path = '/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6'\n", - " else:\n", - " raise ValueError(\"Invalid project; use 'int' or 'obs'.\")\n", - "\n", - " subject_data = {}\n", - "\n", - " for subject in os.listdir(base_path):\n", - " subject_path = os.path.join(base_path, subject, file_appendage)\n", - " if not os.path.isfile(subject_path):\n", - " continue\n", - "\n", - " try:\n", - " df = pd.read_csv(subject_path)\n", - " sessions = []\n", - " for _, row in df.iterrows():\n", - " sessions.append({\n", - " 'session_id': row['ID'].split('_')[1],\n", - " 'calendar_date': row['calendar_date'],\n", - " 'total_days': int(row['Nvaliddays']),\n", - " 'weekdays': int(row['Nvaliddays_WD']),\n", - " 'weekends': int(row['Nvaliddays_WE'])\n", - " })\n", - " subject_data[subject] = sessions\n", - " except Exception as e:\n", - " print(f\"Skipping {subject} due to error: {e}\")\n", - " continue\n", - "\n", - " return subject_data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "66f16dbe-d934-40ca-869b-319d5c024459", - "metadata": {}, - "outputs": [], - "source": [ - "int_result = extract_all_subjects('int')\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5c7c77e4-21ca-47e0-8e2f-653d2098b097", - "metadata": {}, - "outputs": [], - "source": [ - "def sessions_to_dataframe(subject_data):\n", - " rows = []\n", - " for subject, sessions in subject_data.items():\n", - " for session in sessions:\n", - " row = {\n", - " 'subject': subject,\n", - " **session # unpack session fields into row\n", - " }\n", - " rows.append(row)\n", - " return pd.DataFrame(rows)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4f7627dd-80aa-4c2d-a1b0-2d594e7e9028", - "metadata": {}, - "outputs": [], - "source": [ - "data = extract_all_subjects('int')\n", - "df = sessions_to_dataframe(data)\n", - "print(df.head())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9ba2814a-c836-4095-9786-b19c5ef45a9b", - "metadata": {}, - "outputs": [], - "source": [ - "df.\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "34b16c98-c8db-428f-a835-ad6a1d7ca68e", - "metadata": {}, - "outputs": [], - "source": [ - "df.to_csv('./int.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e2bda535-0ce0-4cf7-8b4f-cd37fe33e2f4", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "18eeefd4-6e75-4ed8-836b-d28f213fc3bc", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2e6d6c1d-0e49-466c-9ad4-f7172ea30391", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/code/tests/dsmc/int.csv b/code/tests/dsmc/int.csv deleted file mode 100644 index ef82bad..0000000 --- a/code/tests/dsmc/int.csv +++ /dev/null @@ -1,5 +0,0 @@ -,sub-8024,sub-8016,sub-8037,sub-8005,sub-8008,sub-8011,sub-8023,sub-8015,sub-8006,sub-8018,sub-8003,sub-8036,sub-8004,sub-8019,sub-8021,sub-8035,sub-8026,sub-8014 -sessions,1,2,1,2,2,2,1,1,2,2,2,1,2,2,1,1,2,1 -total_days,9,18,9,18,16,18,9,9,18,18,15,9,12,18,8,9,18,9 -weekdays,5,14,6,14,13,12,7,7,11,14,9,7,6,14,7,7,13,7 -weekends,4,4,3,4,3,6,2,2,7,4,6,2,6,4,1,2,5,2 diff --git a/code/tests/dsmc/obs.csv b/code/tests/dsmc/obs.csv deleted file mode 100644 index b9322f7..0000000 --- a/code/tests/dsmc/obs.csv +++ /dev/null @@ -1,5 +0,0 @@ -,sub-7083,sub-7067,sub-7010,sub-7125,sub-7028,sub-7022,sub-6022,sub-7003,sub-7009,sub-7090,sub-6010,sub-7031,sub-7041,sub-6017,sub-7004,sub-7073,sub-7097,sub-7058,sub-7122,sub-7052,sub-7025,sub-7084,sub-7110,sub-7017,sub-7064,sub-7114,sub-7080,sub-7019,sub-7056,sub-7021,sub-7107,sub-7099,sub-7032,sub-6013,sub-7048,sub-7035,sub-7042,sub-7094,sub-7026,sub-7063,sub-7069,sub-7087,sub-7113,sub-7024,sub-7129,sub-7059,sub-7061,sub-7016,sub-7085,sub-7037,sub-7040,sub-6016,sub-7096,sub-7102,sub-7078,sub-7072,sub-7105,sub-7091,sub-7002,sub-7075,sub-6011,sub-7137,sub-7047,sub-7030,sub-7088,sub-7116,sub-7082,sub-7054,sub-7124,sub-7029,sub-7120,sub-7050,sub-7027,sub-7068,sub-7086,sub-7015,sub-6015,sub-7043,sub-7034,sub-7133,sub-7049,sub-7006,sub-7076,sub-7001,sub-7106,sub-7092,sub-6020,sub-7033,sub-7039,sub-7134,sub-6018,sub-6012,sub-7115,sub-7012,sub-7020,sub-7057 -sessions,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 -total_days,7,7,6,7,7,7,6,7,7,7,7,7,7,7,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,6,14,7,7,6,7,7,7,7,7,7,7,7,7,7,7,7,5,7,7,7,7,7,7,7,7,7,7,18,6,7,7,7,7,7,7,7,5,7,7,6,7,7,7,6,14,7,7,7,7,7,6,7,7,7,7,6,7,7,7,7,7,7,6 -weekdays,5,5,4,5,5,5,4,5,5,5,5,5,5,5,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,4,10,5,5,4,5,5,5,5,5,5,5,5,5,5,5,5,3,5,5,5,5,5,5,5,5,5,5,12,4,5,5,5,5,5,5,5,3,5,5,4,5,5,5,4,10,5,5,5,5,5,5,5,5,5,5,4,5,5,5,5,5,5,5 -weekends,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,4,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,6,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,4,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,1 diff --git a/code/tests/dsmc/qc_outs.md b/code/tests/dsmc/qc_outs.md deleted file mode 100644 index e69de29..0000000 diff --git a/code/tests/dsmc/redcap-check.ipynb b/code/tests/dsmc/redcap-check.ipynb deleted file mode 100644 index c99e7ba..0000000 --- a/code/tests/dsmc/redcap-check.ipynb +++ /dev/null @@ -1,841 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 47, - "id": "cb22edeb-3392-4c91-9b55-95866759218c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "' ID Date filename\\n0 1005 2022-05-10 1005 (2022-05-10)RAW.csv\\n1 1023 2022-04-30 1023 (2022-04-30)RAW.csv\\n2 1027 2022-04-26 1027 (2022-04-26)RAW.csv\\n3 1016 2022-03-23 1016 (2022-03-23)RAW.csv\\n4 994 2022-05-13 994 (2022-05-13)RAW.csv\\n... ... ... ...\\n1152 584 2018-09-15 584 (2018-09-15)RAW.csv\\n1153 584 2018-10-16 584 (2018-10-16)RAW.csv'" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import os\n", - "import sys\n", - "import logging\n", - "import pandas as pd\n", - "import requests\n", - "from datetime import datetime, timedelta\n", - "from io import StringIO\n", - "\n", - "class ID_COMPARISONS:\n", - " \n", - " def __init__(self, daysago=None) -> None:\n", - " self.token = 'DE4E2DB72778DACA9B8848574107D2F5'\n", - " self.INT_DIR = '/Volumes/vosslabhpc/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test'\n", - " self.OBS_DIR = '/Volumes/vosslabhpc/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test'\n", - " self.daysago = daysago\n", - " logging.basicConfig(level=logging.INFO, format=\"%(asctime)s - %(levelname)s - %(message)s\")\n", - "\n", - " def compare_ids(self):\n", - " \"\"\"\n", - " Pulls all files from RDSS\n", - " Pulls the list from RedCap\n", - " Compares IDs and returns a dictionary with two keys:\n", - " - 'matches': normal matches mapping boost_id to a list of dicts (filename, labID, date)\n", - " - 'duplicates': a list of dictionaries each with lab_id, boost_id, filenames (list), and dates (list)\n", - " \"\"\"\n", - " # Retrieve the RedCap report and duplicates from report\n", - " report, report_duplicates = self._return_report()\n", - " # Retrieve the full RDSS file list and duplicate files merged with duplicates from report\n", - " rdss, file_duplicates = self._rdss_file_list(report_duplicates, self.daysago)\n", - "\n", - " # Initialize the result dictionary for normal (non-duplicate) matches\n", - " result = {}\n", - "\n", - " # Iterate over the rows in the cleaned RedCap report\n", - " for _, row in report.iterrows():\n", - " boost_id = str(row['boost_id'])\n", - " lab_id = str(row['lab_id'])\n", - " \n", - " # Find matching files in the RDSS list\n", - " rdss_matches = rdss[rdss['ID'] == lab_id]\n", - " if not rdss_matches.empty:\n", - " if boost_id not in result:\n", - " result[boost_id] = []\n", - " for _, match_row in rdss_matches.iterrows():\n", - " result[boost_id].append({\n", - " 'filename': match_row['filename'],\n", - " 'labID': lab_id,\n", - " 'date': match_row['Date']\n", - " })\n", - " \n", - " # Process duplicates into the desired structure.\n", - " duplicates_dict = []\n", - " if not file_duplicates.empty:\n", - " # Group by lab_id and boost_id; each group represents one duplicate combination.\n", - " grouped = file_duplicates.groupby(['lab_id', 'boost_id'])\n", - " for (lab_id, boost_id), group in grouped:\n", - " duplicates_dict.append({\n", - " 'lab_id': lab_id,\n", - " 'boost_id': boost_id,\n", - " 'filenames': group['filename'].tolist(),\n", - " 'dates': group['Date'].tolist()\n", - " })\n", - " else:\n", - " logging.info(\"Found no duplicates.\")\n", - "\n", - " return {'matches': result, 'duplicates': duplicates_dict}, report\n", - "\n", - " def _return_report(self):\n", - " \"\"\"\n", - " pulls the id report from the rdss via redcap api.\n", - " reads the report as a dataframe.\n", - " checks for boost_ids that are associated with multiple lab_ids, logs a critical error,\n", - " and removes these rows from the dataframe.\n", - " separates duplicate rows (based on any column) from the cleaned data.\n", - " \n", - " returns:\n", - " df_cleaned: dataframe with duplicates removed and problematic boost_ids excluded\n", - " duplicate_rows: dataframe of duplicate rows\n", - " \"\"\"\n", - " url = 'https://redcap.icts.uiowa.edu/redcap/api/'\n", - " data = {\n", - " 'token': self.token,\n", - " 'content': 'report',\n", - " 'report_id': 43327,\n", - " 'format': 'csv'\n", - " }\n", - " r = requests.post(url, data=data)\n", - " if r.status_code != 200:\n", - " print(f\"error! status code is {r.status_code}\")\n", - " sys.exit(1)\n", - " \n", - " df = pd.read_csv(StringIO(r.text))\n", - " \n", - " # identify boost_ids associated with multiple lab_ids.\n", - " boost_id_counts = df.groupby('boost_id')['lab_id'].nunique()\n", - " problematic_boost_ids = boost_id_counts[boost_id_counts > 1].index.tolist()\n", - " \n", - " if problematic_boost_ids:\n", - " logging.critical(f\"found boost_id(s) with multiple lab_ids: {', '.join(map(str, problematic_boost_ids))}. \"\n", - " \"these entries will be removed from processing.\")\n", - " df = df[~df['boost_id'].isin(problematic_boost_ids)]\n", - " \n", - " # identify and separate duplicate rows based on any column.\n", - " duplicate_rows = df[df.duplicated(keep=False)]\n", - " df_cleaned = df.drop_duplicates(keep=False)\n", - " \n", - " if not duplicate_rows.empty:\n", - " logging.info(f\"duplicate rows found:\\n{duplicate_rows}\")\n", - " \n", - " return df_cleaned, duplicate_rows\n", - "\n", - " def _rdss_file_list(self, duplicates, daysago=None):\n", - " \"\"\"\n", - " extracts the first string before the space and the date from filenames ending with .csv\n", - " in the specified folder and stores them in a dataframe.\n", - " \n", - " Also, merges the file list with duplicate report entries based on lab_id.\n", - " \n", - " Returns:\n", - " df: DataFrame of all file entries\n", - " merged_df: DataFrame of file entries that match duplicate lab_ids from the report\n", - " \"\"\"\n", - " extracted_data = []\n", - "\n", - " # Loop through all files in the rdss_dir folder.\n", - " rdss_dir = '/mnt/rdss/VossLab/Repositories/Accelerometer_Data'\n", - " for filename in os.listdir(rdss_dir):\n", - " if filename.endswith('.csv'):\n", - " try:\n", - " base_name = filename.split(' ')[0] # Extract lab_id\n", - " date_part = filename.split('(')[1].split(')')[0] # Extract date\n", - " extracted_data.append({'ID': base_name, 'Date': date_part, 'filename': filename})\n", - " except IndexError:\n", - " print(f\"Skipping file with unexpected format: {filename}\")\n", - "\n", - " df = pd.DataFrame(extracted_data)\n", - "\n", - " if not df.empty:\n", - " df['Date'] = pd.to_datetime(df['Date'], errors='coerce')\n", - "\n", - " if daysago:\n", - " cutoff_date = datetime.today() - timedelta(days=daysago)\n", - " df = df[df['Date'] >= cutoff_date] # Filter files within the last `daysago` days\n", - " else:\n", - " df = df[df['Date'] >= '2024-08-05'] # Filter out rows before the threshold date\n", - "\n", - " # Filter the file list to only include rows where ID is in the duplicate report (if any)\n", - " if not duplicates.empty:\n", - " matched_df = df[df['ID'].isin(duplicates['lab_id'])]\n", - " # Merge with the duplicates to bring in boost_id information from the report\n", - " merged_df = matched_df.merge(duplicates, left_on='ID', right_on='lab_id')\n", - " else:\n", - " merged_df = pd.DataFrame()\n", - "\n", - " return df, merged_df\n", - "\n", - "\n", - "# REPORT EXAMPLE\n", - "\"\"\" lab_id boost_id\n", - "0 1023 8022\n", - "1 1043 7062\n", - "2 1093 6011\n", - "3 1097 6012\n", - "4 1098 6013\n", - ".. ... ...\n", - "90 1192 7058\n", - "91 1193 7059\n", - "\"\"\"\n", - "\n", - "\n", - "# RDSS EXAMPLE\n", - "\"\"\" ID Date filename\n", - "0 1005 2022-05-10 1005 (2022-05-10)RAW.csv\n", - "1 1023 2022-04-30 1023 (2022-04-30)RAW.csv\n", - "2 1027 2022-04-26 1027 (2022-04-26)RAW.csv\n", - "3 1016 2022-03-23 1016 (2022-03-23)RAW.csv\n", - "4 994 2022-05-13 994 (2022-05-13)RAW.csv\n", - "... ... ... ...\n", - "1152 584 2018-09-15 584 (2018-09-15)RAW.csv\n", - "1153 584 2018-10-16 584 (2018-10-16)RAW.csv\"\"\"\n", - "\n", - "# TOKEN FOR REFERENCE\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "id": "e2b57858-f8ba-45e2-a348-2cff64d9f2b6", - "metadata": {}, - "outputs": [], - "source": [ - "I = ID_COMPARISONS(daysago=499)" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "id": "010883f2-2107-4fc6-9258-ab839ae86e9c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2025-08-01 10:37:35,204 - CRITICAL - found boost_id(s) with multiple lab_ids: 7023. these entries will be removed from processing.\n", - "2025-08-01 10:37:49,049 - INFO - Found no duplicates.\n" - ] - } - ], - "source": [ - "matches, report = I.compare_ids()" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "id": "32ba158c-2d71-4ee8-90e3-7b69182455f8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "174" - ] - }, - "execution_count": 67, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(matches['matches'])" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "a40aad2e-2c7d-428d-b9d2-c97a42bcf947", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "40\n" - ] - } - ], - "source": [ - "num_subjects = sum(1 for sid in matches['matches'] if sid.startswith('8'))\n", - "print(num_subjects)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "458d4b74-8b19-43d1-acb3-32600aac443f", - "metadata": {}, - "outputs": [], - "source": [ - "int = pd.read_csv('./int.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "id": "ea5c06d9-992b-4f95-a221-08612d0ee8b7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Unnamed: 0sub-8024sub-8016sub-8037sub-8005sub-8008sub-8011sub-8023sub-8015sub-8006sub-8018sub-8003sub-8036sub-8004sub-8019sub-8021sub-8035sub-8026sub-8014
0sessions121222112221221121
1total_days9189181618991818159121889189
2weekdays51461413127711149761477137
3weekends443436227462641252
\n", - "
" - ], - "text/plain": [ - " Unnamed: 0 sub-8024 sub-8016 sub-8037 sub-8005 sub-8008 sub-8011 \\\n", - "0 sessions 1 2 1 2 2 2 \n", - "1 total_days 9 18 9 18 16 18 \n", - "2 weekdays 5 14 6 14 13 12 \n", - "3 weekends 4 4 3 4 3 6 \n", - "\n", - " sub-8023 sub-8015 sub-8006 sub-8018 sub-8003 sub-8036 sub-8004 \\\n", - "0 1 1 2 2 2 1 2 \n", - "1 9 9 18 18 15 9 12 \n", - "2 7 7 11 14 9 7 6 \n", - "3 2 2 7 4 6 2 6 \n", - "\n", - " sub-8019 sub-8021 sub-8035 sub-8026 sub-8014 \n", - "0 2 1 1 2 1 \n", - "1 18 8 9 18 9 \n", - "2 14 7 7 13 7 \n", - "3 4 1 2 5 2 " - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "int" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "d345e994-4c67-4a5a-b616-69abab6d294f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(4, 19)" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "int.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "b6b16227-d091-42be-a4a2-595bcf68831d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
lab_idboost_id
010238022
110407183
210437062
310517146
410936011
.........
26614027205
26714037206
26814047207
26914057208
27014067209
\n", - "

269 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " lab_id boost_id\n", - "0 1023 8022\n", - "1 1040 7183\n", - "2 1043 7062\n", - "3 1051 7146\n", - "4 1093 6011\n", - ".. ... ...\n", - "266 1402 7205\n", - "267 1403 7206\n", - "268 1404 7207\n", - "269 1405 7208\n", - "270 1406 7209\n", - "\n", - "[269 rows x 2 columns]" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "report" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "e504fcd5-cfe2-4900-87d4-cbb7842b68f6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 8022\n", - "29 8001\n", - "30 8002\n", - "31 8003\n", - "32 8004\n", - "33 8007\n", - "34 8006\n", - "39 8005\n", - "50 8008\n", - "53 8009\n", - "54 8010\n", - "55 8011\n", - "58 8012\n", - "59 8013\n", - "60 8014\n", - "62 8015\n", - "63 8016\n", - "65 8017\n", - "67 8018\n", - "68 8019\n", - "69 8020\n", - "70 8021\n", - "84 8023\n", - "85 8024\n", - "87 8025\n", - "93 8026\n", - "97 8028\n", - "98 8029\n", - "99 8030\n", - "100 8031\n", - "117 8032\n", - "138 8033\n", - "139 8034\n", - "140 8035\n", - "162 8036\n", - "165 8037\n", - "174 8038\n", - "180 8039\n", - "182 8043\n", - "183 8040\n", - "184 8045\n", - "185 8041\n", - "186 8042\n", - "196 8046\n", - "201 8047\n", - "202 8048\n", - "206 8050\n", - "208 8051\n", - "210 8052\n", - "211 8053\n", - "212 8054\n", - "234 8055\n", - "237 8056\n", - "238 8057\n", - "239 8058\n", - "240 8059\n", - "241 8060\n", - "259 8061\n", - "Name: boost_id, dtype: object" - ] - }, - "execution_count": 78, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "report = report[report['boost_id'].astype(str).str.startswith('8')]\n", - "boost_ids = report['boost_id']\n", - "boost_ids" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "id": "c84945e0-eacd-4bea-bbed-9f14afb000f5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['8022',\n", - " '8001',\n", - " '8002',\n", - " '8003',\n", - " '8004',\n", - " '8006',\n", - " '8005',\n", - " '8008',\n", - " '8011',\n", - " '8012',\n", - " '8014',\n", - " '8015',\n", - " '8016',\n", - " '8017',\n", - " '8018',\n", - " '8019',\n", - " '8020',\n", - " '8021',\n", - " '8023',\n", - " '8024',\n", - " '8026',\n", - " '8030',\n", - " '8032',\n", - " '8035',\n", - " '8036',\n", - " '8037',\n", - " '8038',\n", - " '8039',\n", - " '8040',\n", - " '8042',\n", - " '8046',\n", - " '8047',\n", - " '8048',\n", - " '8050',\n", - " '8051',\n", - " '8052',\n", - " '8053',\n", - " '8054',\n", - " '8056',\n", - " '8060']" - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "int_matches = matches['matches']\n", - "\n", - "subject_keys = [k for k in int_matches.keys() if k.startswith('8')]\n", - "subject_keys" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "id": "459016fc-30df-4cd6-b10a-4a3f558eb4af", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Column 1 dtype: object\n", - "First 10 values: ['8022', '8001', '8002', '8003', '8004', '8007', '8006', '8005', '8008', '8009']\n", - "IDs in subject_keys but not in df col1 (0): []\n" - ] - } - ], - "source": [ - "# 1) Extract the “column 1” IDs properly:\n", - "# If `boost_ids` is a DataFrame:\n", - "col1 = boost_ids\n", - "\n", - "# 2) Inspect its dtype and contents\n", - "print(\"Column 1 dtype:\", col1.dtype)\n", - "print(\"First 10 values:\", col1.head(10).tolist())\n", - "\n", - "# 3) Normalize to strings (and strip whitespace)\n", - "# If it’s a float dtype (e.g. 6022.0), cast to int first:\n", - "if pd.api.types.is_float_dtype(col1):\n", - " col1 = col1.dropna().astype(int).astype(str)\n", - "else:\n", - " col1 = col1.astype(str)\n", - "\n", - "df_ids = [s.strip() for s in col1.tolist()]\n", - "\n", - "# 4) Also strip your subject_keys\n", - "subject_keys = [s.strip() for s in subject_keys]\n", - "\n", - "# 5) Now do a set difference\n", - "missing = sorted(set(subject_keys) - set(df_ids))\n", - "print(f\"IDs in subject_keys but not in df col1 ({len(missing)}):\", missing)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "id": "4ebcdbe9-5ac5-45d4-b87f-8d2f35cde086", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "In list only: []\n", - "In series only: ['8007', '8031', '8055', '8025', '8041', '8013', '8029', '8058', '8010', '8033', '8043', '8034', '8045', '8028', '8057', '8009', '8059', '8061']\n" - ] - } - ], - "source": [ - "# 1) Normalize both to sets of strings\n", - "boost_set = set(boost_ids.astype(str))\n", - "subject_set = set(subject_keys)\n", - "\n", - "# 2a) IDs in the list but NOT in the Series\n", - "missing_in_series = list(subject_set - boost_set)\n", - "print(\"In list only: \", missing_in_series)\n", - "\n", - "# 2b) IDs in the Series but NOT in the list\n", - "missing_in_list = list(boost_set - subject_set)\n", - "print(\"In series only: \", missing_in_list)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "074f652b-a5f1-476c-ae1b-87278a8f7107", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/dsmc/test_rdss.py b/code/tests/dsmc/test_rdss.py deleted file mode 100644 index e69de29..0000000 diff --git a/code/tests/gt3x.ipynb b/code/tests/gt3x.ipynb deleted file mode 100644 index 6451d30..0000000 --- a/code/tests/gt3x.ipynb +++ /dev/null @@ -1,100 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "b0951ddb-0d6b-4ac5-a801-821b030f9fd5", - "metadata": {}, - "source": [ - "# gt3x implementation of ggir\n", - "\n", - "## Goals \n", - "- provide a rough implementation of using gt3x in ggir\n", - "- allow for this to be run on argon" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "431867ff-c214-4b11-930b-77a045648ffd", - "metadata": {}, - "outputs": [], - "source": [ - "# imports\n", - "import os\n", - "import shutil" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "bd833fd5-7c65-4194-86ff-b0d0e4e43923", - "metadata": {}, - "outputs": [], - "source": [ - "# create a test environment on lss to add gt3x files\n", - "# initial variables\n", - "test_dir = \"/mnt/lss/Users/zak/ggir\"\n", - "example_files = [\"/mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/hinklin (2025-08-18).gt3x\", \"/mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/Andersen (2025-08-18).gt3x\", \"/mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/Voss (2025-08-18).gt3x\"]\n", - "subjects = [\"1\", \"2\", \"3\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "4ef5da28-42a3-43d8-8b1e-b3ecb148cb55", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "copying /mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/hinklin (2025-08-18).gt3x to /mnt/lss/Users/zak/ggir/sub-1_ses-#_accel.gt3x\n", - "copying /mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/Andersen (2025-08-18).gt3x to /mnt/lss/Users/zak/ggir/sub-2_ses-#_accel.gt3x\n", - "copying /mnt/rdss/VossLab/Repositories/Accelerometer_Data/RawFiles/RawGT3X_Files/Voss (2025-08-18).gt3x to /mnt/lss/Users/zak/ggir/sub-3_ses-#_accel.gt3x\n" - ] - } - ], - "source": [ - "# copy the gt3x files from rdss to lss while renaming\n", - "new_files = []\n", - "counter = 0\n", - "while counter < 3:\n", - " for file in example_files:\n", - " new_files.append([file, f\"sub-{subjects[counter]}_ses-#_accel.gt3x\"])\n", - " counter += 1\n", - "for pair in new_files:\n", - " shutil.copy(pair[0], os.path.join(test_dir, pair[1]))\n", - " print(f\"copying {pair[0]} to {os.path.join(test_dir, pair[1])}\") " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2d17d6e9-8236-4145-ae31-75706b4874fa", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/gt3x/.ipynb_checkpoints/diff-checkpoint.ipynb b/code/tests/gt3x/.ipynb_checkpoints/diff-checkpoint.ipynb deleted file mode 100644 index 1bd54f1..0000000 --- a/code/tests/gt3x/.ipynb_checkpoints/diff-checkpoint.ipynb +++ /dev/null @@ -1,1866 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "9499cc7b-a31d-4a21-8ccd-09e8bd5b38b4", - "metadata": {}, - "source": [ - "# Differences between sampling rates\n", - "\n", - "> this file will be used to look at the QUANTITATIVE differences between the 60Hz sampling rate and the 1Hz" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "5d05c911-3861-4f7b-bf5c-0c171ec1425b", - "metadata": {}, - "outputs": [], - "source": [ - "import os \n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "e80185cc-0806-44b9-85a1-f64fec130e4b", - "metadata": {}, - "outputs": [], - "source": [ - "# build the filepaths and dataframes\n", - "subjects = [\"sub-7059\", \"sub-7058\", \"sub-7057\"]\n", - "def insert(sub):\n", - " return f\"/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6-test-ncp-sleep2/{sub}/accel/output_accel/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv\"\n", - "sixty_hz_file = \"/mnt/lss/Users/zak/out/output_ggir/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv\"" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "283c230c-ec5c-4cc5-bd5a-80e054d3aab8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6-test-ncp-sleep2/sub-7059/accel/output_accel/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv',\n", - " '/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6-test-ncp-sleep2/sub-7058/accel/output_accel/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv',\n", - " '/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6-test-ncp-sleep2/sub-7057/accel/output_accel/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv']" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "original_files = []\n", - "for sub in subjects:\n", - " original_files.append(insert(sub))\n", - "original_files" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "426b633a-cce7-4983-a19e-3196dd423441", - "metadata": {}, - "outputs": [], - "source": [ - "original_dfs = []\n", - "for file in original_files:\n", - " df = pd.read_csv(file)\n", - " original_dfs.append(df)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "d9aeb46e-8523-4a18-ab86-07e4f7c79c1c", - "metadata": {}, - "outputs": [], - "source": [ - "activity_cycles = [\n", - " 'dur_spt_sleep_min',\n", - " 'dur_day_total_IN_min',\n", - " 'dur_day_total_LIG_min',\n", - " 'dur_day_total_MOD_min',\n", - " 'dur_day_total_VIG_min',\n", - " 'ID',\n", - " 'calendar_date'\n", - "]\n", - "if original_dfs:\n", - " original_dfs = [df[activity_cycles] for df in original_dfs]" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "597d9676-252a-4953-9c42-97628dc2a828", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dur_spt_sleep_mindur_day_total_IN_mindur_day_total_LIG_mindur_day_total_MOD_mindur_day_total_VIG_minIDcalendar_date
00.000728.333108.91732.0830.667sub-7057_ses-1_accel2025-02-16
1229.000956.250156.66751.2500.500sub-7057_ses-1_accel2025-02-17
2481.000605.083117.583109.5831.917sub-7057_ses-1_accel2025-02-18
3262.417939.000133.08374.4170.750sub-7057_ses-1_accel2025-02-19
4391.667729.917119.583101.6670.500sub-7057_ses-1_accel2025-02-20
5179.750854.167169.25044.0000.750sub-7057_ses-1_accel2025-02-21
6184.750998.833122.250109.5831.917sub-7058_ses-1_accel2025-02-21
7463.667527.250208.500135.0832.667sub-7058_ses-1_accel2025-02-22
8407.500738.417173.16793.8331.333sub-7058_ses-1_accel2025-02-23
9452.500700.500134.833100.7503.167sub-7058_ses-1_accel2025-02-24
10432.750665.083151.500119.5836.167sub-7058_ses-1_accel2025-02-25
11423.250727.500160.417114.7502.583sub-7058_ses-1_accel2025-02-26
12337.250837.000151.08387.0830.583sub-7058_ses-1_accel2025-02-27
13188.667879.000147.833199.5008.583sub-7059_ses-1_accel2025-02-25
14420.167721.333124.417150.0001.167sub-7059_ses-1_accel2025-02-26
15271.417758.583126.583224.33316.333sub-7059_ses-1_accel2025-02-27
16369.583764.917130.167144.2500.750sub-7059_ses-1_accel2025-02-28
17453.000622.333155.083168.16715.417sub-7059_ses-1_accel2025-03-01
18298.583918.083129.25087.2500.667sub-7059_ses-1_accel2025-03-02
19363.250762.083122.583133.58314.667sub-7059_ses-1_accel2025-03-03
\n", - "
" - ], - "text/plain": [ - " dur_spt_sleep_min dur_day_total_IN_min dur_day_total_LIG_min \\\n", - "0 0.000 728.333 108.917 \n", - "1 229.000 956.250 156.667 \n", - "2 481.000 605.083 117.583 \n", - "3 262.417 939.000 133.083 \n", - "4 391.667 729.917 119.583 \n", - "5 179.750 854.167 169.250 \n", - "6 184.750 998.833 122.250 \n", - "7 463.667 527.250 208.500 \n", - "8 407.500 738.417 173.167 \n", - "9 452.500 700.500 134.833 \n", - "10 432.750 665.083 151.500 \n", - "11 423.250 727.500 160.417 \n", - "12 337.250 837.000 151.083 \n", - "13 188.667 879.000 147.833 \n", - "14 420.167 721.333 124.417 \n", - "15 271.417 758.583 126.583 \n", - "16 369.583 764.917 130.167 \n", - "17 453.000 622.333 155.083 \n", - "18 298.583 918.083 129.250 \n", - "19 363.250 762.083 122.583 \n", - "\n", - " dur_day_total_MOD_min dur_day_total_VIG_min ID \\\n", - "0 32.083 0.667 sub-7057_ses-1_accel \n", - "1 51.250 0.500 sub-7057_ses-1_accel \n", - "2 109.583 1.917 sub-7057_ses-1_accel \n", - "3 74.417 0.750 sub-7057_ses-1_accel \n", - "4 101.667 0.500 sub-7057_ses-1_accel \n", - "5 44.000 0.750 sub-7057_ses-1_accel \n", - "6 109.583 1.917 sub-7058_ses-1_accel \n", - "7 135.083 2.667 sub-7058_ses-1_accel \n", - "8 93.833 1.333 sub-7058_ses-1_accel \n", - "9 100.750 3.167 sub-7058_ses-1_accel \n", - "10 119.583 6.167 sub-7058_ses-1_accel \n", - "11 114.750 2.583 sub-7058_ses-1_accel \n", - "12 87.083 0.583 sub-7058_ses-1_accel \n", - "13 199.500 8.583 sub-7059_ses-1_accel \n", - "14 150.000 1.167 sub-7059_ses-1_accel \n", - "15 224.333 16.333 sub-7059_ses-1_accel \n", - "16 144.250 0.750 sub-7059_ses-1_accel \n", - "17 168.167 15.417 sub-7059_ses-1_accel \n", - "18 87.250 0.667 sub-7059_ses-1_accel \n", - "19 133.583 14.667 sub-7059_ses-1_accel \n", - "\n", - " calendar_date \n", - "0 2025-02-16 \n", - "1 2025-02-17 \n", - "2 2025-02-18 \n", - "3 2025-02-19 \n", - "4 2025-02-20 \n", - "5 2025-02-21 \n", - "6 2025-02-21 \n", - "7 2025-02-22 \n", - "8 2025-02-23 \n", - "9 2025-02-24 \n", - "10 2025-02-25 \n", - "11 2025-02-26 \n", - "12 2025-02-27 \n", - "13 2025-02-25 \n", - "14 2025-02-26 \n", - "15 2025-02-27 \n", - "16 2025-02-28 \n", - "17 2025-03-01 \n", - "18 2025-03-02 \n", - "19 2025-03-03 " - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "new_df = pd.read_csv(sixty_hz_file)\n", - "new_df = new_df[new_df['ID'].isin(['sub-7057_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7059_ses-1_accel'])]\n", - "new_df = new_df[activity_cycles]\n", - "new_df.reset_index(drop=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "a06846d6-5c18-4185-b0d6-eed3fdbe1bff", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dur_spt_sleep_mindur_day_total_IN_mindur_day_total_LIG_mindur_day_total_MOD_mindur_day_total_VIG_minIDcalendar_date
18188.667879.000147.833199.5008.583sub-7059_ses-1_accel2025-02-25
19420.167721.333124.417150.0001.167sub-7059_ses-1_accel2025-02-26
20271.417758.583126.583224.33316.333sub-7059_ses-1_accel2025-02-27
21369.583764.917130.167144.2500.750sub-7059_ses-1_accel2025-02-28
22453.000622.333155.083168.16715.417sub-7059_ses-1_accel2025-03-01
\n", - "
" - ], - "text/plain": [ - " dur_spt_sleep_min dur_day_total_IN_min dur_day_total_LIG_min \\\n", - "18 188.667 879.000 147.833 \n", - "19 420.167 721.333 124.417 \n", - "20 271.417 758.583 126.583 \n", - "21 369.583 764.917 130.167 \n", - "22 453.000 622.333 155.083 \n", - "\n", - " dur_day_total_MOD_min dur_day_total_VIG_min ID \\\n", - "18 199.500 8.583 sub-7059_ses-1_accel \n", - "19 150.000 1.167 sub-7059_ses-1_accel \n", - "20 224.333 16.333 sub-7059_ses-1_accel \n", - "21 144.250 0.750 sub-7059_ses-1_accel \n", - "22 168.167 15.417 sub-7059_ses-1_accel \n", - "\n", - " calendar_date \n", - "18 2025-02-25 \n", - "19 2025-02-26 \n", - "20 2025-02-27 \n", - "21 2025-02-28 \n", - "22 2025-03-01 " - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "new_dfs = []\n", - "for eyed in new_df['ID'].unique():\n", - " new_dfs.append(new_df[new_df['ID']==eyed])\n", - "for df in new_dfs:\n", - " df = df.reset_index(drop=True)\n", - "new_dfs[2].head()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "1b78e2f3-ad5d-4b9a-9050-7d05fe3c8a9a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "First paired original DataFrame:\n", - "Empty DataFrame\n", - "Columns: [dur_spt_sleep_min, dur_day_total_IN_min, dur_day_total_LIG_min, dur_day_total_MOD_min, dur_day_total_VIG_min, ID, calendar_date]\n", - "Index: []\n", - "\n", - "First paired new DataFrame:\n", - "Empty DataFrame\n", - "Columns: [dur_spt_sleep_min, dur_day_total_IN_min, dur_day_total_LIG_min, dur_day_total_MOD_min, dur_day_total_VIG_min, ID, calendar_date]\n", - "Index: []\n" - ] - } - ], - "source": [ - "# Initialize a list to store the paired and filtered DataFrames\n", - "paired_dfs = []\n", - "\n", - "# Iterate through the DataFrames in original_dfs and new_dfs\n", - "for orig_df, new_df in zip(original_dfs, new_dfs):\n", - " # Ensure both DataFrames have the required columns\n", - " if 'ID' in orig_df.columns and 'calendar_date' in orig_df.columns and \\\n", - " 'ID' in new_df.columns and 'calendar_date' in new_df.columns:\n", - " \n", - " # Merge DataFrames on 'ID' to create pairs\n", - " merged_df = pd.merge(orig_df, new_df, on='ID', suffixes=('_orig', '_new'))\n", - " \n", - " # Find common calendar dates\n", - " common_dates = set(orig_df['calendar_date']).intersection(set(new_df['calendar_date']))\n", - " \n", - " # Filter rows where calendar_date is in both DataFrames\n", - " filtered_orig = orig_df[orig_df['calendar_date'].isin(common_dates)].copy()\n", - " filtered_new = new_df[new_df['calendar_date'].isin(common_dates)].copy()\n", - " \n", - " # Store the filtered DataFrames as a pair\n", - " paired_dfs.append((filtered_orig, filtered_new))\n", - " else:\n", - " print(f\"Warning: One or both DataFrames lack 'ID' or 'calendar_date' columns\")\n", - "\n", - "# Example: Inspect the first pair\n", - "if paired_dfs:\n", - " print(\"First paired original DataFrame:\")\n", - " print(paired_dfs[0][0])\n", - " print(\"\\nFirst paired new DataFrame:\")\n", - " print(paired_dfs[0][1])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "22c8285a-1bc1-426e-a95a-ab6225fa4987", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "--- Pair 1 ---\n", - "\n", - "orig dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "orig ID sample: ['sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel']\n", - "orig date sample: ['2025-02-25', '2025-02-26', '2025-02-27', '2025-02-28', '2025-03-01']\n", - "orig nunique IDs: 1, nunique dates: 7\n", - "\n", - "new dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "new ID sample: ['sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel']\n", - "new date sample: ['2025-02-16', '2025-02-17', '2025-02-18', '2025-02-19', '2025-02-20']\n", - "new nunique IDs: 1, nunique dates: 6\n", - "ID overlap size: 0\n", - "\n", - "--- Pair 2 ---\n", - "\n", - "orig dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "orig ID sample: ['sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel']\n", - "orig date sample: ['2025-02-21', '2025-02-22', '2025-02-23', '2025-02-24', '2025-02-25']\n", - "orig nunique IDs: 1, nunique dates: 7\n", - "\n", - "new dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "new ID sample: ['sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel']\n", - "new date sample: ['2025-02-21', '2025-02-22', '2025-02-23', '2025-02-24', '2025-02-25']\n", - "new nunique IDs: 1, nunique dates: 7\n", - "ID overlap size: 1\n", - "\n", - "--- Pair 3 ---\n", - "\n", - "orig dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "orig ID sample: ['sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel']\n", - "orig date sample: ['2025-02-16', '2025-02-17', '2025-02-18', '2025-02-19', '2025-02-20']\n", - "orig nunique IDs: 1, nunique dates: 6\n", - "\n", - "new dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "new ID sample: ['sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel']\n", - "new date sample: ['2025-02-25', '2025-02-26', '2025-02-27', '2025-02-28', '2025-03-01']\n", - "new nunique IDs: 1, nunique dates: 7\n", - "ID overlap size: 0\n" - ] - } - ], - "source": [ - "def peek(df, name):\n", - " print(f\"\\n{name} dtypes:\\n\", df.dtypes)\n", - " print(f\"{name} ID sample:\", df['ID'].astype(str).head().tolist())\n", - " print(f\"{name} date sample:\", df['calendar_date'].head().tolist())\n", - " print(f\"{name} nunique IDs: {df['ID'].nunique()}, nunique dates: {df['calendar_date'].nunique()}\")\n", - "\n", - "for i,(orig_df,new_df) in enumerate(zip(original_dfs,new_dfs),1):\n", - " print(f\"\\n--- Pair {i} ---\")\n", - " peek(orig_df, \"orig\")\n", - " peek(new_df, \"new\")\n", - " print(\"ID overlap size:\", len(set(orig_df['ID'].astype(str)) & set(new_df['ID'].astype(str))))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "183b5847-6dff-4018-976a-a1d5be64073f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Original index 0 filtered head:\n", - " dur_spt_sleep_min_orig dur_day_total_IN_min_orig \\\n", - "0 271.000 655.250 \n", - "1 420.167 727.250 \n", - "2 270.917 765.167 \n", - "3 369.583 767.167 \n", - "4 453.167 618.667 \n", - "\n", - " dur_day_total_LIG_min_orig dur_day_total_MOD_min_orig \\\n", - "0 139.00 200.083 \n", - "1 114.25 154.000 \n", - "2 114.75 226.583 \n", - "3 123.75 148.250 \n", - "4 149.50 175.250 \n", - "\n", - " dur_day_total_VIG_min_orig ID calendar_date \n", - "0 10.000 sub-7059_ses-1_accel 2025-02-25 \n", - "1 1.417 sub-7059_ses-1_accel 2025-02-26 \n", - "2 19.333 sub-7059_ses-1_accel 2025-02-27 \n", - "3 0.917 sub-7059_ses-1_accel 2025-02-28 \n", - "4 17.583 sub-7059_ses-1_accel 2025-03-01 \n", - "\n", - "New index 2 filtered head:\n", - " dur_spt_sleep_min_new dur_day_total_IN_min_new dur_day_total_LIG_min_new \\\n", - "0 188.667 879.000 147.833 \n", - "1 420.167 721.333 124.417 \n", - "2 271.417 758.583 126.583 \n", - "3 369.583 764.917 130.167 \n", - "4 453.000 622.333 155.083 \n", - "\n", - " dur_day_total_MOD_min_new dur_day_total_VIG_min_new ID \\\n", - "0 199.500 8.583 sub-7059_ses-1_accel \n", - "1 150.000 1.167 sub-7059_ses-1_accel \n", - "2 224.333 16.333 sub-7059_ses-1_accel \n", - "3 144.250 0.750 sub-7059_ses-1_accel \n", - "4 168.167 15.417 sub-7059_ses-1_accel \n", - "\n", - " calendar_date \n", - "0 2025-02-25 \n", - "1 2025-02-26 \n", - "2 2025-02-27 \n", - "3 2025-02-28 \n", - "4 2025-03-01 \n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "def _clean(df):\n", - " df = df.copy()\n", - " if 'ID' not in df.columns or 'calendar_date' not in df.columns:\n", - " return None\n", - " df['ID'] = df['ID'].astype(str).str.strip()\n", - " df['calendar_date'] = pd.to_datetime(df['calendar_date'], errors='coerce').dt.normalize()\n", - " return df.dropna(subset=['calendar_date'])\n", - "\n", - "def _overlap_score(o, n):\n", - " # score by per-ID date matches (strongest signal of the right pair)\n", - " common_ids = set(o['ID']) & set(n['ID'])\n", - " if not common_ids:\n", - " return 0\n", - " score = 0\n", - " for cid in list(common_ids):\n", - " od = set(o.loc[o['ID'] == cid, 'calendar_date'])\n", - " nd = set(n.loc[n['ID'] == cid, 'calendar_date'])\n", - " score += len(od & nd)\n", - " # tie-breaker: add small weight for ID overlap size\n", - " score += 0.001 * len(common_ids)\n", - " return score\n", - "\n", - "def pair_and_filter_unordered(original_dfs, new_dfs, verbose=True):\n", - " # clean all upfront\n", - " O = [(_clean(df), i) for i, df in enumerate(original_dfs)]\n", - " N = [(_clean(df), j) for j, df in enumerate(new_dfs)]\n", - " O = [(df,i) for df,i in O if df is not None]\n", - " N = [(df,j) for df,j in N if df is not None]\n", - "\n", - " used_new = set()\n", - " pairs = []\n", - " for o_df, oi in O:\n", - " # find best matching new_df not yet used\n", - " best = (-1, None, None) # (score, n_df, nj)\n", - " for n_df, nj in N:\n", - " if nj in used_new:\n", - " continue\n", - " s = _overlap_score(o_df, n_df)\n", - " if s > best[0]:\n", - " best = (s, n_df, nj)\n", - "\n", - " score, n_df, nj = best\n", - " if score <= 0 or n_df is None:\n", - " if verbose:\n", - " print(f\"[warn] No viable match for original_dfs[{oi}] (no ID+date overlap).\")\n", - " continue\n", - "\n", - " used_new.add(nj)\n", - "\n", - " # inner-join on both keys to enforce alignment\n", - " merged = pd.merge(\n", - " o_df, n_df,\n", - " on=['ID', 'calendar_date'],\n", - " how='inner',\n", - " suffixes=('_orig', '_new')\n", - " )\n", - "\n", - " if merged.empty and verbose:\n", - " # breadcrumbs to help debug\n", - " id_overlap = set(o_df['ID']) & set(n_df['ID'])\n", - " date_overlap = set(o_df['calendar_date']) & set(n_df['calendar_date'])\n", - " print(f\"[info] Matched oi={oi} → nj={nj} (score={score:.3f}) \"\n", - " f\"but inner merge empty. ID overlap={len(id_overlap)}, \"\n", - " f\"global date overlap={len(date_overlap)}.\")\n", - "\n", - " # split back to two filtered views if you want that API\n", - " filtered_orig = merged[[c for c in merged.columns if c.endswith('_orig')] + ['ID', 'calendar_date']]\n", - " filtered_new = merged[[c for c in merged.columns if c.endswith('_new')] + ['ID', 'calendar_date']]\n", - " pairs.append(((oi, filtered_orig), (nj, filtered_new)))\n", - "\n", - " return pairs\n", - "\n", - "# Usage:\n", - "paired_dfs = pair_and_filter_unordered(original_dfs, new_dfs, verbose=True)\n", - "\n", - "# Example inspect:\n", - "if paired_dfs:\n", - " (oi, fo), (nj, fn) = paired_dfs[0]\n", - " print(f\"Original index {oi} filtered head:\\n\", fo.head())\n", - " print(f\"\\nNew index {nj} filtered head:\\n\", fn.head())\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "0e75aa69-fd80-4504-aa02-708c32a162f7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[done] Created 3 plot(s).\n" - ] - } - ], - "source": [ - "\n", - "# metrics to compare\n", - "DUR_COLS = [\n", - " \"dur_spt_sleep_min\",\n", - " \"dur_day_total_IN_min\",\n", - " \"dur_day_total_LIG_min\",\n", - " \"dur_day_total_MOD_min\",\n", - " \"dur_day_total_VIG_min\",\n", - "]\n", - "def plot_dur_differences(pairs, outdir=None, show=True):\n", - " \"\"\"\n", - " pairs: list of ((orig_idx, filtered_orig_df), (new_idx, filtered_new_df))\n", - " as returned by pair_and_filter_unordered(...)\n", - " outdir: optional directory to save PNGs. If None, files aren't saved.\n", - " show: whether to plt.show() each figure.\n", - " \"\"\"\n", - " if outdir:\n", - " os.makedirs(outdir, exist_ok=True)\n", - "\n", - " made = 0\n", - " for (oi, fo), (nj, fn) in pairs:\n", - " if fo.empty or fn.empty:\n", - " print(f\"[skip] Empty filtered DataFrame for pair oi={oi}, nj={nj}\")\n", - " continue\n", - "\n", - " # Merge the two filtered views back together on keys\n", - " merged = pd.merge(\n", - " fo, fn,\n", - " on=[\"ID\", \"calendar_date\"],\n", - " how=\"inner\",\n", - " suffixes=(\"_orig\", \"_new\")\n", - " )\n", - " if merged.empty:\n", - " print(f\"[skip] Inner merge empty for pair oi={oi}, nj={nj}\")\n", - " continue\n", - "\n", - " # Ensure datetime + sort\n", - " merged[\"calendar_date\"] = pd.to_datetime(merged[\"calendar_date\"], errors=\"coerce\")\n", - " merged = merged.dropna(subset=[\"calendar_date\"]).sort_values(\"calendar_date\")\n", - "\n", - " # Build a tidy delta frame: date index, columns = metrics, values = (new - orig)\n", - " delta = pd.DataFrame({\"calendar_date\": merged[\"calendar_date\"].values})\n", - " for col in DUR_COLS:\n", - " ocol = f\"{col}_orig\"\n", - " ncol = f\"{col}_new\"\n", - " # if a metric is missing on either side, fill with NaN to avoid KeyError\n", - " if ocol not in merged.columns or ncol not in merged.columns:\n", - " delta[col] = pd.NA\n", - " else:\n", - " delta[col] = merged[ncol] - merged[ocol]\n", - " delta = delta.set_index(\"calendar_date\")\n", - "\n", - " # Figure title bits\n", - " ids = merged[\"ID\"].dropna().unique().tolist()\n", - " id_label = ids[0] if len(ids) == 1 else f\"{len(ids)} IDs\"\n", - " title = f\"Δ (new − orig) by date • Pair oi={oi} → nj={nj} • {id_label}\"\n", - "\n", - " # Plot — one chart per pair, multiple lines (one per metric)\n", - " plt.figure(figsize=(10, 5))\n", - " for col in DUR_COLS:\n", - " if col in delta.columns:\n", - " # Let matplotlib choose default styles/colors; don't specify colors.\n", - " plt.plot(delta.index, delta[col], marker=\"o\", label=col)\n", - "\n", - " plt.axhline(0, linewidth=1)\n", - " plt.title(title)\n", - " plt.xlabel(\"calendar_date\")\n", - " plt.ylabel(\"Minutes (Δ new − orig)\")\n", - " plt.legend()\n", - " plt.tight_layout()\n", - "\n", - " # Save if requested\n", - " if outdir:\n", - " # Safe filename: include oi, nj, and (optionally) single ID\n", - " safe_id = ids[0] if len(ids) == 1 else \"multi\"\n", - " fname = f\"pair_{oi}_to_{nj}_{safe_id}.png\"\n", - " path = os.path.join(outdir, fname)\n", - " plt.savefig(path, dpi=150)\n", - " print(f\"[saved] {path}\")\n", - "\n", - " if show:\n", - " plt.show()\n", - " else:\n", - " plt.close()\n", - "\n", - " made += 1\n", - "\n", - " print(f\"[done] Created {made} plot(s).\")\n", - "\n", - "# Example usage:\n", - "plot_dur_differences(paired_dfs, show=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "3034c9e1-f723-4958-b8c5-8234d5fbeace", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['Subject', 'Filename', 'Epoch', 'Weight (lbs)', 'Age', 'Gender', 'Date',\n", - " 'Day of Week', 'Day of Week Num',\n", - " 'Number of Freedson (1998) Bouts occurring in this day',\n", - " 'Number of Freedson (1998) Bouts starting in this day',\n", - " 'Number of Freedson (1998) Bouts ending in this day',\n", - " 'Total time of Freedson (1998) Bouts occurring in this day',\n", - " 'Total activity counts of Freedson (1998) Bouts occurring in this day',\n", - " 'Number of Sedentary Bouts occurring in this day',\n", - " 'Number of Sedentary Bouts starting in this day',\n", - " 'Number of Sedentary Bouts ending in this day',\n", - " 'Total time of Sedentary Bouts occurring in this day',\n", - " 'Number of Sedentary Breaks occurring in this day',\n", - " 'Number of Sedentary Breaks starting in this day',\n", - " 'Number of Sedentary Breaks ending in this day',\n", - " 'Total time of Sedentary Breaks occurring in this day', 'Sedentary',\n", - " 'Light', 'Moderate', 'Vigorous', 'Very Vigorous', '% in Sedentary',\n", - " '% in Light', '% in Moderate', '% in Vigorous', '% in Very Vigorous',\n", - " 'Total MVPA', '% in MVPA', 'Average MVPA Per Hour', 'Axis 1 Counts',\n", - " 'Axis 2 Counts', 'Axis 3 Counts', 'Axis 1 Average Counts',\n", - " 'Axis 2 Average Counts', 'Axis 3 Average Counts', 'Axis 1 Max Counts',\n", - " 'Axis 2 Max Counts', 'Axis 3 Max Counts', 'Axis 1 CPM', 'Axis 2 CPM',\n", - " 'Axis 3 CPM', 'Vector Magnitude Counts',\n", - " 'Vector Magnitude Average Counts', 'Vector Magnitude Max Counts',\n", - " 'Vector Magnitude CPM', 'Steps Counts', 'Steps Average Counts',\n", - " 'Steps Max Counts', 'Steps Per Minute', 'Lux Average Counts',\n", - " 'Lux Max Counts', 'Number of Epochs', 'Time', 'Calendar Days'],\n", - " dtype='object')" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "actilife5097 = pd.read_csv(\"/mnt/rdss/VossLab/Repositories/Accelerometer_Data/Test/1192_2-21-2025_Activity.xlsx/1192_2-21-2025_Activity_DailyDetailed.csv\")\n", - "actilife5097.columns" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "5debd00d-8b96-44ff-b759-7c6d49009698", - "metadata": {}, - "outputs": [], - "source": [ - "actilife5097 = actilife5097[['Date', 'Sedentary', 'Light', 'Moderate', 'Vigorous', 'Very Vigorous']]\n", - "actilife5097.to_clipboard()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "852b37c4-226f-47ea-9f87-05695e0818b4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dur_day_total_IN_mindur_day_total_LIG_mindur_day_total_MOD_mindur_day_total_VIG_minIDcalendar_date
11998.833122.250109.5831.917sub-7058_ses-1_accel2025-02-21
12527.250208.500135.0832.667sub-7058_ses-1_accel2025-02-22
13738.417173.16793.8331.333sub-7058_ses-1_accel2025-02-23
14700.500134.833100.7503.167sub-7058_ses-1_accel2025-02-24
15665.083151.500119.5836.167sub-7058_ses-1_accel2025-02-25
16727.500160.417114.7502.583sub-7058_ses-1_accel2025-02-26
17837.000151.08387.0830.583sub-7058_ses-1_accel2025-02-27
\n", - "
" - ], - "text/plain": [ - " dur_day_total_IN_min dur_day_total_LIG_min dur_day_total_MOD_min \\\n", - "11 998.833 122.250 109.583 \n", - "12 527.250 208.500 135.083 \n", - "13 738.417 173.167 93.833 \n", - "14 700.500 134.833 100.750 \n", - "15 665.083 151.500 119.583 \n", - "16 727.500 160.417 114.750 \n", - "17 837.000 151.083 87.083 \n", - "\n", - " dur_day_total_VIG_min ID calendar_date \n", - "11 1.917 sub-7058_ses-1_accel 2025-02-21 \n", - "12 2.667 sub-7058_ses-1_accel 2025-02-22 \n", - "13 1.333 sub-7058_ses-1_accel 2025-02-23 \n", - "14 3.167 sub-7058_ses-1_accel 2025-02-24 \n", - "15 6.167 sub-7058_ses-1_accel 2025-02-25 \n", - "16 2.583 sub-7058_ses-1_accel 2025-02-26 \n", - "17 0.583 sub-7058_ses-1_accel 2025-02-27 " - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_5097 = new_dfs[1]\n", - "test_5097 = test_5097.drop(columns=['dur_spt_sleep_min'])\n", - "test_5097.to_clipboard()\n", - "test_5097" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "a911397d-f3b2-4c78-9505-20a0608dc87d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
DateSedentaryLightModerateVigorousVery Vigorous
02/21/202577348917100
12/22/202564750428900
22/23/202568957617500
32/24/202573056914100
42/25/202562460421200
52/26/202567258018800
62/27/202566661116300
\n", - "
" - ], - "text/plain": [ - " Date Sedentary Light Moderate Vigorous Very Vigorous\n", - "0 2/21/2025 773 489 171 0 0\n", - "1 2/22/2025 647 504 289 0 0\n", - "2 2/23/2025 689 576 175 0 0\n", - "3 2/24/2025 730 569 141 0 0\n", - "4 2/25/2025 624 604 212 0 0\n", - "5 2/26/2025 672 580 188 0 0\n", - "6 2/27/2025 666 611 163 0 0" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "actilife5097" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "7703767c-f0ce-4621-9b8d-61275e86f98e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "def compare_activity_dfs(df1_raw: pd.DataFrame, df2_raw: pd.DataFrame, show_plot=True):\n", - " \"\"\"\n", - " df1_raw columns (example):\n", - " ['Date','Sedentary','Light','Moderate','Vigorous','Very Vigorous']\n", - " df2_raw columns:\n", - " ['dur_day_total_IN_min','dur_day_total_LIG_min','dur_day_total_MOD_min',\n", - " 'dur_day_total_VIG_min','ID','calendar_date']\n", - "\n", - " Notes:\n", - " - Sedentary ↔ IN\n", - " - VIG in df1 is Vigorous + Very Vigorous\n", - " - Differences are computed as: df2 (second table) − df1 (first table)\n", - " \"\"\"\n", - "\n", - " # --- standardize df1 to df2 schema ---\n", - " df1 = df1_raw.copy()\n", - " # parse date\n", - " df1['calendar_date'] = pd.to_datetime(df1['Date'], errors='coerce').dt.normalize()\n", - " # create minutes columns comparable to df2\n", - " df1_std = pd.DataFrame({\n", - " 'calendar_date': df1['calendar_date'],\n", - " 'dur_day_total_IN_min': pd.to_numeric(df1['Sedentary'], errors='coerce'),\n", - " 'dur_day_total_LIG_min': pd.to_numeric(df1['Light'], errors='coerce'),\n", - " 'dur_day_total_MOD_min': pd.to_numeric(df1['Moderate'], errors='coerce'),\n", - " 'dur_day_total_VIG_min': pd.to_numeric(df1['Vigorous'], errors='coerce') \\\n", - " + pd.to_numeric(df1['Very Vigorous'], errors='coerce'),\n", - " })\n", - "\n", - " # --- standardize df2 ---\n", - " df2 = df2_raw.copy()\n", - " df2['calendar_date'] = pd.to_datetime(df2['calendar_date'], errors='coerce').dt.normalize()\n", - " # keep only comparable columns\n", - " keep = ['calendar_date','dur_day_total_IN_min','dur_day_total_LIG_min',\n", - " 'dur_day_total_MOD_min','dur_day_total_VIG_min']\n", - " df2_std = df2[keep].copy()\n", - "\n", - " # --- compare only matching dates (inner merge on date) ---\n", - " merged = pd.merge(df1_std, df2_std, on='calendar_date', how='inner', suffixes=('_df1','_df2'))\n", - " merged = merged.sort_values('calendar_date')\n", - "\n", - " # If nothing matches, return empty and warn\n", - " if merged.empty:\n", - " print(\"[warn] No matching dates between the two dataframes after standardization.\")\n", - " return merged, merged\n", - "\n", - " # --- build differences: df2 − df1 ---\n", - " diffs = pd.DataFrame({'calendar_date': merged['calendar_date']})\n", - " cols = ['dur_day_total_IN_min','dur_day_total_LIG_min','dur_day_total_MOD_min','dur_day_total_VIG_min']\n", - " for c in cols:\n", - " diffs[c + '_diff'] = merged[c + '_df2'] - merged[c + '_df1']\n", - "\n", - " # --- plot differences over time (one chart, one line per activity) ---\n", - " if show_plot:\n", - " plt.figure(figsize=(10, 5))\n", - " for c in cols:\n", - " plt.plot(diffs['calendar_date'], diffs[c + '_diff'], marker='o', label=c.replace('dur_day_total_','').replace('_min','').upper())\n", - " plt.axhline(0, linewidth=1)\n", - " plt.title(\"Per-day differences (SECOND − FIRST) in minutes\")\n", - " plt.xlabel(\"Date\")\n", - " plt.ylabel(\"Minutes (difference)\")\n", - " plt.legend()\n", - " plt.tight_layout()\n", - " plt.show()\n", - "\n", - " # Also return a tidy differences table per day\n", - " return merged, diffs\n", - "merged_aligned, diffs = compare_activity_dfs(actilife5097, test_5097, show_plot=True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "28533759-d236-46eb-96b8-df0acdc85ce5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " calendar_date dur_day_total_IN_min_diff dur_day_total_LIG_min_diff \\\n", - "0 2025-02-21 225.833 -366.750 \n", - "1 2025-02-22 -119.750 -295.500 \n", - "2 2025-02-23 49.417 -402.833 \n", - "3 2025-02-24 -29.500 -434.167 \n", - "4 2025-02-25 41.083 -452.500 \n", - "5 2025-02-26 55.500 -419.583 \n", - "6 2025-02-27 171.000 -459.917 \n", - "\n", - " dur_day_total_MOD_min_diff dur_day_total_VIG_min_diff \n", - "0 -61.417 1.917 \n", - "1 -153.917 2.667 \n", - "2 -81.167 1.333 \n", - "3 -40.250 3.167 \n", - "4 -92.417 6.167 \n", - "5 -73.250 2.583 \n", - "6 -75.917 0.583 \n" - ] - } - ], - "source": [ - "print(diffs)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "c24c7c85-afcd-47f7-be4f-f26959cd635e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
subdateinligmodvig
0sub-1_ses-1_accel2025-08-1833026000
1sub-1_ses-1_accel2025-08-194502901200
2sub-1_ses-1_accel2025-08-20480385300
3sub-2_ses-1_accel2025-08-1857015000
4sub-2_ses-1_accel2025-08-1981018000
5sub-2_ses-1_accel2025-08-208106000
6sub-3_ses-1_accel2025-08-18390180600
7sub-3_ses-1_accel2025-08-1966039000
8sub-3_ses-1_accel2025-08-20330720600
\n", - "
" - ], - "text/plain": [ - " sub date in lig mod vig\n", - "0 sub-1_ses-1_accel 2025-08-18 330 260 0 0\n", - "1 sub-1_ses-1_accel 2025-08-19 450 290 120 0\n", - "2 sub-1_ses-1_accel 2025-08-20 480 385 30 0\n", - "3 sub-2_ses-1_accel 2025-08-18 570 150 0 0\n", - "4 sub-2_ses-1_accel 2025-08-19 810 180 0 0\n", - "5 sub-2_ses-1_accel 2025-08-20 810 60 0 0\n", - "6 sub-3_ses-1_accel 2025-08-18 390 180 60 0\n", - "7 sub-3_ses-1_accel 2025-08-19 660 390 0 0\n", - "8 sub-3_ses-1_accel 2025-08-20 330 720 60 0" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# quantify the times given in the google sheet into a df\n", - "ground_truth = pd.read_csv(\"ground_truth.csv\")\n", - "ground_truth" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "12378800-8be2-4040-86c4-66f4586410ea", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'\\nlocations for actilife numbers\\n/mnt/rdss/VossLab/Repositories/Accelerometer_Data/ActivityFiles/Andersen_8-18-2025_Activity.xlsx\\n/mnt/rdss/VossLab/Repositories/Accelerometer_Data/ActivityFiles/Hinklin_8-18-2025_Activity.xlsx\\n/mnt/rdss/VossLab/Repositories/Accelerometer_Data/ActivityFiles/Voss_8-18-2025_Activity.xlsx\\n'" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"\n", - "locations for actilife numbers\n", - "/mnt/rdss/VossLab/Repositories/Accelerometer_Data/ActivityFiles/Andersen_8-18-2025_Activity.xlsx\n", - "/mnt/rdss/VossLab/Repositories/Accelerometer_Data/ActivityFiles/Hinklin_8-18-2025_Activity.xlsx\n", - "/mnt/rdss/VossLab/Repositories/Accelerometer_Data/ActivityFiles/Voss_8-18-2025_Activity.xlsx\n", - "\"\"\"\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "2e8b7999-0327-41cc-862f-fb504414ec18", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IDfilenameweekdaycalendar_datewindow_numberstart_end_windowsleeponsetsleeponset_tswakeupwakeup_ts...Nblocks_day_total_VIGboutcriter.inboutcriter.ligboutcriter.mvpaboutdur.inboutdur.ligboutdur.mvpaGGIRversionlastDatedaytype
0sub-1_ses-1_accelsub-1_ses-1_accel.gt3xTuesday2025-08-19200:00:00-23:59:5522.22522:13:3030.88206:52:55...1250.90.80.830_20_1010_5_110_5_13.2.62025-08-21WD
1sub-2_ses-1_accelsub-2_ses-1_accel.gt3xTuesday2025-08-19200:00:00-23:59:5522.58122:34:5031.61007:36:35...190.90.80.830_20_1010_5_110_5_13.2.62025-08-21WD
2sub-2_ses-1_accelsub-2_ses-1_accel.gt3xWednesday2025-08-20300:00:00-23:59:55NaNNaN32.27608:16:35...30.90.80.830_20_1010_5_110_5_13.2.62025-08-21WD
3sub-3_ses-1_accelsub-3_ses-1_accel.gt3xTuesday2025-08-19200:00:00-23:59:5521.52821:31:4028.35004:21:00...30.90.80.830_20_1010_5_110_5_13.2.62025-08-21WD
4sub-3_ses-1_accelsub-3_ses-1_accel.gt3xWednesday2025-08-20300:00:00-23:59:55NaNNaN27.77103:46:15...70.90.80.830_20_1010_5_110_5_13.2.62025-08-21WD
\n", - "

5 rows × 116 columns

\n", - "
" - ], - "text/plain": [ - " ID filename weekday calendar_date \\\n", - "0 sub-1_ses-1_accel sub-1_ses-1_accel.gt3x Tuesday 2025-08-19 \n", - "1 sub-2_ses-1_accel sub-2_ses-1_accel.gt3x Tuesday 2025-08-19 \n", - "2 sub-2_ses-1_accel sub-2_ses-1_accel.gt3x Wednesday 2025-08-20 \n", - "3 sub-3_ses-1_accel sub-3_ses-1_accel.gt3x Tuesday 2025-08-19 \n", - "4 sub-3_ses-1_accel sub-3_ses-1_accel.gt3x Wednesday 2025-08-20 \n", - "\n", - " window_number start_end_window sleeponset sleeponset_ts wakeup \\\n", - "0 2 00:00:00-23:59:55 22.225 22:13:30 30.882 \n", - "1 2 00:00:00-23:59:55 22.581 22:34:50 31.610 \n", - "2 3 00:00:00-23:59:55 NaN NaN 32.276 \n", - "3 2 00:00:00-23:59:55 21.528 21:31:40 28.350 \n", - "4 3 00:00:00-23:59:55 NaN NaN 27.771 \n", - "\n", - " wakeup_ts ... Nblocks_day_total_VIG boutcriter.in boutcriter.lig \\\n", - "0 06:52:55 ... 125 0.9 0.8 \n", - "1 07:36:35 ... 19 0.9 0.8 \n", - "2 08:16:35 ... 3 0.9 0.8 \n", - "3 04:21:00 ... 3 0.9 0.8 \n", - "4 03:46:15 ... 7 0.9 0.8 \n", - "\n", - " boutcriter.mvpa boutdur.in boutdur.lig boutdur.mvpa GGIRversion \\\n", - "0 0.8 30_20_10 10_5_1 10_5_1 3.2.6 \n", - "1 0.8 30_20_10 10_5_1 10_5_1 3.2.6 \n", - "2 0.8 30_20_10 10_5_1 10_5_1 3.2.6 \n", - "3 0.8 30_20_10 10_5_1 10_5_1 3.2.6 \n", - "4 0.8 30_20_10 10_5_1 10_5_1 3.2.6 \n", - "\n", - " lastDate daytype \n", - "0 2025-08-21 WD \n", - "1 2025-08-21 WD \n", - "2 2025-08-21 WD \n", - "3 2025-08-21 WD \n", - "4 2025-08-21 WD \n", - "\n", - "[5 rows x 116 columns]" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tests = pd.read_csv(sixty_hz_file)\n", - "tests = tests[tests['ID'].isin(['sub-1_ses-1_accel','sub-2_ses-1_accel','sub-3_ses-1_accel'])]\n", - "tests" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e12944b1-653e-45a4-ab38-972ec4d6fa7d", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/gt3x/.ipynb_checkpoints/sleeplogs-checkpoint.ipynb b/code/tests/gt3x/.ipynb_checkpoints/sleeplogs-checkpoint.ipynb deleted file mode 100644 index 363fcab..0000000 --- a/code/tests/gt3x/.ipynb_checkpoints/sleeplogs-checkpoint.ipynb +++ /dev/null @@ -1,6 +0,0 @@ -{ - "cells": [], - "metadata": {}, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/gt3x/diff.ipynb b/code/tests/gt3x/diff.ipynb deleted file mode 100644 index 6d1728d..0000000 --- a/code/tests/gt3x/diff.ipynb +++ /dev/null @@ -1,1483 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "9499cc7b-a31d-4a21-8ccd-09e8bd5b38b4", - "metadata": {}, - "source": [ - "# Differences between sampling rates\n", - "\n", - "> this file will be used to look at the QUANTITATIVE differences between the 60Hz sampling rate and the 1Hz" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "5d05c911-3861-4f7b-bf5c-0c171ec1425b", - "metadata": {}, - "outputs": [], - "source": [ - "import os \n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "e80185cc-0806-44b9-85a1-f64fec130e4b", - "metadata": {}, - "outputs": [], - "source": [ - "# build the filepaths and dataframes\n", - "subjects = [\"sub-7059\", \"sub-7058\", \"sub-7057\"]\n", - "def insert(sub):\n", - " return f\"/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6/{sub}/accel/output_accel/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv\"\n", - "sixty_hz_file = \"/mnt/lss/Users/zak/out/output_ggir/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv\"" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "283c230c-ec5c-4cc5-bd5a-80e054d3aab8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6/sub-7059/accel/output_accel/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv',\n", - " '/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6/sub-7058/accel/output_accel/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv',\n", - " '/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/derivatives/GGIR-3.2.6/sub-7057/accel/output_accel/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv']" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "original_files = []\n", - "for sub in subjects:\n", - " original_files.append(insert(sub))\n", - "original_files" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "426b633a-cce7-4983-a19e-3196dd423441", - "metadata": {}, - "outputs": [], - "source": [ - "original_dfs = []\n", - "for file in original_files:\n", - " df = pd.read_csv(file)\n", - " original_dfs.append(df)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "d9aeb46e-8523-4a18-ab86-07e4f7c79c1c", - "metadata": {}, - "outputs": [], - "source": [ - "activity_cycles = [\n", - " 'dur_spt_sleep_min',\n", - " 'dur_day_total_IN_min',\n", - " 'dur_day_total_LIG_min',\n", - " 'dur_day_total_MOD_min',\n", - " 'dur_day_total_VIG_min',\n", - " 'ID',\n", - " 'calendar_date'\n", - "]\n", - "if original_dfs:\n", - " original_dfs = [df[activity_cycles] for df in original_dfs]" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "597d9676-252a-4953-9c42-97628dc2a828", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dur_spt_sleep_mindur_day_total_IN_mindur_day_total_LIG_mindur_day_total_MOD_mindur_day_total_VIG_minIDcalendar_date
00.000728.333108.91732.0830.667sub-7057_ses-1_accel2025-02-16
1229.000956.250156.66751.2500.500sub-7057_ses-1_accel2025-02-17
2481.000605.083117.583109.5831.917sub-7057_ses-1_accel2025-02-18
3262.417939.000133.08374.4170.750sub-7057_ses-1_accel2025-02-19
4391.667729.917119.583101.6670.500sub-7057_ses-1_accel2025-02-20
5179.750854.167169.25044.0000.750sub-7057_ses-1_accel2025-02-21
6184.750998.833122.250109.5831.917sub-7058_ses-1_accel2025-02-21
7463.667527.250208.500135.0832.667sub-7058_ses-1_accel2025-02-22
8407.500738.417173.16793.8331.333sub-7058_ses-1_accel2025-02-23
9452.500700.500134.833100.7503.167sub-7058_ses-1_accel2025-02-24
10432.750665.083151.500119.5836.167sub-7058_ses-1_accel2025-02-25
11423.250727.500160.417114.7502.583sub-7058_ses-1_accel2025-02-26
12337.250837.000151.08387.0830.583sub-7058_ses-1_accel2025-02-27
13188.667879.000147.833199.5008.583sub-7059_ses-1_accel2025-02-25
14420.167721.333124.417150.0001.167sub-7059_ses-1_accel2025-02-26
15271.417758.583126.583224.33316.333sub-7059_ses-1_accel2025-02-27
16369.583764.917130.167144.2500.750sub-7059_ses-1_accel2025-02-28
17453.000622.333155.083168.16715.417sub-7059_ses-1_accel2025-03-01
18298.583918.083129.25087.2500.667sub-7059_ses-1_accel2025-03-02
19363.250762.083122.583133.58314.667sub-7059_ses-1_accel2025-03-03
\n", - "
" - ], - "text/plain": [ - " dur_spt_sleep_min dur_day_total_IN_min dur_day_total_LIG_min \\\n", - "0 0.000 728.333 108.917 \n", - "1 229.000 956.250 156.667 \n", - "2 481.000 605.083 117.583 \n", - "3 262.417 939.000 133.083 \n", - "4 391.667 729.917 119.583 \n", - "5 179.750 854.167 169.250 \n", - "6 184.750 998.833 122.250 \n", - "7 463.667 527.250 208.500 \n", - "8 407.500 738.417 173.167 \n", - "9 452.500 700.500 134.833 \n", - "10 432.750 665.083 151.500 \n", - "11 423.250 727.500 160.417 \n", - "12 337.250 837.000 151.083 \n", - "13 188.667 879.000 147.833 \n", - "14 420.167 721.333 124.417 \n", - "15 271.417 758.583 126.583 \n", - "16 369.583 764.917 130.167 \n", - "17 453.000 622.333 155.083 \n", - "18 298.583 918.083 129.250 \n", - "19 363.250 762.083 122.583 \n", - "\n", - " dur_day_total_MOD_min dur_day_total_VIG_min ID \\\n", - "0 32.083 0.667 sub-7057_ses-1_accel \n", - "1 51.250 0.500 sub-7057_ses-1_accel \n", - "2 109.583 1.917 sub-7057_ses-1_accel \n", - "3 74.417 0.750 sub-7057_ses-1_accel \n", - "4 101.667 0.500 sub-7057_ses-1_accel \n", - "5 44.000 0.750 sub-7057_ses-1_accel \n", - "6 109.583 1.917 sub-7058_ses-1_accel \n", - "7 135.083 2.667 sub-7058_ses-1_accel \n", - "8 93.833 1.333 sub-7058_ses-1_accel \n", - "9 100.750 3.167 sub-7058_ses-1_accel \n", - "10 119.583 6.167 sub-7058_ses-1_accel \n", - "11 114.750 2.583 sub-7058_ses-1_accel \n", - "12 87.083 0.583 sub-7058_ses-1_accel \n", - "13 199.500 8.583 sub-7059_ses-1_accel \n", - "14 150.000 1.167 sub-7059_ses-1_accel \n", - "15 224.333 16.333 sub-7059_ses-1_accel \n", - "16 144.250 0.750 sub-7059_ses-1_accel \n", - "17 168.167 15.417 sub-7059_ses-1_accel \n", - "18 87.250 0.667 sub-7059_ses-1_accel \n", - "19 133.583 14.667 sub-7059_ses-1_accel \n", - "\n", - " calendar_date \n", - "0 2025-02-16 \n", - "1 2025-02-17 \n", - "2 2025-02-18 \n", - "3 2025-02-19 \n", - "4 2025-02-20 \n", - "5 2025-02-21 \n", - "6 2025-02-21 \n", - "7 2025-02-22 \n", - "8 2025-02-23 \n", - "9 2025-02-24 \n", - "10 2025-02-25 \n", - "11 2025-02-26 \n", - "12 2025-02-27 \n", - "13 2025-02-25 \n", - "14 2025-02-26 \n", - "15 2025-02-27 \n", - "16 2025-02-28 \n", - "17 2025-03-01 \n", - "18 2025-03-02 \n", - "19 2025-03-03 " - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "new_df = pd.read_csv(sixty_hz_file)\n", - "new_df = new_df[new_df['ID'].isin(['sub-7057_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7059_ses-1_accel'])]\n", - "new_df = new_df[activity_cycles]\n", - "new_df.reset_index(drop=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "a06846d6-5c18-4185-b0d6-eed3fdbe1bff", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
dur_spt_sleep_mindur_day_total_IN_mindur_day_total_LIG_mindur_day_total_MOD_mindur_day_total_VIG_minIDcalendar_date
18188.667879.000147.833199.5008.583sub-7059_ses-1_accel2025-02-25
19420.167721.333124.417150.0001.167sub-7059_ses-1_accel2025-02-26
20271.417758.583126.583224.33316.333sub-7059_ses-1_accel2025-02-27
21369.583764.917130.167144.2500.750sub-7059_ses-1_accel2025-02-28
22453.000622.333155.083168.16715.417sub-7059_ses-1_accel2025-03-01
\n", - "
" - ], - "text/plain": [ - " dur_spt_sleep_min dur_day_total_IN_min dur_day_total_LIG_min \\\n", - "18 188.667 879.000 147.833 \n", - "19 420.167 721.333 124.417 \n", - "20 271.417 758.583 126.583 \n", - "21 369.583 764.917 130.167 \n", - "22 453.000 622.333 155.083 \n", - "\n", - " dur_day_total_MOD_min dur_day_total_VIG_min ID \\\n", - "18 199.500 8.583 sub-7059_ses-1_accel \n", - "19 150.000 1.167 sub-7059_ses-1_accel \n", - "20 224.333 16.333 sub-7059_ses-1_accel \n", - "21 144.250 0.750 sub-7059_ses-1_accel \n", - "22 168.167 15.417 sub-7059_ses-1_accel \n", - "\n", - " calendar_date \n", - "18 2025-02-25 \n", - "19 2025-02-26 \n", - "20 2025-02-27 \n", - "21 2025-02-28 \n", - "22 2025-03-01 " - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "new_dfs = []\n", - "for eyed in new_df['ID'].unique():\n", - " new_dfs.append(new_df[new_df['ID']==eyed])\n", - "for df in new_dfs:\n", - " df = df.reset_index(drop=True)\n", - "new_dfs[2].head()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "1b78e2f3-ad5d-4b9a-9050-7d05fe3c8a9a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "First paired original DataFrame:\n", - "Empty DataFrame\n", - "Columns: [dur_spt_sleep_min, dur_day_total_IN_min, dur_day_total_LIG_min, dur_day_total_MOD_min, dur_day_total_VIG_min, ID, calendar_date]\n", - "Index: []\n", - "\n", - "First paired new DataFrame:\n", - "Empty DataFrame\n", - "Columns: [dur_spt_sleep_min, dur_day_total_IN_min, dur_day_total_LIG_min, dur_day_total_MOD_min, dur_day_total_VIG_min, ID, calendar_date]\n", - "Index: []\n" - ] - } - ], - "source": [ - "# Initialize a list to store the paired and filtered DataFrames\n", - "paired_dfs = []\n", - "\n", - "# Iterate through the DataFrames in original_dfs and new_dfs\n", - "for orig_df, new_df in zip(original_dfs, new_dfs):\n", - " # Ensure both DataFrames have the required columns\n", - " if 'ID' in orig_df.columns and 'calendar_date' in orig_df.columns and \\\n", - " 'ID' in new_df.columns and 'calendar_date' in new_df.columns:\n", - " \n", - " # Merge DataFrames on 'ID' to create pairs\n", - " merged_df = pd.merge(orig_df, new_df, on='ID', suffixes=('_orig', '_new'))\n", - " \n", - " # Find common calendar dates\n", - " common_dates = set(orig_df['calendar_date']).intersection(set(new_df['calendar_date']))\n", - " \n", - " # Filter rows where calendar_date is in both DataFrames\n", - " filtered_orig = orig_df[orig_df['calendar_date'].isin(common_dates)].copy()\n", - " filtered_new = new_df[new_df['calendar_date'].isin(common_dates)].copy()\n", - " \n", - " # Store the filtered DataFrames as a pair\n", - " paired_dfs.append((filtered_orig, filtered_new))\n", - " else:\n", - " print(f\"Warning: One or both DataFrames lack 'ID' or 'calendar_date' columns\")\n", - "\n", - "# Example: Inspect the first pair\n", - "if paired_dfs:\n", - " print(\"First paired original DataFrame:\")\n", - " print(paired_dfs[0][0])\n", - " print(\"\\nFirst paired new DataFrame:\")\n", - " print(paired_dfs[0][1])" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "22c8285a-1bc1-426e-a95a-ab6225fa4987", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "--- Pair 1 ---\n", - "\n", - "orig dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "orig ID sample: ['sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel']\n", - "orig date sample: ['2025-02-25', '2025-02-26', '2025-02-27', '2025-02-28', '2025-03-01']\n", - "orig nunique IDs: 1, nunique dates: 7\n", - "\n", - "new dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "new ID sample: ['sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel']\n", - "new date sample: ['2025-02-16', '2025-02-17', '2025-02-18', '2025-02-19', '2025-02-20']\n", - "new nunique IDs: 1, nunique dates: 6\n", - "ID overlap size: 0\n", - "\n", - "--- Pair 2 ---\n", - "\n", - "orig dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "orig ID sample: ['sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel']\n", - "orig date sample: ['2025-02-21', '2025-02-22', '2025-02-23', '2025-02-24', '2025-02-25']\n", - "orig nunique IDs: 1, nunique dates: 7\n", - "\n", - "new dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "new ID sample: ['sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel', 'sub-7058_ses-1_accel']\n", - "new date sample: ['2025-02-21', '2025-02-22', '2025-02-23', '2025-02-24', '2025-02-25']\n", - "new nunique IDs: 1, nunique dates: 7\n", - "ID overlap size: 1\n", - "\n", - "--- Pair 3 ---\n", - "\n", - "orig dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "orig ID sample: ['sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel', 'sub-7057_ses-1_accel']\n", - "orig date sample: ['2025-02-16', '2025-02-17', '2025-02-18', '2025-02-19', '2025-02-20']\n", - "orig nunique IDs: 1, nunique dates: 6\n", - "\n", - "new dtypes:\n", - " dur_spt_sleep_min float64\n", - "dur_day_total_IN_min float64\n", - "dur_day_total_LIG_min float64\n", - "dur_day_total_MOD_min float64\n", - "dur_day_total_VIG_min float64\n", - "ID object\n", - "calendar_date object\n", - "dtype: object\n", - "new ID sample: ['sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel', 'sub-7059_ses-1_accel']\n", - "new date sample: ['2025-02-25', '2025-02-26', '2025-02-27', '2025-02-28', '2025-03-01']\n", - "new nunique IDs: 1, nunique dates: 7\n", - "ID overlap size: 0\n" - ] - } - ], - "source": [ - "def peek(df, name):\n", - " print(f\"\\n{name} dtypes:\\n\", df.dtypes)\n", - " print(f\"{name} ID sample:\", df['ID'].astype(str).head().tolist())\n", - " print(f\"{name} date sample:\", df['calendar_date'].head().tolist())\n", - " print(f\"{name} nunique IDs: {df['ID'].nunique()}, nunique dates: {df['calendar_date'].nunique()}\")\n", - "\n", - "for i,(orig_df,new_df) in enumerate(zip(original_dfs,new_dfs),1):\n", - " print(f\"\\n--- Pair {i} ---\")\n", - " peek(orig_df, \"orig\")\n", - " peek(new_df, \"new\")\n", - " print(\"ID overlap size:\", len(set(orig_df['ID'].astype(str)) & set(new_df['ID'].astype(str))))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "183b5847-6dff-4018-976a-a1d5be64073f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Original index 0 filtered head:\n", - " dur_spt_sleep_min_orig dur_day_total_IN_min_orig \\\n", - "0 271.000 655.250 \n", - "1 420.167 727.250 \n", - "2 270.917 765.167 \n", - "3 369.583 767.167 \n", - "4 453.167 618.667 \n", - "\n", - " dur_day_total_LIG_min_orig dur_day_total_MOD_min_orig \\\n", - "0 139.00 200.083 \n", - "1 114.25 154.000 \n", - "2 114.75 226.583 \n", - "3 123.75 148.250 \n", - "4 149.50 175.250 \n", - "\n", - " dur_day_total_VIG_min_orig ID calendar_date \n", - "0 10.000 sub-7059_ses-1_accel 2025-02-25 \n", - "1 1.417 sub-7059_ses-1_accel 2025-02-26 \n", - "2 19.333 sub-7059_ses-1_accel 2025-02-27 \n", - "3 0.917 sub-7059_ses-1_accel 2025-02-28 \n", - "4 17.583 sub-7059_ses-1_accel 2025-03-01 \n", - "\n", - "New index 2 filtered head:\n", - " dur_spt_sleep_min_new dur_day_total_IN_min_new dur_day_total_LIG_min_new \\\n", - "0 188.667 879.000 147.833 \n", - "1 420.167 721.333 124.417 \n", - "2 271.417 758.583 126.583 \n", - "3 369.583 764.917 130.167 \n", - "4 453.000 622.333 155.083 \n", - "\n", - " dur_day_total_MOD_min_new dur_day_total_VIG_min_new ID \\\n", - "0 199.500 8.583 sub-7059_ses-1_accel \n", - "1 150.000 1.167 sub-7059_ses-1_accel \n", - "2 224.333 16.333 sub-7059_ses-1_accel \n", - "3 144.250 0.750 sub-7059_ses-1_accel \n", - "4 168.167 15.417 sub-7059_ses-1_accel \n", - "\n", - " calendar_date \n", - "0 2025-02-25 \n", - "1 2025-02-26 \n", - "2 2025-02-27 \n", - "3 2025-02-28 \n", - "4 2025-03-01 \n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "def _clean(df):\n", - " df = df.copy()\n", - " if 'ID' not in df.columns or 'calendar_date' not in df.columns:\n", - " return None\n", - " df['ID'] = df['ID'].astype(str).str.strip()\n", - " df['calendar_date'] = pd.to_datetime(df['calendar_date'], errors='coerce').dt.normalize()\n", - " return df.dropna(subset=['calendar_date'])\n", - "\n", - "def _overlap_score(o, n):\n", - " # score by per-ID date matches (strongest signal of the right pair)\n", - " common_ids = set(o['ID']) & set(n['ID'])\n", - " if not common_ids:\n", - " return 0\n", - " score = 0\n", - " for cid in list(common_ids):\n", - " od = set(o.loc[o['ID'] == cid, 'calendar_date'])\n", - " nd = set(n.loc[n['ID'] == cid, 'calendar_date'])\n", - " score += len(od & nd)\n", - " # tie-breaker: add small weight for ID overlap size\n", - " score += 0.001 * len(common_ids)\n", - " return score\n", - "\n", - "def pair_and_filter_unordered(original_dfs, new_dfs, verbose=True):\n", - " # clean all upfront\n", - " O = [(_clean(df), i) for i, df in enumerate(original_dfs)]\n", - " N = [(_clean(df), j) for j, df in enumerate(new_dfs)]\n", - " O = [(df,i) for df,i in O if df is not None]\n", - " N = [(df,j) for df,j in N if df is not None]\n", - "\n", - " used_new = set()\n", - " pairs = []\n", - " for o_df, oi in O:\n", - " # find best matching new_df not yet used\n", - " best = (-1, None, None) # (score, n_df, nj)\n", - " for n_df, nj in N:\n", - " if nj in used_new:\n", - " continue\n", - " s = _overlap_score(o_df, n_df)\n", - " if s > best[0]:\n", - " best = (s, n_df, nj)\n", - "\n", - " score, n_df, nj = best\n", - " if score <= 0 or n_df is None:\n", - " if verbose:\n", - " print(f\"[warn] No viable match for original_dfs[{oi}] (no ID+date overlap).\")\n", - " continue\n", - "\n", - " used_new.add(nj)\n", - "\n", - " # inner-join on both keys to enforce alignment\n", - " merged = pd.merge(\n", - " o_df, n_df,\n", - " on=['ID', 'calendar_date'],\n", - " how='inner',\n", - " suffixes=('_orig', '_new')\n", - " )\n", - "\n", - " if merged.empty and verbose:\n", - " # breadcrumbs to help debug\n", - " id_overlap = set(o_df['ID']) & set(n_df['ID'])\n", - " date_overlap = set(o_df['calendar_date']) & set(n_df['calendar_date'])\n", - " print(f\"[info] Matched oi={oi} → nj={nj} (score={score:.3f}) \"\n", - " f\"but inner merge empty. ID overlap={len(id_overlap)}, \"\n", - " f\"global date overlap={len(date_overlap)}.\")\n", - "\n", - " # split back to two filtered views if you want that API\n", - " filtered_orig = merged[[c for c in merged.columns if c.endswith('_orig')] + ['ID', 'calendar_date']]\n", - " filtered_new = merged[[c for c in merged.columns if c.endswith('_new')] + ['ID', 'calendar_date']]\n", - " pairs.append(((oi, filtered_orig), (nj, filtered_new)))\n", - "\n", - " return pairs\n", - "\n", - "# Usage:\n", - "paired_dfs = pair_and_filter_unordered(original_dfs, new_dfs, verbose=True)\n", - "\n", - "# Example inspect:\n", - "if paired_dfs:\n", - " (oi, fo), (nj, fn) = paired_dfs[0]\n", - " print(f\"Original index {oi} filtered head:\\n\", fo.head())\n", - " print(f\"\\nNew index {nj} filtered head:\\n\", fn.head())\n" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "0e75aa69-fd80-4504-aa02-708c32a162f7", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[done] Created 3 plot(s).\n" - ] - } - ], - "source": [ - "\n", - "# metrics to compare\n", - "DUR_COLS = [\n", - " \"dur_spt_sleep_min\",\n", - " \"dur_day_total_IN_min\",\n", - " \"dur_day_total_LIG_min\",\n", - " \"dur_day_total_MOD_min\",\n", - " \"dur_day_total_VIG_min\",\n", - "]\n", - "def plot_dur_differences(pairs, outdir=None, show=True):\n", - " \"\"\"\n", - " pairs: list of ((orig_idx, filtered_orig_df), (new_idx, filtered_new_df))\n", - " as returned by pair_and_filter_unordered(...)\n", - " outdir: optional directory to save PNGs. If None, files aren't saved.\n", - " show: whether to plt.show() each figure.\n", - " \"\"\"\n", - " if outdir:\n", - " os.makedirs(outdir, exist_ok=True)\n", - "\n", - " made = 0\n", - " for (oi, fo), (nj, fn) in pairs:\n", - " if fo.empty or fn.empty:\n", - " print(f\"[skip] Empty filtered DataFrame for pair oi={oi}, nj={nj}\")\n", - " continue\n", - "\n", - " # Merge the two filtered views back together on keys\n", - " merged = pd.merge(\n", - " fo, fn,\n", - " on=[\"ID\", \"calendar_date\"],\n", - " how=\"inner\",\n", - " suffixes=(\"_orig\", \"_new\")\n", - " )\n", - " if merged.empty:\n", - " print(f\"[skip] Inner merge empty for pair oi={oi}, nj={nj}\")\n", - " continue\n", - "\n", - " # Ensure datetime + sort\n", - " merged[\"calendar_date\"] = pd.to_datetime(merged[\"calendar_date\"], errors=\"coerce\")\n", - " merged = merged.dropna(subset=[\"calendar_date\"]).sort_values(\"calendar_date\")\n", - "\n", - " # Build a tidy delta frame: date index, columns = metrics, values = (new - orig)\n", - " delta = pd.DataFrame({\"calendar_date\": merged[\"calendar_date\"].values})\n", - " for col in DUR_COLS:\n", - " ocol = f\"{col}_orig\"\n", - " ncol = f\"{col}_new\"\n", - " # if a metric is missing on either side, fill with NaN to avoid KeyError\n", - " if ocol not in merged.columns or ncol not in merged.columns:\n", - " delta[col] = pd.NA\n", - " else:\n", - " delta[col] = merged[ncol] - merged[ocol]\n", - " delta = delta.set_index(\"calendar_date\")\n", - "\n", - " # Figure title bits\n", - " ids = merged[\"ID\"].dropna().unique().tolist()\n", - " id_label = ids[0] if len(ids) == 1 else f\"{len(ids)} IDs\"\n", - " title = f\"Δ (new − orig) by date • Pair oi={oi} → nj={nj} • {id_label}\"\n", - "\n", - " # Plot — one chart per pair, multiple lines (one per metric)\n", - " plt.figure(figsize=(10, 5))\n", - " for col in DUR_COLS:\n", - " if col in delta.columns:\n", - " # Let matplotlib choose default styles/colors; don't specify colors.\n", - " plt.plot(delta.index, delta[col], marker=\"o\", label=col)\n", - "\n", - " plt.axhline(0, linewidth=1)\n", - " plt.title(title)\n", - " plt.xlabel(\"calendar_date\")\n", - " plt.ylabel(\"Minutes (Δ new − orig)\")\n", - " plt.legend()\n", - " plt.tight_layout()\n", - " plt.\n", - "\n", - " # Save if requested\n", - " if outdir:\n", - " # Safe filename: include oi, nj, and (optionally) single ID\n", - " safe_id = ids[0] if len(ids) == 1 else \"multi\"\n", - " fname = f\"pair_{oi}_to_{nj}_{safe_id}.png\"\n", - " path = os.path.join(outdir, fname)\n", - " plt.savefig(path, dpi=150)\n", - " print(f\"[saved] {path}\")\n", - "\n", - " if show:\n", - " plt.show()\n", - " else:\n", - " plt.close()\n", - "\n", - " made += 1\n", - "\n", - " print(f\"[done] Created {made} plot(s).\")\n", - "\n", - "# Example usage:\n", - "plot_dur_differences(paired_dfs, show=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "3034c9e1-f723-4958-b8c5-8234d5fbeace", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
SubjectFilenameEpochWeight (lbs)AgeGenderDateDay of WeekDay of Week NumNumber of Freedson (1998) Bouts occurring in this day...Vector Magnitude CPMSteps CountsSteps Average CountsSteps Max CountsSteps Per MinuteLux Average CountsLux Max CountsNumber of EpochsTimeCalendar Days
011911191 (2025-02-15)60sec.agd60028F2/15/2025Saturday60...352.3731.9191.90039391
111911191 (2025-02-15)60sec.agd60028F2/16/2025Sunday77...2031.188589.7919.7009099091
211911191 (2025-02-15)60sec.agd60028F2/17/2025Monday17...1456.1126388.81078.800144014401
311911191 (2025-02-15)60sec.agd60028F2/18/2025Tuesday211...1409.5132569.3849.300142214221
411911191 (2025-02-15)60sec.agd60028F2/19/2025Wednesday39...1282.0127148.9998.900142914291
511911191 (2025-02-15)60sec.agd60028F2/20/2025Thursday411...1448.8127429.0959.000141014101
611911191 (2025-02-15)60sec.agd60028F2/21/2025Friday58...1376.3111987.81077.800144014401
\n", - "

7 rows × 60 columns

\n", - "
" - ], - "text/plain": [ - " Subject Filename Epoch Weight (lbs) Age Gender \\\n", - "0 1191 1191 (2025-02-15)60sec.agd 60 0 28 F \n", - "1 1191 1191 (2025-02-15)60sec.agd 60 0 28 F \n", - "2 1191 1191 (2025-02-15)60sec.agd 60 0 28 F \n", - "3 1191 1191 (2025-02-15)60sec.agd 60 0 28 F \n", - "4 1191 1191 (2025-02-15)60sec.agd 60 0 28 F \n", - "5 1191 1191 (2025-02-15)60sec.agd 60 0 28 F \n", - "6 1191 1191 (2025-02-15)60sec.agd 60 0 28 F \n", - "\n", - " Date Day of Week Day of Week Num \\\n", - "0 2/15/2025 Saturday 6 \n", - "1 2/16/2025 Sunday 7 \n", - "2 2/17/2025 Monday 1 \n", - "3 2/18/2025 Tuesday 2 \n", - "4 2/19/2025 Wednesday 3 \n", - "5 2/20/2025 Thursday 4 \n", - "6 2/21/2025 Friday 5 \n", - "\n", - " Number of Freedson (1998) Bouts occurring in this day ... \\\n", - "0 0 ... \n", - "1 7 ... \n", - "2 7 ... \n", - "3 11 ... \n", - "4 9 ... \n", - "5 11 ... \n", - "6 8 ... \n", - "\n", - " Vector Magnitude CPM Steps Counts Steps Average Counts Steps Max Counts \\\n", - "0 352.3 73 1.9 19 \n", - "1 2031.1 8858 9.7 91 \n", - "2 1456.1 12638 8.8 107 \n", - "3 1409.5 13256 9.3 84 \n", - "4 1282.0 12714 8.9 99 \n", - "5 1448.8 12742 9.0 95 \n", - "6 1376.3 11198 7.8 107 \n", - "\n", - " Steps Per Minute Lux Average Counts Lux Max Counts Number of Epochs \\\n", - "0 1.9 0 0 39 \n", - "1 9.7 0 0 909 \n", - "2 8.8 0 0 1440 \n", - "3 9.3 0 0 1422 \n", - "4 8.9 0 0 1429 \n", - "5 9.0 0 0 1410 \n", - "6 7.8 0 0 1440 \n", - "\n", - " Time Calendar Days \n", - "0 39 1 \n", - "1 909 1 \n", - "2 1440 1 \n", - "3 1422 1 \n", - "4 1429 1 \n", - "5 1410 1 \n", - "6 1440 1 \n", - "\n", - "[7 rows x 60 columns]" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "actilife5097 = pd.read_csv(\"/mnt/rdss/VossLab/Repositories/Accelerometer_Data/Test/1191_2-15-2025_Activity.xlsx/1191_2-15-2025_Activity_DailyDetailed.csv\")\n", - "actilife5097" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "a4b095e1-6e45-417b-849f-dc7ed610ca3d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['Subject', 'Filename', 'Epoch', 'Weight (lbs)', 'Age', 'Gender', 'Date',\n", - " 'Day of Week', 'Day of Week Num',\n", - " 'Number of Freedson (1998) Bouts occurring in this day',\n", - " 'Number of Freedson (1998) Bouts starting in this day',\n", - " 'Number of Freedson (1998) Bouts ending in this day',\n", - " 'Total time of Freedson (1998) Bouts occurring in this day',\n", - " 'Total activity counts of Freedson (1998) Bouts occurring in this day',\n", - " 'Number of Sedentary Bouts occurring in this day',\n", - " 'Number of Sedentary Bouts starting in this day',\n", - " 'Number of Sedentary Bouts ending in this day',\n", - " 'Total time of Sedentary Bouts occurring in this day',\n", - " 'Number of Sedentary Breaks occurring in this day',\n", - " 'Number of Sedentary Breaks starting in this day',\n", - " 'Number of Sedentary Breaks ending in this day',\n", - " 'Total time of Sedentary Breaks occurring in this day', 'Sedentary',\n", - " 'Light', 'Moderate', 'Vigorous', 'Very Vigorous', '% in Sedentary',\n", - " '% in Light', '% in Moderate', '% in Vigorous', '% in Very Vigorous',\n", - " 'Total MVPA', '% in MVPA', 'Average MVPA Per Hour', 'Axis 1 Counts',\n", - " 'Axis 2 Counts', 'Axis 3 Counts', 'Axis 1 Average Counts',\n", - " 'Axis 2 Average Counts', 'Axis 3 Average Counts', 'Axis 1 Max Counts',\n", - " 'Axis 2 Max Counts', 'Axis 3 Max Counts', 'Axis 1 CPM', 'Axis 2 CPM',\n", - " 'Axis 3 CPM', 'Vector Magnitude Counts',\n", - " 'Vector Magnitude Average Counts', 'Vector Magnitude Max Counts',\n", - " 'Vector Magnitude CPM', 'Steps Counts', 'Steps Average Counts',\n", - " 'Steps Max Counts', 'Steps Per Minute', 'Lux Average Counts',\n", - " 'Lux Max Counts', 'Number of Epochs', 'Time', 'Calendar Days'],\n", - " dtype='object')" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "actilife5097.columns" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "554eba03-8324-4dc7-9cd5-f85023b1297f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
SedentaryLightModerateVigorousVery Vigorous
0327000
132346412200
274255614200
382841717700
478450214300
574350016700
680449414200
\n", - "
" - ], - "text/plain": [ - " Sedentary Light Moderate Vigorous Very Vigorous\n", - "0 32 7 0 0 0\n", - "1 323 464 122 0 0\n", - "2 742 556 142 0 0\n", - "3 828 417 177 0 0\n", - "4 784 502 143 0 0\n", - "5 743 500 167 0 0\n", - "6 804 494 142 0 0" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "actilife_columns = ['Sedentary', 'Light', 'Moderate', 'Vigorous', 'Very Vigorous']\n", - "actilife5097 = actilife5097[actilife_columns]\n", - "actilife5097" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cd21ab34-34c6-439f-9b99-f8e1d039ce72", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/code/tests/gt3x/ground_truth.csv b/code/tests/gt3x/ground_truth.csv deleted file mode 100644 index 3306ad1..0000000 --- a/code/tests/gt3x/ground_truth.csv +++ /dev/null @@ -1,10 +0,0 @@ -sub,date,in,lig,mod,vig -sub-1_ses-1_accel,2025-08-18,330,260,0,0 -sub-1_ses-1_accel,2025-08-19,450,290,120,0 -sub-1_ses-1_accel,2025-08-20,480,385,30,0 -sub-2_ses-1_accel,2025-08-18,570,150,0,0 -sub-2_ses-1_accel,2025-08-19,810,180,0,0 -sub-2_ses-1_accel,2025-08-20,810,60,0,0 -sub-3_ses-1_accel,2025-08-18,390,180,60,0 -sub-3_ses-1_accel,2025-08-19,660,390,0,0 -sub-3_ses-1_accel,2025-08-20,330,720, 60,0 diff --git a/code/tests/gt3x/plots.py b/code/tests/gt3x/plots.py deleted file mode 100644 index fef9080..0000000 --- a/code/tests/gt3x/plots.py +++ /dev/null @@ -1,162 +0,0 @@ -import pandas as pd -import matplotlib.pyplot as plt -import seaborn as sns - -def day_plot(df_day, - sleep_col='dur_spt_sleep_min', - dates_col='calendar_date'): - """ - Plots a horizontal stacked bar of daily activity composition: - Sleep, Inactivity, Light, MVPA, and Unidentified time. - Also places the duration (in hours) beneath each segment. - Expects columns: - dur_day_total_IN_min, dur_day_total_LIG_min, - dur_day_total_MOD_min, dur_day_total_VIG_min, dur_spt_min - and a 'Day' column for labeling. - """ - - # Define colors - colors = { - "Sleep": "#782D73", # Soft blue - "Inactivity": "#E57A44", # Neutral light gray - "Light": "#95D075", # Muted green - "MVPA": "#7A89C2", # Soft coral red - "Unidentified": "#B0B0B0" # Medium gray - } - - sns.set_theme(style="white") - total_minutes = 24 * 60 - bar_height = 0.4 - - fig, ax = plt.subplots( - figsize=(10, 3 + 0.3 * len(df_day)) - ) - - # --- 1) Compute custom y-positions with extra space between subjects --- - # extract subject numbers from filename - subject_nums = ( - df_day['filename'] - .str.extract(r'sub-(\d+)')[0] - .astype(int) - ) - default_space = 1.9 - extra_space = 0.8 - y_positions = [] - boundary_ys = [] - subject_changes = [] - current_y = 0.0 - - for i, subj in enumerate(subject_nums): - if i == 0: - # first row - y_positions.append(current_y) - else: - if subj != subject_nums.iat[i - 1]: - # subject changed → add extra_space - current_y += default_space + extra_space - # record midpoint for dotted line - boundary = current_y - (default_space + extra_space) / 2 - boundary_ys.append(boundary) - # store subject number for labeling - subject_changes.append((boundary, f"Subject {subj}")) - else: - # same subject → normal spacing - current_y += default_space - y_positions.append(current_y) - master_durations = {} - # --- 2) Plot each day's stacked bar at its computed y-position --- - min_width_for_inside_label = 45 # minutes - for i, (idx, row) in enumerate(df_day.iterrows()): - y_val = y_positions[i] - # build durations - durations = { - 'Sleep': row[sleep_col], - 'Inactivity': row['dur_day_total_IN_min'], - 'Light': row['dur_day_total_LIG_min'], - 'MVPA': row['dur_day_total_MOD_min'] + row['dur_day_total_VIG_min'] - } - identified = sum(durations.values()) - unidentified = total_minutes - identified - if unidentified > 0: - durations['Unidentified'] = unidentified - # store durations for output - filename = str([row['filename'],row[dates_col]]) - master_durations[filename] = durations - - left = 0.0 - above_toggle = False - for cat, val in durations.items(): - ax.barh( - y=y_val, - width=val, - left=left, - height=bar_height, - color=colors[cat], - edgecolor='none' - ) - center_x = left + val / 2 - # choose label position - if val >= min_width_for_inside_label: - text_y = y_val - bar_height / 2 - 0.1 - va = 'top' - else: - if above_toggle: - text_y = y_val + bar_height / 2 + 0.05 - va = 'bottom' - else: - text_y = y_val - bar_height / 2 - 0.25 - va = 'top' - above_toggle = not above_toggle - - if val > 1: - ax.text( - center_x, - text_y, - f"{val/60:.1f} h", - ha='center', - va=va, - fontsize=8 - ) - left += val - - # Day labels on y-axis - ax.set_yticks(y_positions) - date_labels = df_day[dates_col].astype(str).str.replace(r'\s*00:00:00$', '', regex=True) - ax.set_yticklabels(date_labels) - - # Add dotted lines between subjects and subject labels - for b, label in subject_changes: - ax.axhline(y=b, color='black', linestyle='--', linewidth=0.7) - ax.text( - total_minutes + 30, - b, - label, - ha='left', - va='center', - fontsize=9, - color='black' - ) - - # Clean up x-axis - ax.set_xticks([0, total_minutes/2, total_minutes]) - ax.set_xticklabels(["0 h", "12 h", "24 h"], fontsize=9) - ax.spines[['top', 'right', 'left', 'bottom']].set_visible(False) - ax.tick_params(axis='y', length=0) - ax.set_xlim(0, total_minutes + 100) # Extended to accommodate labels - - # Legend - handles = [plt.Rectangle((0, 0), 1, 1, color=colors[k]) for k in colors] - ax.legend(handles, list(colors.keys()), - bbox_to_anchor=(1.01, 1), - loc='upper left', - frameon=False) - - fig.suptitle("Daily Activity Composition", fontsize=14, y=0.95) - plt.tight_layout() - plt.savefig('gt3x_plot.png', dpi=300) - return master_durations - -df_day = pd.read_csv('/mnt/lss/Users/zak/out/output_ggir/results/part5_daysummary_MM_L44.8M100.6V428.8_T5A5.csv') -durations = day_plot(df_day) -df_durations = pd.DataFrame(durations) -df_durations.to_csv('gt3x_durations.csv', index=True) diff --git a/code/tests/gt3x/sleeplogs.ipynb b/code/tests/gt3x/sleeplogs.ipynb deleted file mode 100644 index d8046fb..0000000 --- a/code/tests/gt3x/sleeplogs.ipynb +++ /dev/null @@ -1,592 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "21ac2cda-2964-49ed-b7c7-94f38d516329", - "metadata": {}, - "source": [ - "# sleep log creation" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "cedbb512-7123-48ea-8ab6-80653f659113", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "from datetime import datetime, timedelta\n", - "import os" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "20fa0abf-625c-4ccb-96a7-1a667d147057", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IDD1_dateD1_inbedD1_wakeupD2_dateD2_inbedD2_wakeupD3_dateD3_inbedD3_wakeup...D7_wakeupD8_dateD8_inbedD8_wakeupD9_dateD9_inbedD9_wakeupD10_dateD10_inbedD10_wakeup
0sub-7062_ses-1_accel2025-02-2222:15:0005:55:002025-02-2322:15:0004:50:002025-02-2421:45:0004:30:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
1sub-7146_ses-1_accel2025-05-0509:00:0014:30:002025-05-0609:00:0015:00:002025-05-0709:00:0015:00:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
2sub-7001_ses-1_accel2024-09-0600:00:0006:00:002024-09-0721:00:0008:30:002024-09-0822:00:0006:45:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
3sub-7002_ses-1_accel2024-08-0822:46:0006:55:002024-08-0922:46:0006:59:002024-08-1022:39:0007:53:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
4sub-7003_ses-1_accel2024-08-2123:20:0006:20:002024-08-2221:30:0007:01:002024-08-2311:30:0009:02:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
..................................................................
121sub-7159_ses-1_accel2025-06-0522:40:0007:10:002025-06-0622:15:0009:00:002025-06-0723:30:0009:45:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
122sub-7160_ses-1_accel2025-06-0422:34:0006:00:002025-06-0521:43:0005:56:002025-06-0622:34:0006:34:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
123sub-7165_ses-1_accel2025-06-1223:30:0005:30:002025-06-1323:00:0005:45:002025-06-1423:00:0005:45:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
124sub-7161_ses-1_accel2025-06-1022:10:0006:00:002025-06-1122:00:0006:00:002025-06-1221:52:0006:30:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
125sub-7170_ses-1_accel2025-06-1023:35:0007:00:002025-06-1122:57:0004:54:002025-06-1222:50:0006:00:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
\n", - "

126 rows × 31 columns

\n", - "
" - ], - "text/plain": [ - " ID D1_date D1_inbed D1_wakeup D2_date \\\n", - "0 sub-7062_ses-1_accel 2025-02-22 22:15:00 05:55:00 2025-02-23 \n", - "1 sub-7146_ses-1_accel 2025-05-05 09:00:00 14:30:00 2025-05-06 \n", - "2 sub-7001_ses-1_accel 2024-09-06 00:00:00 06:00:00 2024-09-07 \n", - "3 sub-7002_ses-1_accel 2024-08-08 22:46:00 06:55:00 2024-08-09 \n", - "4 sub-7003_ses-1_accel 2024-08-21 23:20:00 06:20:00 2024-08-22 \n", - ".. ... ... ... ... ... \n", - "121 sub-7159_ses-1_accel 2025-06-05 22:40:00 07:10:00 2025-06-06 \n", - "122 sub-7160_ses-1_accel 2025-06-04 22:34:00 06:00:00 2025-06-05 \n", - "123 sub-7165_ses-1_accel 2025-06-12 23:30:00 05:30:00 2025-06-13 \n", - "124 sub-7161_ses-1_accel 2025-06-10 22:10:00 06:00:00 2025-06-11 \n", - "125 sub-7170_ses-1_accel 2025-06-10 23:35:00 07:00:00 2025-06-11 \n", - "\n", - " D2_inbed D2_wakeup D3_date D3_inbed D3_wakeup ... D7_wakeup \\\n", - "0 22:15:00 04:50:00 2025-02-24 21:45:00 04:30:00 ... NaN \n", - "1 09:00:00 15:00:00 2025-05-07 09:00:00 15:00:00 ... NaN \n", - "2 21:00:00 08:30:00 2024-09-08 22:00:00 06:45:00 ... NaN \n", - "3 22:46:00 06:59:00 2024-08-10 22:39:00 07:53:00 ... NaN \n", - "4 21:30:00 07:01:00 2024-08-23 11:30:00 09:02:00 ... NaN \n", - ".. ... ... ... ... ... ... ... \n", - "121 22:15:00 09:00:00 2025-06-07 23:30:00 09:45:00 ... NaN \n", - "122 21:43:00 05:56:00 2025-06-06 22:34:00 06:34:00 ... NaN \n", - "123 23:00:00 05:45:00 2025-06-14 23:00:00 05:45:00 ... NaN \n", - "124 22:00:00 06:00:00 2025-06-12 21:52:00 06:30:00 ... NaN \n", - "125 22:57:00 04:54:00 2025-06-12 22:50:00 06:00:00 ... NaN \n", - "\n", - " D8_date D8_inbed D8_wakeup D9_date D9_inbed D9_wakeup D10_date D10_inbed \\\n", - "0 NaN NaN NaN NaN NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN NaN NaN NaN NaN \n", - "2 NaN NaN NaN NaN NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN NaN NaN NaN NaN \n", - ".. ... ... ... ... ... ... ... ... \n", - "121 NaN NaN NaN NaN NaN NaN NaN NaN \n", - "122 NaN NaN NaN NaN NaN NaN NaN NaN \n", - "123 NaN NaN NaN NaN NaN NaN NaN NaN \n", - "124 NaN NaN NaN NaN NaN NaN NaN NaN \n", - "125 NaN NaN NaN NaN NaN NaN NaN NaN \n", - "\n", - " D10_wakeup \n", - "0 NaN \n", - "1 NaN \n", - "2 NaN \n", - "3 NaN \n", - "4 NaN \n", - ".. ... \n", - "121 NaN \n", - "122 NaN \n", - "123 NaN \n", - "124 NaN \n", - "125 NaN \n", - "\n", - "[126 rows x 31 columns]" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "obs_sleep = \"/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/sleep_log_observational.csv\"\n", - "obs = pd.read_csv(obs_sleep)\n", - "obs" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "09efdc1f-58af-473e-a5f9-2e9d173f5329", - "metadata": {}, - "outputs": [], - "source": [ - "obs_subs = [\"sub-7057_ses-1_accel\", 'sub-7058_ses-1_accel', 'sub-7059_ses-1_accel']\n", - "obs['ID'] = obs['ID'].astype(str)\n", - "obs = obs[obs['ID'].isin(obs_subs)]" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "8ab6dfa0-83d9-489f-8311-f643f39d6d34", - "metadata": {}, - "outputs": [], - "source": [ - "sub3 = [\"22:00:00\", \"05:00:00\", \"21:00:00\", \"04:30:00\", \"21:30:00\"]\n", - "sub2 = [\"22:45:00\", \"07:30:00\", \"22:30:00\", \"08:15:00\", \"23:00:00\"]\n", - "sub1 = [\"22:00:00\", \"07:15:00\", \"22:15:00\", \"07:00:00\", \"21:55:00\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "f6299259-955e-4a8e-bd1d-3c45b1db2943", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ID D1_date D1_inbed D1_wakeup D2_date D2_inbed \\\n", - "1 sub-7058_ses-1_accel 2025-02-21 22:30:00 07:20:00 2025-02-22 21:30:00 \n", - "2 sub-7059_ses-1_accel 2025-02-25 22:30:00 06:20:00 2025-02-26 22:40:00 \n", - "3 sub-1_ses-1_accel 2025-08-18 22:00:00 07:15:00 2025-08-19 22:15:00 \n", - "4 sub-2_ses-1_accel 2025-08-18 22:45:00 07:30:00 2025-08-19 22:30:00 \n", - "5 sub-3_ses-1_accel 2025-08-18 22:00:00 05:00:00 2025-08-19 21:00:00 \n", - "\n", - " D2_wakeup D3_date D3_inbed D3_wakeup ... D7_wakeup D8_date D8_inbed \\\n", - "1 07:00:00 2025-02-23 21:15:00 06:00:00 ... NaN NaN NaN \n", - "2 07:30:00 2025-02-27 22:30:00 05:00:00 ... NaN NaN NaN \n", - "3 07:00:00 2025-08-20 21:55:00 NaN ... NaN NaN NaN \n", - "4 08:15:00 2025-08-20 23:00:00 NaN ... NaN NaN NaN \n", - "5 04:30:00 2025-08-20 21:30:00 NaN ... NaN NaN NaN \n", - "\n", - " D8_wakeup D9_date D9_inbed D9_wakeup D10_date D10_inbed D10_wakeup \n", - "1 NaN NaN NaN NaN NaN NaN NaN \n", - "2 NaN NaN NaN NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN NaN NaN NaN \n", - "5 NaN NaN NaN NaN NaN NaN NaN \n", - "\n", - "[5 rows x 31 columns]\n" - ] - } - ], - "source": [ - "from datetime import datetime, timedelta\n", - "import pandas as pd\n", - "\n", - "subjects = {\"sub1\": sub1, \"sub2\": sub2, \"sub3\": sub3}\n", - "\n", - "# Build new rows\n", - "new_rows = []\n", - "base_date = datetime(2025, 8, 18)\n", - "\n", - "for idx, (name, times) in enumerate(subjects.items(), start=1):\n", - " row = {}\n", - " row[\"ID\"] = f\"sub-{idx}_ses-1_accel\"\n", - " \n", - " # handle full inbed/wakeup pairs\n", - " for day in range(len(times) // 2):\n", - " dcol = f\"D{day+1}_date\"\n", - " icol = f\"D{day+1}_inbed\"\n", - " wcol = f\"D{day+1}_wakeup\"\n", - " row[dcol] = (base_date + timedelta(days=day)).date().isoformat()\n", - " row[icol] = times[2 * day]\n", - " row[wcol] = times[2 * day + 1]\n", - " \n", - " # handle leftover \"inbed\" if odd length\n", - " if len(times) % 2 == 1:\n", - " leftover_day = len(times) // 2 + 1\n", - " dcol = f\"D{leftover_day}_date\"\n", - " icol = f\"D{leftover_day}_inbed\"\n", - " row[dcol] = (base_date + timedelta(days=leftover_day - 1)).date().isoformat()\n", - " row[icol] = times[-1]\n", - " # no wakeup available\n", - " \n", - " new_rows.append(row)\n", - "\n", - "# Append to DataFrame, aligning by column names\n", - "obs = pd.concat([obs, pd.DataFrame(new_rows)], ignore_index=True)\n", - "\n", - "print(obs.tail())\n" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "dc50e750-89b0-41ae-bbbe-176dd96afd2d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " ID D1_date D1_inbed D1_wakeup D2_date D2_inbed \\\n", - "0 sub-7057_ses-1_accel 2025-02-15 22:40:00 08:30:00 2025-02-17 22:00:00 \n", - "1 sub-7058_ses-1_accel 2025-02-21 22:30:00 07:20:00 2025-02-22 21:30:00 \n", - "2 sub-7059_ses-1_accel 2025-02-25 22:30:00 06:20:00 2025-02-26 22:40:00 \n", - "3 sub-1_ses-1_accel 2025-08-18 22:00:00 07:15:00 2025-08-19 22:15:00 \n", - "4 sub-2_ses-1_accel 2025-08-18 22:45:00 07:30:00 2025-08-19 22:30:00 \n", - "\n", - " D2_wakeup D3_date D3_inbed D3_wakeup D4_date D4_inbed D4_wakeup \\\n", - "0 09:30:00 2025-02-19 01:00:00 11:30:00 2025-02-20 00:00:00 10:30:00 \n", - "1 07:00:00 2025-02-23 21:15:00 06:00:00 2025-02-24 21:30:00 06:00:00 \n", - "2 07:30:00 2025-02-27 22:30:00 05:00:00 2025-03-01 01:20:00 09:20:00 \n", - "3 07:00:00 2025-08-20 21:55:00 NaN NaN NaN NaN \n", - "4 08:15:00 2025-08-20 23:00:00 NaN NaN NaN NaN \n", - "\n", - " D5_date D5_inbed D5_wakeup D6_date D6_inbed D6_wakeup \n", - "0 2025-02-21 02:00:00 06:15:00 NaN NaN NaN \n", - "1 2025-02-25 21:30:00 06:00:00 2025-02-26 21:10:00 06:00:00 \n", - "2 2025-03-02 23:20:00 06:30:00 NaN NaN NaN \n", - "3 NaN NaN NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN NaN NaN \n" - ] - } - ], - "source": [ - "# figure out which columns are actually used (non-empty in any row)\n", - "used_cols = [c for c in obs.columns if not obs[c].isna().all()]\n", - "\n", - "# restrict the DataFrame to those columns\n", - "obs = obs[used_cols]\n", - "\n", - "print(obs.head())" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "id": "ebe784db-de2a-42b1-b8f7-f8e92478345c", - "metadata": {}, - "outputs": [], - "source": [ - "obs.to_csv(\"/mnt/lss/Users/zak/ggir/sleep.csv\", index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fa7ef9c3-07f4-4e2e-a146-155e98f63f99", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/non-wear/.gitignore b/code/tests/non-wear/.gitignore deleted file mode 100644 index e69de29..0000000 diff --git a/code/tests/non-wear/.ipynb_checkpoints/non-wear-test-checkpoint.ipynb b/code/tests/non-wear/.ipynb_checkpoints/non-wear-test-checkpoint.ipynb deleted file mode 100644 index 363fcab..0000000 --- a/code/tests/non-wear/.ipynb_checkpoints/non-wear-test-checkpoint.ipynb +++ /dev/null @@ -1,6 +0,0 @@ -{ - "cells": [], - "metadata": {}, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/non-wear/.ipynb_checkpoints/nonwear2-checkpoint.ipynb b/code/tests/non-wear/.ipynb_checkpoints/nonwear2-checkpoint.ipynb deleted file mode 100644 index d313c25..0000000 --- a/code/tests/non-wear/.ipynb_checkpoints/nonwear2-checkpoint.ipynb +++ /dev/null @@ -1,3614 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 62, - "id": "d865efd5-7f0d-42b6-89de-0a43e162dd97", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "found boost_id(s) with multiple lab_ids: 7023. these entries will be removed from processing.\n", - "Skipping file with unexpected format: 498_WearTime.csv\n", - "Skipping file with unexpected format: 633_WearTime.csv\n", - "Skipping file with unexpected format: 619_WearTime.csv\n", - "Skipping file with unexpected format: 92_WearTime.csv\n", - "Skipping file with unexpected format: 555_WearTime.csv\n", - "Skipping file with unexpected format: 649_WearTime.csv\n", - "Skipping file with unexpected format: 557_WearTime.csv\n", - "Skipping file with unexpected format: 504_WearTime.csv\n", - "Skipping file with unexpected format: 207_WearTime.csv\n", - "Skipping file with unexpected format: AP_WearTime.csv\n", - "Skipping file with unexpected format: 648_WearTime.csv\n", - "Skipping file with unexpected format: 589_WearTime.csv\n", - "Skipping file with unexpected format: 505_WearTime.csv\n", - "Skipping file with unexpected format: 579_WearTime.csv\n", - "Skipping file with unexpected format: 634_WearTime.csv\n", - "Skipping file with unexpected format: 500_WearTime.csv\n", - "Skipping file with unexpected format: 553_WearTime.csv\n", - "Skipping file with unexpected format: KS_WearTime.csv\n", - "Skipping file with unexpected format: 552_WearTime.csv\n", - "Skipping file with unexpected format: 666_WearTime.csv\n", - "Skipping file with unexpected format: 635_WearTime.csv\n", - "Skipping file with unexpected format: 311_WearTime.csv\n", - "Skipping file with unexpected format: 503_WearTime.csv\n", - "Skipping file with unexpected format: 200_WearTime.csv\n", - "Skipping file with unexpected format: 529_WearTime.csv\n", - "Skipping file with unexpected format: 664_WearTime.csv\n", - "Skipping file with unexpected format: 201_WearTime.csv\n", - "Skipping file with unexpected format: 523_WearTime.csv\n", - "Skipping file with unexpected format: 585_WearTime.csv\n", - "Skipping file with unexpected format: 644_WearTime.csv\n", - "Skipping file with unexpected format: 509_WearTime.csv\n", - "Skipping file with unexpected format: 645_WearTime.csv\n", - "Skipping file with unexpected format: 508_WearTime.csv\n", - "Skipping file with unexpected format: 616_WearTime.csv\n", - "Skipping file with unexpected format: 68_WearTime.csv\n", - "Skipping file with unexpected format: 522_WearTime.csv\n", - "Skipping file with unexpected format: 571_WearTime.csv\n", - "Skipping file with unexpected format: 614_WearTime.csv\n", - "Skipping file with unexpected format: 573_WearTime.csv\n", - "Skipping file with unexpected format: 615_WearTime.csv\n", - "Skipping file with unexpected format: 669_WearTime.csv\n", - "Skipping file with unexpected format: 577_WearTime.csv\n", - "Skipping file with unexpected format: 643_WearTime.csv\n", - "Skipping file with unexpected format: 582_WearTime.csv\n", - "Skipping file with unexpected format: 44_WearTime.csv\n", - "Skipping file with unexpected format: 583_WearTime.csv\n", - "Skipping file with unexpected format: 642_WearTime.csv\n", - "Skipping file with unexpected format: 45_WearTime.csv\n", - "Skipping file with unexpected format: 576_WearTime.csv\n", - "Skipping file with unexpected format: 613_WearTime.csv\n", - "Skipping file with unexpected format: 640_WearTime.csv\n", - "Skipping file with unexpected format: 574_WearTime.csv\n", - "Skipping file with unexpected format: 527_WearTime.csv\n", - "Skipping file with unexpected format: 575_WearTime.csv\n", - "Skipping file with unexpected format: 526_WearTime.csv\n", - "Skipping file with unexpected format: 638_WearTime.csv\n", - "Skipping file with unexpected format: 650_WearTime.csv\n", - "Skipping file with unexpected format: 537_WearTime.csv\n", - "Skipping file with unexpected format: 629_WearTime.csv\n", - "Skipping file with unexpected format: 234_WearTime.csv\n", - "Skipping file with unexpected format: 565_WearTime.csv\n", - "Skipping file with unexpected format: 628_WearTime.csv\n", - "Skipping file with unexpected format: 536_WearTime.csv\n", - "Skipping file with unexpected format: 590_WearTime.csv\n", - "Skipping file with unexpected format: 534_WearTime.csv\n", - "Skipping file with unexpected format: 567_WearTime.csv\n", - "Skipping file with unexpected format: 600_WearTime.csv\n", - "Skipping file with unexpected format: 593_WearTime.csv\n", - "Skipping file with unexpected format: 601_WearTime.csv\n", - "Skipping file with unexpected format: 566_WearTime.csv\n", - "Skipping file with unexpected format: 604_WearTime.csv\n", - "Skipping file with unexpected format: 596_WearTime.csv\n", - "Skipping file with unexpected format: 549_WearTime.csv\n", - "Skipping file with unexpected format: DK_WearTime.csv\n", - "Skipping file with unexpected format: 605_WearTime.csv\n", - "Skipping file with unexpected format: 656_WearTime.csv\n", - "Skipping file with unexpected format: 597_WearTime.csv\n", - "Skipping file with unexpected format: RC1day_WearTime.csv\n", - "Skipping file with unexpected format: 533_WearTime.csv\n", - "Skipping file with unexpected format: 560_WearTime.csv\n", - "Skipping file with unexpected format: 157_WearTime.csv\n", - "Skipping file with unexpected format: 519_WearTime.csv\n", - "Skipping file with unexpected format: 607_WearTime.csv\n", - "Skipping file with unexpected format: 655_WearTime.csv\n", - "Skipping file with unexpected format: 594_WearTime.csv\n", - "Skipping file with unexpected format: 472_WearTime.csv\n", - "Skipping file with unexpected format: 540_WearTime.csv\n", - "Skipping file with unexpected format: 182_WearTime.csv\n", - "Skipping file with unexpected format: 627_WearTime.csv\n", - "Skipping file with unexpected format: 626_WearTime.csv\n", - "Skipping file with unexpected format: 538_WearTime.csv\n", - "Skipping file with unexpected format: 541_WearTime.csv\n", - "Skipping file with unexpected format: 58_WearTime.csv\n", - "Skipping file with unexpected format: 512_WearTime.csv\n", - "Skipping file with unexpected format: 87_WearTime.csv\n", - "Skipping file with unexpected format: 624_WearTime.csv\n", - "Skipping file with unexpected format: 542_WearTime.csv\n", - "Skipping file with unexpected format: 625_WearTime.csv\n", - "Skipping file with unexpected format: 598_WearTime.csv\n", - "Skipping file with unexpected format: 547_WearTime.csv\n", - "Skipping file with unexpected format: 659_WearTime.csv\n", - "Skipping file with unexpected format: 217_WearTime.csv\n", - "Skipping file with unexpected format: 620_WearTime.csv\n", - "Skipping file with unexpected format: 621_WearTime.csv\n", - "Skipping file with unexpected format: 658_WearTime.csv\n", - "Skipping file with unexpected format: 599_WearTime.csv\n", - "Skipping file with unexpected format: 517_WearTime.csv\n", - "Skipping file with unexpected format: 609_WearTime.csv\n", - "Skipping file with unexpected format: 608_WearTime.csv\n", - "Skipping file with unexpected format: 516_WearTime.csv\n", - "Skipping file with unexpected format: 622_WearTime.csv\n", - "Skipping file with unexpected format: 661_WearTime.csv\n", - "Skipping file with unexpected format: 675_WearTime.csv\n", - "Skipping file with unexpected format: 671_WearTime.csv\n", - "Skipping file with unexpected format: 673_WearTime.csv\n", - "Skipping file with unexpected format: 676_WearTime.csv\n", - "Skipping file with unexpected format: 674_WearTime.csv\n", - "Skipping file with unexpected format: 670_WearTime.csv\n", - "Skipping file with unexpected format: 680_WearTime.csv\n", - "Skipping file with unexpected format: 687_WearTime.csv\n", - "Skipping file with unexpected format: 684_WearTime.csv\n", - "Skipping file with unexpected format: 683_WearTime.csv\n", - "Skipping file with unexpected format: 677_WearTime.csv\n", - "Skipping file with unexpected format: 691_WearTime.csv\n", - "Skipping file with unexpected format: 686_WearTime.csv\n", - "Skipping file with unexpected format: 694_WearTime.csv\n", - "Skipping file with unexpected format: 667_WearTime.csv\n", - "Skipping file with unexpected format: 695_WearTime.csv\n", - "Skipping file with unexpected format: 690_WearTime.csv\n", - "Skipping file with unexpected format: 678_WearTime.csv\n", - "Skipping file with unexpected format: 706_WearTime.csv\n", - "Skipping file with unexpected format: 525_WearTime.csv\n", - "Skipping file with unexpected format: 702_WearTime.csv\n", - "Skipping file with unexpected format: 700_WearTime.csv\n", - "Skipping file with unexpected format: 510_WearTime.csv\n", - "Skipping file with unexpected format: 720_WearTime.csv\n", - "Skipping file with unexpected format: 715_WearTime.csv\n", - "Skipping file with unexpected format: 717_WearTime.csv\n", - "Skipping file with unexpected format: 707_WearTime.csv\n", - "Skipping file with unexpected format: 697_WearTime.csv\n", - "Skipping file with unexpected format: 710_WearTime.csv\n", - "Skipping file with unexpected format: 709_WearTime.csv\n", - "Skipping file with unexpected format: 689_WearTime.csv\n", - "Skipping file with unexpected format: 721_WearTime.csv\n", - "Skipping file with unexpected format: 728_WearTime.csv\n", - "Skipping file with unexpected format: 723_WearTime.csv\n", - "Skipping file with unexpected format: 708_WearTime.csv\n", - "Skipping file with unexpected format: 714_WearTime.csv\n", - "Skipping file with unexpected format: 722_WearTime.csv\n", - "Skipping file with unexpected format: 727_WearTime.csv\n", - "Skipping file with unexpected format: 730_WearTime.csv\n", - "Skipping file with unexpected format: 487_WearTime.csv\n", - "Skipping file with unexpected format: 731_WearTime.csv\n", - "Skipping file with unexpected format: 699_WearTime.csv\n", - "Skipping file with unexpected format: 725_WearTime.csv\n", - "Skipping file with unexpected format: 713_WearTime.csv\n", - "Skipping file with unexpected format: 729_WearTime.csv\n", - "Skipping file with unexpected format: 52_WearTime.csv\n", - "Skipping file with unexpected format: 261_WearTime.csv\n", - "Skipping file with unexpected format: 734_WearTime.csv\n", - "Skipping file with unexpected format: 736_WearTime.csv\n", - "Skipping file with unexpected format: 733_WearTime.csv\n", - "Skipping file with unexpected format: 738_WearTime.csv\n", - "Skipping file with unexpected format: 741_WearTime.csv\n", - "Skipping file with unexpected format: 197_WearTime.csv\n", - "Skipping file with unexpected format: 581_WearTime.csv\n", - "Skipping file with unexpected format: 71_WearTime.csv\n", - "Skipping file with unexpected format: 176_WearTime.csv\n", - "Skipping file with unexpected format: 750_WearTime.csv\n", - "Skipping file with unexpected format: 753_WearTime.csv\n", - "Skipping file with unexpected format: 757_WearTime.csv\n", - "Skipping file with unexpected format: 758_WearTime.csv\n", - "Skipping file with unexpected format: 763_WearTime.csv\n", - "Skipping file with unexpected format: 759_WearTime.csv\n", - "Skipping file with unexpected format: 760_WearTime.csv\n", - "Skipping file with unexpected format: 764_WearTime.csv\n", - "Skipping file with unexpected format: 507_WearTime.csv\n", - "Skipping file with unexpected format: 766_WearTime.csv\n", - "Skipping file with unexpected format: 769_WearTime.csv\n", - "Skipping file with unexpected format: 770_WearTime.csv\n", - "Skipping file with unexpected format: 767_WearTime.csv\n", - "Skipping file with unexpected format: 774_WearTime.csv\n", - "Skipping file with unexpected format: 772_WearTime.csv\n", - "Skipping file with unexpected format: 771_WearTime.csv\n", - "Skipping file with unexpected format: 776_WearTime.csv\n", - "Skipping file with unexpected format: 775_WearTime.csv\n", - "Skipping file with unexpected format: 778_WearTime.csv\n", - "Skipping file with unexpected format: 780_WearTime.csv\n", - "Skipping file with unexpected format: 777_WearTime.csv\n", - "Skipping file with unexpected format: 782_WearTime.csv\n", - "Skipping file with unexpected format: 781_WearTime.csv\n", - "Skipping file with unexpected format: 785_WearTime.csv\n", - "Skipping file with unexpected format: 786_WearTime.csv\n", - "Skipping file with unexpected format: 788_WearTime.csv\n", - "Skipping file with unexpected format: 784_WearTime.csv\n", - "Skipping file with unexpected format: 790_WearTime.csv\n", - "Skipping file with unexpected format: 792_WearTime.csv\n", - "Skipping file with unexpected format: 1121-9-04-2024_WearTime.csv\n", - "Skipping file with unexpected format: 1249-3-19-2025_WearTime.csv\n", - "Found no duplicates.\n", - "Matches:\n", - "Boost ID: 8022\n", - " - 1023_2-7-2025_WearTime.csv (Lab ID: 1023, Date: 2025-02-07 00:00:00)\n", - " - 1023_4-17-2025_WearTime.csv (Lab ID: 1023, Date: 2025-04-17 00:00:00)\n", - "Boost ID: 7062\n", - " - 1043_2-22-2025_WearTime.csv (Lab ID: 1043, Date: 2025-02-22 00:00:00)\n", - "Boost ID: 7146\n", - " - 1051_5-5-2025_WearTime.csv (Lab ID: 1051, Date: 2025-05-05 00:00:00)\n", - "Boost ID: 6011\n", - " - 1093_8-10-2024_WearTime.csv (Lab ID: 1093, Date: 2024-08-10 00:00:00)\n", - "Boost ID: 6013\n", - " - 1098_8-15-2024_WearTime.csv (Lab ID: 1098, Date: 2024-08-15 00:00:00)\n", - "Boost ID: 6022, 7143\n", - " - 1108_5-8-2025_WearTime.csv (Lab ID: 1108, Date: 2025-05-08 00:00:00)\n", - "Boost ID: 7001\n", - " - 1111_9-6-2024_WearTime.csv (Lab ID: 1111, Date: 2024-09-06 00:00:00)\n", - "Boost ID: 7002\n", - " - 1112_8-8-2024_WearTime.csv (Lab ID: 1112, Date: 2024-08-08 00:00:00)\n", - "Boost ID: 7003\n", - " - 1113_8-21-2024_WearTime.csv (Lab ID: 1113, Date: 2024-08-21 00:00:00)\n", - "Boost ID: 7004\n", - " - 1114_9-5-2024_WearTime.csv (Lab ID: 1114, Date: 2024-09-05 00:00:00)\n", - "Boost ID: 7006\n", - " - 1115_8-6-2024_WearTime.csv (Lab ID: 1115, Date: 2024-08-06 00:00:00)\n", - "Boost ID: 7012\n", - " - 1116_8-30-2024_WearTime.csv (Lab ID: 1116, Date: 2024-08-30 00:00:00)\n", - "Boost ID: 7009\n", - " - 1117_8-7-2024_WearTime.csv (Lab ID: 1117, Date: 2024-08-07 00:00:00)\n", - "Boost ID: 7010\n", - " - 1118_8-9-2024_WearTime.csv (Lab ID: 1118, Date: 2024-08-09 00:00:00)\n", - "Boost ID: 7015\n", - " - 1120_8-14-2024_WearTime.csv (Lab ID: 1120, Date: 2024-08-14 00:00:00)\n", - "Boost ID: 7017\n", - " - 1122_8-23-2024_WearTime.csv (Lab ID: 1122, Date: 2024-08-23 00:00:00)\n", - "Boost ID: 8001\n", - " - 1123_9-21-2024_WearTime.csv (Lab ID: 1123, Date: 2024-09-21 00:00:00)\n", - "Boost ID: 8002\n", - " - 1124_9-14-2024_WearTime.csv (Lab ID: 1124, Date: 2024-09-14 00:00:00)\n", - " - 1124_11-7-2024_WearTime.csv (Lab ID: 1124, Date: 2024-11-07 00:00:00)\n", - " - 1124_2-26-2025_WearTime.csv (Lab ID: 1124, Date: 2025-02-26 00:00:00)\n", - " - 1124_5-5-2025_WearTime.csv (Lab ID: 1124, Date: 2025-05-05 00:00:00)\n", - "Boost ID: 8003\n", - " - 1125_10-5-2024_WearTime.csv (Lab ID: 1125, Date: 2024-10-05 00:00:00)\n", - " - 1125_2-1-2025_WearTime.csv (Lab ID: 1125, Date: 2025-02-01 00:00:00)\n", - " - 1125_5-31-2025_WearTime.csv (Lab ID: 1125, Date: 2025-05-31 00:00:00)\n", - "Boost ID: 8004\n", - " - 1126_9-26-2024_WearTime.csv (Lab ID: 1126, Date: 2024-09-26 00:00:00)\n", - " - 1126_11-23-2024_WearTime.csv (Lab ID: 1126, Date: 2024-11-23 00:00:00)\n", - " - 1126_3-12-2025_WearTime.csv (Lab ID: 1126, Date: 2025-03-12 00:00:00)\n", - " - 1126_4-30-2025_WearTime.csv (Lab ID: 1126, Date: 2025-04-30 00:00:00)\n", - "Boost ID: 8006\n", - " - 1129_9-21-2024_WearTime.csv (Lab ID: 1129, Date: 2024-09-21 00:00:00)\n", - " - 1129_12-13-2024_WearTime.csv (Lab ID: 1129, Date: 2024-12-13 00:00:00)\n", - " - 1129_4-16-2025_WearTime.csv (Lab ID: 1129, Date: 2025-04-16 00:00:00)\n", - " - 1129_5-14-2025_WearTime.csv (Lab ID: 1129, Date: 2025-05-14 00:00:00)\n", - "Boost ID: 7019\n", - " - 1130_9-25-2024_WearTime.csv (Lab ID: 1130, Date: 2024-09-25 00:00:00)\n", - "Boost ID: 7020\n", - " - 1131_10-9-2024_WearTime.csv (Lab ID: 1131, Date: 2024-10-09 00:00:00)\n", - "Boost ID: 7021\n", - " - 1132_10-3-2024_WearTime.csv (Lab ID: 1132, Date: 2024-10-03 00:00:00)\n", - "Boost ID: 7022\n", - " - 1133_10-2-2024_WearTime.csv (Lab ID: 1133, Date: 2024-10-02 00:00:00)\n", - "Boost ID: 8005\n", - " - 1134_10-31-2024_WearTime.csv (Lab ID: 1134, Date: 2024-10-31 00:00:00)\n", - " - 1134_1-16-2025_WearTime.csv (Lab ID: 1134, Date: 2025-01-16 00:00:00)\n", - " - 1134_5-22-2025_WearTime.csv (Lab ID: 1134, Date: 2025-05-22 00:00:00)\n", - " - 1134_6-26-2025_WearTime.csv (Lab ID: 1134, Date: 2025-06-26 00:00:00)\n", - "Boost ID: 7024\n", - " - 1136_10-12-2024_WearTime.csv (Lab ID: 1136, Date: 2024-10-12 00:00:00)\n", - "Boost ID: 7025\n", - " - 1137_10-12-2024_WearTime.csv (Lab ID: 1137, Date: 2024-10-12 00:00:00)\n", - "Boost ID: 7026\n", - " - 1138_10-25-2024_WearTime.csv (Lab ID: 1138, Date: 2024-10-25 00:00:00)\n", - "Boost ID: 7027\n", - " - 1139_11-8-2024_WearTime.csv (Lab ID: 1139, Date: 2024-11-08 00:00:00)\n", - "Boost ID: 7028\n", - " - 1140_10-29-2024_WearTime.csv (Lab ID: 1140, Date: 2024-10-29 00:00:00)\n", - "Boost ID: 7029\n", - " - 1141_11-6-2024_WearTime.csv (Lab ID: 1141, Date: 2024-11-06 00:00:00)\n", - "Boost ID: 7030\n", - " - 1142_10-25-2024_WearTime.csv (Lab ID: 1142, Date: 2024-10-25 00:00:00)\n", - "Boost ID: 7032\n", - " - 1144_11-13-2024_WearTime.csv (Lab ID: 1144, Date: 2024-11-13 00:00:00)\n", - "Boost ID: 7033\n", - " - 1145_11-7-2024_WearTime.csv (Lab ID: 1145, Date: 2024-11-07 00:00:00)\n", - "Boost ID: 8008\n", - " - 1146_11-5-2024_WearTime.csv (Lab ID: 1146, Date: 2024-11-05 00:00:00)\n", - " - 1146_1-10-2025_WearTime.csv (Lab ID: 1146, Date: 2025-01-10 00:00:00)\n", - "Boost ID: 7034\n", - " - 1147_11-15-2024_WearTime.csv (Lab ID: 1147, Date: 2024-11-15 00:00:00)\n", - "Boost ID: 7035\n", - " - 1148_11-5-2024_WearTime.csv (Lab ID: 1148, Date: 2024-11-05 00:00:00)\n", - "Boost ID: 8011\n", - " - 1151_12-7-2024_WearTime.csv (Lab ID: 1151, Date: 2024-12-07 00:00:00)\n", - " - 1151_2-20-2025_WearTime.csv (Lab ID: 1151, Date: 2025-02-20 00:00:00)\n", - "Boost ID: 7031\n", - " - 1155_12-19-2024_WearTime.csv (Lab ID: 1155, Date: 2024-12-19 00:00:00)\n", - "Boost ID: 8012\n", - " - 1158_1-9-2025_WearTime.csv (Lab ID: 1158, Date: 2025-01-09 00:00:00)\n", - " - 1158_5-9-2025_WearTime.csv (Lab ID: 1158, Date: 2025-05-09 00:00:00)\n", - "Boost ID: 8014\n", - " - 1160_1-15-2025_WearTime.csv (Lab ID: 1160, Date: 2025-01-15 00:00:00)\n", - " - 1160_5-3-2025_WearTime.csv (Lab ID: 1160, Date: 2025-05-03 00:00:00)\n", - "Boost ID: 7037\n", - " - 1161_1-18-2025_WearTime.csv (Lab ID: 1161, Date: 2025-01-18 00:00:00)\n", - "Boost ID: 8015\n", - " - 1162_1-29-2025_WearTime.csv (Lab ID: 1162, Date: 2025-01-29 00:00:00)\n", - "Boost ID: 8016\n", - " - 1163_2-19-2025_WearTime.csv (Lab ID: 1163, Date: 2025-02-19 00:00:00)\n", - " - 1163_4-7-2025_WearTime.csv (Lab ID: 1163, Date: 2025-04-07 00:00:00)\n", - "Boost ID: 8017\n", - " - 1165_4-9-2025_WearTime.csv (Lab ID: 1165, Date: 2025-04-09 00:00:00)\n", - "Boost ID: 7039\n", - " - 1166_1-21-2025_WearTime.csv (Lab ID: 1166, Date: 2025-01-21 00:00:00)\n", - "Boost ID: 8018\n", - " - 1167_1-22-2025_WearTime.csv (Lab ID: 1167, Date: 2025-01-22 00:00:00)\n", - " - 1167_5-21-25_WearTime.csv (Lab ID: 1167, Date: 2025-05-21 00:00:00)\n", - "Boost ID: 8019\n", - " - 1168_1-28-2025_WearTime.csv (Lab ID: 1168, Date: 2025-01-28 00:00:00)\n", - " - 1168_4-23-2025_WearTime.csv (Lab ID: 1168, Date: 2025-04-23 00:00:00)\n", - "Boost ID: 8020\n", - " - 1169_1-30-2025_WearTime.csv (Lab ID: 1169, Date: 2025-01-30 00:00:00)\n", - " - 1169_4-9-2025_WearTime.csv (Lab ID: 1169, Date: 2025-04-09 00:00:00)\n", - "Boost ID: 8021\n", - " - 1170_1-29-2025_WearTime.csv (Lab ID: 1170, Date: 2025-01-29 00:00:00)\n", - " - 1170_5-24-2025_WearTime.csv (Lab ID: 1170, Date: 2025-05-24 00:00:00)\n", - "Boost ID: 7040\n", - " - 1171_2-8-2025_WearTime.csv (Lab ID: 1171, Date: 2025-02-08 00:00:00)\n", - "Boost ID: 7041\n", - " - 1172_1-28-2025_WearTime.csv (Lab ID: 1172, Date: 2025-01-28 00:00:00)\n", - " - 1172_5-29-2025_WearTime.csv (Lab ID: 1172, Date: 2025-05-29 00:00:00)\n", - "Boost ID: 7042\n", - " - 1173_3-1-2025_WearTime.csv (Lab ID: 1173, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7043\n", - " - 1174_1-28-2025_WearTime.csv (Lab ID: 1174, Date: 2025-01-28 00:00:00)\n", - "Boost ID: 7047\n", - " - 1178_2-12-2025_WearTime.csv (Lab ID: 1178, Date: 2025-02-12 00:00:00)\n", - "Boost ID: 7048\n", - " - 1179_3-11-2025_WearTime.csv (Lab ID: 1179, Date: 2025-03-11 00:00:00)\n", - "Boost ID: 7049\n", - " - 1180_2-18-2025_WearTime.csv (Lab ID: 1180, Date: 2025-02-18 00:00:00)\n", - "Boost ID: 7050\n", - " - 1181_2-21-2025_WearTime.csv (Lab ID: 1181, Date: 2025-02-21 00:00:00)\n", - "Boost ID: 7052\n", - " - 1183_2-13-2025_WearTime.csv (Lab ID: 1183, Date: 2025-02-13 00:00:00)\n", - "Boost ID: 8023\n", - " - 1185_4-10-2025_WearTime.csv (Lab ID: 1185, Date: 2025-04-10 00:00:00)\n", - "Boost ID: 8024\n", - " - 1186_3-8-2025_WearTime.csv (Lab ID: 1186, Date: 2025-03-08 00:00:00)\n", - " - 1186_5-30-2025_WearTime.csv (Lab ID: 1186, Date: 2025-05-30 00:00:00)\n", - "Boost ID: 7054\n", - " - 1187_2-11-2025_WearTime.csv (Lab ID: 1187, Date: 2025-02-11 00:00:00)\n", - "Boost ID: 7056\n", - " - 1190_2-22-2025_WearTime.csv (Lab ID: 1190, Date: 2025-02-22 00:00:00)\n", - "Boost ID: 7057\n", - " - 1191_2-15-2025_WearTime.csv (Lab ID: 1191, Date: 2025-02-15 00:00:00)\n", - "Boost ID: 7058\n", - " - 1192_2-21-2025_WearTime.csv (Lab ID: 1192, Date: 2025-02-21 00:00:00)\n", - "Boost ID: 7059\n", - " - 1193_2-25-2025_WearTime.csv (Lab ID: 1193, Date: 2025-02-25 00:00:00)\n", - "Boost ID: 8026\n", - " - 1194_2-4-2025_WearTime.csv (Lab ID: 1194, Date: 2025-02-04 00:00:00)\n", - " - 1194_5-23-2025_WearTime.csv (Lab ID: 1194, Date: 2025-05-23 00:00:00)\n", - "Boost ID: 7061\n", - " - 1196_2-25-2025_WearTime.csv (Lab ID: 1196, Date: 2025-02-25 00:00:00)\n", - "Boost ID: 7063\n", - " - 1197_2-25-2025_WearTime.csv (Lab ID: 1197, Date: 2025-02-25 00:00:00)\n", - "Boost ID: 8030\n", - " - 1200_2-21-2025_WearTime.csv (Lab ID: 1200, Date: 2025-02-21 00:00:00)\n", - " - 1200_5-10-2025_WearTime.csv (Lab ID: 1200, Date: 2025-05-10 00:00:00)\n", - "Boost ID: 7064\n", - " - 1202_3-1-2025_WearTime.csv (Lab ID: 1202, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7067\n", - " - 1205_2-21-2025_WearTime.csv (Lab ID: 1205, Date: 2025-02-21 00:00:00)\n", - "Boost ID: 7068\n", - " - 1206_2-27-2025_WearTime.csv (Lab ID: 1206, Date: 2025-02-27 00:00:00)\n", - "Boost ID: 7069\n", - " - 1207_3-1-2025_WearTime.csv (Lab ID: 1207, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7072\n", - " - 1210_3-1-2025_WearTime.csv (Lab ID: 1210, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7073\n", - " - 1211_3-1-2025_wearTime.csv (Lab ID: 1211, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7075\n", - " - 1213_3-4-2025_WearTime.csv (Lab ID: 1213, Date: 2025-03-04 00:00:00)\n", - "Boost ID: 7076\n", - " - 1214_3-11-2025_WearTime.csv (Lab ID: 1214, Date: 2025-03-11 00:00:00)\n", - "Boost ID: 7077\n", - " - 1215_3-14-2025_WearTime.csv (Lab ID: 1215, Date: 2025-03-14 00:00:00)\n", - "Boost ID: 7078\n", - " - 1216_3-8-2025_WearTime.csv (Lab ID: 1216, Date: 2025-03-08 00:00:00)\n", - "Boost ID: 7079\n", - " - 1217_3-13-2025_WearTime.csv (Lab ID: 1217, Date: 2025-03-13 00:00:00)\n", - "Boost ID: 7080\n", - " - 1218_3-7-2025_WearTime.csv (Lab ID: 1218, Date: 2025-03-07 00:00:00)\n", - "Boost ID: 7082\n", - " - 1220_3-29-2025_WearTime.csv (Lab ID: 1220, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 8032\n", - " - 1221_5-22-2025_WearTime.csv (Lab ID: 1221, Date: 2025-05-22 00:00:00)\n", - "Boost ID: 7083\n", - " - 1222_3-6-2025_WearTime.csv (Lab ID: 1222, Date: 2025-03-06 00:00:00)\n", - "Boost ID: 7084\n", - " - 1223_3-29-2025_WearTime.csv (Lab ID: 1223, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 7085\n", - " - 1224_3-18-2025_WearTime.csv (Lab ID: 1224, Date: 2025-03-18 00:00:00)\n", - "Boost ID: 7086\n", - " - 1225_3-6-2025_WearTime.csv (Lab ID: 1225, Date: 2025-03-06 00:00:00)\n", - "Boost ID: 7087\n", - " - 1226_3-6-2025_WearTime.csv (Lab ID: 1226, Date: 2025-03-06 00:00:00)\n", - "Boost ID: 7088\n", - " - 1227_4-3-2025_WearTime.csv (Lab ID: 1227, Date: 2025-04-03 00:00:00)\n", - "Boost ID: 7089\n", - " - 1228_3-20-2025_WearTime.csv (Lab ID: 1228, Date: 2025-03-20 00:00:00)\n", - "Boost ID: 7093\n", - " - 1232_3-12-2025_WearTime.csv (Lab ID: 1232, Date: 2025-03-12 00:00:00)\n", - "Boost ID: 7094\n", - " - 1233_3-27-2025_WearTime.csv (Lab ID: 1233, Date: 2025-03-27 00:00:00)\n", - "Boost ID: 7065\n", - " - 1234_3-20-2025_WearTime.csv (Lab ID: 1234, Date: 2025-03-20 00:00:00)\n", - "Boost ID: 7096\n", - " - 1236_3-29-2025_WearTime.csv (Lab ID: 1236, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 7098\n", - " - 1239_4-5-2025_WearTime.csv (Lab ID: 1239, Date: 2025-04-05 00:00:00)\n", - "Boost ID: 7102\n", - " - 1242_2-28-2025_WearTime.csv (Lab ID: 1242, Date: 2025-02-28 00:00:00)\n", - "Boost ID: 7045\n", - " - 1243_3-20-2025_WearTime.csv (Lab ID: 1243, Date: 2025-03-20 00:00:00)\n", - "Boost ID: 7103\n", - " - 1244_4-3-2025_WearTime.csv (Lab ID: 1244, Date: 2025-04-03 00:00:00)\n", - "Boost ID: 7104\n", - " - 1245_4-3-2025_WearTime.csv (Lab ID: 1245, Date: 2025-04-03 00:00:00)\n", - "Boost ID: 7105\n", - " - 1246_3-14-2025_WearTime.csv (Lab ID: 1246, Date: 2025-03-14 00:00:00)\n", - "Boost ID: 8034\n", - " - 1248_3-29-2025_WearTime.csv (Lab ID: 1248, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 8035\n", - " - 1249_5-31-2025_WearTime.csv (Lab ID: 1249, Date: 2025-05-31 00:00:00)\n", - "Boost ID: 7091\n", - " - 1250_3-27-2025_WearTime.csv (Lab ID: 1250, Date: 2025-03-27 00:00:00)\n", - "Boost ID: 7070\n", - " - 1251_4-5-2025_WearTime.csv (Lab ID: 1251, Date: 2025-04-05 00:00:00)\n", - "Boost ID: 7106\n", - " - 1252_3-28-2025_WearTime.csv (Lab ID: 1252, Date: 2025-03-28 00:00:00)\n", - "Boost ID: 7107\n", - " - 1254_4-12-2025_WearTime.csv (Lab ID: 1254, Date: 2025-04-12 00:00:00)\n", - "Boost ID: 7108\n", - " - 1255_3-14-2025_WearTime.csv (Lab ID: 1255, Date: 2025-03-14 00:00:00)\n", - "Boost ID: 7110\n", - " - 1257_4-4-2025_WearTime.csv (Lab ID: 1257, Date: 2025-04-04 00:00:00)\n", - "Boost ID: 7092\n", - " - 1260_3-28-2025_WearTime.csv (Lab ID: 1260, Date: 2025-03-28 00:00:00)\n", - "Boost ID: 7090\n", - " - 1261_4-11-2025_WearTime.csv (Lab ID: 1261, Date: 2025-04-11 00:00:00)\n", - "Boost ID: 7113\n", - " - 1262_4-4-2025_WearTime.csv (Lab ID: 1262, Date: 2025-04-04 00:00:00)\n", - "Boost ID: 7114\n", - " - 1263_3-29-2025_WearTime.csv (Lab ID: 1263, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 7097\n", - " - 1264_4-5-2025_WearTime.csv (Lab ID: 1264, Date: 2025-04-05 00:00:00)\n", - "Boost ID: 7115\n", - " - 1265_4-2-2025_WearTime.csv (Lab ID: 1265, Date: 2025-04-02 00:00:00)\n", - "Boost ID: 7116\n", - " - 1266_4-3-2025_WearTime.csv (Lab ID: 1266, Date: 2025-04-03 00:00:00)\n", - "Boost ID: 7117\n", - " - 1267_3-22-2025_WearTime.csv (Lab ID: 1267, Date: 2025-03-22 00:00:00)\n", - "Boost ID: 7118\n", - " - 1268_4-8-2025_WearTime.csv (Lab ID: 1268, Date: 2025-04-08 00:00:00)\n", - "Boost ID: 7120\n", - " - 1270_4-12-2025_WearTime.csv (Lab ID: 1270, Date: 2025-04-12 00:00:00)\n", - "Boost ID: 7122\n", - " - 1272_4-5-2025_WearTime.csv (Lab ID: 1272, Date: 2025-04-05 00:00:00)\n", - "Boost ID: 7111\n", - " - 1275_4-18-2025_WearTime.csv (Lab ID: 1275, Date: 2025-04-18 00:00:00)\n", - "Boost ID: 8037\n", - " - 1276_4-4-2025_WearTime.csv (Lab ID: 1276, Date: 2025-04-04 00:00:00)\n", - "Boost ID: 7124\n", - " - 1290_4-10-2025_WearTime.csv (Lab ID: 1290, Date: 2025-04-10 00:00:00)\n", - "Boost ID: 7125\n", - " - 1291_4-10-2025_WearTime.csv (Lab ID: 1291, Date: 2025-04-10 00:00:00)\n", - "Boost ID: 7128\n", - " - 1298_4-18-2025_WearTime.csv (Lab ID: 1298, Date: 2025-04-18 00:00:00)\n", - "Boost ID: 7129\n", - " - 1299_4-19-2025_WearTime.csv (Lab ID: 1299, Date: 2025-04-19 00:00:00)\n", - "Boost ID: 7130\n", - " - 1300_4-18-2025_WearTime.csv (Lab ID: 1300, Date: 2025-04-18 00:00:00)\n", - "Boost ID: 8038\n", - " - 1302_4-26-2025_WearTime.csv (Lab ID: 1302, Date: 2025-04-26 00:00:00)\n", - "Boost ID: 7133\n", - " - 1304_4-29-2025_WearTime.csv (Lab ID: 1304, Date: 2025-04-29 00:00:00)\n", - "Boost ID: 7132\n", - " - 1305_4-24-2025_WearTime.csv (Lab ID: 1305, Date: 2025-04-24 00:00:00)\n", - "Boost ID: 7134\n", - " - 1311_5-1-2025_WearTime.csv (Lab ID: 1311, Date: 2025-05-01 00:00:00)\n", - "Boost ID: 7136\n", - " - 1313_6-3-2025_WearTime.csv (Lab ID: 1313, Date: 2025-06-03 00:00:00)\n", - "Boost ID: 8039\n", - " - 1314_5-20-2025_WearTime.csv (Lab ID: 1314, Date: 2025-05-20 00:00:00)\n", - "Boost ID: 7137\n", - " - 1315_5-5-2025_WearTime.csv (Lab ID: 1315, Date: 2025-05-05 00:00:00)\n", - "Boost ID: 8040\n", - " - 1317_5-20-2025_WearTime.csv (Lab ID: 1317, Date: 2025-05-20 00:00:00)\n", - "Boost ID: 8042\n", - " - 1320_5-20-2025_WearTime.csv (Lab ID: 1320, Date: 2025-05-20 00:00:00)\n", - "Boost ID: 7138\n", - " - 1321_5-17-2025_WearTime.csv (Lab ID: 1321, Date: 2025-05-17 00:00:00)\n", - "Boost ID: 7139\n", - " - 1322_5-10-2025_WearTime.csv (Lab ID: 1322, Date: 2025-05-10 00:00:00)\n", - "Boost ID: 7140\n", - " - 1323_5-10-2025_Sleep.csv (Lab ID: 1323, Date: 2025-05-10 00:00:00)\n", - "Boost ID: 7141\n", - " - 1324_5-17-2025_WearTime.csv (Lab ID: 1324, Date: 2025-05-17 00:00:00)\n", - "Boost ID: 7142\n", - " - 1325_5-21-2025_WearTime.csv (Lab ID: 1325, Date: 2025-05-21 00:00:00)\n", - "Boost ID: 7145\n", - " - 1327_5-10-2025_WearTime.csv (Lab ID: 1327, Date: 2025-05-10 00:00:00)\n", - "Boost ID: 7147\n", - " - 1328_6-24-25_WearTime.csv (Lab ID: 1328, Date: 2025-06-24 00:00:00)\n", - "Boost ID: 8046\n", - " - 1330_5-28-2025_WearTime.csv (Lab ID: 1330, Date: 2025-05-28 00:00:00)\n", - "Boost ID: 7150\n", - " - 1332_5-24-2025_WearTime.csv (Lab ID: 1332, Date: 2025-05-24 00:00:00)\n", - "Boost ID: 7151\n", - " - 1333_5-13-2025_WearTime.csv (Lab ID: 1333, Date: 2025-05-13 00:00:00)\n", - "Boost ID: 7152\n", - " - 1334_5-24-2025_WearTime.csv (Lab ID: 1334, Date: 2025-05-24 00:00:00)\n", - "Boost ID: 8047\n", - " - 1335_5-14-2025_WearTime.csv (Lab ID: 1335, Date: 2025-05-14 00:00:00)\n", - "Boost ID: 8048\n", - " - 1336_6-6-2025_WearTime.csv (Lab ID: 1336, Date: 2025-06-06 00:00:00)\n", - "Boost ID: 7153\n", - " - 1337_5-17-2025_WearTime.csv (Lab ID: 1337, Date: 2025-05-17 00:00:00)\n", - "Boost ID: 7155\n", - " - 1340_6-3-2025_WearTime.csv (Lab ID: 1340, Date: 2025-06-03 00:00:00)\n", - "Boost ID: 8050\n", - " - 1341_5-21-2025_WearTime.csv (Lab ID: 1341, Date: 2025-05-21 00:00:00)\n", - "Boost ID: 7156\n", - " - 1342_5-24-2025_WearTime.csv (Lab ID: 1342, Date: 2025-05-24 00:00:00)\n", - "Boost ID: 8051\n", - " - 1343_6-5-2025_WearTime.csv (Lab ID: 1343, Date: 2025-06-05 00:00:00)\n", - "Boost ID: 7157\n", - " - 1344_5-16-2025_WearTime.csv (Lab ID: 1344, Date: 2025-05-16 00:00:00)\n", - "Boost ID: 8052\n", - " - 1345_5-28-2025_WearTime.csv (Lab ID: 1345, Date: 2025-05-28 00:00:00)\n", - "Boost ID: 8053\n", - " - 1346_6-4-2025_WearTime.csv (Lab ID: 1346, Date: 2025-06-04 00:00:00)\n", - "Boost ID: 8054\n", - " - 1347_5-30-2025_WearTime.csv (Lab ID: 1347, Date: 2025-05-30 00:00:00)\n", - "Boost ID: 7158\n", - " - 1348_6-5-2025_Sleep.csv (Lab ID: 1348, Date: 2025-06-05 00:00:00)\n", - "Boost ID: 7159\n", - " - 1349_6-5-2025_WearTime.csv (Lab ID: 1349, Date: 2025-06-05 00:00:00)\n", - "Boost ID: 7160\n", - " - 1350_6-4-2025_WearTime.csv (Lab ID: 1350, Date: 2025-06-04 00:00:00)\n", - "Boost ID: 7164\n", - " - 1354_6-12-2025_WearTime.csv (Lab ID: 1354, Date: 2025-06-12 00:00:00)\n", - "Boost ID: 7165\n", - " - 1355_6-12-2025_WearTime.csv (Lab ID: 1355, Date: 2025-06-12 00:00:00)\n", - "Boost ID: 7161\n", - " - 1356_6-10-2025_WearTime.csv (Lab ID: 1356, Date: 2025-06-10 00:00:00)\n", - "Boost ID: 7167\n", - " - 1358_6-21-2025_WearTime.csv (Lab ID: 1358, Date: 2025-06-21 00:00:00)\n", - "Boost ID: 7168\n", - " - 1359_6-20-2025_WearTime.csv (Lab ID: 1359, Date: 2025-06-20 00:00:00)\n", - "Boost ID: 7170\n", - " - 1361_6-10-2025_WearTime.csv (Lab ID: 1361, Date: 2025-06-10 00:00:00)\n", - "Boost ID: 7172\n", - " - 1363_6-18-2025_WearTime.csv (Lab ID: 1363, Date: 2025-06-18 00:00:00)\n", - "Boost ID: 7174\n", - " - 1365_6-28-2025_WearTime.csv (Lab ID: 1365, Date: 2025-06-28 00:00:00)\n", - "Boost ID: 7175\n", - " - 1366_7-2-2025_WearTime.csv (Lab ID: 1366, Date: 2025-07-02 00:00:00)\n", - "Boost ID: 7178\n", - " - 1369_6-26-2025_WearTime.csv (Lab ID: 1369, Date: 2025-06-26 00:00:00)\n", - "Boost ID: 7180\n", - " - 1372_7-2-2025_WearTime.csv (Lab ID: 1372, Date: 2025-07-02 00:00:00)\n", - "Boost ID: 8056\n", - " - 1373_7-3-2025_WearTime.csv (Lab ID: 1373, Date: 2025-07-03 00:00:00)\n", - "\n", - "Duplicates:\n", - "\n", - "Sessions DataFrame:\n", - " subject_id session_id filename \\\n", - "0 sub-8022 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "1 sub-8022 ses-2 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "2 sub-7062 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "3 sub-7146 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "4 sub-6011 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - ".. ... ... ... \n", - "197 sub-7174 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "198 sub-7175 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "199 sub-7178 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "200 sub-7180 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "201 sub-8056 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "\n", - " date \n", - "0 2025-02-07 \n", - "1 2025-04-17 \n", - "2 2025-02-22 \n", - "3 2025-05-05 \n", - "4 2024-08-10 \n", - ".. ... \n", - "197 2025-06-28 \n", - "198 2025-07-02 \n", - "199 2025-06-26 \n", - "200 2025-07-02 \n", - "201 2025-07-03 \n", - "\n", - "[202 rows x 4 columns]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/nix-shell.RrgKp6/ipykernel_184880/761771891.py:154: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", - " df['Date'] = pd.to_datetime(df['Date'], errors='coerce')\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import os\n", - "import requests\n", - "import sys\n", - "from io import StringIO\n", - "from datetime import datetime, timedelta\n", - "\n", - "\n", - "'''\n", - "This script is designed to create a sleep log file for the group analysis of accelerometer data.\n", - "It reads the individual participant files by first matching labID with studyID, then builds path to individual files on the RDSS\n", - "Aggregates the sleep data by participant and session (with _accel suffix) and saves it to a CSV file.\n", - "'''\n", - "\n", - "token = 'DE4E2DB72778DACA9B8848574107D2F5'\n", - "INT_DIR = '/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test'\n", - "OBS_DIR = '/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test'\n", - "rdss_dir = '/mnt/rdss/VossLab/Repositories/Accelerometer_Data/WearTime'\n", - "\n", - "def compare_ids(rdss_dir, token, daysago=350):\n", - " \"\"\"\n", - " Pulls all files from RDSS\n", - " Pulls the list from RedCap\n", - " Compares IDs and returns a dictionary with two keys:\n", - " - 'matches': normal matches mapping boost_id to a list of dicts (filename, labID, date)\n", - " - 'duplicates': a list of dictionaries each with lab_id, boost_id, filenames (list), and dates (list)\n", - " \"\"\"\n", - " # Retrieve the RedCap report and duplicates from report\n", - " report, report_duplicates = _return_report(token)\n", - " # Retrieve the full RDSS file list and duplicate files merged with duplicates from report\n", - " rdss, file_duplicates = _rdss_file_list(report_duplicates)\n", - "\n", - " # Initialize the result dictionary for normal (non-duplicate) matches\n", - " result = {}\n", - "\n", - " # Iterate over the rows in the cleaned RedCap report\n", - " for _, row in report.iterrows():\n", - " boost_id = str(row['boost_id'])\n", - " lab_id = str(row['lab_id'])\n", - " \n", - " # Find matching files in the RDSS list\n", - " rdss_matches = rdss[rdss['ID'] == lab_id]\n", - " if not rdss_matches.empty:\n", - " if boost_id not in result:\n", - " result[boost_id] = []\n", - " for _, match_row in rdss_matches.iterrows():\n", - " result[boost_id].append({\n", - " 'filename': match_row['filename'],\n", - " 'labID': lab_id,\n", - " 'date': match_row['Date']\n", - " })\n", - " \n", - " # Process duplicates into the desired structure.\n", - " duplicates_dict = []\n", - " if not file_duplicates.empty:\n", - " # Group by lab_id and boost_id; each group represents one duplicate combination.\n", - " grouped = file_duplicates.groupby(['lab_id', 'boost_id'])\n", - " for (lab_id, boost_id), group in grouped:\n", - " duplicates_dict.append({\n", - " 'lab_id': lab_id,\n", - " 'boost_id': boost_id,\n", - " 'filenames': group['filename'].tolist(),\n", - " 'dates': group['Date'].tolist()\n", - " })\n", - " else:\n", - " print(\"Found no duplicates.\")\n", - "\n", - " return {'matches': result, 'duplicates': duplicates_dict}\n", - "\n", - "def _return_report(token):\n", - " \"\"\"\n", - " pulls the id report from the rdss via redcap api.\n", - " reads the report as a dataframe.\n", - " checks for boost_ids that are associated with multiple lab_ids, logs a critical error,\n", - " and removes these rows from the dataframe.\n", - " separates duplicate rows (based on any column) from the cleaned data.\n", - " \n", - " returns:\n", - " df_cleaned: dataframe with duplicates removed and problematic boost_ids excluded\n", - " duplicate_rows: dataframe of duplicate rows\n", - " \"\"\"\n", - " url = 'https://redcap.icts.uiowa.edu/redcap/api/'\n", - " data = {\n", - " 'token': token,\n", - " 'content': 'report',\n", - " 'report_id': 43327,\n", - " 'format': 'csv'\n", - " }\n", - " r = requests.post(url, data=data)\n", - " if r.status_code != 200:\n", - " print(f\"error! status code is {r.status_code}\")\n", - " sys.exit(1)\n", - " \n", - " df = pd.read_csv(StringIO(r.text))\n", - " \n", - " # identify boost_ids associated with multiple lab_ids.\n", - " boost_id_counts = df.groupby('boost_id')['lab_id'].nunique()\n", - " problematic_boost_ids = boost_id_counts[boost_id_counts > 1].index.tolist()\n", - " \n", - " if problematic_boost_ids:\n", - " print(f\"found boost_id(s) with multiple lab_ids: {', '.join(map(str, problematic_boost_ids))}. \"\n", - " \"these entries will be removed from processing.\")\n", - " df = df[~df['boost_id'].isin(problematic_boost_ids)]\n", - " \n", - " # identify and separate duplicate rows based on any column.\n", - " duplicate_rows = df[df.duplicated(keep=False)]\n", - " df_cleaned = df.drop_duplicates(keep=False)\n", - " \n", - " if not duplicate_rows.empty:\n", - " print(f\"duplicate rows found:\\n{duplicate_rows}\")\n", - " \n", - " return df_cleaned, duplicate_rows\n", - "\n", - "def _rdss_file_list(duplicates, daysago=None):\n", - " \"\"\"\n", - " extracts the first string before the space and the date from filenames ending with .csv\n", - " in the specified folder and stores them in a dataframe.\n", - " \n", - " Also, merges the file list with duplicate report entries based on lab_id.\n", - " \n", - " Returns:\n", - " df: DataFrame of all file entries\n", - " merged_df: DataFrame of file entries that match duplicate lab_ids from the report\n", - " \"\"\"\n", - " extracted_data = []\n", - "\n", - " # Loop through all files in the rdss_dir folder.\n", - " for filename in os.listdir(rdss_dir):\n", - " if filename.endswith('.csv'):\n", - " try:\n", - " # Handle both old and new filename formats\n", - " if '_' in filename and filename.endswith('.csv'):\n", - " # New format: 1288_4-26-2025_Sleep.csv\n", - " parts = filename.replace('.csv', '').split('_')\n", - " if len(parts) >= 3:\n", - " base_name = parts[0] # lab_id\n", - " date_part = parts[1] # date\n", - " extracted_data.append({'ID': base_name, 'Date': date_part, 'filename': filename})\n", - " else:\n", - " print(f\"Skipping file with unexpected format: {filename}\")\n", - " else:\n", - " try:\n", - " base_name = filename.split(' ')[0] # Extract lab_id (old format)\n", - " date_part = filename.split('(')[1].split(')')[0] # Extract date (old format)\n", - " extracted_data.append({'ID': base_name, 'Date': date_part, 'filename': filename})\n", - " except IndexError:\n", - " print(f\"Skipping file with unexpected format: {filename}\")\n", - " except IndexError:\n", - " print(f\"Skipping file with unexpected format: {filename}\")\n", - "\n", - " df = pd.DataFrame(extracted_data)\n", - "\n", - " if not df.empty:\n", - " df['Date'] = pd.to_datetime(df['Date'], errors='coerce')\n", - "\n", - " if daysago:\n", - " cutoff_date = datetime.today() - timedelta(days=daysago)\n", - " df = df[df['Date'] >= cutoff_date] # Filter files within the last `daysago` days\n", - " else:\n", - " df = df[df['Date'] >= '2024-08-05'] # Filter out rows before the threshold date\n", - "\n", - " # Filter the file list to only include rows where ID is in the duplicate report (if any)\n", - " if not duplicates.empty:\n", - " matched_df = df[df['ID'].isin(duplicates['lab_id'])]\n", - " # Merge with the duplicates to bring in boost_id information from the report\n", - " merged_df = matched_df.merge(duplicates, left_on='ID', right_on='lab_id')\n", - " else:\n", - " merged_df = pd.DataFrame()\n", - "\n", - " return df, merged_df\n", - "\n", - "matches = compare_ids(rdss_dir, token, daysago=None)\n", - "# Print the matches and duplicates for verification\n", - "print(\"Matches:\")\n", - "for boost_id, files in matches['matches'].items():\n", - " print(f\"Boost ID: {boost_id}\")\n", - " for file_info in files:\n", - " print(f\" - {file_info['filename']} (Lab ID: {file_info['labID']}, Date: {file_info['date']})\")\n", - "print(\"\\nDuplicates:\")\n", - "for dup in matches['duplicates']:\n", - " print(f\"Lab ID: {dup['lab_id']}, Boost ID: {dup['boost_id']}\")\n", - " print(f\" Filenames: {', '.join(dup['filenames'])}\")\n", - " print(f\" Dates: {', '.join(map(str, dup['dates']))}\")\n", - "# The above code is a complete script that compares IDs from RDSS and RedCap, identifies matches and duplicates, and prints the results.\n", - "\n", - "'''\n", - "Below we create the sessions, where if the same subject ID has multiple files, we will create a session for each file ordered by date.\n", - "this will now be stored as a dataframe with the columns:\n", - " # 'subject_id', 'session_id', 'filename', 'date'\n", - " # where subject_id is 'sub-', session_id is 'ses-', filename is the file name with full path, and date is the date of the file.\n", - "'''\n", - "def create_sessions(matches):\n", - " \"\"\"\n", - " Create sessions from the matches dictionary.\n", - " \n", - " Args:\n", - " matches (dict): Dictionary containing matches with boost_id as keys and list of file info as values.\n", - " \n", - " Returns:\n", - " pd.DataFrame: DataFrame with columns 'subject_id', 'session_id', 'filename', 'date'.\n", - " \"\"\"\n", - " sessions = []\n", - " \n", - " for boost_id, files in matches['matches'].items():\n", - " subject_id = f'sub-{boost_id}'\n", - " for i, file_info in enumerate(files):\n", - " session_id = f'ses-{i + 1}' # Session number starts from 1\n", - " sessions.append({\n", - " 'subject_id': subject_id,\n", - " 'session_id': session_id,\n", - " 'filename': os.path.join(rdss_dir, file_info['filename']),\n", - " 'date': file_info['date']\n", - " })\n", - " \n", - " return pd.DataFrame(sessions)\n", - "\n", - "# Create sessions from the Matches\n", - "sessions_df = create_sessions(matches)\n", - "# Print the sessions DataFrame for verification\n", - "print(\"\\nSessions DataFrame:\")\n", - "print(sessions_df)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "bc89751b-cef3-4872-9c6e-43c1dbd7fb86", - "metadata": {}, - "outputs": [], - "source": [ - "sessions_df.to_clipboard()" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "id": "d05fe919-605c-4555-ae82-b13d553e222b", - "metadata": {}, - "outputs": [], - "source": [ - "s8022_test = [pd.read_csv(sessions_df.iloc[0]['filename'],skiprows=1), pd.read_csv(sessions_df.iloc[1]['filename'],skiprows=1)]" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "id": "7f978be0-e110-4230-8979-fed7d181d469", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
DateWear Time (minutes)Non-Wear Time (minutes)Wear %Non-Wear %Vector Magnitude
02/7/2025132111991.78.31060314.3
12/8/20251439199.90.11997886.7
22/9/20251440010001882234.5
32/10/20251440010001647210.0
42/11/20251440010001820595.0
52/12/20251440010001382595.7
62/13/20251440010002210102.8
72/14/20251440010001688519.2
82/15/202513489293.66.41319762.8
92/16/20250144001001586.9
10Date/Time StartDate/Time StopWear or Non-WearLength (minutes)Use?NaN
112/7/2025 12:00 AM2/7/2025 6:55 AMWear415TRUENaN
122/7/2025 6:55 AM2/7/2025 7:28 AMNon-Wear33FALSENaN
132/7/2025 7:28 AM2/7/2025 5:21 PMWear593TRUENaN
142/7/2025 5:21 PM2/7/2025 6:47 PMNon-Wear86FALSENaN
152/7/2025 6:47 PM2/8/2025 10:05 AMWear918TRUENaN
162/8/2025 10:05 AM2/8/2025 10:06 AMNon-Wear1FALSENaN
172/8/2025 10:06 AM2/15/2025 10:28 PMWear10822TRUENaN
182/15/2025 10:28 PM2/17/2025 12:00 AMNon-Wear1532FALSENaN
\n", - "
" - ], - "text/plain": [ - " Date Wear Time (minutes) Non-Wear Time (minutes) \\\n", - "0 2/7/2025 1321 119 \n", - "1 2/8/2025 1439 1 \n", - "2 2/9/2025 1440 0 \n", - "3 2/10/2025 1440 0 \n", - "4 2/11/2025 1440 0 \n", - "5 2/12/2025 1440 0 \n", - "6 2/13/2025 1440 0 \n", - "7 2/14/2025 1440 0 \n", - "8 2/15/2025 1348 92 \n", - "9 2/16/2025 0 1440 \n", - "10 Date/Time Start Date/Time Stop Wear or Non-Wear \n", - "11 2/7/2025 12:00 AM 2/7/2025 6:55 AM Wear \n", - "12 2/7/2025 6:55 AM 2/7/2025 7:28 AM Non-Wear \n", - "13 2/7/2025 7:28 AM 2/7/2025 5:21 PM Wear \n", - "14 2/7/2025 5:21 PM 2/7/2025 6:47 PM Non-Wear \n", - "15 2/7/2025 6:47 PM 2/8/2025 10:05 AM Wear \n", - "16 2/8/2025 10:05 AM 2/8/2025 10:06 AM Non-Wear \n", - "17 2/8/2025 10:06 AM 2/15/2025 10:28 PM Wear \n", - "18 2/15/2025 10:28 PM 2/17/2025 12:00 AM Non-Wear \n", - "\n", - " Wear % Non-Wear % Vector Magnitude \n", - "0 91.7 8.3 1060314.3 \n", - "1 99.9 0.1 1997886.7 \n", - "2 100 0 1882234.5 \n", - "3 100 0 1647210.0 \n", - "4 100 0 1820595.0 \n", - "5 100 0 1382595.7 \n", - "6 100 0 2210102.8 \n", - "7 100 0 1688519.2 \n", - "8 93.6 6.4 1319762.8 \n", - "9 0 100 1586.9 \n", - "10 Length (minutes) Use? NaN \n", - "11 415 TRUE NaN \n", - "12 33 FALSE NaN \n", - "13 593 TRUE NaN \n", - "14 86 FALSE NaN \n", - "15 918 TRUE NaN \n", - "16 1 FALSE NaN \n", - "17 10822 TRUE NaN \n", - "18 1532 FALSE NaN " - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_s1 = s8022_test[0]\n", - "test_s2 = s8022_test[1]\n", - "test_s1" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "677a0c6c-ac4b-47cb-bcc1-b08d94ca01e2", - "metadata": {}, - "outputs": [ - { - "ename": "IndexError", - "evalue": "index 0 is out of bounds for axis 0 with size 0", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mIndexError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[78]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# 2) Find the index of the row where your second header lives\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m hdr_idx = \u001b[43mtest_s1\u001b[49m\u001b[43m.\u001b[49m\u001b[43mindex\u001b[49m\u001b[43m[\u001b[49m\u001b[43mtest_s1\u001b[49m\u001b[43m.\u001b[49m\u001b[43miloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[43m==\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mDate/Time Start\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[32m 4\u001b[39m \u001b[38;5;66;03m# 3) Pull out that row’s values to use as your new column names\u001b[39;00m\n\u001b[32m 5\u001b[39m new_header = test_s1.iloc[hdr_idx]\n", - "\u001b[36mFile \u001b[39m\u001b[32m/nix/store/59bmf68pd17hp8cphcrpijv7cjs3frwh-python3.13-pandas-2.2.3/lib/python3.13/site-packages/pandas/core/indexes/base.py:5389\u001b[39m, in \u001b[36mIndex.__getitem__\u001b[39m\u001b[34m(self, key)\u001b[39m\n\u001b[32m 5386\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m is_integer(key) \u001b[38;5;129;01mor\u001b[39;00m is_float(key):\n\u001b[32m 5387\u001b[39m \u001b[38;5;66;03m# GH#44051 exclude bool, which would return a 2d ndarray\u001b[39;00m\n\u001b[32m 5388\u001b[39m key = com.cast_scalar_indexer(key)\n\u001b[32m-> \u001b[39m\u001b[32m5389\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgetitem\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 5391\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(key, \u001b[38;5;28mslice\u001b[39m):\n\u001b[32m 5392\u001b[39m \u001b[38;5;66;03m# This case is separated from the conditional above to avoid\u001b[39;00m\n\u001b[32m 5393\u001b[39m \u001b[38;5;66;03m# pessimization com.is_bool_indexer and ndim checks.\u001b[39;00m\n\u001b[32m 5394\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._getitem_slice(key)\n", - "\u001b[31mIndexError\u001b[39m: index 0 is out of bounds for axis 0 with size 0" - ] - } - ], - "source": [ - "# 2) Find the index of the row where your second header lives\n", - "hdr_idx = test_s1.index[test_s1.iloc[:, 0] == \"Date/Time Start\"][0]\n", - "\n", - "# 3) Pull out that row’s values to use as your new column names\n", - "new_header = test_s1.iloc[hdr_idx]\n", - "\n", - "# 4) Drop everything up through that header row, reset the index\n", - "test_s1 = test_s1.iloc[hdr_idx+1 : ].reset_index(drop=True)\n", - "\n", - "# 5) Assign the new_header as the DataFrame’s columns\n", - "test_s1.columns = new_header" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "id": "bc870d3a-9046-422e-be22-8148e6a96146", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
10Date/Time StartDate/Time StopWear or Non-WearLength (minutes)Use?NaN
02/7/2025 12:00 AM2/7/2025 6:55 AMWear415TRUENaN
12/7/2025 6:55 AM2/7/2025 7:28 AMNon-Wear33FALSENaN
22/7/2025 7:28 AM2/7/2025 5:21 PMWear593TRUENaN
32/7/2025 5:21 PM2/7/2025 6:47 PMNon-Wear86FALSENaN
42/7/2025 6:47 PM2/8/2025 10:05 AMWear918TRUENaN
52/8/2025 10:05 AM2/8/2025 10:06 AMNon-Wear1FALSENaN
62/8/2025 10:06 AM2/15/2025 10:28 PMWear10822TRUENaN
72/15/2025 10:28 PM2/17/2025 12:00 AMNon-Wear1532FALSENaN
\n", - "
" - ], - "text/plain": [ - "10 Date/Time Start Date/Time Stop Wear or Non-Wear Length (minutes) \\\n", - "0 2/7/2025 12:00 AM 2/7/2025 6:55 AM Wear 415 \n", - "1 2/7/2025 6:55 AM 2/7/2025 7:28 AM Non-Wear 33 \n", - "2 2/7/2025 7:28 AM 2/7/2025 5:21 PM Wear 593 \n", - "3 2/7/2025 5:21 PM 2/7/2025 6:47 PM Non-Wear 86 \n", - "4 2/7/2025 6:47 PM 2/8/2025 10:05 AM Wear 918 \n", - "5 2/8/2025 10:05 AM 2/8/2025 10:06 AM Non-Wear 1 \n", - "6 2/8/2025 10:06 AM 2/15/2025 10:28 PM Wear 10822 \n", - "7 2/15/2025 10:28 PM 2/17/2025 12:00 AM Non-Wear 1532 \n", - "\n", - "10 Use? NaN \n", - "0 TRUE NaN \n", - "1 FALSE NaN \n", - "2 TRUE NaN \n", - "3 FALSE NaN \n", - "4 TRUE NaN \n", - "5 FALSE NaN \n", - "6 TRUE NaN \n", - "7 FALSE NaN " - ] - }, - "execution_count": 67, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_s1" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "0907fc50-1686-48de-8407-ff029862453c", - "metadata": {}, - "outputs": [], - "source": [ - "test_s1 = test_s1[['Date/Time Start', 'Date/Time Stop', 'Wear or Non-Wear']]" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "b8a4a8e3-5ab2-43a8-a04a-078558d0a954", - "metadata": {}, - "outputs": [], - "source": [ - "test_s1 = test_s1[test_s1['Wear or Non-Wear']=='Non-Wear']" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "id": "0e043d0a-dd80-4c4f-8eff-3e62cf91fb70", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
10Date/Time StartDate/Time StopWear or Non-Wear
12/7/2025 6:55 AM2/7/2025 7:28 AMNon-Wear
32/7/2025 5:21 PM2/7/2025 6:47 PMNon-Wear
52/8/2025 10:05 AM2/8/2025 10:06 AMNon-Wear
72/15/2025 10:28 PM2/17/2025 12:00 AMNon-Wear
\n", - "
" - ], - "text/plain": [ - "10 Date/Time Start Date/Time Stop Wear or Non-Wear\n", - "1 2/7/2025 6:55 AM 2/7/2025 7:28 AM Non-Wear\n", - "3 2/7/2025 5:21 PM 2/7/2025 6:47 PM Non-Wear\n", - "5 2/8/2025 10:05 AM 2/8/2025 10:06 AM Non-Wear\n", - "7 2/15/2025 10:28 PM 2/17/2025 12:00 AM Non-Wear" - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nonwear_df = test_s1\n", - "nonwear_df" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "id": "c0105e2f-0f50-46fd-868d-ab82a6762514", - "metadata": {}, - "outputs": [], - "source": [ - "int_sleep = pd.read_csv('/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/sleep_log_intervention.csv')\n", - "int_sleep.to_clipboard()" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "cb5984f5-302d-4f75-a7c2-53788af603d2", - "metadata": {}, - "outputs": [], - "source": [ - "sleep_test = int_sleep[int_sleep['ID']=='sub-8022_ses-1_accel']\n", - "sleep_test.to_clipboard()\n", - "sleep_df = sleep_test" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "id": "52ffc19a-ec45-4832-9fff-2a58ce281b8d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[off_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:41: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[on_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[off_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:41: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[on_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[off_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:41: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[on_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[off_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:41: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[on_col] = pd.NA\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "# 1) parse your nonwear datetimes and extract just the date\n", - "nonwear_df['Date/Time Start'] = pd.to_datetime(nonwear_df['Date/Time Start'])\n", - "nonwear_df['Date/Time Stop' ] = pd.to_datetime(nonwear_df['Date/Time Stop'])\n", - "nonwear_df['nw_date'] = nonwear_df['Date/Time Start'].dt.date\n", - "\n", - "# 2) build a dict: date → list of (start_time_str, stop_time_str)\n", - "nw_dict = {\n", - " d: list(zip(\n", - " grp['Date/Time Start'].dt.strftime('%H:%M:%S'),\n", - " grp['Date/Time Stop' ].dt.strftime('%H:%M:%S'),\n", - " ))\n", - " for d, grp in nonwear_df.groupby('nw_date')\n", - "}\n", - "\n", - "# 3) make sure your sleep dates are actual date objects\n", - "for i in range(1, 11):\n", - " col = f'D{i}_date'\n", - " if col in sleep_df.columns:\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "\n", - "# 4) for each row and each day, pluck out the intervals and write new cols\n", - "for idx, row in sleep_df.iterrows():\n", - " for i in range(1, 11):\n", - " date_col = f'D{i}_date'\n", - " if pd.isna(row.get(date_col)):\n", - " continue\n", - "\n", - " day = row[date_col]\n", - " intervals = nw_dict.get(day, [])\n", - "\n", - " for j, (off_time, on_time) in enumerate(intervals, start=1):\n", - " off_col = f'D{i}_nonwear{j}_off'\n", - " on_col = f'D{i}_nonwear{j}_on'\n", - "\n", - " # create the column if it doesn’t exist yet\n", - " if off_col not in sleep_df.columns:\n", - " sleep_df[off_col] = pd.NA\n", - " if on_col not in sleep_df.columns:\n", - " sleep_df[on_col] = pd.NA\n", - "\n", - " # assign the times\n", - " sleep_df.at[idx, off_col] = off_time\n", - " sleep_df.at[idx, on_col ] = on_time\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "id": "213fc478-9af2-4cfc-9a1d-8ed76ee5d05e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IDD1_dateD1_inbedD1_wakeupD2_dateD2_inbedD2_wakeupD3_dateD3_inbedD3_wakeup...D10_inbedD10_wakeupD1_nonwear1_offD1_nonwear1_onD1_nonwear2_offD1_nonwear2_onD2_nonwear1_offD2_nonwear1_onD8_nonwear1_offD8_nonwear1_on
0sub-8022_ses-1_accel2025-02-0719:00:0008:30:002025-02-0823:45:0007:30:002025-02-0923:55:0007:00:00...NaNNaN06:55:0007:28:0017:21:0018:47:0010:05:0010:06:0022:28:0000:00:00
\n", - "

1 rows × 39 columns

\n", - "
" - ], - "text/plain": [ - " ID D1_date D1_inbed D1_wakeup D2_date D2_inbed \\\n", - "0 sub-8022_ses-1_accel 2025-02-07 19:00:00 08:30:00 2025-02-08 23:45:00 \n", - "\n", - " D2_wakeup D3_date D3_inbed D3_wakeup ... D10_inbed D10_wakeup \\\n", - "0 07:30:00 2025-02-09 23:55:00 07:00:00 ... NaN NaN \n", - "\n", - " D1_nonwear1_off D1_nonwear1_on D1_nonwear2_off D1_nonwear2_on \\\n", - "0 06:55:00 07:28:00 17:21:00 18:47:00 \n", - "\n", - " D2_nonwear1_off D2_nonwear1_on D8_nonwear1_off D8_nonwear1_on \n", - "0 10:05:00 10:06:00 22:28:00 00:00:00 \n", - "\n", - "[1 rows x 39 columns]" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sleep_df" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "id": "c4625594-8368-447d-afd0-05baa0df5139", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "\n", - "def integrate_nonwear(sleep_df: pd.DataFrame,\n", - " wear_files_df: pd.DataFrame,\n", - " id_col: str = \"ID\") -> pd.DataFrame:\n", - " \"\"\"\n", - " Updates sleep_df in‑place by reading each wear‑time CSV in wear_files_df,\n", - " extracting Non‑Wear intervals, and appending them to the matching row\n", - " in sleep_df under D{day}_nonwear{n}_{off,on} columns.\n", - " \n", - " wear_files_df must have columns: subject_id, session_id, filename, date\n", - " sleep_df must have an ID column like \"sub-8022_ses-1_accel\" and\n", - " D1_date … D10_date columns of type date or datetime.\n", - " \"\"\"\n", - " for _, wf in wear_files_df.iterrows():\n", - " # build the sleep_df ID key\n", - " key = f\"{wf.subject_id}_{wf.session_id}_accel\"\n", - "\n", - " # 1) read raw CSV and splice out the non-wear table\n", - " raw = pd.read_csv(wf.filename, header=0, dtype=str)\n", - " # locate the second-header row\n", - " mask = (raw.iloc[:,0]\n", - " .astype(str)\n", - " .str.strip()\n", - " .str.contains(\"Date/Time Start\", na=False))\n", - " if not mask.any():\n", - " continue # no header found, skip\n", - " hdr_idx = mask.idxmax()\n", - " new_hdr = raw.iloc[hdr_idx]\n", - " df = raw.iloc[hdr_idx+1 : ].reset_index(drop=True)\n", - " df.columns = new_hdr\n", - " df = df[['Date/Time Start','Date/Time Stop','Wear or Non-Wear']]\n", - " nonwear = df[df['Wear or Non-Wear']=='Non-Wear'].copy()\n", - "\n", - " # 2) parse datetimes and group by date\n", - " nonwear['Date/Time Start'] = pd.to_datetime(nonwear['Date/Time Start'])\n", - " nonwear['Date/Time Stop'] = pd.to_datetime(nonwear['Date/Time Stop'])\n", - " nonwear['nw_date'] = nonwear['Date/Time Start'].dt.date\n", - " nw_dict = (\n", - " nonwear\n", - " .groupby('nw_date')\n", - " .apply(lambda g: list(zip(\n", - " g['Date/Time Start'].dt.strftime('%H:%M:%S'),\n", - " g['Date/Time Stop'].dt.strftime('%H:%M:%S'),\n", - " )))\n", - " .to_dict()\n", - " )\n", - "\n", - " # 3) find matching sleep_df row\n", - " matches = sleep_df.index[sleep_df[id_col] == key]\n", - " if len(matches) == 0:\n", - " continue\n", - " ridx = matches[0]\n", - "\n", - " # 4) for each D{i}_date, assign its intervals\n", - " for i in range(1, 11):\n", - " date_col = f'D{i}_date'\n", - " if date_col not in sleep_df.columns:\n", - " break\n", - " raw_date = sleep_df.at[ridx, date_col]\n", - " if pd.isna(raw_date):\n", - " continue\n", - " day = pd.to_datetime(raw_date).date()\n", - " intervals = nw_dict.get(day, [])\n", - " for j, (off_t, on_t) in enumerate(intervals, start=1):\n", - " off_col = f'D{i}_nonwear{j}_off'\n", - " on_col = f'D{i}_nonwear{j}_on'\n", - " # create columns if missing\n", - " if off_col not in sleep_df:\n", - " sleep_df[off_col] = pd.NA\n", - " if on_col not in sleep_df:\n", - " sleep_df[on_col] = pd.NA\n", - " sleep_df.at[ridx, off_col] = off_t\n", - " sleep_df.at[ridx, on_col ] = on_t\n", - "\n", - " return sleep_df\n" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "5d005d79-6ba3-436b-8449-27abd6e1352a", - "metadata": {}, - "outputs": [], - "source": [ - "# sleep_df: your DataFrame of all sleep logs\n", - "# wear_files_df: DataFrame with columns [subject_id, session_id, filename, date]\n", - "int_sleep = pd.read_csv('/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/sleep_log_intervention.csv')\n", - "\n", - "updated = integrate_nonwear(int_sleep, sessions_df)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "id": "fc3c663d-1438-47fc-8263-fd1167cc765e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IDD1_dateD1_inbedD1_wakeupD2_dateD2_inbedD2_wakeupD3_dateD3_inbedD3_wakeup...D7_wakeupD8_dateD8_inbedD8_wakeupD9_dateD9_inbedD9_wakeupD10_dateD10_inbedD10_wakeup
0sub-8022_ses-1_accel2025-02-0719:00:0008:30:002025-02-0823:45:0007:30:002025-02-0923:55:0007:00:00...07:00:002025-02-1501:00:0009:00:00NaNNaNNaNNaNNaNNaN
1sub-8022_ses-2_accel2025-04-1700:00:0006:30:002025-04-1823:10:0007:40:002025-04-2002:45:0007:30:00...08:00:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
2sub-8001_ses-1_accel2024-09-2100:30:0008:30:002024-09-2200:15:0007:40:002024-09-2305:20:0009:30:00...09:00:002024-09-2800:30:0008:45:002024-09-2900:30:0008:15:002024-09-3000:20:0008:30:00
3sub-8002_ses-1_accel2024-09-1422:15:0006:45:002024-09-1523:00:0006:45:002024-09-1622:51:0006:45:00...07:00:002024-09-2122:30:0006:45:002024-09-2222:45:0006:45:00NaNNaNNaN
4sub-8002_ses-2_accel2024-11-0723:00:0003:30:002024-11-0821:30:0005:30:002024-11-0921:30:0005:30:00...06:15:002024-11-1422:45:0006:15:002024-11-1522:30:0007:00:00NaNNaNNaN
5sub-8002_ses-3_accel2025-02-2623:00:0006:30:002025-02-2723:00:0006:30:002025-02-2823:00:0007:30:00...07:00:002025-03-0522:30:0006:30:002025-03-0623:00:0006:30:00NaNNaNNaN
6sub-8002_ses-4_accel2025-05-0522:30:0006:30:002025-05-0622:30:0006:30:002025-05-0723:00:0007:00:00...06:45:002025-05-1223:15:0007:00:002025-05-1322:30:0006:45:00NaNNaNNaN
7sub-8003_ses-1_accel2024-10-0522:30:0007:30:002024-10-0621:30:0006:00:002024-10-0722:00:0006:00:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
8sub-8003_ses-2_accel2025-02-0122:50:0007:00:002025-02-0222:00:0006:15:002025-02-0322:30:0005:30:00...07:15:002025-02-0823:00:0007:00:002025-02-0922:30:0006:15:00NaNNaNNaN
9sub-8004_ses-1_accel2024-09-2618:45:0005:55:002024-09-2722:00:0007:01:002024-09-2821:57:0006:12:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
10sub-8004_ses-2_accel2024-11-2323:00:0006:56:002024-11-2421:43:0005:51:002024-11-2520:55:0005:26:00...06:04:002024-11-3019:30:0006:20:002024-12-0120:30:0005:40:00NaNNaNNaN
11sub-8004_ses-3_accel2025-03-1221:15:0006:45:002025-03-1321:00:0006:15:002025-03-1421:15:0007:30:00...06:10:002025-03-1920:30:0006:45:002025-03-2021:00:0006:00:00NaNNaNNaN
12sub-8004_ses-4_accel2025-04-3021:30:0005:45:002025-05-0122:00:0006:00:002025-05-0220:45:0006:00:00...06:15:002025-05-0721:15:0006:15:002025-05-0821:30:0006:00:00NaNNaNNaN
13sub-8006_ses-1_accel2024-09-2123:00:0007:30:002024-09-2223:00:0005:30:002024-09-2322:30:0006:00:00...07:00:002024-09-2821:30:0006:30:002024-09-2923:00:0005:30:00NaNNaNNaN
14sub-8006_ses-2_accel2024-12-1322:00:0007:00:002024-12-1421:00:0007:00:002024-12-1523:00:0006:00:00...05:25:002024-12-2023:00:0008:00:002024-12-2122:00:0007:10:00NaNNaNNaN
15sub-8006_ses-3_accel2025-04-1623:00:0006:22:002025-04-1723:00:0006:00:002025-04-1818:00:0007:00:00...06:20:002025-04-2321:45:0006:17:002025-04-2420:00:0006:30:00NaNNaNNaN
16sub-8006_ses-4_accel2025-05-1422:20:0006:40:002025-05-1522:30:0006:30:002025-05-1623:30:0006:30:00...06:50:002025-05-2121:45:0006:11:002025-05-2222:00:0006:40:00NaNNaNNaN
17sub-8005_ses-1_accel2024-10-3123:00:0007:30:002024-11-0123:30:0007:45:002024-11-0223:25:0008:15:00...08:05:002024-11-0800:30:0008:30:002024-11-0900:15:0009:15:00NaNNaNNaN
18sub-8005_ses-2_accel2025-01-1622:30:0006:45:002025-01-1723:40:0008:38:002025-01-1823:50:0008:50:00...07:50:002025-01-2500:10:0007:50:00NaNNaNNaNNaNNaNNaN
19sub-8005_ses-3_accel2025-05-2223:00:0007:15:002025-05-2323:00:0008:00:002025-05-2423:15:0008:00:00...07:50:002025-05-3000:00:0007:50:00NaNNaNNaNNaNNaNNaN
20sub-8008_ses-1_accel2024-11-0500:00:0008:00:002024-11-0622:30:0009:00:002024-11-0723:30:0008:00:00...09:00:002024-11-1300:00:0007:30:002024-11-1400:00:0011:00:00NaNNaNNaN
21sub-8008_ses-2_accel2025-01-1003:46:0009:30:002025-01-1102:00:0010:30:002025-01-1203:00:0011:00:00...04:30:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
22sub-8011_ses-1_accel2024-12-0700:00:0007:30:002024-12-0823:38:0006:31:002024-12-0922:47:0006:47:00...07:08:002024-12-1500:13:0007:45:002024-12-1600:01:0006:40:00NaNNaNNaN
23sub-8011_ses-2_accel2025-02-2000:00:0007:53:002025-02-2100:23:0006:30:002025-02-2222:42:0008:00:00...06:11:002025-03-0100:56:0007:18:00NaNNaNNaNNaNNaNNaN
24sub-8012_ses-1_accel2025-05-0923:00:0007:00:002025-05-1023:15:0006:25:002025-05-1222:00:0006:25:00...07:45:002025-05-1723:30:0008:45:00NaNNaNNaNNaNNaNNaN
25sub-8012_ses-2_accel2025-01-0920:45:0006:00:002025-01-1022:30:0006:15:002025-01-1220:30:0006:15:00...05:55:002025-01-1721:45:0007:00:00NaNNaNNaNNaNNaNNaN
26sub-8014_ses-1_accel2025-01-1521:15:0003:50:002025-01-1621:00:0003:50:002025-01-1721:00:0004:50:00...03:50:002025-01-2221:15:0003:50:002025-01-2321:15:0003:50:00NaNNaNNaN
27sub-8014_ses-2_accel2025-05-0323:00:0007:05:002025-05-0421:15:0003:50:002025-05-0520:25:0002:50:00...06:15:002025-05-1023:30:0006:15:002025-05-1121:05:0002:50:00NaNNaNNaN
28sub-8015_ses-1_accel2025-01-2922:05:0006:00:002025-01-3022:00:0006:00:002025-01-3122:30:0007:54:00...06:05:002025-02-0622:35:0005:49:00NaNNaNNaNNaNNaNNaN
29sub-8016_ses-1_accel2025-02-1921:53:0005:30:002025-02-2022:07:0005:30:002025-02-2122:40:0008:50:00...08:30:002025-02-2621:00:0005:50:002025-02-2721:45:0005:15:00NaNNaNNaN
30sub-8016_ses-2_accel2025-04-0722:50:0005:00:002025-04-0822:00:0005:00:002025-04-1023:15:0009:15:00...09:15:002025-04-1600:30:0006:20:00NaNNaNNaNNaNNaNNaN
31sub-8017_ses-1_accel2025-04-0922:20:0006:37:002025-04-1022:24:0006:32:002025-04-1122:10:0008:17:00...06:17:002025-04-1622:01:0006:35:002025-04-1722:20:0005:30:00NaNNaNNaN
32sub-8018_ses-1_accel2025-01-2223:30:0010:15:002025-01-2323:30:0010:00:002025-01-2423:30:0010:00:00...09:30:002025-01-3100:00:0009:15:00NaNNaNNaNNaNNaNNaN
33sub-8019_ses-1_accel2025-01-2823:06:0006:30:002025-01-2923:00:0006:00:002025-01-3023:17:0006:00:00...06:00:002025-02-0522:50:0006:25:00NaNNaNNaNNaNNaNNaN
34sub-8019_ses-2_accel2025-04-2323:02:0005:30:002025-04-2422:40:0006:20:002025-04-2523:25:0007:30:00...06:20:002025-04-3023:10:0006:30:002025-05-0122:55:0006:28:00NaNNaNNaN
35sub-8020_ses-1_accel2025-01-3021:30:0002:30:002025-01-3121:00:0005:00:002025-02-0119:45:0005:00:00...05:30:002025-02-0621:30:0006:00:002025-02-0722:00:0005:30:00NaNNaNNaN
36sub-8020_ses-2_accel2025-04-0919:43:0005:00:002025-04-1019:45:0005:40:002025-04-1120:53:0006:00:00...05:30:002025-04-1622:34:0004:00:002025-04-1721:30:0006:35:00NaNNaNNaN
37sub-8021_ses-1_accel2025-01-2923:19:0008:00:002025-01-3023:34:0008:01:002025-01-3123:07:0009:15:00...07:29:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
38sub-8021_ses-2_accel2025-05-2400:00:0008:20:002025-05-2523:45:0009:00:002025-05-2623:30:0006:00:00...09:00:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
39sub-8023_ses-1_accel2025-04-1023:00:0005:50:002025-04-1222:30:0009:00:002025-04-1323:00:0005:15:00...06:15:002025-04-1901:15:0008:50:00NaNNaNNaNNaNNaNNaN
40sub-8024_ses-1_accel2025-03-0821:43:0006:43:002025-03-0921:30:0005:13:002025-03-1020:40:0004:30:00...06:05:002025-03-1521:48:0006:10:002025-03-1621:30:0005:00:00NaNNaNNaN
41sub-8024_ses-2_accel2025-05-3022:30:0007:30:002025-05-3122:00:0006:00:002025-06-0123:00:0005:45:00...05:50:002025-06-0622:30:0007:00:002025-06-0723:00:0007:00:00NaNNaNNaN
42sub-8026_ses-1_accel2025-02-0420:30:0005:30:002025-02-0521:00:0006:00:002025-02-0619:30:0006:00:00...05:30:002025-02-1122:30:0006:00:002025-02-1221:00:0006:00:00NaNNaNNaN
43sub-8026_ses-2_accel2025-05-2300:00:0006:00:002025-05-2423:30:0007:50:002025-05-2523:30:0008:30:00...05:50:002025-05-3022:30:0006:01:002025-05-3123:00:0008:40:00NaNNaNNaN
44sub-8030_ses-1_accel2025-02-2121:30:0006:10:002025-02-2221:30:0006:04:002025-02-2320:30:0005:10:00...06:10:002025-02-2821:30:0004:55:002025-03-0122:00:0004:55:00NaNNaNNaN
45sub-8030_ses-2_accel2025-05-1022:40:0007:05:002025-05-1122:45:0006:17:002025-05-1222:30:0005:17:00...05:59:002025-05-1722:50:0006:32:002025-05-1823:00:0005:30:00NaNNaNNaN
46sub-8032_ses-1_accel2025-05-2220:35:0005:34:002025-05-2321:00:0006:48:002025-05-2420:40:0007:14:00...05:39:002025-05-2919:55:0005:35:002025-05-3020:40:0005:57:00NaNNaNNaN
47sub-8034_ses-1_accel2025-03-2921:30:0007:30:002025-03-3021:30:0006:00:002025-03-3122:00:0006:30:00...06:20:002025-04-0521:00:0007:50:002025-04-0621:00:0007:00:00NaNNaNNaN
48sub-8035_ses-1_accel2025-03-1921:45:0005:45:002025-03-2022:42:0006:45:002025-03-2123:50:0006:00:00...05:37:002025-03-2621:45:0005:35:002025-03-2721:30:0005:39:00NaNNaNNaN
49sub-8036_ses-1_accel2025-03-2522:30:0007:00:002025-03-2722:30:0006:00:002025-03-2821:30:0002:30:00...06:00:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
50sub-8038_ses-1_accel2025-04-2623:30:0009:50:002025-04-2723:15:0008:04:002025-04-2823:00:0008:20:00...05:44:002025-05-0423:30:0008:20:00NaNNaNNaNNaNNaNNaN
51sub-8039_ses-1_accel2025-05-2023:20:0005:55:002025-05-2223:30:0006:00:002025-05-2400:05:0006:00:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
52sub-8040_ses-1_accel2025-05-2022:30:0006:15:002025-05-2122:45:0006:30:002025-05-2222:45:0006:15:00...06:45:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
53sub-8042_ses-1_accel2025-05-2021:17:0006:13:002025-05-2121:55:0005:38:002025-05-2222:29:0006:05:00...06:15:002025-05-2721:55:0006:15:002025-05-2822:05:0005:53:00NaNNaNNaN
54sub-8046_ses-1_accel2025-05-2822:00:0006:00:002025-05-2922:28:0006:20:002025-05-3022:20:0007:15:00...06:25:002025-06-0423:00:0006:15:002025-06-0522:30:0006:25:00NaNNaNNaN
55sub-8047_ses-1_accel2025-05-1422:45:0005:15:002025-05-1522:00:0005:55:002025-05-1622:20:0006:36:00...05:52:002025-05-2122:10:0006:00:002025-05-2222:07:0005:54:00NaNNaNNaN
56sub-8050_ses-1_accel2025-05-2100:00:0006:30:002025-05-2200:00:0006:10:002025-05-2300:20:0006:30:00...07:00:002025-05-2800:30:0006:30:002025-05-2900:00:0006:15:002025-05-3000:00:0006:45:00
57sub-8051_ses-1_accel2025-06-0501:00:0007:45:002025-06-0601:00:0008:00:002025-06-0700:15:0006:30:00...10:00:002025-06-1201:50:0009:00:002025-06-1301:00:0009:00:002025-06-1403:00:0009:00:00
58sub-8053_ses-1_accel2025-06-0423:48:0006:30:002025-06-0523:35:0007:35:002025-06-0623:15:0006:30:00...07:10:002025-06-1222:01:0005:30:00NaNNaNNaNNaNNaNNaN
59sub-8054_ses-1_accel2025-05-3000:00:0006:45:002025-05-3123:30:0006:00:002025-06-0123:40:0006:15:00...05:45:002025-06-0800:00:0006:00:00NaNNaNNaNNaNNaNNaN
\n", - "

60 rows × 31 columns

\n", - "
" - ], - "text/plain": [ - " ID D1_date D1_inbed D1_wakeup D2_date \\\n", - "0 sub-8022_ses-1_accel 2025-02-07 19:00:00 08:30:00 2025-02-08 \n", - "1 sub-8022_ses-2_accel 2025-04-17 00:00:00 06:30:00 2025-04-18 \n", - "2 sub-8001_ses-1_accel 2024-09-21 00:30:00 08:30:00 2024-09-22 \n", - "3 sub-8002_ses-1_accel 2024-09-14 22:15:00 06:45:00 2024-09-15 \n", - "4 sub-8002_ses-2_accel 2024-11-07 23:00:00 03:30:00 2024-11-08 \n", - "5 sub-8002_ses-3_accel 2025-02-26 23:00:00 06:30:00 2025-02-27 \n", - "6 sub-8002_ses-4_accel 2025-05-05 22:30:00 06:30:00 2025-05-06 \n", - "7 sub-8003_ses-1_accel 2024-10-05 22:30:00 07:30:00 2024-10-06 \n", - "8 sub-8003_ses-2_accel 2025-02-01 22:50:00 07:00:00 2025-02-02 \n", - "9 sub-8004_ses-1_accel 2024-09-26 18:45:00 05:55:00 2024-09-27 \n", - "10 sub-8004_ses-2_accel 2024-11-23 23:00:00 06:56:00 2024-11-24 \n", - "11 sub-8004_ses-3_accel 2025-03-12 21:15:00 06:45:00 2025-03-13 \n", - "12 sub-8004_ses-4_accel 2025-04-30 21:30:00 05:45:00 2025-05-01 \n", - "13 sub-8006_ses-1_accel 2024-09-21 23:00:00 07:30:00 2024-09-22 \n", - "14 sub-8006_ses-2_accel 2024-12-13 22:00:00 07:00:00 2024-12-14 \n", - "15 sub-8006_ses-3_accel 2025-04-16 23:00:00 06:22:00 2025-04-17 \n", - "16 sub-8006_ses-4_accel 2025-05-14 22:20:00 06:40:00 2025-05-15 \n", - "17 sub-8005_ses-1_accel 2024-10-31 23:00:00 07:30:00 2024-11-01 \n", - "18 sub-8005_ses-2_accel 2025-01-16 22:30:00 06:45:00 2025-01-17 \n", - "19 sub-8005_ses-3_accel 2025-05-22 23:00:00 07:15:00 2025-05-23 \n", - "20 sub-8008_ses-1_accel 2024-11-05 00:00:00 08:00:00 2024-11-06 \n", - "21 sub-8008_ses-2_accel 2025-01-10 03:46:00 09:30:00 2025-01-11 \n", - "22 sub-8011_ses-1_accel 2024-12-07 00:00:00 07:30:00 2024-12-08 \n", - "23 sub-8011_ses-2_accel 2025-02-20 00:00:00 07:53:00 2025-02-21 \n", - "24 sub-8012_ses-1_accel 2025-05-09 23:00:00 07:00:00 2025-05-10 \n", - "25 sub-8012_ses-2_accel 2025-01-09 20:45:00 06:00:00 2025-01-10 \n", - "26 sub-8014_ses-1_accel 2025-01-15 21:15:00 03:50:00 2025-01-16 \n", - "27 sub-8014_ses-2_accel 2025-05-03 23:00:00 07:05:00 2025-05-04 \n", - "28 sub-8015_ses-1_accel 2025-01-29 22:05:00 06:00:00 2025-01-30 \n", - "29 sub-8016_ses-1_accel 2025-02-19 21:53:00 05:30:00 2025-02-20 \n", - "30 sub-8016_ses-2_accel 2025-04-07 22:50:00 05:00:00 2025-04-08 \n", - "31 sub-8017_ses-1_accel 2025-04-09 22:20:00 06:37:00 2025-04-10 \n", - "32 sub-8018_ses-1_accel 2025-01-22 23:30:00 10:15:00 2025-01-23 \n", - "33 sub-8019_ses-1_accel 2025-01-28 23:06:00 06:30:00 2025-01-29 \n", - "34 sub-8019_ses-2_accel 2025-04-23 23:02:00 05:30:00 2025-04-24 \n", - "35 sub-8020_ses-1_accel 2025-01-30 21:30:00 02:30:00 2025-01-31 \n", - "36 sub-8020_ses-2_accel 2025-04-09 19:43:00 05:00:00 2025-04-10 \n", - "37 sub-8021_ses-1_accel 2025-01-29 23:19:00 08:00:00 2025-01-30 \n", - "38 sub-8021_ses-2_accel 2025-05-24 00:00:00 08:20:00 2025-05-25 \n", - "39 sub-8023_ses-1_accel 2025-04-10 23:00:00 05:50:00 2025-04-12 \n", - "40 sub-8024_ses-1_accel 2025-03-08 21:43:00 06:43:00 2025-03-09 \n", - "41 sub-8024_ses-2_accel 2025-05-30 22:30:00 07:30:00 2025-05-31 \n", - "42 sub-8026_ses-1_accel 2025-02-04 20:30:00 05:30:00 2025-02-05 \n", - "43 sub-8026_ses-2_accel 2025-05-23 00:00:00 06:00:00 2025-05-24 \n", - "44 sub-8030_ses-1_accel 2025-02-21 21:30:00 06:10:00 2025-02-22 \n", - "45 sub-8030_ses-2_accel 2025-05-10 22:40:00 07:05:00 2025-05-11 \n", - "46 sub-8032_ses-1_accel 2025-05-22 20:35:00 05:34:00 2025-05-23 \n", - "47 sub-8034_ses-1_accel 2025-03-29 21:30:00 07:30:00 2025-03-30 \n", - "48 sub-8035_ses-1_accel 2025-03-19 21:45:00 05:45:00 2025-03-20 \n", - "49 sub-8036_ses-1_accel 2025-03-25 22:30:00 07:00:00 2025-03-27 \n", - "50 sub-8038_ses-1_accel 2025-04-26 23:30:00 09:50:00 2025-04-27 \n", - "51 sub-8039_ses-1_accel 2025-05-20 23:20:00 05:55:00 2025-05-22 \n", - "52 sub-8040_ses-1_accel 2025-05-20 22:30:00 06:15:00 2025-05-21 \n", - "53 sub-8042_ses-1_accel 2025-05-20 21:17:00 06:13:00 2025-05-21 \n", - "54 sub-8046_ses-1_accel 2025-05-28 22:00:00 06:00:00 2025-05-29 \n", - "55 sub-8047_ses-1_accel 2025-05-14 22:45:00 05:15:00 2025-05-15 \n", - "56 sub-8050_ses-1_accel 2025-05-21 00:00:00 06:30:00 2025-05-22 \n", - "57 sub-8051_ses-1_accel 2025-06-05 01:00:00 07:45:00 2025-06-06 \n", - "58 sub-8053_ses-1_accel 2025-06-04 23:48:00 06:30:00 2025-06-05 \n", - "59 sub-8054_ses-1_accel 2025-05-30 00:00:00 06:45:00 2025-05-31 \n", - "\n", - " D2_inbed D2_wakeup D3_date D3_inbed D3_wakeup ... D7_wakeup \\\n", - "0 23:45:00 07:30:00 2025-02-09 23:55:00 07:00:00 ... 07:00:00 \n", - "1 23:10:00 07:40:00 2025-04-20 02:45:00 07:30:00 ... 08:00:00 \n", - "2 00:15:00 07:40:00 2024-09-23 05:20:00 09:30:00 ... 09:00:00 \n", - "3 23:00:00 06:45:00 2024-09-16 22:51:00 06:45:00 ... 07:00:00 \n", - "4 21:30:00 05:30:00 2024-11-09 21:30:00 05:30:00 ... 06:15:00 \n", - "5 23:00:00 06:30:00 2025-02-28 23:00:00 07:30:00 ... 07:00:00 \n", - "6 22:30:00 06:30:00 2025-05-07 23:00:00 07:00:00 ... 06:45:00 \n", - "7 21:30:00 06:00:00 2024-10-07 22:00:00 06:00:00 ... NaN \n", - "8 22:00:00 06:15:00 2025-02-03 22:30:00 05:30:00 ... 07:15:00 \n", - "9 22:00:00 07:01:00 2024-09-28 21:57:00 06:12:00 ... NaN \n", - "10 21:43:00 05:51:00 2024-11-25 20:55:00 05:26:00 ... 06:04:00 \n", - "11 21:00:00 06:15:00 2025-03-14 21:15:00 07:30:00 ... 06:10:00 \n", - "12 22:00:00 06:00:00 2025-05-02 20:45:00 06:00:00 ... 06:15:00 \n", - "13 23:00:00 05:30:00 2024-09-23 22:30:00 06:00:00 ... 07:00:00 \n", - "14 21:00:00 07:00:00 2024-12-15 23:00:00 06:00:00 ... 05:25:00 \n", - "15 23:00:00 06:00:00 2025-04-18 18:00:00 07:00:00 ... 06:20:00 \n", - "16 22:30:00 06:30:00 2025-05-16 23:30:00 06:30:00 ... 06:50:00 \n", - "17 23:30:00 07:45:00 2024-11-02 23:25:00 08:15:00 ... 08:05:00 \n", - "18 23:40:00 08:38:00 2025-01-18 23:50:00 08:50:00 ... 07:50:00 \n", - "19 23:00:00 08:00:00 2025-05-24 23:15:00 08:00:00 ... 07:50:00 \n", - "20 22:30:00 09:00:00 2024-11-07 23:30:00 08:00:00 ... 09:00:00 \n", - "21 02:00:00 10:30:00 2025-01-12 03:00:00 11:00:00 ... 04:30:00 \n", - "22 23:38:00 06:31:00 2024-12-09 22:47:00 06:47:00 ... 07:08:00 \n", - "23 00:23:00 06:30:00 2025-02-22 22:42:00 08:00:00 ... 06:11:00 \n", - "24 23:15:00 06:25:00 2025-05-12 22:00:00 06:25:00 ... 07:45:00 \n", - "25 22:30:00 06:15:00 2025-01-12 20:30:00 06:15:00 ... 05:55:00 \n", - "26 21:00:00 03:50:00 2025-01-17 21:00:00 04:50:00 ... 03:50:00 \n", - "27 21:15:00 03:50:00 2025-05-05 20:25:00 02:50:00 ... 06:15:00 \n", - "28 22:00:00 06:00:00 2025-01-31 22:30:00 07:54:00 ... 06:05:00 \n", - "29 22:07:00 05:30:00 2025-02-21 22:40:00 08:50:00 ... 08:30:00 \n", - "30 22:00:00 05:00:00 2025-04-10 23:15:00 09:15:00 ... 09:15:00 \n", - "31 22:24:00 06:32:00 2025-04-11 22:10:00 08:17:00 ... 06:17:00 \n", - "32 23:30:00 10:00:00 2025-01-24 23:30:00 10:00:00 ... 09:30:00 \n", - "33 23:00:00 06:00:00 2025-01-30 23:17:00 06:00:00 ... 06:00:00 \n", - "34 22:40:00 06:20:00 2025-04-25 23:25:00 07:30:00 ... 06:20:00 \n", - "35 21:00:00 05:00:00 2025-02-01 19:45:00 05:00:00 ... 05:30:00 \n", - "36 19:45:00 05:40:00 2025-04-11 20:53:00 06:00:00 ... 05:30:00 \n", - "37 23:34:00 08:01:00 2025-01-31 23:07:00 09:15:00 ... 07:29:00 \n", - "38 23:45:00 09:00:00 2025-05-26 23:30:00 06:00:00 ... 09:00:00 \n", - "39 22:30:00 09:00:00 2025-04-13 23:00:00 05:15:00 ... 06:15:00 \n", - "40 21:30:00 05:13:00 2025-03-10 20:40:00 04:30:00 ... 06:05:00 \n", - "41 22:00:00 06:00:00 2025-06-01 23:00:00 05:45:00 ... 05:50:00 \n", - "42 21:00:00 06:00:00 2025-02-06 19:30:00 06:00:00 ... 05:30:00 \n", - "43 23:30:00 07:50:00 2025-05-25 23:30:00 08:30:00 ... 05:50:00 \n", - "44 21:30:00 06:04:00 2025-02-23 20:30:00 05:10:00 ... 06:10:00 \n", - "45 22:45:00 06:17:00 2025-05-12 22:30:00 05:17:00 ... 05:59:00 \n", - "46 21:00:00 06:48:00 2025-05-24 20:40:00 07:14:00 ... 05:39:00 \n", - "47 21:30:00 06:00:00 2025-03-31 22:00:00 06:30:00 ... 06:20:00 \n", - "48 22:42:00 06:45:00 2025-03-21 23:50:00 06:00:00 ... 05:37:00 \n", - "49 22:30:00 06:00:00 2025-03-28 21:30:00 02:30:00 ... 06:00:00 \n", - "50 23:15:00 08:04:00 2025-04-28 23:00:00 08:20:00 ... 05:44:00 \n", - "51 23:30:00 06:00:00 2025-05-24 00:05:00 06:00:00 ... NaN \n", - "52 22:45:00 06:30:00 2025-05-22 22:45:00 06:15:00 ... 06:45:00 \n", - "53 21:55:00 05:38:00 2025-05-22 22:29:00 06:05:00 ... 06:15:00 \n", - "54 22:28:00 06:20:00 2025-05-30 22:20:00 07:15:00 ... 06:25:00 \n", - "55 22:00:00 05:55:00 2025-05-16 22:20:00 06:36:00 ... 05:52:00 \n", - "56 00:00:00 06:10:00 2025-05-23 00:20:00 06:30:00 ... 07:00:00 \n", - "57 01:00:00 08:00:00 2025-06-07 00:15:00 06:30:00 ... 10:00:00 \n", - "58 23:35:00 07:35:00 2025-06-06 23:15:00 06:30:00 ... 07:10:00 \n", - "59 23:30:00 06:00:00 2025-06-01 23:40:00 06:15:00 ... 05:45:00 \n", - "\n", - " D8_date D8_inbed D8_wakeup D9_date D9_inbed D9_wakeup \\\n", - "0 2025-02-15 01:00:00 09:00:00 NaN NaN NaN \n", - "1 NaN NaN NaN NaN NaN NaN \n", - "2 2024-09-28 00:30:00 08:45:00 2024-09-29 00:30:00 08:15:00 \n", - "3 2024-09-21 22:30:00 06:45:00 2024-09-22 22:45:00 06:45:00 \n", - "4 2024-11-14 22:45:00 06:15:00 2024-11-15 22:30:00 07:00:00 \n", - "5 2025-03-05 22:30:00 06:30:00 2025-03-06 23:00:00 06:30:00 \n", - "6 2025-05-12 23:15:00 07:00:00 2025-05-13 22:30:00 06:45:00 \n", - "7 NaN NaN NaN NaN NaN NaN \n", - "8 2025-02-08 23:00:00 07:00:00 2025-02-09 22:30:00 06:15:00 \n", - "9 NaN NaN NaN NaN NaN NaN \n", - "10 2024-11-30 19:30:00 06:20:00 2024-12-01 20:30:00 05:40:00 \n", - "11 2025-03-19 20:30:00 06:45:00 2025-03-20 21:00:00 06:00:00 \n", - "12 2025-05-07 21:15:00 06:15:00 2025-05-08 21:30:00 06:00:00 \n", - "13 2024-09-28 21:30:00 06:30:00 2024-09-29 23:00:00 05:30:00 \n", - "14 2024-12-20 23:00:00 08:00:00 2024-12-21 22:00:00 07:10:00 \n", - "15 2025-04-23 21:45:00 06:17:00 2025-04-24 20:00:00 06:30:00 \n", - "16 2025-05-21 21:45:00 06:11:00 2025-05-22 22:00:00 06:40:00 \n", - "17 2024-11-08 00:30:00 08:30:00 2024-11-09 00:15:00 09:15:00 \n", - "18 2025-01-25 00:10:00 07:50:00 NaN NaN NaN \n", - "19 2025-05-30 00:00:00 07:50:00 NaN NaN NaN \n", - "20 2024-11-13 00:00:00 07:30:00 2024-11-14 00:00:00 11:00:00 \n", - "21 NaN NaN NaN NaN NaN NaN \n", - "22 2024-12-15 00:13:00 07:45:00 2024-12-16 00:01:00 06:40:00 \n", - "23 2025-03-01 00:56:00 07:18:00 NaN NaN NaN \n", - "24 2025-05-17 23:30:00 08:45:00 NaN NaN NaN \n", - "25 2025-01-17 21:45:00 07:00:00 NaN NaN NaN \n", - "26 2025-01-22 21:15:00 03:50:00 2025-01-23 21:15:00 03:50:00 \n", - "27 2025-05-10 23:30:00 06:15:00 2025-05-11 21:05:00 02:50:00 \n", - "28 2025-02-06 22:35:00 05:49:00 NaN NaN NaN \n", - "29 2025-02-26 21:00:00 05:50:00 2025-02-27 21:45:00 05:15:00 \n", - "30 2025-04-16 00:30:00 06:20:00 NaN NaN NaN \n", - "31 2025-04-16 22:01:00 06:35:00 2025-04-17 22:20:00 05:30:00 \n", - "32 2025-01-31 00:00:00 09:15:00 NaN NaN NaN \n", - "33 2025-02-05 22:50:00 06:25:00 NaN NaN NaN \n", - "34 2025-04-30 23:10:00 06:30:00 2025-05-01 22:55:00 06:28:00 \n", - "35 2025-02-06 21:30:00 06:00:00 2025-02-07 22:00:00 05:30:00 \n", - "36 2025-04-16 22:34:00 04:00:00 2025-04-17 21:30:00 06:35:00 \n", - "37 NaN NaN NaN NaN NaN NaN \n", - "38 NaN NaN NaN NaN NaN NaN \n", - "39 2025-04-19 01:15:00 08:50:00 NaN NaN NaN \n", - "40 2025-03-15 21:48:00 06:10:00 2025-03-16 21:30:00 05:00:00 \n", - "41 2025-06-06 22:30:00 07:00:00 2025-06-07 23:00:00 07:00:00 \n", - "42 2025-02-11 22:30:00 06:00:00 2025-02-12 21:00:00 06:00:00 \n", - "43 2025-05-30 22:30:00 06:01:00 2025-05-31 23:00:00 08:40:00 \n", - "44 2025-02-28 21:30:00 04:55:00 2025-03-01 22:00:00 04:55:00 \n", - "45 2025-05-17 22:50:00 06:32:00 2025-05-18 23:00:00 05:30:00 \n", - "46 2025-05-29 19:55:00 05:35:00 2025-05-30 20:40:00 05:57:00 \n", - "47 2025-04-05 21:00:00 07:50:00 2025-04-06 21:00:00 07:00:00 \n", - "48 2025-03-26 21:45:00 05:35:00 2025-03-27 21:30:00 05:39:00 \n", - "49 NaN NaN NaN NaN NaN NaN \n", - "50 2025-05-04 23:30:00 08:20:00 NaN NaN NaN \n", - "51 NaN NaN NaN NaN NaN NaN \n", - "52 NaN NaN NaN NaN NaN NaN \n", - "53 2025-05-27 21:55:00 06:15:00 2025-05-28 22:05:00 05:53:00 \n", - "54 2025-06-04 23:00:00 06:15:00 2025-06-05 22:30:00 06:25:00 \n", - "55 2025-05-21 22:10:00 06:00:00 2025-05-22 22:07:00 05:54:00 \n", - "56 2025-05-28 00:30:00 06:30:00 2025-05-29 00:00:00 06:15:00 \n", - "57 2025-06-12 01:50:00 09:00:00 2025-06-13 01:00:00 09:00:00 \n", - "58 2025-06-12 22:01:00 05:30:00 NaN NaN NaN \n", - "59 2025-06-08 00:00:00 06:00:00 NaN NaN NaN \n", - "\n", - " D10_date D10_inbed D10_wakeup \n", - "0 NaN NaN NaN \n", - "1 NaN NaN NaN \n", - "2 2024-09-30 00:20:00 08:30:00 \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - "5 NaN NaN NaN \n", - "6 NaN NaN NaN \n", - "7 NaN NaN NaN \n", - "8 NaN NaN NaN \n", - "9 NaN NaN NaN \n", - "10 NaN NaN NaN \n", - "11 NaN NaN NaN \n", - "12 NaN NaN NaN \n", - "13 NaN NaN NaN \n", - "14 NaN NaN NaN \n", - "15 NaN NaN NaN \n", - "16 NaN NaN NaN \n", - "17 NaN NaN NaN \n", - "18 NaN NaN NaN \n", - "19 NaN NaN NaN \n", - "20 NaN NaN NaN \n", - "21 NaN NaN NaN \n", - "22 NaN NaN NaN \n", - "23 NaN NaN NaN \n", - "24 NaN NaN NaN \n", - "25 NaN NaN NaN \n", - "26 NaN NaN NaN \n", - "27 NaN NaN NaN \n", - "28 NaN NaN NaN \n", - "29 NaN NaN NaN \n", - "30 NaN NaN NaN \n", - "31 NaN NaN NaN \n", - "32 NaN NaN NaN \n", - "33 NaN NaN NaN \n", - "34 NaN NaN NaN \n", - "35 NaN NaN NaN \n", - "36 NaN NaN NaN \n", - "37 NaN NaN NaN \n", - "38 NaN NaN NaN \n", - "39 NaN NaN NaN \n", - "40 NaN NaN NaN \n", - "41 NaN NaN NaN \n", - "42 NaN NaN NaN \n", - "43 NaN NaN NaN \n", - "44 NaN NaN NaN \n", - "45 NaN NaN NaN \n", - "46 NaN NaN NaN \n", - "47 NaN NaN NaN \n", - "48 NaN NaN NaN \n", - "49 NaN NaN NaN \n", - "50 NaN NaN NaN \n", - "51 NaN NaN NaN \n", - "52 NaN NaN NaN \n", - "53 NaN NaN NaN \n", - "54 NaN NaN NaN \n", - "55 NaN NaN NaN \n", - "56 2025-05-30 00:00:00 06:45:00 \n", - "57 2025-06-14 03:00:00 09:00:00 \n", - "58 NaN NaN NaN \n", - "59 NaN NaN NaN \n", - "\n", - "[60 rows x 31 columns]" - ] - }, - "execution_count": 82, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "updated" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "id": "728b50a2-ac17-4ba0-9026-3046b5249994", - "metadata": {}, - "outputs": [], - "source": [ - "updated.to_csv('./sleep_w_nonwear.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9193f3fa-e715-4555-a9da-2480056b407a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/non-wear/non-wear-test.ipynb b/code/tests/non-wear/non-wear-test.ipynb deleted file mode 100644 index 4729e03..0000000 --- a/code/tests/non-wear/non-wear-test.ipynb +++ /dev/null @@ -1,1091 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "3fb4a319-39a2-4dbd-867f-0fc05daa2b93", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import os" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "7a424200-1fb0-49c0-ae27-0a250437994b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IDD1_dateD1_inbedD1_wakeupD2_dateD2_inbedD2_wakeupD3_dateD3_inbedD3_wakeup...D7_wakeupD8_dateD8_inbedD8_wakeupD9_dateD9_inbedD9_wakeupD10_dateD10_inbedD10_wakeup
0sub-8022_ses-1_accel2025-02-0719:00:0008:30:002025-02-0823:45:0007:30:002025-02-0923:55:0007:00:00...07:00:002025-02-1501:00:0009:00:00NaNNaNNaNNaNNaNNaN
1sub-8022_ses-2_accel2025-04-1700:00:0006:30:002025-04-1823:10:0007:40:002025-04-2002:45:0007:30:00...08:00:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
2sub-8001_ses-1_accel2024-09-2100:30:0008:30:002024-09-2200:15:0007:40:002024-09-2305:20:0009:30:00...09:00:002024-09-2800:30:0008:45:002024-09-2900:30:0008:15:002024-09-3000:20:0008:30:00
3sub-8002_ses-1_accel2024-09-1422:15:0006:45:002024-09-1523:00:0006:45:002024-09-1622:51:0006:45:00...07:00:002024-09-2122:30:0006:45:002024-09-2222:45:0006:45:00NaNNaNNaN
4sub-8002_ses-2_accel2024-11-0723:00:0003:30:002024-11-0821:30:0005:30:002024-11-0921:30:0005:30:00...06:15:002024-11-1422:45:0006:15:002024-11-1522:30:0007:00:00NaNNaNNaN
\n", - "

5 rows × 31 columns

\n", - "
" - ], - "text/plain": [ - " ID D1_date D1_inbed D1_wakeup D2_date D2_inbed \\\n", - "0 sub-8022_ses-1_accel 2025-02-07 19:00:00 08:30:00 2025-02-08 23:45:00 \n", - "1 sub-8022_ses-2_accel 2025-04-17 00:00:00 06:30:00 2025-04-18 23:10:00 \n", - "2 sub-8001_ses-1_accel 2024-09-21 00:30:00 08:30:00 2024-09-22 00:15:00 \n", - "3 sub-8002_ses-1_accel 2024-09-14 22:15:00 06:45:00 2024-09-15 23:00:00 \n", - "4 sub-8002_ses-2_accel 2024-11-07 23:00:00 03:30:00 2024-11-08 21:30:00 \n", - "\n", - " D2_wakeup D3_date D3_inbed D3_wakeup ... D7_wakeup D8_date \\\n", - "0 07:30:00 2025-02-09 23:55:00 07:00:00 ... 07:00:00 2025-02-15 \n", - "1 07:40:00 2025-04-20 02:45:00 07:30:00 ... 08:00:00 NaN \n", - "2 07:40:00 2024-09-23 05:20:00 09:30:00 ... 09:00:00 2024-09-28 \n", - "3 06:45:00 2024-09-16 22:51:00 06:45:00 ... 07:00:00 2024-09-21 \n", - "4 05:30:00 2024-11-09 21:30:00 05:30:00 ... 06:15:00 2024-11-14 \n", - "\n", - " D8_inbed D8_wakeup D9_date D9_inbed D9_wakeup D10_date D10_inbed \\\n", - "0 01:00:00 09:00:00 NaN NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN NaN NaN NaN \n", - "2 00:30:00 08:45:00 2024-09-29 00:30:00 08:15:00 2024-09-30 00:20:00 \n", - "3 22:30:00 06:45:00 2024-09-22 22:45:00 06:45:00 NaN NaN \n", - "4 22:45:00 06:15:00 2024-11-15 22:30:00 07:00:00 NaN NaN \n", - "\n", - " D10_wakeup \n", - "0 NaN \n", - "1 NaN \n", - "2 08:30:00 \n", - "3 NaN \n", - "4 NaN \n", - "\n", - "[5 rows x 31 columns]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "int_sleep = pd.read_csv('/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/sleep_log_intervention.csv')\n", - "int_sleep.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "c0475254-fcab-46af-92e4-738ae6d35b3d", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import sys\n", - "import logging\n", - "import pandas as pd\n", - "import requests\n", - "from datetime import datetime, timedelta\n", - "from io import StringIO\n", - "\n", - "class ID_COMPARISONS:\n", - " \n", - " def __init__(self, token, daysago=None) -> None:\n", - " self.token = token\n", - " self.INT_DIR = 'mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test'\n", - " self.OBS_DIR = '/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test'\n", - " self.daysago = daysago\n", - " logging.basicConfig(level=logging.INFO, format=\"%(asctime)s - %(levelname)s - %(message)s\")\n", - "\n", - " def compare_ids(self):\n", - " \"\"\"\n", - " Pulls all files from RDSS\n", - " Pulls the list from RedCap\n", - " Compares IDs and returns a dictionary with two keys:\n", - " - 'matches': normal matches mapping boost_id to a list of dicts (filename, labID, date)\n", - " - 'duplicates': a list of dictionaries each with lab_id, boost_id, filenames (list), and dates (list)\n", - " \"\"\"\n", - " # Retrieve the RedCap report and duplicates from report\n", - " report, report_duplicates = self._return_report()\n", - " # Retrieve the full RDSS file list and duplicate files merged with duplicates from report\n", - " rdss, file_duplicates = self._rdss_file_list(report_duplicates, self.daysago)\n", - "\n", - " # Initialize the result dictionary for normal (non-duplicate) matches\n", - " result = {}\n", - "\n", - " # Iterate over the rows in the cleaned RedCap report\n", - " for _, row in report.iterrows():\n", - " boost_id = str(row['boost_id'])\n", - " lab_id = str(row['lab_id'])\n", - " \n", - " # Find matching files in the RDSS list\n", - " rdss_matches = rdss[rdss['ID'] == lab_id]\n", - " if not rdss_matches.empty:\n", - " if boost_id not in result:\n", - " result[boost_id] = []\n", - " for _, match_row in rdss_matches.iterrows():\n", - " result[boost_id].append({\n", - " 'filename': match_row['filename'],\n", - " 'labID': lab_id,\n", - " 'date': match_row['Date']\n", - " })\n", - " \n", - " # Process duplicates into the desired structure.\n", - " duplicates_dict = []\n", - " if not file_duplicates.empty:\n", - " # Group by lab_id and boost_id; each group represents one duplicate combination.\n", - " grouped = file_duplicates.groupby(['lab_id', 'boost_id'])\n", - " for (lab_id, boost_id), group in grouped:\n", - " duplicates_dict.append({\n", - " 'lab_id': lab_id,\n", - " 'boost_id': boost_id,\n", - " 'filenames': group['filename'].tolist(),\n", - " 'dates': group['Date'].tolist()\n", - " })\n", - " else:\n", - " logging.info(\"Found no duplicates.\")\n", - "\n", - " return {'matches': result, 'duplicates': duplicates_dict}\n", - "\n", - " def _return_report(self):\n", - " \"\"\"\n", - " pulls the id report from the rdss via redcap api.\n", - " reads the report as a dataframe.\n", - " checks for boost_ids that are associated with multiple lab_ids, logs a critical error,\n", - " and removes these rows from the dataframe.\n", - " separates duplicate rows (based on any column) from the cleaned data.\n", - " \n", - " returns:\n", - " df_cleaned: dataframe with duplicates removed and problematic boost_ids excluded\n", - " duplicate_rows: dataframe of duplicate rows\n", - " \"\"\"\n", - " url = 'https://redcap.icts.uiowa.edu/redcap/api/'\n", - " data = {\n", - " 'token': self.token,\n", - " 'content': 'report',\n", - " 'report_id': 43327,\n", - " 'format': 'csv'\n", - " }\n", - " r = requests.post(url, data=data)\n", - " if r.status_code != 200:\n", - " print(f\"error! status code is {r.status_code}\")\n", - " sys.exit(1)\n", - " \n", - " df = pd.read_csv(StringIO(r.text))\n", - " \n", - " # identify boost_ids associated with multiple lab_ids.\n", - " boost_id_counts = df.groupby('boost_id')['lab_id'].nunique()\n", - " problematic_boost_ids = boost_id_counts[boost_id_counts > 1].index.tolist()\n", - " \n", - " if problematic_boost_ids:\n", - " logging.critical(f\"found boost_id(s) with multiple lab_ids: {', '.join(map(str, problematic_boost_ids))}. \"\n", - " \"these entries will be removed from processing.\")\n", - " df = df[~df['boost_id'].isin(problematic_boost_ids)]\n", - " \n", - " # identify and separate duplicate rows based on any column.\n", - " duplicate_rows = df[df.duplicated(keep=False)]\n", - " df_cleaned = df.drop_duplicates(keep=False)\n", - " \n", - " if not duplicate_rows.empty:\n", - " logging.info(f\"duplicate rows found:\\n{duplicate_rows}\")\n", - " \n", - " return df_cleaned, duplicate_rows\n", - "\n", - " def _rdss_file_list(self, duplicates, daysago=None):\n", - " \"\"\"\n", - " extracts the first string before the space and the date from filenames ending with .csv\n", - " in the specified folder and stores them in a dataframe.\n", - " \n", - " Also, merges the file list with duplicate report entries based on lab_id.\n", - " \n", - " Returns:\n", - " df: DataFrame of all file entries\n", - " merged_df: DataFrame of file entries that match duplicate lab_ids from the report\n", - " \"\"\"\n", - " extracted_data = []\n", - "\n", - " # Loop through all files in the rdss_dir folder.\n", - " rdss_dir = '/mnt/rdss/VossLab/Repositories/Accelerometer_Data'\n", - " for filename in os.listdir(rdss_dir):\n", - " if filename.endswith('.csv'):\n", - " try:\n", - " base_name = filename.split(' ')[0] # Extract lab_id\n", - " date_part = filename.split('(')[1].split(')')[0] # Extract date\n", - " extracted_data.append({'ID': base_name, 'Date': date_part, 'filename': filename})\n", - " except IndexError:\n", - " print(f\"Skipping file with unexpected format: {filename}\")\n", - "\n", - " df = pd.DataFrame(extracted_data)\n", - "\n", - " if not df.empty:\n", - " df['Date'] = pd.to_datetime(df['Date'], errors='coerce')\n", - "\n", - " if daysago:\n", - " cutoff_date = datetime.today() - timedelta(days=daysago)\n", - " df = df[df['Date'] >= cutoff_date] # Filter files within the last `daysago` days\n", - " else:\n", - " df = df[df['Date'] >= '2024-08-05'] # Filter out rows before the threshold date\n", - "\n", - " # Filter the file list to only include rows where ID is in the duplicate report (if any)\n", - " if not duplicates.empty:\n", - " matched_df = df[df['ID'].isin(duplicates['lab_id'])]\n", - " # Merge with the duplicates to bring in boost_id information from the report\n", - " merged_df = matched_df.merge(duplicates, left_on='ID', right_on='lab_id')\n", - " else:\n", - " merged_df = pd.DataFrame()\n", - "\n", - " return df, merged_df\n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "10029188-8118-4b3f-9b29-06d86d79c675", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2025-07-29 10:33:46,042 - CRITICAL - found boost_id(s) with multiple lab_ids: 7023. these entries will be removed from processing.\n", - "2025-07-29 10:33:46,616 - INFO - Found no duplicates.\n" - ] - } - ], - "source": [ - "token = \"DE4E2DB72778DACA9B8848574107D2F5\"\n", - "id = ID_COMPARISONS(token=token, daysago=400)\n", - "results = id.compare_ids()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "96026804-49c6-46e4-99b3-23bc76c95160", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'matches': {'8022': [{'filename': '1023 (2025-02-07)RAW.csv',\n", - " 'labID': '1023',\n", - " 'date': Timestamp('2025-02-07 00:00:00')},\n", - " {'filename': '1023 (2025-04-17)RAW.csv',\n", - " 'labID': '1023',\n", - " 'date': Timestamp('2025-04-17 00:00:00')}],\n", - " '7062': [{'filename': '1043 (2025-02-22)RAW.csv',\n", - " 'labID': '1043',\n", - " 'date': Timestamp('2025-02-22 00:00:00')}],\n", - " '7146': [{'filename': '1051 (2025-05-05)RAW.csv',\n", - " 'labID': '1051',\n", - " 'date': Timestamp('2025-05-05 00:00:00')}],\n", - " '6011': [{'filename': '1093 (2024-08-09)RAW.csv',\n", - " 'labID': '1093',\n", - " 'date': Timestamp('2024-08-09 00:00:00')}],\n", - " '6013': [{'filename': '1098 (2024-08-14)RAW.csv',\n", - " 'labID': '1098',\n", - " 'date': Timestamp('2024-08-14 00:00:00')}],\n", - " '6022, 7143': [{'filename': '1108 (2025-05-08)RAW.csv',\n", - " 'labID': '1108',\n", - " 'date': Timestamp('2025-05-08 00:00:00')}],\n", - " '7001': [{'filename': '1111 (2024-09-05)RAW.csv',\n", - " 'labID': '1111',\n", - " 'date': Timestamp('2024-09-05 00:00:00')}],\n", - " '7002': [{'filename': '1112 (2024-08-07)RAW.csv',\n", - " 'labID': '1112',\n", - " 'date': Timestamp('2024-08-07 00:00:00')}],\n", - " '7003': [{'filename': '1113 (2024-08-20)RAW.csv',\n", - " 'labID': '1113',\n", - " 'date': Timestamp('2024-08-20 00:00:00')}],\n", - " '7004': [{'filename': '1114 (2024-09-04)RAW.csv',\n", - " 'labID': '1114',\n", - " 'date': Timestamp('2024-09-04 00:00:00')}],\n", - " '7006': [{'filename': '1115 (2024-08-05)RAW.csv',\n", - " 'labID': '1115',\n", - " 'date': Timestamp('2024-08-05 00:00:00')}],\n", - " '7012': [{'filename': '1116 (2024-08-29)RAW.csv',\n", - " 'labID': '1116',\n", - " 'date': Timestamp('2024-08-29 00:00:00')}],\n", - " '7009': [{'filename': '1117 (2024-08-07)RAW.csv',\n", - " 'labID': '1117',\n", - " 'date': Timestamp('2024-08-07 00:00:00')}],\n", - " '7010': [{'filename': '1118 (2024-08-09)RAW.csv',\n", - " 'labID': '1118',\n", - " 'date': Timestamp('2024-08-09 00:00:00')}],\n", - " '7015': [{'filename': '1120 (2024-08-13)RAW.csv',\n", - " 'labID': '1120',\n", - " 'date': Timestamp('2024-08-13 00:00:00')}],\n", - " '7016': [{'filename': '1121 (2024-09-03)RAW.csv',\n", - " 'labID': '1121',\n", - " 'date': Timestamp('2024-09-03 00:00:00')}],\n", - " '7017': [{'filename': '1122 (2024-08-22)RAW.csv',\n", - " 'labID': '1122',\n", - " 'date': Timestamp('2024-08-22 00:00:00')}],\n", - " '8001': [{'filename': '1123 (2024-09-20)RAW.csv',\n", - " 'labID': '1123',\n", - " 'date': Timestamp('2024-09-20 00:00:00')}],\n", - " '8002': [{'filename': '1124 (2024-11-07)RAW.csv',\n", - " 'labID': '1124',\n", - " 'date': Timestamp('2024-11-07 00:00:00')},\n", - " {'filename': '1124 (2024-09-13)RAW.csv',\n", - " 'labID': '1124',\n", - " 'date': Timestamp('2024-09-13 00:00:00')},\n", - " {'filename': '1124 (2025-02-26)RAW.csv',\n", - " 'labID': '1124',\n", - " 'date': Timestamp('2025-02-26 00:00:00')},\n", - " {'filename': '1124 (2025-05-05)RAW.csv',\n", - " 'labID': '1124',\n", - " 'date': Timestamp('2025-05-05 00:00:00')}],\n", - " '8003': [{'filename': '1125 (2025-02-01)RAW.csv',\n", - " 'labID': '1125',\n", - " 'date': Timestamp('2025-02-01 00:00:00')},\n", - " {'filename': '1125 (2024-10-04)RAW.csv',\n", - " 'labID': '1125',\n", - " 'date': Timestamp('2024-10-04 00:00:00')},\n", - " {'filename': '1125 (2025-05-31)RAW.csv',\n", - " 'labID': '1125',\n", - " 'date': Timestamp('2025-05-31 00:00:00')}],\n", - " '8004': [{'filename': '1126 (2024-09-25)RAW.csv',\n", - " 'labID': '1126',\n", - " 'date': Timestamp('2024-09-25 00:00:00')},\n", - " {'filename': '1126 (2024-11-22)RAW.csv',\n", - " 'labID': '1126',\n", - " 'date': Timestamp('2024-11-22 00:00:00')},\n", - " {'filename': '1126 (2025-04-30)RAW.csv',\n", - " 'labID': '1126',\n", - " 'date': Timestamp('2025-04-30 00:00:00')},\n", - " {'filename': '1126 (2025-03-12)RAW.csv',\n", - " 'labID': '1126',\n", - " 'date': Timestamp('2025-03-12 00:00:00')}],\n", - " '8006': [{'filename': '1129 (2024-09-20)RAW.csv',\n", - " 'labID': '1129',\n", - " 'date': Timestamp('2024-09-20 00:00:00')},\n", - " {'filename': '1129 (2024-12-12)RAW.csv',\n", - " 'labID': '1129',\n", - " 'date': Timestamp('2024-12-12 00:00:00')},\n", - " {'filename': '1129 (2025-05-14)RAW.csv',\n", - " 'labID': '1129',\n", - " 'date': Timestamp('2025-05-14 00:00:00')},\n", - " {'filename': '1129 (2025-04-16)RAW.csv',\n", - " 'labID': '1129',\n", - " 'date': Timestamp('2025-04-16 00:00:00')}],\n", - " '7019': [{'filename': '1130 (2024-09-24)RAW.csv',\n", - " 'labID': '1130',\n", - " 'date': Timestamp('2024-09-24 00:00:00')}],\n", - " '7020': [{'filename': '1131 (2024-10-08)RAW.csv',\n", - " 'labID': '1131',\n", - " 'date': Timestamp('2024-10-08 00:00:00')}],\n", - " '7021': [{'filename': '1132 (2024-10-02)RAW.csv',\n", - " 'labID': '1132',\n", - " 'date': Timestamp('2024-10-02 00:00:00')}],\n", - " '7022': [{'filename': '1133 (2024-10-01)RAW.csv',\n", - " 'labID': '1133',\n", - " 'date': Timestamp('2024-10-01 00:00:00')}],\n", - " '8005': [{'filename': '1134 (2024-10-30)RAW.csv',\n", - " 'labID': '1134',\n", - " 'date': Timestamp('2024-10-30 00:00:00')},\n", - " {'filename': '1134 (2025-01-15)RAW.csv',\n", - " 'labID': '1134',\n", - " 'date': Timestamp('2025-01-15 00:00:00')},\n", - " {'filename': '1134 (2025-05-22)RAW.csv',\n", - " 'labID': '1134',\n", - " 'date': Timestamp('2025-05-22 00:00:00')},\n", - " {'filename': '1134 (2025-06-26)RAW.csv',\n", - " 'labID': '1134',\n", - " 'date': Timestamp('2025-06-26 00:00:00')}],\n", - " '7024': [{'filename': '1136 (2024-10-11)RAW.csv',\n", - " 'labID': '1136',\n", - " 'date': Timestamp('2024-10-11 00:00:00')}],\n", - " '7025': [{'filename': '1137 (2024-10-11)RAW.csv',\n", - " 'labID': '1137',\n", - " 'date': Timestamp('2024-10-11 00:00:00')}],\n", - " '7026': [{'filename': '1138 (2024-10-24)RAW.csv',\n", - " 'labID': '1138',\n", - " 'date': Timestamp('2024-10-24 00:00:00')}],\n", - " '7027': [{'filename': '1139 (2024-11-08)RAW.csv',\n", - " 'labID': '1139',\n", - " 'date': Timestamp('2024-11-08 00:00:00')}],\n", - " '7028': [{'filename': '1140 (2024-10-28)RAW.csv',\n", - " 'labID': '1140',\n", - " 'date': Timestamp('2024-10-28 00:00:00')}],\n", - " '7029': [{'filename': '1141 (2024-11-05)RAW.csv',\n", - " 'labID': '1141',\n", - " 'date': Timestamp('2024-11-05 00:00:00')}],\n", - " '7030': [{'filename': '1142 (2024-10-24)RAW.csv',\n", - " 'labID': '1142',\n", - " 'date': Timestamp('2024-10-24 00:00:00')}],\n", - " '7032': [{'filename': '1144 (2024-11-12)RAW.csv',\n", - " 'labID': '1144',\n", - " 'date': Timestamp('2024-11-12 00:00:00')}],\n", - " '7033': [{'filename': '1145 (2024-11-06)RAW.csv',\n", - " 'labID': '1145',\n", - " 'date': Timestamp('2024-11-06 00:00:00')}],\n", - " '8008': [{'filename': '1146 (2024-11-04)RAW.csv',\n", - " 'labID': '1146',\n", - " 'date': Timestamp('2024-11-04 00:00:00')},\n", - " {'filename': '1146 (2025-01-09)RAW.csv',\n", - " 'labID': '1146',\n", - " 'date': Timestamp('2025-01-09 00:00:00')},\n", - " {'filename': '1146 (2025-03-19)RAW.csv',\n", - " 'labID': '1146',\n", - " 'date': Timestamp('2025-03-19 00:00:00')}],\n", - " '7034': [{'filename': '1147 (2024-11-14)RAW.csv',\n", - " 'labID': '1147',\n", - " 'date': Timestamp('2024-11-14 00:00:00')}],\n", - " '7035': [{'filename': '1148 (2024-11-04)RAW.csv',\n", - " 'labID': '1148',\n", - " 'date': Timestamp('2024-11-04 00:00:00')}],\n", - " '8011': [{'filename': '1151 (2025-02-20)RAW.csv',\n", - " 'labID': '1151',\n", - " 'date': Timestamp('2025-02-20 00:00:00')},\n", - " {'filename': '1151 (2024-12-06)RAW.csv',\n", - " 'labID': '1151',\n", - " 'date': Timestamp('2024-12-06 00:00:00')}],\n", - " '7031': [{'filename': '1155 (2024-12-18)RAW.csv',\n", - " 'labID': '1155',\n", - " 'date': Timestamp('2024-12-18 00:00:00')}],\n", - " '8012': [{'filename': '1158 (2025-05-09)RAW.csv',\n", - " 'labID': '1158',\n", - " 'date': Timestamp('2025-05-09 00:00:00')},\n", - " {'filename': '1158 (2025-01-09)RAW.csv',\n", - " 'labID': '1158',\n", - " 'date': Timestamp('2025-01-09 00:00:00')}],\n", - " '8014': [{'filename': '1160 (2025-01-15)RAW.csv',\n", - " 'labID': '1160',\n", - " 'date': Timestamp('2025-01-15 00:00:00')},\n", - " {'filename': '1160 (2025-05-03)RAW.csv',\n", - " 'labID': '1160',\n", - " 'date': Timestamp('2025-05-03 00:00:00')}],\n", - " '7037': [{'filename': '1161 (2025-01-18)RAW.csv',\n", - " 'labID': '1161',\n", - " 'date': Timestamp('2025-01-18 00:00:00')}],\n", - " '8015': [{'filename': '1162 (2025-01-29)RAW.csv',\n", - " 'labID': '1162',\n", - " 'date': Timestamp('2025-01-29 00:00:00')}],\n", - " '8016': [{'filename': '1163 (2025-02-19)RAW.csv',\n", - " 'labID': '1163',\n", - " 'date': Timestamp('2025-02-19 00:00:00')},\n", - " {'filename': '1163 (2025-04-07)RAW.csv',\n", - " 'labID': '1163',\n", - " 'date': Timestamp('2025-04-07 00:00:00')}],\n", - " '8017': [{'filename': '1165 (2025-04-09)RAW.csv',\n", - " 'labID': '1165',\n", - " 'date': Timestamp('2025-04-09 00:00:00')}],\n", - " '7039': [{'filename': '1166 (2025-01-21)RAW.csv',\n", - " 'labID': '1166',\n", - " 'date': Timestamp('2025-01-21 00:00:00')}],\n", - " '8018': [{'filename': '1167 (2025-01-22)RAW.csv',\n", - " 'labID': '1167',\n", - " 'date': Timestamp('2025-01-22 00:00:00')},\n", - " {'filename': '1167 (2025-01-21)RAW.csv',\n", - " 'labID': '1167',\n", - " 'date': Timestamp('2025-01-21 00:00:00')},\n", - " {'filename': '1167 (2025-05-21)RAW.csv',\n", - " 'labID': '1167',\n", - " 'date': Timestamp('2025-05-21 00:00:00')}],\n", - " '8019': [{'filename': '1168 (2025-01-28)RAW.csv',\n", - " 'labID': '1168',\n", - " 'date': Timestamp('2025-01-28 00:00:00')},\n", - " {'filename': '1168 (2025-04-23)RAW.csv',\n", - " 'labID': '1168',\n", - " 'date': Timestamp('2025-04-23 00:00:00')}],\n", - " '8020': [{'filename': '1169 (2025-04-09)RAW.csv',\n", - " 'labID': '1169',\n", - " 'date': Timestamp('2025-04-09 00:00:00')},\n", - " {'filename': '1169 (2025-01-30)RAW.csv',\n", - " 'labID': '1169',\n", - " 'date': Timestamp('2025-01-30 00:00:00')}],\n", - " '8021': [{'filename': '1170 (2025-01-29)RAW.csv',\n", - " 'labID': '1170',\n", - " 'date': Timestamp('2025-01-29 00:00:00')},\n", - " {'filename': '1170 (2025-05-24)RAW.csv',\n", - " 'labID': '1170',\n", - " 'date': Timestamp('2025-05-24 00:00:00')}],\n", - " '7040': [{'filename': '1171 (2025-02-08)RAW.csv',\n", - " 'labID': '1171',\n", - " 'date': Timestamp('2025-02-08 00:00:00')}],\n", - " '7041': [{'filename': '1172 (2025-01-28)RAW.csv',\n", - " 'labID': '1172',\n", - " 'date': Timestamp('2025-01-28 00:00:00')},\n", - " {'filename': '1172 (2025-05-29)RAW.csv',\n", - " 'labID': '1172',\n", - " 'date': Timestamp('2025-05-29 00:00:00')}],\n", - " '7042': [{'filename': '1173 (2025-03-01)RAW.csv',\n", - " 'labID': '1173',\n", - " 'date': Timestamp('2025-03-01 00:00:00')}],\n", - " '7043': [{'filename': '1174 (2025-01-28)RAW.csv',\n", - " 'labID': '1174',\n", - " 'date': Timestamp('2025-01-28 00:00:00')},\n", - " {'filename': '1174 (2025-01-27)RAW.csv',\n", - " 'labID': '1174',\n", - " 'date': Timestamp('2025-01-27 00:00:00')}],\n", - " '7047': [{'filename': '1178 (2025-02-12)RAW.csv',\n", - " 'labID': '1178',\n", - " 'date': Timestamp('2025-02-12 00:00:00')}],\n", - " '7048': [{'filename': '1179 (2025-03-11)RAW.csv',\n", - " 'labID': '1179',\n", - " 'date': Timestamp('2025-03-11 00:00:00')}],\n", - " '7049': [{'filename': '1180 (2025-02-18)RAW.csv',\n", - " 'labID': '1180',\n", - " 'date': Timestamp('2025-02-18 00:00:00')}],\n", - " '7050': [{'filename': '1181 (2025-02-21)RAW.csv',\n", - " 'labID': '1181',\n", - " 'date': Timestamp('2025-02-21 00:00:00')}],\n", - " '7052': [{'filename': '1183 (2025-02-13)RAW.csv',\n", - " 'labID': '1183',\n", - " 'date': Timestamp('2025-02-13 00:00:00')}],\n", - " '8023': [{'filename': '1185 (2025-04-10)RAW.csv',\n", - " 'labID': '1185',\n", - " 'date': Timestamp('2025-04-10 00:00:00')}],\n", - " '8024': [{'filename': '1186 (2025-03-08)RAW.csv',\n", - " 'labID': '1186',\n", - " 'date': Timestamp('2025-03-08 00:00:00')},\n", - " {'filename': '1186 (2025-05-30)RAW.csv',\n", - " 'labID': '1186',\n", - " 'date': Timestamp('2025-05-30 00:00:00')}],\n", - " '7054': [{'filename': '1187 (2025-02-11)RAW.csv',\n", - " 'labID': '1187',\n", - " 'date': Timestamp('2025-02-11 00:00:00')}],\n", - " '7056': [{'filename': '1190 (2025-02-22)RAW.csv',\n", - " 'labID': '1190',\n", - " 'date': Timestamp('2025-02-22 00:00:00')}],\n", - " '7057': [{'filename': '1191 (2025-02-15)RAW.csv',\n", - " 'labID': '1191',\n", - " 'date': Timestamp('2025-02-15 00:00:00')}],\n", - " '7058': [{'filename': '1192 (2025-02-21)RAW.csv',\n", - " 'labID': '1192',\n", - " 'date': Timestamp('2025-02-21 00:00:00')}],\n", - " '7059': [{'filename': '1193 (2025-02-25)RAW.csv',\n", - " 'labID': '1193',\n", - " 'date': Timestamp('2025-02-25 00:00:00')}],\n", - " '8026': [{'filename': '1194 (2025-02-04)RAW.csv',\n", - " 'labID': '1194',\n", - " 'date': Timestamp('2025-02-04 00:00:00')},\n", - " {'filename': '1194 (2025-05-23)RAW.csv',\n", - " 'labID': '1194',\n", - " 'date': Timestamp('2025-05-23 00:00:00')}],\n", - " '7061': [{'filename': '1196 (2025-02-15)RAW.csv',\n", - " 'labID': '1196',\n", - " 'date': Timestamp('2025-02-15 00:00:00')}],\n", - " '7063': [{'filename': '1197 (2025-02-25)RAW.csv',\n", - " 'labID': '1197',\n", - " 'date': Timestamp('2025-02-25 00:00:00')}],\n", - " '8030': [{'filename': '1200 (2025-05-10)RAW.csv',\n", - " 'labID': '1200',\n", - " 'date': Timestamp('2025-05-10 00:00:00')}],\n", - " '7064': [{'filename': '1202 (2025-03-01)RAW.csv',\n", - " 'labID': '1202',\n", - " 'date': Timestamp('2025-03-01 00:00:00')}],\n", - " '7067': [{'filename': '1205 (2025-02-21)RAW.csv',\n", - " 'labID': '1205',\n", - " 'date': Timestamp('2025-02-21 00:00:00')}],\n", - " '7068': [{'filename': '1206 (2025-02-27)RAW.csv',\n", - " 'labID': '1206',\n", - " 'date': Timestamp('2025-02-27 00:00:00')}],\n", - " '7069': [{'filename': '1207 (2025-03-01)RAW.csv',\n", - " 'labID': '1207',\n", - " 'date': Timestamp('2025-03-01 00:00:00')}],\n", - " '7072': [{'filename': '1210 (2025-03-01)RAW.csv',\n", - " 'labID': '1210',\n", - " 'date': Timestamp('2025-03-01 00:00:00')}],\n", - " '7073': [{'filename': '1211 (2025-03-01)RAW.csv',\n", - " 'labID': '1211',\n", - " 'date': Timestamp('2025-03-01 00:00:00')}],\n", - " '7075': [{'filename': '1213 (2025-03-04)RAW.csv',\n", - " 'labID': '1213',\n", - " 'date': Timestamp('2025-03-04 00:00:00')}],\n", - " '7076': [{'filename': '1214 (2025-03-11)RAW.csv',\n", - " 'labID': '1214',\n", - " 'date': Timestamp('2025-03-11 00:00:00')}],\n", - " '7077': [{'filename': '1215 (2025-03-14)RAW.csv',\n", - " 'labID': '1215',\n", - " 'date': Timestamp('2025-03-14 00:00:00')}],\n", - " '7078': [{'filename': '1216 (2025-03-08)RAW.csv',\n", - " 'labID': '1216',\n", - " 'date': Timestamp('2025-03-08 00:00:00')}],\n", - " '7079': [{'filename': '1217 (2025-03-13)RAW.csv',\n", - " 'labID': '1217',\n", - " 'date': Timestamp('2025-03-13 00:00:00')}],\n", - " '7080': [{'filename': '1218 (2025-03-07)RAW.csv',\n", - " 'labID': '1218',\n", - " 'date': Timestamp('2025-03-07 00:00:00')}],\n", - " '7082': [{'filename': '1220 (2025-03-19)RAW.csv',\n", - " 'labID': '1220',\n", - " 'date': Timestamp('2025-03-19 00:00:00')}],\n", - " '8032': [{'filename': '1221 (2025-05-22)RAW.csv',\n", - " 'labID': '1221',\n", - " 'date': Timestamp('2025-05-22 00:00:00')}],\n", - " '7083': [{'filename': '1222 (2025-03-06)RAW.csv',\n", - " 'labID': '1222',\n", - " 'date': Timestamp('2025-03-06 00:00:00')}],\n", - " '7084': [{'filename': '1223 (2025-03-29)RAW.csv',\n", - " 'labID': '1223',\n", - " 'date': Timestamp('2025-03-29 00:00:00')}],\n", - " '7085': [{'filename': '1224 (2025-03-18)RAW.csv',\n", - " 'labID': '1224',\n", - " 'date': Timestamp('2025-03-18 00:00:00')}],\n", - " '7086': [{'filename': '1225 (2025-03-06)RAW.csv',\n", - " 'labID': '1225',\n", - " 'date': Timestamp('2025-03-06 00:00:00')}],\n", - " '7087': [{'filename': '1226 (2025-03-06)RAW.csv',\n", - " 'labID': '1226',\n", - " 'date': Timestamp('2025-03-06 00:00:00')}],\n", - " '7088': [{'filename': '1227 (2025-04-03)RAW.csv',\n", - " 'labID': '1227',\n", - " 'date': Timestamp('2025-04-03 00:00:00')}],\n", - " '7089': [{'filename': '1228 (2025-03-20)RAW.csv',\n", - " 'labID': '1228',\n", - " 'date': Timestamp('2025-03-20 00:00:00')}],\n", - " '7093': [{'filename': '1232 (2025-03-12)RAW.csv',\n", - " 'labID': '1232',\n", - " 'date': Timestamp('2025-03-12 00:00:00')}],\n", - " '7094': [{'filename': '1233 (2025-03-27)RAW.csv',\n", - " 'labID': '1233',\n", - " 'date': Timestamp('2025-03-27 00:00:00')}],\n", - " '7065': [{'filename': '1234 (2025-03-20)RAW.csv',\n", - " 'labID': '1234',\n", - " 'date': Timestamp('2025-03-20 00:00:00')}],\n", - " '7096': [{'filename': '1236 (2025-03-29)RAW.csv',\n", - " 'labID': '1236',\n", - " 'date': Timestamp('2025-03-29 00:00:00')}],\n", - " '7098': [{'filename': '1239 (2025-04-05)RAW.csv',\n", - " 'labID': '1239',\n", - " 'date': Timestamp('2025-04-05 00:00:00')}],\n", - " '7099': [{'filename': '1240 (2025-03-08)RAW.csv',\n", - " 'labID': '1240',\n", - " 'date': Timestamp('2025-03-08 00:00:00')}],\n", - " '7102': [{'filename': '1242 (2025-03-28)RAW.csv',\n", - " 'labID': '1242',\n", - " 'date': Timestamp('2025-03-28 00:00:00')}],\n", - " '7045': [{'filename': '1243 (2025-03-20)RAW.csv',\n", - " 'labID': '1243',\n", - " 'date': Timestamp('2025-03-20 00:00:00')}],\n", - " '7103': [{'filename': '1244 (2025-04-03)RAW.csv',\n", - " 'labID': '1244',\n", - " 'date': Timestamp('2025-04-03 00:00:00')}],\n", - " '7104': [{'filename': '1245 (2025-04-03)RAW.csv',\n", - " 'labID': '1245',\n", - " 'date': Timestamp('2025-04-03 00:00:00')}],\n", - " '7105': [{'filename': '1246 (2025-03-14)RAW.csv',\n", - " 'labID': '1246',\n", - " 'date': Timestamp('2025-03-14 00:00:00')}],\n", - " '8035': [{'filename': '1249 (2025-03-19)RAW.csv',\n", - " 'labID': '1249',\n", - " 'date': Timestamp('2025-03-19 00:00:00')},\n", - " {'filename': '1249 (2025-05-31)RAW.csv',\n", - " 'labID': '1249',\n", - " 'date': Timestamp('2025-05-31 00:00:00')}],\n", - " '7091': [{'filename': '1250 (2025-03-27)RAW.csv',\n", - " 'labID': '1250',\n", - " 'date': Timestamp('2025-03-27 00:00:00')}],\n", - " '7070': [{'filename': '1251 (2025-04-05)RAW.csv',\n", - " 'labID': '1251',\n", - " 'date': Timestamp('2025-04-05 00:00:00')}],\n", - " '7106': [{'filename': '1252 (2025-03-28)RAW.csv',\n", - " 'labID': '1252',\n", - " 'date': Timestamp('2025-03-28 00:00:00')}],\n", - " '7107': [{'filename': '1254 (2025-04-12)RAW.csv',\n", - " 'labID': '1254',\n", - " 'date': Timestamp('2025-04-12 00:00:00')}],\n", - " '7108': [{'filename': '1255 (2025-03-14)RAW.csv',\n", - " 'labID': '1255',\n", - " 'date': Timestamp('2025-03-14 00:00:00')}],\n", - " '7110': [{'filename': '1257 (2025-04-04)RAW.csv',\n", - " 'labID': '1257',\n", - " 'date': Timestamp('2025-04-04 00:00:00')}],\n", - " '7092': [{'filename': '1260 (2025-03-28)RAW.csv',\n", - " 'labID': '1260',\n", - " 'date': Timestamp('2025-03-28 00:00:00')}],\n", - " '7090': [{'filename': '1261 (2025-04-11)RAW.csv',\n", - " 'labID': '1261',\n", - " 'date': Timestamp('2025-04-11 00:00:00')}],\n", - " '7113': [{'filename': '1262 (2025-04-04)RAW.csv',\n", - " 'labID': '1262',\n", - " 'date': Timestamp('2025-04-04 00:00:00')}],\n", - " '7114': [{'filename': '1263 (2025-03-29)RAW.csv',\n", - " 'labID': '1263',\n", - " 'date': Timestamp('2025-03-29 00:00:00')}],\n", - " '7097': [{'filename': '1264 (2025-04-05)RAW.csv',\n", - " 'labID': '1264',\n", - " 'date': Timestamp('2025-04-05 00:00:00')}],\n", - " '7115': [{'filename': '1265 (2025-04-02)RAW.csv',\n", - " 'labID': '1265',\n", - " 'date': Timestamp('2025-04-02 00:00:00')}],\n", - " '7116': [{'filename': '1266 (2025-04-03)RAW.csv',\n", - " 'labID': '1266',\n", - " 'date': Timestamp('2025-04-03 00:00:00')}],\n", - " '7117': [{'filename': '1267 (2025-03-22)RAW.csv',\n", - " 'labID': '1267',\n", - " 'date': Timestamp('2025-03-22 00:00:00')}],\n", - " '7118': [{'filename': '1268 (2025-04-08)RAW.csv',\n", - " 'labID': '1268',\n", - " 'date': Timestamp('2025-04-08 00:00:00')}],\n", - " '7120': [{'filename': '1270 (2025-04-12)RAW.csv',\n", - " 'labID': '1270',\n", - " 'date': Timestamp('2025-04-12 00:00:00')}],\n", - " '7122': [{'filename': '1272 (2025-04-05)RAW.csv',\n", - " 'labID': '1272',\n", - " 'date': Timestamp('2025-04-05 00:00:00')}],\n", - " '8036': [{'filename': '1273 (2025-03-25)RAW.csv',\n", - " 'labID': '1273',\n", - " 'date': Timestamp('2025-03-25 00:00:00')}],\n", - " '8037': [{'filename': '1276 (2025-04-04)RAW.csv',\n", - " 'labID': '1276',\n", - " 'date': Timestamp('2025-04-04 00:00:00')}],\n", - " '7124': [{'filename': '1290 (2025-04-10)RAW.csv',\n", - " 'labID': '1290',\n", - " 'date': Timestamp('2025-04-10 00:00:00')}],\n", - " '7125': [{'filename': '1291 (2025-04-10)RAW.csv',\n", - " 'labID': '1291',\n", - " 'date': Timestamp('2025-04-10 00:00:00')}],\n", - " '7128': [{'filename': '1298 (2025-04-18)RAW.csv',\n", - " 'labID': '1298',\n", - " 'date': Timestamp('2025-04-18 00:00:00')}],\n", - " '7129': [{'filename': '1299 (2025-04-19)RAW.csv',\n", - " 'labID': '1299',\n", - " 'date': Timestamp('2025-04-19 00:00:00')}],\n", - " '8038': [{'filename': '1302 (2025-04-26)RAW.csv',\n", - " 'labID': '1302',\n", - " 'date': Timestamp('2025-04-26 00:00:00')}],\n", - " '7133': [{'filename': '1304 (2025-04-29)RAW.csv',\n", - " 'labID': '1304',\n", - " 'date': Timestamp('2025-04-29 00:00:00')}],\n", - " '7134': [{'filename': '1311 (2025-05-01)RAW.csv',\n", - " 'labID': '1311',\n", - " 'date': Timestamp('2025-05-01 00:00:00')}],\n", - " '7136': [{'filename': '1313 (2025-06-03)RAW.csv',\n", - " 'labID': '1313',\n", - " 'date': Timestamp('2025-06-03 00:00:00')}],\n", - " '8039': [{'filename': '1314 (2025-05-20)RAW.csv',\n", - " 'labID': '1314',\n", - " 'date': Timestamp('2025-05-20 00:00:00')}],\n", - " '7137': [{'filename': '1315 (2025-05-05)RAW.csv',\n", - " 'labID': '1315',\n", - " 'date': Timestamp('2025-05-05 00:00:00')}],\n", - " '8040': [{'filename': '1317 (2025-05-20)RAW.csv',\n", - " 'labID': '1317',\n", - " 'date': Timestamp('2025-05-20 00:00:00')}],\n", - " '8042': [{'filename': '1320 (2025-05-20)RAW.csv',\n", - " 'labID': '1320',\n", - " 'date': Timestamp('2025-05-20 00:00:00')}],\n", - " '7138': [{'filename': '1321 (2025-05-17)RAW.csv',\n", - " 'labID': '1321',\n", - " 'date': Timestamp('2025-05-17 00:00:00')}],\n", - " '7139': [{'filename': '1322 (2025-05-10)RAW.csv',\n", - " 'labID': '1322',\n", - " 'date': Timestamp('2025-05-10 00:00:00')}],\n", - " '7140': [{'filename': '1323 (2025-05-10)RAW.csv',\n", - " 'labID': '1323',\n", - " 'date': Timestamp('2025-05-10 00:00:00')}],\n", - " '7141': [{'filename': '1324 (2025-05-17)RAW.csv',\n", - " 'labID': '1324',\n", - " 'date': Timestamp('2025-05-17 00:00:00')}],\n", - " '7142': [{'filename': '1325 (2025-05-21)RAW.csv',\n", - " 'labID': '1325',\n", - " 'date': Timestamp('2025-05-21 00:00:00')}],\n", - " '7145': [{'filename': '1327 (2025-05-10)RAW.csv',\n", - " 'labID': '1327',\n", - " 'date': Timestamp('2025-05-10 00:00:00')}],\n", - " '7147': [{'filename': '1328 (2025-06-24)RAW.csv',\n", - " 'labID': '1328',\n", - " 'date': Timestamp('2025-06-24 00:00:00')}],\n", - " '8046': [{'filename': '1330 (2025-05-28)RAW.csv',\n", - " 'labID': '1330',\n", - " 'date': Timestamp('2025-05-28 00:00:00')}],\n", - " '7150': [{'filename': '1332 (2025-05-24)RAW.csv',\n", - " 'labID': '1332',\n", - " 'date': Timestamp('2025-05-24 00:00:00')}],\n", - " '7151': [{'filename': '1333 (2025-05-13)RAW.csv',\n", - " 'labID': '1333',\n", - " 'date': Timestamp('2025-05-13 00:00:00')}],\n", - " '7152': [{'filename': '1334 (2025-05-24)RAW.csv',\n", - " 'labID': '1334',\n", - " 'date': Timestamp('2025-05-24 00:00:00')}],\n", - " '8047': [{'filename': '1335 (2025-05-14)RAW.csv',\n", - " 'labID': '1335',\n", - " 'date': Timestamp('2025-05-14 00:00:00')}],\n", - " '8048': [{'filename': '1336 (2025-06-06)RAW.csv',\n", - " 'labID': '1336',\n", - " 'date': Timestamp('2025-06-06 00:00:00')}],\n", - " '7153': [{'filename': '1337 (2025-05-17)RAW.csv',\n", - " 'labID': '1337',\n", - " 'date': Timestamp('2025-05-17 00:00:00')}],\n", - " '7155': [{'filename': '1340 (2025-06-03)RAW.csv',\n", - " 'labID': '1340',\n", - " 'date': Timestamp('2025-06-03 00:00:00')}],\n", - " '8050': [{'filename': '1341 (2025-05-21)RAW.csv',\n", - " 'labID': '1341',\n", - " 'date': Timestamp('2025-05-21 00:00:00')}],\n", - " '7156': [{'filename': '1342 (2025-05-24)RAW.csv',\n", - " 'labID': '1342',\n", - " 'date': Timestamp('2025-05-24 00:00:00')}],\n", - " '8051': [{'filename': '1343 (2025-06-20)RAW.csv',\n", - " 'labID': '1343',\n", - " 'date': Timestamp('2025-06-20 00:00:00')}],\n", - " '7157': [{'filename': '1344 (2025-05-16)RAW.csv',\n", - " 'labID': '1344',\n", - " 'date': Timestamp('2025-05-16 00:00:00')}],\n", - " '8052': [{'filename': '1345 (2025-05-28)RAW.csv',\n", - " 'labID': '1345',\n", - " 'date': Timestamp('2025-05-28 00:00:00')}],\n", - " '8053': [{'filename': '1346 (2025-06-04)RAW.csv',\n", - " 'labID': '1346',\n", - " 'date': Timestamp('2025-06-04 00:00:00')}],\n", - " '8054': [{'filename': '1347 (2025-05-30)RAW.csv',\n", - " 'labID': '1347',\n", - " 'date': Timestamp('2025-05-30 00:00:00')}],\n", - " '7158': [{'filename': '1348 (2025-06-05)RAW.csv',\n", - " 'labID': '1348',\n", - " 'date': Timestamp('2025-06-05 00:00:00')}],\n", - " '7159': [{'filename': '1349 (2025-06-05)RAW.csv',\n", - " 'labID': '1349',\n", - " 'date': Timestamp('2025-06-05 00:00:00')}],\n", - " '7160': [{'filename': '1350 (2025-06-04)RAW.csv',\n", - " 'labID': '1350',\n", - " 'date': Timestamp('2025-06-04 00:00:00')}],\n", - " '7164': [{'filename': '1354 (2025-06-12)RAW.csv',\n", - " 'labID': '1354',\n", - " 'date': Timestamp('2025-06-12 00:00:00')}],\n", - " '7165': [{'filename': '1355 (2025-06-12)RAW.csv',\n", - " 'labID': '1355',\n", - " 'date': Timestamp('2025-06-12 00:00:00')}],\n", - " '7161': [{'filename': '1356 (2025-06-10)RAW.csv',\n", - " 'labID': '1356',\n", - " 'date': Timestamp('2025-06-10 00:00:00')}],\n", - " '7167': [{'filename': '1358 (2025-06-21)RAW.csv',\n", - " 'labID': '1358',\n", - " 'date': Timestamp('2025-06-21 00:00:00')}],\n", - " '7168': [{'filename': '1359 (2025-06-20)RAW.csv',\n", - " 'labID': '1359',\n", - " 'date': Timestamp('2025-06-20 00:00:00')}],\n", - " '7170': [{'filename': '1361 (2025-06-10)RAW.csv',\n", - " 'labID': '1361',\n", - " 'date': Timestamp('2025-06-10 00:00:00')}],\n", - " '7172': [{'filename': '1363 (2025-06-18)RAW.csv',\n", - " 'labID': '1363',\n", - " 'date': Timestamp('2025-06-18 00:00:00')}],\n", - " '7174': [{'filename': '1365 (2025-06-28)RAW.csv',\n", - " 'labID': '1365',\n", - " 'date': Timestamp('2025-06-28 00:00:00')}],\n", - " '7175': [{'filename': '1366 (2025-07-02)RAW.csv',\n", - " 'labID': '1366',\n", - " 'date': Timestamp('2025-07-02 00:00:00')}],\n", - " '7178': [{'filename': '1369 (2025-06-26)RAW.csv',\n", - " 'labID': '1369',\n", - " 'date': Timestamp('2025-06-26 00:00:00')}],\n", - " '7180': [{'filename': '1372 (2025-07-02)RAW.csv',\n", - " 'labID': '1372',\n", - " 'date': Timestamp('2025-07-02 00:00:00')}],\n", - " '8056': [{'filename': '1373 (2025-07-03)RAW.csv',\n", - " 'labID': '1373',\n", - " 'date': Timestamp('2025-07-03 00:00:00')}]},\n", - " 'duplicates': []}" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "results\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2795c01b-8017-4f0d-8a2a-a57444f494de", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1a74ec55-b805-4dd5-8ebd-ddbd7e8ae5ae", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/non-wear/nonwear2.ipynb b/code/tests/non-wear/nonwear2.ipynb deleted file mode 100644 index d313c25..0000000 --- a/code/tests/non-wear/nonwear2.ipynb +++ /dev/null @@ -1,3614 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 62, - "id": "d865efd5-7f0d-42b6-89de-0a43e162dd97", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "found boost_id(s) with multiple lab_ids: 7023. these entries will be removed from processing.\n", - "Skipping file with unexpected format: 498_WearTime.csv\n", - "Skipping file with unexpected format: 633_WearTime.csv\n", - "Skipping file with unexpected format: 619_WearTime.csv\n", - "Skipping file with unexpected format: 92_WearTime.csv\n", - "Skipping file with unexpected format: 555_WearTime.csv\n", - "Skipping file with unexpected format: 649_WearTime.csv\n", - "Skipping file with unexpected format: 557_WearTime.csv\n", - "Skipping file with unexpected format: 504_WearTime.csv\n", - "Skipping file with unexpected format: 207_WearTime.csv\n", - "Skipping file with unexpected format: AP_WearTime.csv\n", - "Skipping file with unexpected format: 648_WearTime.csv\n", - "Skipping file with unexpected format: 589_WearTime.csv\n", - "Skipping file with unexpected format: 505_WearTime.csv\n", - "Skipping file with unexpected format: 579_WearTime.csv\n", - "Skipping file with unexpected format: 634_WearTime.csv\n", - "Skipping file with unexpected format: 500_WearTime.csv\n", - "Skipping file with unexpected format: 553_WearTime.csv\n", - "Skipping file with unexpected format: KS_WearTime.csv\n", - "Skipping file with unexpected format: 552_WearTime.csv\n", - "Skipping file with unexpected format: 666_WearTime.csv\n", - "Skipping file with unexpected format: 635_WearTime.csv\n", - "Skipping file with unexpected format: 311_WearTime.csv\n", - "Skipping file with unexpected format: 503_WearTime.csv\n", - "Skipping file with unexpected format: 200_WearTime.csv\n", - "Skipping file with unexpected format: 529_WearTime.csv\n", - "Skipping file with unexpected format: 664_WearTime.csv\n", - "Skipping file with unexpected format: 201_WearTime.csv\n", - "Skipping file with unexpected format: 523_WearTime.csv\n", - "Skipping file with unexpected format: 585_WearTime.csv\n", - "Skipping file with unexpected format: 644_WearTime.csv\n", - "Skipping file with unexpected format: 509_WearTime.csv\n", - "Skipping file with unexpected format: 645_WearTime.csv\n", - "Skipping file with unexpected format: 508_WearTime.csv\n", - "Skipping file with unexpected format: 616_WearTime.csv\n", - "Skipping file with unexpected format: 68_WearTime.csv\n", - "Skipping file with unexpected format: 522_WearTime.csv\n", - "Skipping file with unexpected format: 571_WearTime.csv\n", - "Skipping file with unexpected format: 614_WearTime.csv\n", - "Skipping file with unexpected format: 573_WearTime.csv\n", - "Skipping file with unexpected format: 615_WearTime.csv\n", - "Skipping file with unexpected format: 669_WearTime.csv\n", - "Skipping file with unexpected format: 577_WearTime.csv\n", - "Skipping file with unexpected format: 643_WearTime.csv\n", - "Skipping file with unexpected format: 582_WearTime.csv\n", - "Skipping file with unexpected format: 44_WearTime.csv\n", - "Skipping file with unexpected format: 583_WearTime.csv\n", - "Skipping file with unexpected format: 642_WearTime.csv\n", - "Skipping file with unexpected format: 45_WearTime.csv\n", - "Skipping file with unexpected format: 576_WearTime.csv\n", - "Skipping file with unexpected format: 613_WearTime.csv\n", - "Skipping file with unexpected format: 640_WearTime.csv\n", - "Skipping file with unexpected format: 574_WearTime.csv\n", - "Skipping file with unexpected format: 527_WearTime.csv\n", - "Skipping file with unexpected format: 575_WearTime.csv\n", - "Skipping file with unexpected format: 526_WearTime.csv\n", - "Skipping file with unexpected format: 638_WearTime.csv\n", - "Skipping file with unexpected format: 650_WearTime.csv\n", - "Skipping file with unexpected format: 537_WearTime.csv\n", - "Skipping file with unexpected format: 629_WearTime.csv\n", - "Skipping file with unexpected format: 234_WearTime.csv\n", - "Skipping file with unexpected format: 565_WearTime.csv\n", - "Skipping file with unexpected format: 628_WearTime.csv\n", - "Skipping file with unexpected format: 536_WearTime.csv\n", - "Skipping file with unexpected format: 590_WearTime.csv\n", - "Skipping file with unexpected format: 534_WearTime.csv\n", - "Skipping file with unexpected format: 567_WearTime.csv\n", - "Skipping file with unexpected format: 600_WearTime.csv\n", - "Skipping file with unexpected format: 593_WearTime.csv\n", - "Skipping file with unexpected format: 601_WearTime.csv\n", - "Skipping file with unexpected format: 566_WearTime.csv\n", - "Skipping file with unexpected format: 604_WearTime.csv\n", - "Skipping file with unexpected format: 596_WearTime.csv\n", - "Skipping file with unexpected format: 549_WearTime.csv\n", - "Skipping file with unexpected format: DK_WearTime.csv\n", - "Skipping file with unexpected format: 605_WearTime.csv\n", - "Skipping file with unexpected format: 656_WearTime.csv\n", - "Skipping file with unexpected format: 597_WearTime.csv\n", - "Skipping file with unexpected format: RC1day_WearTime.csv\n", - "Skipping file with unexpected format: 533_WearTime.csv\n", - "Skipping file with unexpected format: 560_WearTime.csv\n", - "Skipping file with unexpected format: 157_WearTime.csv\n", - "Skipping file with unexpected format: 519_WearTime.csv\n", - "Skipping file with unexpected format: 607_WearTime.csv\n", - "Skipping file with unexpected format: 655_WearTime.csv\n", - "Skipping file with unexpected format: 594_WearTime.csv\n", - "Skipping file with unexpected format: 472_WearTime.csv\n", - "Skipping file with unexpected format: 540_WearTime.csv\n", - "Skipping file with unexpected format: 182_WearTime.csv\n", - "Skipping file with unexpected format: 627_WearTime.csv\n", - "Skipping file with unexpected format: 626_WearTime.csv\n", - "Skipping file with unexpected format: 538_WearTime.csv\n", - "Skipping file with unexpected format: 541_WearTime.csv\n", - "Skipping file with unexpected format: 58_WearTime.csv\n", - "Skipping file with unexpected format: 512_WearTime.csv\n", - "Skipping file with unexpected format: 87_WearTime.csv\n", - "Skipping file with unexpected format: 624_WearTime.csv\n", - "Skipping file with unexpected format: 542_WearTime.csv\n", - "Skipping file with unexpected format: 625_WearTime.csv\n", - "Skipping file with unexpected format: 598_WearTime.csv\n", - "Skipping file with unexpected format: 547_WearTime.csv\n", - "Skipping file with unexpected format: 659_WearTime.csv\n", - "Skipping file with unexpected format: 217_WearTime.csv\n", - "Skipping file with unexpected format: 620_WearTime.csv\n", - "Skipping file with unexpected format: 621_WearTime.csv\n", - "Skipping file with unexpected format: 658_WearTime.csv\n", - "Skipping file with unexpected format: 599_WearTime.csv\n", - "Skipping file with unexpected format: 517_WearTime.csv\n", - "Skipping file with unexpected format: 609_WearTime.csv\n", - "Skipping file with unexpected format: 608_WearTime.csv\n", - "Skipping file with unexpected format: 516_WearTime.csv\n", - "Skipping file with unexpected format: 622_WearTime.csv\n", - "Skipping file with unexpected format: 661_WearTime.csv\n", - "Skipping file with unexpected format: 675_WearTime.csv\n", - "Skipping file with unexpected format: 671_WearTime.csv\n", - "Skipping file with unexpected format: 673_WearTime.csv\n", - "Skipping file with unexpected format: 676_WearTime.csv\n", - "Skipping file with unexpected format: 674_WearTime.csv\n", - "Skipping file with unexpected format: 670_WearTime.csv\n", - "Skipping file with unexpected format: 680_WearTime.csv\n", - "Skipping file with unexpected format: 687_WearTime.csv\n", - "Skipping file with unexpected format: 684_WearTime.csv\n", - "Skipping file with unexpected format: 683_WearTime.csv\n", - "Skipping file with unexpected format: 677_WearTime.csv\n", - "Skipping file with unexpected format: 691_WearTime.csv\n", - "Skipping file with unexpected format: 686_WearTime.csv\n", - "Skipping file with unexpected format: 694_WearTime.csv\n", - "Skipping file with unexpected format: 667_WearTime.csv\n", - "Skipping file with unexpected format: 695_WearTime.csv\n", - "Skipping file with unexpected format: 690_WearTime.csv\n", - "Skipping file with unexpected format: 678_WearTime.csv\n", - "Skipping file with unexpected format: 706_WearTime.csv\n", - "Skipping file with unexpected format: 525_WearTime.csv\n", - "Skipping file with unexpected format: 702_WearTime.csv\n", - "Skipping file with unexpected format: 700_WearTime.csv\n", - "Skipping file with unexpected format: 510_WearTime.csv\n", - "Skipping file with unexpected format: 720_WearTime.csv\n", - "Skipping file with unexpected format: 715_WearTime.csv\n", - "Skipping file with unexpected format: 717_WearTime.csv\n", - "Skipping file with unexpected format: 707_WearTime.csv\n", - "Skipping file with unexpected format: 697_WearTime.csv\n", - "Skipping file with unexpected format: 710_WearTime.csv\n", - "Skipping file with unexpected format: 709_WearTime.csv\n", - "Skipping file with unexpected format: 689_WearTime.csv\n", - "Skipping file with unexpected format: 721_WearTime.csv\n", - "Skipping file with unexpected format: 728_WearTime.csv\n", - "Skipping file with unexpected format: 723_WearTime.csv\n", - "Skipping file with unexpected format: 708_WearTime.csv\n", - "Skipping file with unexpected format: 714_WearTime.csv\n", - "Skipping file with unexpected format: 722_WearTime.csv\n", - "Skipping file with unexpected format: 727_WearTime.csv\n", - "Skipping file with unexpected format: 730_WearTime.csv\n", - "Skipping file with unexpected format: 487_WearTime.csv\n", - "Skipping file with unexpected format: 731_WearTime.csv\n", - "Skipping file with unexpected format: 699_WearTime.csv\n", - "Skipping file with unexpected format: 725_WearTime.csv\n", - "Skipping file with unexpected format: 713_WearTime.csv\n", - "Skipping file with unexpected format: 729_WearTime.csv\n", - "Skipping file with unexpected format: 52_WearTime.csv\n", - "Skipping file with unexpected format: 261_WearTime.csv\n", - "Skipping file with unexpected format: 734_WearTime.csv\n", - "Skipping file with unexpected format: 736_WearTime.csv\n", - "Skipping file with unexpected format: 733_WearTime.csv\n", - "Skipping file with unexpected format: 738_WearTime.csv\n", - "Skipping file with unexpected format: 741_WearTime.csv\n", - "Skipping file with unexpected format: 197_WearTime.csv\n", - "Skipping file with unexpected format: 581_WearTime.csv\n", - "Skipping file with unexpected format: 71_WearTime.csv\n", - "Skipping file with unexpected format: 176_WearTime.csv\n", - "Skipping file with unexpected format: 750_WearTime.csv\n", - "Skipping file with unexpected format: 753_WearTime.csv\n", - "Skipping file with unexpected format: 757_WearTime.csv\n", - "Skipping file with unexpected format: 758_WearTime.csv\n", - "Skipping file with unexpected format: 763_WearTime.csv\n", - "Skipping file with unexpected format: 759_WearTime.csv\n", - "Skipping file with unexpected format: 760_WearTime.csv\n", - "Skipping file with unexpected format: 764_WearTime.csv\n", - "Skipping file with unexpected format: 507_WearTime.csv\n", - "Skipping file with unexpected format: 766_WearTime.csv\n", - "Skipping file with unexpected format: 769_WearTime.csv\n", - "Skipping file with unexpected format: 770_WearTime.csv\n", - "Skipping file with unexpected format: 767_WearTime.csv\n", - "Skipping file with unexpected format: 774_WearTime.csv\n", - "Skipping file with unexpected format: 772_WearTime.csv\n", - "Skipping file with unexpected format: 771_WearTime.csv\n", - "Skipping file with unexpected format: 776_WearTime.csv\n", - "Skipping file with unexpected format: 775_WearTime.csv\n", - "Skipping file with unexpected format: 778_WearTime.csv\n", - "Skipping file with unexpected format: 780_WearTime.csv\n", - "Skipping file with unexpected format: 777_WearTime.csv\n", - "Skipping file with unexpected format: 782_WearTime.csv\n", - "Skipping file with unexpected format: 781_WearTime.csv\n", - "Skipping file with unexpected format: 785_WearTime.csv\n", - "Skipping file with unexpected format: 786_WearTime.csv\n", - "Skipping file with unexpected format: 788_WearTime.csv\n", - "Skipping file with unexpected format: 784_WearTime.csv\n", - "Skipping file with unexpected format: 790_WearTime.csv\n", - "Skipping file with unexpected format: 792_WearTime.csv\n", - "Skipping file with unexpected format: 1121-9-04-2024_WearTime.csv\n", - "Skipping file with unexpected format: 1249-3-19-2025_WearTime.csv\n", - "Found no duplicates.\n", - "Matches:\n", - "Boost ID: 8022\n", - " - 1023_2-7-2025_WearTime.csv (Lab ID: 1023, Date: 2025-02-07 00:00:00)\n", - " - 1023_4-17-2025_WearTime.csv (Lab ID: 1023, Date: 2025-04-17 00:00:00)\n", - "Boost ID: 7062\n", - " - 1043_2-22-2025_WearTime.csv (Lab ID: 1043, Date: 2025-02-22 00:00:00)\n", - "Boost ID: 7146\n", - " - 1051_5-5-2025_WearTime.csv (Lab ID: 1051, Date: 2025-05-05 00:00:00)\n", - "Boost ID: 6011\n", - " - 1093_8-10-2024_WearTime.csv (Lab ID: 1093, Date: 2024-08-10 00:00:00)\n", - "Boost ID: 6013\n", - " - 1098_8-15-2024_WearTime.csv (Lab ID: 1098, Date: 2024-08-15 00:00:00)\n", - "Boost ID: 6022, 7143\n", - " - 1108_5-8-2025_WearTime.csv (Lab ID: 1108, Date: 2025-05-08 00:00:00)\n", - "Boost ID: 7001\n", - " - 1111_9-6-2024_WearTime.csv (Lab ID: 1111, Date: 2024-09-06 00:00:00)\n", - "Boost ID: 7002\n", - " - 1112_8-8-2024_WearTime.csv (Lab ID: 1112, Date: 2024-08-08 00:00:00)\n", - "Boost ID: 7003\n", - " - 1113_8-21-2024_WearTime.csv (Lab ID: 1113, Date: 2024-08-21 00:00:00)\n", - "Boost ID: 7004\n", - " - 1114_9-5-2024_WearTime.csv (Lab ID: 1114, Date: 2024-09-05 00:00:00)\n", - "Boost ID: 7006\n", - " - 1115_8-6-2024_WearTime.csv (Lab ID: 1115, Date: 2024-08-06 00:00:00)\n", - "Boost ID: 7012\n", - " - 1116_8-30-2024_WearTime.csv (Lab ID: 1116, Date: 2024-08-30 00:00:00)\n", - "Boost ID: 7009\n", - " - 1117_8-7-2024_WearTime.csv (Lab ID: 1117, Date: 2024-08-07 00:00:00)\n", - "Boost ID: 7010\n", - " - 1118_8-9-2024_WearTime.csv (Lab ID: 1118, Date: 2024-08-09 00:00:00)\n", - "Boost ID: 7015\n", - " - 1120_8-14-2024_WearTime.csv (Lab ID: 1120, Date: 2024-08-14 00:00:00)\n", - "Boost ID: 7017\n", - " - 1122_8-23-2024_WearTime.csv (Lab ID: 1122, Date: 2024-08-23 00:00:00)\n", - "Boost ID: 8001\n", - " - 1123_9-21-2024_WearTime.csv (Lab ID: 1123, Date: 2024-09-21 00:00:00)\n", - "Boost ID: 8002\n", - " - 1124_9-14-2024_WearTime.csv (Lab ID: 1124, Date: 2024-09-14 00:00:00)\n", - " - 1124_11-7-2024_WearTime.csv (Lab ID: 1124, Date: 2024-11-07 00:00:00)\n", - " - 1124_2-26-2025_WearTime.csv (Lab ID: 1124, Date: 2025-02-26 00:00:00)\n", - " - 1124_5-5-2025_WearTime.csv (Lab ID: 1124, Date: 2025-05-05 00:00:00)\n", - "Boost ID: 8003\n", - " - 1125_10-5-2024_WearTime.csv (Lab ID: 1125, Date: 2024-10-05 00:00:00)\n", - " - 1125_2-1-2025_WearTime.csv (Lab ID: 1125, Date: 2025-02-01 00:00:00)\n", - " - 1125_5-31-2025_WearTime.csv (Lab ID: 1125, Date: 2025-05-31 00:00:00)\n", - "Boost ID: 8004\n", - " - 1126_9-26-2024_WearTime.csv (Lab ID: 1126, Date: 2024-09-26 00:00:00)\n", - " - 1126_11-23-2024_WearTime.csv (Lab ID: 1126, Date: 2024-11-23 00:00:00)\n", - " - 1126_3-12-2025_WearTime.csv (Lab ID: 1126, Date: 2025-03-12 00:00:00)\n", - " - 1126_4-30-2025_WearTime.csv (Lab ID: 1126, Date: 2025-04-30 00:00:00)\n", - "Boost ID: 8006\n", - " - 1129_9-21-2024_WearTime.csv (Lab ID: 1129, Date: 2024-09-21 00:00:00)\n", - " - 1129_12-13-2024_WearTime.csv (Lab ID: 1129, Date: 2024-12-13 00:00:00)\n", - " - 1129_4-16-2025_WearTime.csv (Lab ID: 1129, Date: 2025-04-16 00:00:00)\n", - " - 1129_5-14-2025_WearTime.csv (Lab ID: 1129, Date: 2025-05-14 00:00:00)\n", - "Boost ID: 7019\n", - " - 1130_9-25-2024_WearTime.csv (Lab ID: 1130, Date: 2024-09-25 00:00:00)\n", - "Boost ID: 7020\n", - " - 1131_10-9-2024_WearTime.csv (Lab ID: 1131, Date: 2024-10-09 00:00:00)\n", - "Boost ID: 7021\n", - " - 1132_10-3-2024_WearTime.csv (Lab ID: 1132, Date: 2024-10-03 00:00:00)\n", - "Boost ID: 7022\n", - " - 1133_10-2-2024_WearTime.csv (Lab ID: 1133, Date: 2024-10-02 00:00:00)\n", - "Boost ID: 8005\n", - " - 1134_10-31-2024_WearTime.csv (Lab ID: 1134, Date: 2024-10-31 00:00:00)\n", - " - 1134_1-16-2025_WearTime.csv (Lab ID: 1134, Date: 2025-01-16 00:00:00)\n", - " - 1134_5-22-2025_WearTime.csv (Lab ID: 1134, Date: 2025-05-22 00:00:00)\n", - " - 1134_6-26-2025_WearTime.csv (Lab ID: 1134, Date: 2025-06-26 00:00:00)\n", - "Boost ID: 7024\n", - " - 1136_10-12-2024_WearTime.csv (Lab ID: 1136, Date: 2024-10-12 00:00:00)\n", - "Boost ID: 7025\n", - " - 1137_10-12-2024_WearTime.csv (Lab ID: 1137, Date: 2024-10-12 00:00:00)\n", - "Boost ID: 7026\n", - " - 1138_10-25-2024_WearTime.csv (Lab ID: 1138, Date: 2024-10-25 00:00:00)\n", - "Boost ID: 7027\n", - " - 1139_11-8-2024_WearTime.csv (Lab ID: 1139, Date: 2024-11-08 00:00:00)\n", - "Boost ID: 7028\n", - " - 1140_10-29-2024_WearTime.csv (Lab ID: 1140, Date: 2024-10-29 00:00:00)\n", - "Boost ID: 7029\n", - " - 1141_11-6-2024_WearTime.csv (Lab ID: 1141, Date: 2024-11-06 00:00:00)\n", - "Boost ID: 7030\n", - " - 1142_10-25-2024_WearTime.csv (Lab ID: 1142, Date: 2024-10-25 00:00:00)\n", - "Boost ID: 7032\n", - " - 1144_11-13-2024_WearTime.csv (Lab ID: 1144, Date: 2024-11-13 00:00:00)\n", - "Boost ID: 7033\n", - " - 1145_11-7-2024_WearTime.csv (Lab ID: 1145, Date: 2024-11-07 00:00:00)\n", - "Boost ID: 8008\n", - " - 1146_11-5-2024_WearTime.csv (Lab ID: 1146, Date: 2024-11-05 00:00:00)\n", - " - 1146_1-10-2025_WearTime.csv (Lab ID: 1146, Date: 2025-01-10 00:00:00)\n", - "Boost ID: 7034\n", - " - 1147_11-15-2024_WearTime.csv (Lab ID: 1147, Date: 2024-11-15 00:00:00)\n", - "Boost ID: 7035\n", - " - 1148_11-5-2024_WearTime.csv (Lab ID: 1148, Date: 2024-11-05 00:00:00)\n", - "Boost ID: 8011\n", - " - 1151_12-7-2024_WearTime.csv (Lab ID: 1151, Date: 2024-12-07 00:00:00)\n", - " - 1151_2-20-2025_WearTime.csv (Lab ID: 1151, Date: 2025-02-20 00:00:00)\n", - "Boost ID: 7031\n", - " - 1155_12-19-2024_WearTime.csv (Lab ID: 1155, Date: 2024-12-19 00:00:00)\n", - "Boost ID: 8012\n", - " - 1158_1-9-2025_WearTime.csv (Lab ID: 1158, Date: 2025-01-09 00:00:00)\n", - " - 1158_5-9-2025_WearTime.csv (Lab ID: 1158, Date: 2025-05-09 00:00:00)\n", - "Boost ID: 8014\n", - " - 1160_1-15-2025_WearTime.csv (Lab ID: 1160, Date: 2025-01-15 00:00:00)\n", - " - 1160_5-3-2025_WearTime.csv (Lab ID: 1160, Date: 2025-05-03 00:00:00)\n", - "Boost ID: 7037\n", - " - 1161_1-18-2025_WearTime.csv (Lab ID: 1161, Date: 2025-01-18 00:00:00)\n", - "Boost ID: 8015\n", - " - 1162_1-29-2025_WearTime.csv (Lab ID: 1162, Date: 2025-01-29 00:00:00)\n", - "Boost ID: 8016\n", - " - 1163_2-19-2025_WearTime.csv (Lab ID: 1163, Date: 2025-02-19 00:00:00)\n", - " - 1163_4-7-2025_WearTime.csv (Lab ID: 1163, Date: 2025-04-07 00:00:00)\n", - "Boost ID: 8017\n", - " - 1165_4-9-2025_WearTime.csv (Lab ID: 1165, Date: 2025-04-09 00:00:00)\n", - "Boost ID: 7039\n", - " - 1166_1-21-2025_WearTime.csv (Lab ID: 1166, Date: 2025-01-21 00:00:00)\n", - "Boost ID: 8018\n", - " - 1167_1-22-2025_WearTime.csv (Lab ID: 1167, Date: 2025-01-22 00:00:00)\n", - " - 1167_5-21-25_WearTime.csv (Lab ID: 1167, Date: 2025-05-21 00:00:00)\n", - "Boost ID: 8019\n", - " - 1168_1-28-2025_WearTime.csv (Lab ID: 1168, Date: 2025-01-28 00:00:00)\n", - " - 1168_4-23-2025_WearTime.csv (Lab ID: 1168, Date: 2025-04-23 00:00:00)\n", - "Boost ID: 8020\n", - " - 1169_1-30-2025_WearTime.csv (Lab ID: 1169, Date: 2025-01-30 00:00:00)\n", - " - 1169_4-9-2025_WearTime.csv (Lab ID: 1169, Date: 2025-04-09 00:00:00)\n", - "Boost ID: 8021\n", - " - 1170_1-29-2025_WearTime.csv (Lab ID: 1170, Date: 2025-01-29 00:00:00)\n", - " - 1170_5-24-2025_WearTime.csv (Lab ID: 1170, Date: 2025-05-24 00:00:00)\n", - "Boost ID: 7040\n", - " - 1171_2-8-2025_WearTime.csv (Lab ID: 1171, Date: 2025-02-08 00:00:00)\n", - "Boost ID: 7041\n", - " - 1172_1-28-2025_WearTime.csv (Lab ID: 1172, Date: 2025-01-28 00:00:00)\n", - " - 1172_5-29-2025_WearTime.csv (Lab ID: 1172, Date: 2025-05-29 00:00:00)\n", - "Boost ID: 7042\n", - " - 1173_3-1-2025_WearTime.csv (Lab ID: 1173, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7043\n", - " - 1174_1-28-2025_WearTime.csv (Lab ID: 1174, Date: 2025-01-28 00:00:00)\n", - "Boost ID: 7047\n", - " - 1178_2-12-2025_WearTime.csv (Lab ID: 1178, Date: 2025-02-12 00:00:00)\n", - "Boost ID: 7048\n", - " - 1179_3-11-2025_WearTime.csv (Lab ID: 1179, Date: 2025-03-11 00:00:00)\n", - "Boost ID: 7049\n", - " - 1180_2-18-2025_WearTime.csv (Lab ID: 1180, Date: 2025-02-18 00:00:00)\n", - "Boost ID: 7050\n", - " - 1181_2-21-2025_WearTime.csv (Lab ID: 1181, Date: 2025-02-21 00:00:00)\n", - "Boost ID: 7052\n", - " - 1183_2-13-2025_WearTime.csv (Lab ID: 1183, Date: 2025-02-13 00:00:00)\n", - "Boost ID: 8023\n", - " - 1185_4-10-2025_WearTime.csv (Lab ID: 1185, Date: 2025-04-10 00:00:00)\n", - "Boost ID: 8024\n", - " - 1186_3-8-2025_WearTime.csv (Lab ID: 1186, Date: 2025-03-08 00:00:00)\n", - " - 1186_5-30-2025_WearTime.csv (Lab ID: 1186, Date: 2025-05-30 00:00:00)\n", - "Boost ID: 7054\n", - " - 1187_2-11-2025_WearTime.csv (Lab ID: 1187, Date: 2025-02-11 00:00:00)\n", - "Boost ID: 7056\n", - " - 1190_2-22-2025_WearTime.csv (Lab ID: 1190, Date: 2025-02-22 00:00:00)\n", - "Boost ID: 7057\n", - " - 1191_2-15-2025_WearTime.csv (Lab ID: 1191, Date: 2025-02-15 00:00:00)\n", - "Boost ID: 7058\n", - " - 1192_2-21-2025_WearTime.csv (Lab ID: 1192, Date: 2025-02-21 00:00:00)\n", - "Boost ID: 7059\n", - " - 1193_2-25-2025_WearTime.csv (Lab ID: 1193, Date: 2025-02-25 00:00:00)\n", - "Boost ID: 8026\n", - " - 1194_2-4-2025_WearTime.csv (Lab ID: 1194, Date: 2025-02-04 00:00:00)\n", - " - 1194_5-23-2025_WearTime.csv (Lab ID: 1194, Date: 2025-05-23 00:00:00)\n", - "Boost ID: 7061\n", - " - 1196_2-25-2025_WearTime.csv (Lab ID: 1196, Date: 2025-02-25 00:00:00)\n", - "Boost ID: 7063\n", - " - 1197_2-25-2025_WearTime.csv (Lab ID: 1197, Date: 2025-02-25 00:00:00)\n", - "Boost ID: 8030\n", - " - 1200_2-21-2025_WearTime.csv (Lab ID: 1200, Date: 2025-02-21 00:00:00)\n", - " - 1200_5-10-2025_WearTime.csv (Lab ID: 1200, Date: 2025-05-10 00:00:00)\n", - "Boost ID: 7064\n", - " - 1202_3-1-2025_WearTime.csv (Lab ID: 1202, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7067\n", - " - 1205_2-21-2025_WearTime.csv (Lab ID: 1205, Date: 2025-02-21 00:00:00)\n", - "Boost ID: 7068\n", - " - 1206_2-27-2025_WearTime.csv (Lab ID: 1206, Date: 2025-02-27 00:00:00)\n", - "Boost ID: 7069\n", - " - 1207_3-1-2025_WearTime.csv (Lab ID: 1207, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7072\n", - " - 1210_3-1-2025_WearTime.csv (Lab ID: 1210, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7073\n", - " - 1211_3-1-2025_wearTime.csv (Lab ID: 1211, Date: 2025-03-01 00:00:00)\n", - "Boost ID: 7075\n", - " - 1213_3-4-2025_WearTime.csv (Lab ID: 1213, Date: 2025-03-04 00:00:00)\n", - "Boost ID: 7076\n", - " - 1214_3-11-2025_WearTime.csv (Lab ID: 1214, Date: 2025-03-11 00:00:00)\n", - "Boost ID: 7077\n", - " - 1215_3-14-2025_WearTime.csv (Lab ID: 1215, Date: 2025-03-14 00:00:00)\n", - "Boost ID: 7078\n", - " - 1216_3-8-2025_WearTime.csv (Lab ID: 1216, Date: 2025-03-08 00:00:00)\n", - "Boost ID: 7079\n", - " - 1217_3-13-2025_WearTime.csv (Lab ID: 1217, Date: 2025-03-13 00:00:00)\n", - "Boost ID: 7080\n", - " - 1218_3-7-2025_WearTime.csv (Lab ID: 1218, Date: 2025-03-07 00:00:00)\n", - "Boost ID: 7082\n", - " - 1220_3-29-2025_WearTime.csv (Lab ID: 1220, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 8032\n", - " - 1221_5-22-2025_WearTime.csv (Lab ID: 1221, Date: 2025-05-22 00:00:00)\n", - "Boost ID: 7083\n", - " - 1222_3-6-2025_WearTime.csv (Lab ID: 1222, Date: 2025-03-06 00:00:00)\n", - "Boost ID: 7084\n", - " - 1223_3-29-2025_WearTime.csv (Lab ID: 1223, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 7085\n", - " - 1224_3-18-2025_WearTime.csv (Lab ID: 1224, Date: 2025-03-18 00:00:00)\n", - "Boost ID: 7086\n", - " - 1225_3-6-2025_WearTime.csv (Lab ID: 1225, Date: 2025-03-06 00:00:00)\n", - "Boost ID: 7087\n", - " - 1226_3-6-2025_WearTime.csv (Lab ID: 1226, Date: 2025-03-06 00:00:00)\n", - "Boost ID: 7088\n", - " - 1227_4-3-2025_WearTime.csv (Lab ID: 1227, Date: 2025-04-03 00:00:00)\n", - "Boost ID: 7089\n", - " - 1228_3-20-2025_WearTime.csv (Lab ID: 1228, Date: 2025-03-20 00:00:00)\n", - "Boost ID: 7093\n", - " - 1232_3-12-2025_WearTime.csv (Lab ID: 1232, Date: 2025-03-12 00:00:00)\n", - "Boost ID: 7094\n", - " - 1233_3-27-2025_WearTime.csv (Lab ID: 1233, Date: 2025-03-27 00:00:00)\n", - "Boost ID: 7065\n", - " - 1234_3-20-2025_WearTime.csv (Lab ID: 1234, Date: 2025-03-20 00:00:00)\n", - "Boost ID: 7096\n", - " - 1236_3-29-2025_WearTime.csv (Lab ID: 1236, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 7098\n", - " - 1239_4-5-2025_WearTime.csv (Lab ID: 1239, Date: 2025-04-05 00:00:00)\n", - "Boost ID: 7102\n", - " - 1242_2-28-2025_WearTime.csv (Lab ID: 1242, Date: 2025-02-28 00:00:00)\n", - "Boost ID: 7045\n", - " - 1243_3-20-2025_WearTime.csv (Lab ID: 1243, Date: 2025-03-20 00:00:00)\n", - "Boost ID: 7103\n", - " - 1244_4-3-2025_WearTime.csv (Lab ID: 1244, Date: 2025-04-03 00:00:00)\n", - "Boost ID: 7104\n", - " - 1245_4-3-2025_WearTime.csv (Lab ID: 1245, Date: 2025-04-03 00:00:00)\n", - "Boost ID: 7105\n", - " - 1246_3-14-2025_WearTime.csv (Lab ID: 1246, Date: 2025-03-14 00:00:00)\n", - "Boost ID: 8034\n", - " - 1248_3-29-2025_WearTime.csv (Lab ID: 1248, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 8035\n", - " - 1249_5-31-2025_WearTime.csv (Lab ID: 1249, Date: 2025-05-31 00:00:00)\n", - "Boost ID: 7091\n", - " - 1250_3-27-2025_WearTime.csv (Lab ID: 1250, Date: 2025-03-27 00:00:00)\n", - "Boost ID: 7070\n", - " - 1251_4-5-2025_WearTime.csv (Lab ID: 1251, Date: 2025-04-05 00:00:00)\n", - "Boost ID: 7106\n", - " - 1252_3-28-2025_WearTime.csv (Lab ID: 1252, Date: 2025-03-28 00:00:00)\n", - "Boost ID: 7107\n", - " - 1254_4-12-2025_WearTime.csv (Lab ID: 1254, Date: 2025-04-12 00:00:00)\n", - "Boost ID: 7108\n", - " - 1255_3-14-2025_WearTime.csv (Lab ID: 1255, Date: 2025-03-14 00:00:00)\n", - "Boost ID: 7110\n", - " - 1257_4-4-2025_WearTime.csv (Lab ID: 1257, Date: 2025-04-04 00:00:00)\n", - "Boost ID: 7092\n", - " - 1260_3-28-2025_WearTime.csv (Lab ID: 1260, Date: 2025-03-28 00:00:00)\n", - "Boost ID: 7090\n", - " - 1261_4-11-2025_WearTime.csv (Lab ID: 1261, Date: 2025-04-11 00:00:00)\n", - "Boost ID: 7113\n", - " - 1262_4-4-2025_WearTime.csv (Lab ID: 1262, Date: 2025-04-04 00:00:00)\n", - "Boost ID: 7114\n", - " - 1263_3-29-2025_WearTime.csv (Lab ID: 1263, Date: 2025-03-29 00:00:00)\n", - "Boost ID: 7097\n", - " - 1264_4-5-2025_WearTime.csv (Lab ID: 1264, Date: 2025-04-05 00:00:00)\n", - "Boost ID: 7115\n", - " - 1265_4-2-2025_WearTime.csv (Lab ID: 1265, Date: 2025-04-02 00:00:00)\n", - "Boost ID: 7116\n", - " - 1266_4-3-2025_WearTime.csv (Lab ID: 1266, Date: 2025-04-03 00:00:00)\n", - "Boost ID: 7117\n", - " - 1267_3-22-2025_WearTime.csv (Lab ID: 1267, Date: 2025-03-22 00:00:00)\n", - "Boost ID: 7118\n", - " - 1268_4-8-2025_WearTime.csv (Lab ID: 1268, Date: 2025-04-08 00:00:00)\n", - "Boost ID: 7120\n", - " - 1270_4-12-2025_WearTime.csv (Lab ID: 1270, Date: 2025-04-12 00:00:00)\n", - "Boost ID: 7122\n", - " - 1272_4-5-2025_WearTime.csv (Lab ID: 1272, Date: 2025-04-05 00:00:00)\n", - "Boost ID: 7111\n", - " - 1275_4-18-2025_WearTime.csv (Lab ID: 1275, Date: 2025-04-18 00:00:00)\n", - "Boost ID: 8037\n", - " - 1276_4-4-2025_WearTime.csv (Lab ID: 1276, Date: 2025-04-04 00:00:00)\n", - "Boost ID: 7124\n", - " - 1290_4-10-2025_WearTime.csv (Lab ID: 1290, Date: 2025-04-10 00:00:00)\n", - "Boost ID: 7125\n", - " - 1291_4-10-2025_WearTime.csv (Lab ID: 1291, Date: 2025-04-10 00:00:00)\n", - "Boost ID: 7128\n", - " - 1298_4-18-2025_WearTime.csv (Lab ID: 1298, Date: 2025-04-18 00:00:00)\n", - "Boost ID: 7129\n", - " - 1299_4-19-2025_WearTime.csv (Lab ID: 1299, Date: 2025-04-19 00:00:00)\n", - "Boost ID: 7130\n", - " - 1300_4-18-2025_WearTime.csv (Lab ID: 1300, Date: 2025-04-18 00:00:00)\n", - "Boost ID: 8038\n", - " - 1302_4-26-2025_WearTime.csv (Lab ID: 1302, Date: 2025-04-26 00:00:00)\n", - "Boost ID: 7133\n", - " - 1304_4-29-2025_WearTime.csv (Lab ID: 1304, Date: 2025-04-29 00:00:00)\n", - "Boost ID: 7132\n", - " - 1305_4-24-2025_WearTime.csv (Lab ID: 1305, Date: 2025-04-24 00:00:00)\n", - "Boost ID: 7134\n", - " - 1311_5-1-2025_WearTime.csv (Lab ID: 1311, Date: 2025-05-01 00:00:00)\n", - "Boost ID: 7136\n", - " - 1313_6-3-2025_WearTime.csv (Lab ID: 1313, Date: 2025-06-03 00:00:00)\n", - "Boost ID: 8039\n", - " - 1314_5-20-2025_WearTime.csv (Lab ID: 1314, Date: 2025-05-20 00:00:00)\n", - "Boost ID: 7137\n", - " - 1315_5-5-2025_WearTime.csv (Lab ID: 1315, Date: 2025-05-05 00:00:00)\n", - "Boost ID: 8040\n", - " - 1317_5-20-2025_WearTime.csv (Lab ID: 1317, Date: 2025-05-20 00:00:00)\n", - "Boost ID: 8042\n", - " - 1320_5-20-2025_WearTime.csv (Lab ID: 1320, Date: 2025-05-20 00:00:00)\n", - "Boost ID: 7138\n", - " - 1321_5-17-2025_WearTime.csv (Lab ID: 1321, Date: 2025-05-17 00:00:00)\n", - "Boost ID: 7139\n", - " - 1322_5-10-2025_WearTime.csv (Lab ID: 1322, Date: 2025-05-10 00:00:00)\n", - "Boost ID: 7140\n", - " - 1323_5-10-2025_Sleep.csv (Lab ID: 1323, Date: 2025-05-10 00:00:00)\n", - "Boost ID: 7141\n", - " - 1324_5-17-2025_WearTime.csv (Lab ID: 1324, Date: 2025-05-17 00:00:00)\n", - "Boost ID: 7142\n", - " - 1325_5-21-2025_WearTime.csv (Lab ID: 1325, Date: 2025-05-21 00:00:00)\n", - "Boost ID: 7145\n", - " - 1327_5-10-2025_WearTime.csv (Lab ID: 1327, Date: 2025-05-10 00:00:00)\n", - "Boost ID: 7147\n", - " - 1328_6-24-25_WearTime.csv (Lab ID: 1328, Date: 2025-06-24 00:00:00)\n", - "Boost ID: 8046\n", - " - 1330_5-28-2025_WearTime.csv (Lab ID: 1330, Date: 2025-05-28 00:00:00)\n", - "Boost ID: 7150\n", - " - 1332_5-24-2025_WearTime.csv (Lab ID: 1332, Date: 2025-05-24 00:00:00)\n", - "Boost ID: 7151\n", - " - 1333_5-13-2025_WearTime.csv (Lab ID: 1333, Date: 2025-05-13 00:00:00)\n", - "Boost ID: 7152\n", - " - 1334_5-24-2025_WearTime.csv (Lab ID: 1334, Date: 2025-05-24 00:00:00)\n", - "Boost ID: 8047\n", - " - 1335_5-14-2025_WearTime.csv (Lab ID: 1335, Date: 2025-05-14 00:00:00)\n", - "Boost ID: 8048\n", - " - 1336_6-6-2025_WearTime.csv (Lab ID: 1336, Date: 2025-06-06 00:00:00)\n", - "Boost ID: 7153\n", - " - 1337_5-17-2025_WearTime.csv (Lab ID: 1337, Date: 2025-05-17 00:00:00)\n", - "Boost ID: 7155\n", - " - 1340_6-3-2025_WearTime.csv (Lab ID: 1340, Date: 2025-06-03 00:00:00)\n", - "Boost ID: 8050\n", - " - 1341_5-21-2025_WearTime.csv (Lab ID: 1341, Date: 2025-05-21 00:00:00)\n", - "Boost ID: 7156\n", - " - 1342_5-24-2025_WearTime.csv (Lab ID: 1342, Date: 2025-05-24 00:00:00)\n", - "Boost ID: 8051\n", - " - 1343_6-5-2025_WearTime.csv (Lab ID: 1343, Date: 2025-06-05 00:00:00)\n", - "Boost ID: 7157\n", - " - 1344_5-16-2025_WearTime.csv (Lab ID: 1344, Date: 2025-05-16 00:00:00)\n", - "Boost ID: 8052\n", - " - 1345_5-28-2025_WearTime.csv (Lab ID: 1345, Date: 2025-05-28 00:00:00)\n", - "Boost ID: 8053\n", - " - 1346_6-4-2025_WearTime.csv (Lab ID: 1346, Date: 2025-06-04 00:00:00)\n", - "Boost ID: 8054\n", - " - 1347_5-30-2025_WearTime.csv (Lab ID: 1347, Date: 2025-05-30 00:00:00)\n", - "Boost ID: 7158\n", - " - 1348_6-5-2025_Sleep.csv (Lab ID: 1348, Date: 2025-06-05 00:00:00)\n", - "Boost ID: 7159\n", - " - 1349_6-5-2025_WearTime.csv (Lab ID: 1349, Date: 2025-06-05 00:00:00)\n", - "Boost ID: 7160\n", - " - 1350_6-4-2025_WearTime.csv (Lab ID: 1350, Date: 2025-06-04 00:00:00)\n", - "Boost ID: 7164\n", - " - 1354_6-12-2025_WearTime.csv (Lab ID: 1354, Date: 2025-06-12 00:00:00)\n", - "Boost ID: 7165\n", - " - 1355_6-12-2025_WearTime.csv (Lab ID: 1355, Date: 2025-06-12 00:00:00)\n", - "Boost ID: 7161\n", - " - 1356_6-10-2025_WearTime.csv (Lab ID: 1356, Date: 2025-06-10 00:00:00)\n", - "Boost ID: 7167\n", - " - 1358_6-21-2025_WearTime.csv (Lab ID: 1358, Date: 2025-06-21 00:00:00)\n", - "Boost ID: 7168\n", - " - 1359_6-20-2025_WearTime.csv (Lab ID: 1359, Date: 2025-06-20 00:00:00)\n", - "Boost ID: 7170\n", - " - 1361_6-10-2025_WearTime.csv (Lab ID: 1361, Date: 2025-06-10 00:00:00)\n", - "Boost ID: 7172\n", - " - 1363_6-18-2025_WearTime.csv (Lab ID: 1363, Date: 2025-06-18 00:00:00)\n", - "Boost ID: 7174\n", - " - 1365_6-28-2025_WearTime.csv (Lab ID: 1365, Date: 2025-06-28 00:00:00)\n", - "Boost ID: 7175\n", - " - 1366_7-2-2025_WearTime.csv (Lab ID: 1366, Date: 2025-07-02 00:00:00)\n", - "Boost ID: 7178\n", - " - 1369_6-26-2025_WearTime.csv (Lab ID: 1369, Date: 2025-06-26 00:00:00)\n", - "Boost ID: 7180\n", - " - 1372_7-2-2025_WearTime.csv (Lab ID: 1372, Date: 2025-07-02 00:00:00)\n", - "Boost ID: 8056\n", - " - 1373_7-3-2025_WearTime.csv (Lab ID: 1373, Date: 2025-07-03 00:00:00)\n", - "\n", - "Duplicates:\n", - "\n", - "Sessions DataFrame:\n", - " subject_id session_id filename \\\n", - "0 sub-8022 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "1 sub-8022 ses-2 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "2 sub-7062 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "3 sub-7146 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "4 sub-6011 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - ".. ... ... ... \n", - "197 sub-7174 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "198 sub-7175 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "199 sub-7178 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "200 sub-7180 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "201 sub-8056 ses-1 /mnt/rdss/VossLab/Repositories/Accelerometer_D... \n", - "\n", - " date \n", - "0 2025-02-07 \n", - "1 2025-04-17 \n", - "2 2025-02-22 \n", - "3 2025-05-05 \n", - "4 2024-08-10 \n", - ".. ... \n", - "197 2025-06-28 \n", - "198 2025-07-02 \n", - "199 2025-06-26 \n", - "200 2025-07-02 \n", - "201 2025-07-03 \n", - "\n", - "[202 rows x 4 columns]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/nix-shell.RrgKp6/ipykernel_184880/761771891.py:154: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", - " df['Date'] = pd.to_datetime(df['Date'], errors='coerce')\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "import os\n", - "import requests\n", - "import sys\n", - "from io import StringIO\n", - "from datetime import datetime, timedelta\n", - "\n", - "\n", - "'''\n", - "This script is designed to create a sleep log file for the group analysis of accelerometer data.\n", - "It reads the individual participant files by first matching labID with studyID, then builds path to individual files on the RDSS\n", - "Aggregates the sleep data by participant and session (with _accel suffix) and saves it to a CSV file.\n", - "'''\n", - "\n", - "token = 'DE4E2DB72778DACA9B8848574107D2F5'\n", - "INT_DIR = '/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test'\n", - "OBS_DIR = '/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test'\n", - "rdss_dir = '/mnt/rdss/VossLab/Repositories/Accelerometer_Data/WearTime'\n", - "\n", - "def compare_ids(rdss_dir, token, daysago=350):\n", - " \"\"\"\n", - " Pulls all files from RDSS\n", - " Pulls the list from RedCap\n", - " Compares IDs and returns a dictionary with two keys:\n", - " - 'matches': normal matches mapping boost_id to a list of dicts (filename, labID, date)\n", - " - 'duplicates': a list of dictionaries each with lab_id, boost_id, filenames (list), and dates (list)\n", - " \"\"\"\n", - " # Retrieve the RedCap report and duplicates from report\n", - " report, report_duplicates = _return_report(token)\n", - " # Retrieve the full RDSS file list and duplicate files merged with duplicates from report\n", - " rdss, file_duplicates = _rdss_file_list(report_duplicates)\n", - "\n", - " # Initialize the result dictionary for normal (non-duplicate) matches\n", - " result = {}\n", - "\n", - " # Iterate over the rows in the cleaned RedCap report\n", - " for _, row in report.iterrows():\n", - " boost_id = str(row['boost_id'])\n", - " lab_id = str(row['lab_id'])\n", - " \n", - " # Find matching files in the RDSS list\n", - " rdss_matches = rdss[rdss['ID'] == lab_id]\n", - " if not rdss_matches.empty:\n", - " if boost_id not in result:\n", - " result[boost_id] = []\n", - " for _, match_row in rdss_matches.iterrows():\n", - " result[boost_id].append({\n", - " 'filename': match_row['filename'],\n", - " 'labID': lab_id,\n", - " 'date': match_row['Date']\n", - " })\n", - " \n", - " # Process duplicates into the desired structure.\n", - " duplicates_dict = []\n", - " if not file_duplicates.empty:\n", - " # Group by lab_id and boost_id; each group represents one duplicate combination.\n", - " grouped = file_duplicates.groupby(['lab_id', 'boost_id'])\n", - " for (lab_id, boost_id), group in grouped:\n", - " duplicates_dict.append({\n", - " 'lab_id': lab_id,\n", - " 'boost_id': boost_id,\n", - " 'filenames': group['filename'].tolist(),\n", - " 'dates': group['Date'].tolist()\n", - " })\n", - " else:\n", - " print(\"Found no duplicates.\")\n", - "\n", - " return {'matches': result, 'duplicates': duplicates_dict}\n", - "\n", - "def _return_report(token):\n", - " \"\"\"\n", - " pulls the id report from the rdss via redcap api.\n", - " reads the report as a dataframe.\n", - " checks for boost_ids that are associated with multiple lab_ids, logs a critical error,\n", - " and removes these rows from the dataframe.\n", - " separates duplicate rows (based on any column) from the cleaned data.\n", - " \n", - " returns:\n", - " df_cleaned: dataframe with duplicates removed and problematic boost_ids excluded\n", - " duplicate_rows: dataframe of duplicate rows\n", - " \"\"\"\n", - " url = 'https://redcap.icts.uiowa.edu/redcap/api/'\n", - " data = {\n", - " 'token': token,\n", - " 'content': 'report',\n", - " 'report_id': 43327,\n", - " 'format': 'csv'\n", - " }\n", - " r = requests.post(url, data=data)\n", - " if r.status_code != 200:\n", - " print(f\"error! status code is {r.status_code}\")\n", - " sys.exit(1)\n", - " \n", - " df = pd.read_csv(StringIO(r.text))\n", - " \n", - " # identify boost_ids associated with multiple lab_ids.\n", - " boost_id_counts = df.groupby('boost_id')['lab_id'].nunique()\n", - " problematic_boost_ids = boost_id_counts[boost_id_counts > 1].index.tolist()\n", - " \n", - " if problematic_boost_ids:\n", - " print(f\"found boost_id(s) with multiple lab_ids: {', '.join(map(str, problematic_boost_ids))}. \"\n", - " \"these entries will be removed from processing.\")\n", - " df = df[~df['boost_id'].isin(problematic_boost_ids)]\n", - " \n", - " # identify and separate duplicate rows based on any column.\n", - " duplicate_rows = df[df.duplicated(keep=False)]\n", - " df_cleaned = df.drop_duplicates(keep=False)\n", - " \n", - " if not duplicate_rows.empty:\n", - " print(f\"duplicate rows found:\\n{duplicate_rows}\")\n", - " \n", - " return df_cleaned, duplicate_rows\n", - "\n", - "def _rdss_file_list(duplicates, daysago=None):\n", - " \"\"\"\n", - " extracts the first string before the space and the date from filenames ending with .csv\n", - " in the specified folder and stores them in a dataframe.\n", - " \n", - " Also, merges the file list with duplicate report entries based on lab_id.\n", - " \n", - " Returns:\n", - " df: DataFrame of all file entries\n", - " merged_df: DataFrame of file entries that match duplicate lab_ids from the report\n", - " \"\"\"\n", - " extracted_data = []\n", - "\n", - " # Loop through all files in the rdss_dir folder.\n", - " for filename in os.listdir(rdss_dir):\n", - " if filename.endswith('.csv'):\n", - " try:\n", - " # Handle both old and new filename formats\n", - " if '_' in filename and filename.endswith('.csv'):\n", - " # New format: 1288_4-26-2025_Sleep.csv\n", - " parts = filename.replace('.csv', '').split('_')\n", - " if len(parts) >= 3:\n", - " base_name = parts[0] # lab_id\n", - " date_part = parts[1] # date\n", - " extracted_data.append({'ID': base_name, 'Date': date_part, 'filename': filename})\n", - " else:\n", - " print(f\"Skipping file with unexpected format: {filename}\")\n", - " else:\n", - " try:\n", - " base_name = filename.split(' ')[0] # Extract lab_id (old format)\n", - " date_part = filename.split('(')[1].split(')')[0] # Extract date (old format)\n", - " extracted_data.append({'ID': base_name, 'Date': date_part, 'filename': filename})\n", - " except IndexError:\n", - " print(f\"Skipping file with unexpected format: {filename}\")\n", - " except IndexError:\n", - " print(f\"Skipping file with unexpected format: {filename}\")\n", - "\n", - " df = pd.DataFrame(extracted_data)\n", - "\n", - " if not df.empty:\n", - " df['Date'] = pd.to_datetime(df['Date'], errors='coerce')\n", - "\n", - " if daysago:\n", - " cutoff_date = datetime.today() - timedelta(days=daysago)\n", - " df = df[df['Date'] >= cutoff_date] # Filter files within the last `daysago` days\n", - " else:\n", - " df = df[df['Date'] >= '2024-08-05'] # Filter out rows before the threshold date\n", - "\n", - " # Filter the file list to only include rows where ID is in the duplicate report (if any)\n", - " if not duplicates.empty:\n", - " matched_df = df[df['ID'].isin(duplicates['lab_id'])]\n", - " # Merge with the duplicates to bring in boost_id information from the report\n", - " merged_df = matched_df.merge(duplicates, left_on='ID', right_on='lab_id')\n", - " else:\n", - " merged_df = pd.DataFrame()\n", - "\n", - " return df, merged_df\n", - "\n", - "matches = compare_ids(rdss_dir, token, daysago=None)\n", - "# Print the matches and duplicates for verification\n", - "print(\"Matches:\")\n", - "for boost_id, files in matches['matches'].items():\n", - " print(f\"Boost ID: {boost_id}\")\n", - " for file_info in files:\n", - " print(f\" - {file_info['filename']} (Lab ID: {file_info['labID']}, Date: {file_info['date']})\")\n", - "print(\"\\nDuplicates:\")\n", - "for dup in matches['duplicates']:\n", - " print(f\"Lab ID: {dup['lab_id']}, Boost ID: {dup['boost_id']}\")\n", - " print(f\" Filenames: {', '.join(dup['filenames'])}\")\n", - " print(f\" Dates: {', '.join(map(str, dup['dates']))}\")\n", - "# The above code is a complete script that compares IDs from RDSS and RedCap, identifies matches and duplicates, and prints the results.\n", - "\n", - "'''\n", - "Below we create the sessions, where if the same subject ID has multiple files, we will create a session for each file ordered by date.\n", - "this will now be stored as a dataframe with the columns:\n", - " # 'subject_id', 'session_id', 'filename', 'date'\n", - " # where subject_id is 'sub-', session_id is 'ses-', filename is the file name with full path, and date is the date of the file.\n", - "'''\n", - "def create_sessions(matches):\n", - " \"\"\"\n", - " Create sessions from the matches dictionary.\n", - " \n", - " Args:\n", - " matches (dict): Dictionary containing matches with boost_id as keys and list of file info as values.\n", - " \n", - " Returns:\n", - " pd.DataFrame: DataFrame with columns 'subject_id', 'session_id', 'filename', 'date'.\n", - " \"\"\"\n", - " sessions = []\n", - " \n", - " for boost_id, files in matches['matches'].items():\n", - " subject_id = f'sub-{boost_id}'\n", - " for i, file_info in enumerate(files):\n", - " session_id = f'ses-{i + 1}' # Session number starts from 1\n", - " sessions.append({\n", - " 'subject_id': subject_id,\n", - " 'session_id': session_id,\n", - " 'filename': os.path.join(rdss_dir, file_info['filename']),\n", - " 'date': file_info['date']\n", - " })\n", - " \n", - " return pd.DataFrame(sessions)\n", - "\n", - "# Create sessions from the Matches\n", - "sessions_df = create_sessions(matches)\n", - "# Print the sessions DataFrame for verification\n", - "print(\"\\nSessions DataFrame:\")\n", - "print(sessions_df)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "bc89751b-cef3-4872-9c6e-43c1dbd7fb86", - "metadata": {}, - "outputs": [], - "source": [ - "sessions_df.to_clipboard()" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "id": "d05fe919-605c-4555-ae82-b13d553e222b", - "metadata": {}, - "outputs": [], - "source": [ - "s8022_test = [pd.read_csv(sessions_df.iloc[0]['filename'],skiprows=1), pd.read_csv(sessions_df.iloc[1]['filename'],skiprows=1)]" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "id": "7f978be0-e110-4230-8979-fed7d181d469", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
DateWear Time (minutes)Non-Wear Time (minutes)Wear %Non-Wear %Vector Magnitude
02/7/2025132111991.78.31060314.3
12/8/20251439199.90.11997886.7
22/9/20251440010001882234.5
32/10/20251440010001647210.0
42/11/20251440010001820595.0
52/12/20251440010001382595.7
62/13/20251440010002210102.8
72/14/20251440010001688519.2
82/15/202513489293.66.41319762.8
92/16/20250144001001586.9
10Date/Time StartDate/Time StopWear or Non-WearLength (minutes)Use?NaN
112/7/2025 12:00 AM2/7/2025 6:55 AMWear415TRUENaN
122/7/2025 6:55 AM2/7/2025 7:28 AMNon-Wear33FALSENaN
132/7/2025 7:28 AM2/7/2025 5:21 PMWear593TRUENaN
142/7/2025 5:21 PM2/7/2025 6:47 PMNon-Wear86FALSENaN
152/7/2025 6:47 PM2/8/2025 10:05 AMWear918TRUENaN
162/8/2025 10:05 AM2/8/2025 10:06 AMNon-Wear1FALSENaN
172/8/2025 10:06 AM2/15/2025 10:28 PMWear10822TRUENaN
182/15/2025 10:28 PM2/17/2025 12:00 AMNon-Wear1532FALSENaN
\n", - "
" - ], - "text/plain": [ - " Date Wear Time (minutes) Non-Wear Time (minutes) \\\n", - "0 2/7/2025 1321 119 \n", - "1 2/8/2025 1439 1 \n", - "2 2/9/2025 1440 0 \n", - "3 2/10/2025 1440 0 \n", - "4 2/11/2025 1440 0 \n", - "5 2/12/2025 1440 0 \n", - "6 2/13/2025 1440 0 \n", - "7 2/14/2025 1440 0 \n", - "8 2/15/2025 1348 92 \n", - "9 2/16/2025 0 1440 \n", - "10 Date/Time Start Date/Time Stop Wear or Non-Wear \n", - "11 2/7/2025 12:00 AM 2/7/2025 6:55 AM Wear \n", - "12 2/7/2025 6:55 AM 2/7/2025 7:28 AM Non-Wear \n", - "13 2/7/2025 7:28 AM 2/7/2025 5:21 PM Wear \n", - "14 2/7/2025 5:21 PM 2/7/2025 6:47 PM Non-Wear \n", - "15 2/7/2025 6:47 PM 2/8/2025 10:05 AM Wear \n", - "16 2/8/2025 10:05 AM 2/8/2025 10:06 AM Non-Wear \n", - "17 2/8/2025 10:06 AM 2/15/2025 10:28 PM Wear \n", - "18 2/15/2025 10:28 PM 2/17/2025 12:00 AM Non-Wear \n", - "\n", - " Wear % Non-Wear % Vector Magnitude \n", - "0 91.7 8.3 1060314.3 \n", - "1 99.9 0.1 1997886.7 \n", - "2 100 0 1882234.5 \n", - "3 100 0 1647210.0 \n", - "4 100 0 1820595.0 \n", - "5 100 0 1382595.7 \n", - "6 100 0 2210102.8 \n", - "7 100 0 1688519.2 \n", - "8 93.6 6.4 1319762.8 \n", - "9 0 100 1586.9 \n", - "10 Length (minutes) Use? NaN \n", - "11 415 TRUE NaN \n", - "12 33 FALSE NaN \n", - "13 593 TRUE NaN \n", - "14 86 FALSE NaN \n", - "15 918 TRUE NaN \n", - "16 1 FALSE NaN \n", - "17 10822 TRUE NaN \n", - "18 1532 FALSE NaN " - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_s1 = s8022_test[0]\n", - "test_s2 = s8022_test[1]\n", - "test_s1" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "677a0c6c-ac4b-47cb-bcc1-b08d94ca01e2", - "metadata": {}, - "outputs": [ - { - "ename": "IndexError", - "evalue": "index 0 is out of bounds for axis 0 with size 0", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mIndexError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[78]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# 2) Find the index of the row where your second header lives\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m hdr_idx = \u001b[43mtest_s1\u001b[49m\u001b[43m.\u001b[49m\u001b[43mindex\u001b[49m\u001b[43m[\u001b[49m\u001b[43mtest_s1\u001b[49m\u001b[43m.\u001b[49m\u001b[43miloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[43m==\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mDate/Time Start\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[32m 4\u001b[39m \u001b[38;5;66;03m# 3) Pull out that row’s values to use as your new column names\u001b[39;00m\n\u001b[32m 5\u001b[39m new_header = test_s1.iloc[hdr_idx]\n", - "\u001b[36mFile \u001b[39m\u001b[32m/nix/store/59bmf68pd17hp8cphcrpijv7cjs3frwh-python3.13-pandas-2.2.3/lib/python3.13/site-packages/pandas/core/indexes/base.py:5389\u001b[39m, in \u001b[36mIndex.__getitem__\u001b[39m\u001b[34m(self, key)\u001b[39m\n\u001b[32m 5386\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m is_integer(key) \u001b[38;5;129;01mor\u001b[39;00m is_float(key):\n\u001b[32m 5387\u001b[39m \u001b[38;5;66;03m# GH#44051 exclude bool, which would return a 2d ndarray\u001b[39;00m\n\u001b[32m 5388\u001b[39m key = com.cast_scalar_indexer(key)\n\u001b[32m-> \u001b[39m\u001b[32m5389\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgetitem\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 5391\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(key, \u001b[38;5;28mslice\u001b[39m):\n\u001b[32m 5392\u001b[39m \u001b[38;5;66;03m# This case is separated from the conditional above to avoid\u001b[39;00m\n\u001b[32m 5393\u001b[39m \u001b[38;5;66;03m# pessimization com.is_bool_indexer and ndim checks.\u001b[39;00m\n\u001b[32m 5394\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._getitem_slice(key)\n", - "\u001b[31mIndexError\u001b[39m: index 0 is out of bounds for axis 0 with size 0" - ] - } - ], - "source": [ - "# 2) Find the index of the row where your second header lives\n", - "hdr_idx = test_s1.index[test_s1.iloc[:, 0] == \"Date/Time Start\"][0]\n", - "\n", - "# 3) Pull out that row’s values to use as your new column names\n", - "new_header = test_s1.iloc[hdr_idx]\n", - "\n", - "# 4) Drop everything up through that header row, reset the index\n", - "test_s1 = test_s1.iloc[hdr_idx+1 : ].reset_index(drop=True)\n", - "\n", - "# 5) Assign the new_header as the DataFrame’s columns\n", - "test_s1.columns = new_header" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "id": "bc870d3a-9046-422e-be22-8148e6a96146", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
10Date/Time StartDate/Time StopWear or Non-WearLength (minutes)Use?NaN
02/7/2025 12:00 AM2/7/2025 6:55 AMWear415TRUENaN
12/7/2025 6:55 AM2/7/2025 7:28 AMNon-Wear33FALSENaN
22/7/2025 7:28 AM2/7/2025 5:21 PMWear593TRUENaN
32/7/2025 5:21 PM2/7/2025 6:47 PMNon-Wear86FALSENaN
42/7/2025 6:47 PM2/8/2025 10:05 AMWear918TRUENaN
52/8/2025 10:05 AM2/8/2025 10:06 AMNon-Wear1FALSENaN
62/8/2025 10:06 AM2/15/2025 10:28 PMWear10822TRUENaN
72/15/2025 10:28 PM2/17/2025 12:00 AMNon-Wear1532FALSENaN
\n", - "
" - ], - "text/plain": [ - "10 Date/Time Start Date/Time Stop Wear or Non-Wear Length (minutes) \\\n", - "0 2/7/2025 12:00 AM 2/7/2025 6:55 AM Wear 415 \n", - "1 2/7/2025 6:55 AM 2/7/2025 7:28 AM Non-Wear 33 \n", - "2 2/7/2025 7:28 AM 2/7/2025 5:21 PM Wear 593 \n", - "3 2/7/2025 5:21 PM 2/7/2025 6:47 PM Non-Wear 86 \n", - "4 2/7/2025 6:47 PM 2/8/2025 10:05 AM Wear 918 \n", - "5 2/8/2025 10:05 AM 2/8/2025 10:06 AM Non-Wear 1 \n", - "6 2/8/2025 10:06 AM 2/15/2025 10:28 PM Wear 10822 \n", - "7 2/15/2025 10:28 PM 2/17/2025 12:00 AM Non-Wear 1532 \n", - "\n", - "10 Use? NaN \n", - "0 TRUE NaN \n", - "1 FALSE NaN \n", - "2 TRUE NaN \n", - "3 FALSE NaN \n", - "4 TRUE NaN \n", - "5 FALSE NaN \n", - "6 TRUE NaN \n", - "7 FALSE NaN " - ] - }, - "execution_count": 67, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_s1" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "0907fc50-1686-48de-8407-ff029862453c", - "metadata": {}, - "outputs": [], - "source": [ - "test_s1 = test_s1[['Date/Time Start', 'Date/Time Stop', 'Wear or Non-Wear']]" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "b8a4a8e3-5ab2-43a8-a04a-078558d0a954", - "metadata": {}, - "outputs": [], - "source": [ - "test_s1 = test_s1[test_s1['Wear or Non-Wear']=='Non-Wear']" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "id": "0e043d0a-dd80-4c4f-8eff-3e62cf91fb70", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
10Date/Time StartDate/Time StopWear or Non-Wear
12/7/2025 6:55 AM2/7/2025 7:28 AMNon-Wear
32/7/2025 5:21 PM2/7/2025 6:47 PMNon-Wear
52/8/2025 10:05 AM2/8/2025 10:06 AMNon-Wear
72/15/2025 10:28 PM2/17/2025 12:00 AMNon-Wear
\n", - "
" - ], - "text/plain": [ - "10 Date/Time Start Date/Time Stop Wear or Non-Wear\n", - "1 2/7/2025 6:55 AM 2/7/2025 7:28 AM Non-Wear\n", - "3 2/7/2025 5:21 PM 2/7/2025 6:47 PM Non-Wear\n", - "5 2/8/2025 10:05 AM 2/8/2025 10:06 AM Non-Wear\n", - "7 2/15/2025 10:28 PM 2/17/2025 12:00 AM Non-Wear" - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "nonwear_df = test_s1\n", - "nonwear_df" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "id": "c0105e2f-0f50-46fd-868d-ab82a6762514", - "metadata": {}, - "outputs": [], - "source": [ - "int_sleep = pd.read_csv('/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/sleep_log_intervention.csv')\n", - "int_sleep.to_clipboard()" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "cb5984f5-302d-4f75-a7c2-53788af603d2", - "metadata": {}, - "outputs": [], - "source": [ - "sleep_test = int_sleep[int_sleep['ID']=='sub-8022_ses-1_accel']\n", - "sleep_test.to_clipboard()\n", - "sleep_df = sleep_test" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "id": "52ffc19a-ec45-4832-9fff-2a58ce281b8d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:21: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[off_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:41: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[on_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[off_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:41: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[on_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[off_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:41: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[on_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:39: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[off_col] = pd.NA\n", - "/tmp/nix-shell.RrgKp6/ipykernel_184880/3756629236.py:41: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " sleep_df[on_col] = pd.NA\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "# 1) parse your nonwear datetimes and extract just the date\n", - "nonwear_df['Date/Time Start'] = pd.to_datetime(nonwear_df['Date/Time Start'])\n", - "nonwear_df['Date/Time Stop' ] = pd.to_datetime(nonwear_df['Date/Time Stop'])\n", - "nonwear_df['nw_date'] = nonwear_df['Date/Time Start'].dt.date\n", - "\n", - "# 2) build a dict: date → list of (start_time_str, stop_time_str)\n", - "nw_dict = {\n", - " d: list(zip(\n", - " grp['Date/Time Start'].dt.strftime('%H:%M:%S'),\n", - " grp['Date/Time Stop' ].dt.strftime('%H:%M:%S'),\n", - " ))\n", - " for d, grp in nonwear_df.groupby('nw_date')\n", - "}\n", - "\n", - "# 3) make sure your sleep dates are actual date objects\n", - "for i in range(1, 11):\n", - " col = f'D{i}_date'\n", - " if col in sleep_df.columns:\n", - " sleep_df[col] = pd.to_datetime(sleep_df[col]).dt.date\n", - "\n", - "# 4) for each row and each day, pluck out the intervals and write new cols\n", - "for idx, row in sleep_df.iterrows():\n", - " for i in range(1, 11):\n", - " date_col = f'D{i}_date'\n", - " if pd.isna(row.get(date_col)):\n", - " continue\n", - "\n", - " day = row[date_col]\n", - " intervals = nw_dict.get(day, [])\n", - "\n", - " for j, (off_time, on_time) in enumerate(intervals, start=1):\n", - " off_col = f'D{i}_nonwear{j}_off'\n", - " on_col = f'D{i}_nonwear{j}_on'\n", - "\n", - " # create the column if it doesn’t exist yet\n", - " if off_col not in sleep_df.columns:\n", - " sleep_df[off_col] = pd.NA\n", - " if on_col not in sleep_df.columns:\n", - " sleep_df[on_col] = pd.NA\n", - "\n", - " # assign the times\n", - " sleep_df.at[idx, off_col] = off_time\n", - " sleep_df.at[idx, on_col ] = on_time\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "id": "213fc478-9af2-4cfc-9a1d-8ed76ee5d05e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IDD1_dateD1_inbedD1_wakeupD2_dateD2_inbedD2_wakeupD3_dateD3_inbedD3_wakeup...D10_inbedD10_wakeupD1_nonwear1_offD1_nonwear1_onD1_nonwear2_offD1_nonwear2_onD2_nonwear1_offD2_nonwear1_onD8_nonwear1_offD8_nonwear1_on
0sub-8022_ses-1_accel2025-02-0719:00:0008:30:002025-02-0823:45:0007:30:002025-02-0923:55:0007:00:00...NaNNaN06:55:0007:28:0017:21:0018:47:0010:05:0010:06:0022:28:0000:00:00
\n", - "

1 rows × 39 columns

\n", - "
" - ], - "text/plain": [ - " ID D1_date D1_inbed D1_wakeup D2_date D2_inbed \\\n", - "0 sub-8022_ses-1_accel 2025-02-07 19:00:00 08:30:00 2025-02-08 23:45:00 \n", - "\n", - " D2_wakeup D3_date D3_inbed D3_wakeup ... D10_inbed D10_wakeup \\\n", - "0 07:30:00 2025-02-09 23:55:00 07:00:00 ... NaN NaN \n", - "\n", - " D1_nonwear1_off D1_nonwear1_on D1_nonwear2_off D1_nonwear2_on \\\n", - "0 06:55:00 07:28:00 17:21:00 18:47:00 \n", - "\n", - " D2_nonwear1_off D2_nonwear1_on D8_nonwear1_off D8_nonwear1_on \n", - "0 10:05:00 10:06:00 22:28:00 00:00:00 \n", - "\n", - "[1 rows x 39 columns]" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sleep_df" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "id": "c4625594-8368-447d-afd0-05baa0df5139", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "\n", - "def integrate_nonwear(sleep_df: pd.DataFrame,\n", - " wear_files_df: pd.DataFrame,\n", - " id_col: str = \"ID\") -> pd.DataFrame:\n", - " \"\"\"\n", - " Updates sleep_df in‑place by reading each wear‑time CSV in wear_files_df,\n", - " extracting Non‑Wear intervals, and appending them to the matching row\n", - " in sleep_df under D{day}_nonwear{n}_{off,on} columns.\n", - " \n", - " wear_files_df must have columns: subject_id, session_id, filename, date\n", - " sleep_df must have an ID column like \"sub-8022_ses-1_accel\" and\n", - " D1_date … D10_date columns of type date or datetime.\n", - " \"\"\"\n", - " for _, wf in wear_files_df.iterrows():\n", - " # build the sleep_df ID key\n", - " key = f\"{wf.subject_id}_{wf.session_id}_accel\"\n", - "\n", - " # 1) read raw CSV and splice out the non-wear table\n", - " raw = pd.read_csv(wf.filename, header=0, dtype=str)\n", - " # locate the second-header row\n", - " mask = (raw.iloc[:,0]\n", - " .astype(str)\n", - " .str.strip()\n", - " .str.contains(\"Date/Time Start\", na=False))\n", - " if not mask.any():\n", - " continue # no header found, skip\n", - " hdr_idx = mask.idxmax()\n", - " new_hdr = raw.iloc[hdr_idx]\n", - " df = raw.iloc[hdr_idx+1 : ].reset_index(drop=True)\n", - " df.columns = new_hdr\n", - " df = df[['Date/Time Start','Date/Time Stop','Wear or Non-Wear']]\n", - " nonwear = df[df['Wear or Non-Wear']=='Non-Wear'].copy()\n", - "\n", - " # 2) parse datetimes and group by date\n", - " nonwear['Date/Time Start'] = pd.to_datetime(nonwear['Date/Time Start'])\n", - " nonwear['Date/Time Stop'] = pd.to_datetime(nonwear['Date/Time Stop'])\n", - " nonwear['nw_date'] = nonwear['Date/Time Start'].dt.date\n", - " nw_dict = (\n", - " nonwear\n", - " .groupby('nw_date')\n", - " .apply(lambda g: list(zip(\n", - " g['Date/Time Start'].dt.strftime('%H:%M:%S'),\n", - " g['Date/Time Stop'].dt.strftime('%H:%M:%S'),\n", - " )))\n", - " .to_dict()\n", - " )\n", - "\n", - " # 3) find matching sleep_df row\n", - " matches = sleep_df.index[sleep_df[id_col] == key]\n", - " if len(matches) == 0:\n", - " continue\n", - " ridx = matches[0]\n", - "\n", - " # 4) for each D{i}_date, assign its intervals\n", - " for i in range(1, 11):\n", - " date_col = f'D{i}_date'\n", - " if date_col not in sleep_df.columns:\n", - " break\n", - " raw_date = sleep_df.at[ridx, date_col]\n", - " if pd.isna(raw_date):\n", - " continue\n", - " day = pd.to_datetime(raw_date).date()\n", - " intervals = nw_dict.get(day, [])\n", - " for j, (off_t, on_t) in enumerate(intervals, start=1):\n", - " off_col = f'D{i}_nonwear{j}_off'\n", - " on_col = f'D{i}_nonwear{j}_on'\n", - " # create columns if missing\n", - " if off_col not in sleep_df:\n", - " sleep_df[off_col] = pd.NA\n", - " if on_col not in sleep_df:\n", - " sleep_df[on_col] = pd.NA\n", - " sleep_df.at[ridx, off_col] = off_t\n", - " sleep_df.at[ridx, on_col ] = on_t\n", - "\n", - " return sleep_df\n" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "5d005d79-6ba3-436b-8449-27abd6e1352a", - "metadata": {}, - "outputs": [], - "source": [ - "# sleep_df: your DataFrame of all sleep logs\n", - "# wear_files_df: DataFrame with columns [subject_id, session_id, filename, date]\n", - "int_sleep = pd.read_csv('/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test/sleep_log_intervention.csv')\n", - "\n", - "updated = integrate_nonwear(int_sleep, sessions_df)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "id": "fc3c663d-1438-47fc-8263-fd1167cc765e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
IDD1_dateD1_inbedD1_wakeupD2_dateD2_inbedD2_wakeupD3_dateD3_inbedD3_wakeup...D7_wakeupD8_dateD8_inbedD8_wakeupD9_dateD9_inbedD9_wakeupD10_dateD10_inbedD10_wakeup
0sub-8022_ses-1_accel2025-02-0719:00:0008:30:002025-02-0823:45:0007:30:002025-02-0923:55:0007:00:00...07:00:002025-02-1501:00:0009:00:00NaNNaNNaNNaNNaNNaN
1sub-8022_ses-2_accel2025-04-1700:00:0006:30:002025-04-1823:10:0007:40:002025-04-2002:45:0007:30:00...08:00:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
2sub-8001_ses-1_accel2024-09-2100:30:0008:30:002024-09-2200:15:0007:40:002024-09-2305:20:0009:30:00...09:00:002024-09-2800:30:0008:45:002024-09-2900:30:0008:15:002024-09-3000:20:0008:30:00
3sub-8002_ses-1_accel2024-09-1422:15:0006:45:002024-09-1523:00:0006:45:002024-09-1622:51:0006:45:00...07:00:002024-09-2122:30:0006:45:002024-09-2222:45:0006:45:00NaNNaNNaN
4sub-8002_ses-2_accel2024-11-0723:00:0003:30:002024-11-0821:30:0005:30:002024-11-0921:30:0005:30:00...06:15:002024-11-1422:45:0006:15:002024-11-1522:30:0007:00:00NaNNaNNaN
5sub-8002_ses-3_accel2025-02-2623:00:0006:30:002025-02-2723:00:0006:30:002025-02-2823:00:0007:30:00...07:00:002025-03-0522:30:0006:30:002025-03-0623:00:0006:30:00NaNNaNNaN
6sub-8002_ses-4_accel2025-05-0522:30:0006:30:002025-05-0622:30:0006:30:002025-05-0723:00:0007:00:00...06:45:002025-05-1223:15:0007:00:002025-05-1322:30:0006:45:00NaNNaNNaN
7sub-8003_ses-1_accel2024-10-0522:30:0007:30:002024-10-0621:30:0006:00:002024-10-0722:00:0006:00:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
8sub-8003_ses-2_accel2025-02-0122:50:0007:00:002025-02-0222:00:0006:15:002025-02-0322:30:0005:30:00...07:15:002025-02-0823:00:0007:00:002025-02-0922:30:0006:15:00NaNNaNNaN
9sub-8004_ses-1_accel2024-09-2618:45:0005:55:002024-09-2722:00:0007:01:002024-09-2821:57:0006:12:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
10sub-8004_ses-2_accel2024-11-2323:00:0006:56:002024-11-2421:43:0005:51:002024-11-2520:55:0005:26:00...06:04:002024-11-3019:30:0006:20:002024-12-0120:30:0005:40:00NaNNaNNaN
11sub-8004_ses-3_accel2025-03-1221:15:0006:45:002025-03-1321:00:0006:15:002025-03-1421:15:0007:30:00...06:10:002025-03-1920:30:0006:45:002025-03-2021:00:0006:00:00NaNNaNNaN
12sub-8004_ses-4_accel2025-04-3021:30:0005:45:002025-05-0122:00:0006:00:002025-05-0220:45:0006:00:00...06:15:002025-05-0721:15:0006:15:002025-05-0821:30:0006:00:00NaNNaNNaN
13sub-8006_ses-1_accel2024-09-2123:00:0007:30:002024-09-2223:00:0005:30:002024-09-2322:30:0006:00:00...07:00:002024-09-2821:30:0006:30:002024-09-2923:00:0005:30:00NaNNaNNaN
14sub-8006_ses-2_accel2024-12-1322:00:0007:00:002024-12-1421:00:0007:00:002024-12-1523:00:0006:00:00...05:25:002024-12-2023:00:0008:00:002024-12-2122:00:0007:10:00NaNNaNNaN
15sub-8006_ses-3_accel2025-04-1623:00:0006:22:002025-04-1723:00:0006:00:002025-04-1818:00:0007:00:00...06:20:002025-04-2321:45:0006:17:002025-04-2420:00:0006:30:00NaNNaNNaN
16sub-8006_ses-4_accel2025-05-1422:20:0006:40:002025-05-1522:30:0006:30:002025-05-1623:30:0006:30:00...06:50:002025-05-2121:45:0006:11:002025-05-2222:00:0006:40:00NaNNaNNaN
17sub-8005_ses-1_accel2024-10-3123:00:0007:30:002024-11-0123:30:0007:45:002024-11-0223:25:0008:15:00...08:05:002024-11-0800:30:0008:30:002024-11-0900:15:0009:15:00NaNNaNNaN
18sub-8005_ses-2_accel2025-01-1622:30:0006:45:002025-01-1723:40:0008:38:002025-01-1823:50:0008:50:00...07:50:002025-01-2500:10:0007:50:00NaNNaNNaNNaNNaNNaN
19sub-8005_ses-3_accel2025-05-2223:00:0007:15:002025-05-2323:00:0008:00:002025-05-2423:15:0008:00:00...07:50:002025-05-3000:00:0007:50:00NaNNaNNaNNaNNaNNaN
20sub-8008_ses-1_accel2024-11-0500:00:0008:00:002024-11-0622:30:0009:00:002024-11-0723:30:0008:00:00...09:00:002024-11-1300:00:0007:30:002024-11-1400:00:0011:00:00NaNNaNNaN
21sub-8008_ses-2_accel2025-01-1003:46:0009:30:002025-01-1102:00:0010:30:002025-01-1203:00:0011:00:00...04:30:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
22sub-8011_ses-1_accel2024-12-0700:00:0007:30:002024-12-0823:38:0006:31:002024-12-0922:47:0006:47:00...07:08:002024-12-1500:13:0007:45:002024-12-1600:01:0006:40:00NaNNaNNaN
23sub-8011_ses-2_accel2025-02-2000:00:0007:53:002025-02-2100:23:0006:30:002025-02-2222:42:0008:00:00...06:11:002025-03-0100:56:0007:18:00NaNNaNNaNNaNNaNNaN
24sub-8012_ses-1_accel2025-05-0923:00:0007:00:002025-05-1023:15:0006:25:002025-05-1222:00:0006:25:00...07:45:002025-05-1723:30:0008:45:00NaNNaNNaNNaNNaNNaN
25sub-8012_ses-2_accel2025-01-0920:45:0006:00:002025-01-1022:30:0006:15:002025-01-1220:30:0006:15:00...05:55:002025-01-1721:45:0007:00:00NaNNaNNaNNaNNaNNaN
26sub-8014_ses-1_accel2025-01-1521:15:0003:50:002025-01-1621:00:0003:50:002025-01-1721:00:0004:50:00...03:50:002025-01-2221:15:0003:50:002025-01-2321:15:0003:50:00NaNNaNNaN
27sub-8014_ses-2_accel2025-05-0323:00:0007:05:002025-05-0421:15:0003:50:002025-05-0520:25:0002:50:00...06:15:002025-05-1023:30:0006:15:002025-05-1121:05:0002:50:00NaNNaNNaN
28sub-8015_ses-1_accel2025-01-2922:05:0006:00:002025-01-3022:00:0006:00:002025-01-3122:30:0007:54:00...06:05:002025-02-0622:35:0005:49:00NaNNaNNaNNaNNaNNaN
29sub-8016_ses-1_accel2025-02-1921:53:0005:30:002025-02-2022:07:0005:30:002025-02-2122:40:0008:50:00...08:30:002025-02-2621:00:0005:50:002025-02-2721:45:0005:15:00NaNNaNNaN
30sub-8016_ses-2_accel2025-04-0722:50:0005:00:002025-04-0822:00:0005:00:002025-04-1023:15:0009:15:00...09:15:002025-04-1600:30:0006:20:00NaNNaNNaNNaNNaNNaN
31sub-8017_ses-1_accel2025-04-0922:20:0006:37:002025-04-1022:24:0006:32:002025-04-1122:10:0008:17:00...06:17:002025-04-1622:01:0006:35:002025-04-1722:20:0005:30:00NaNNaNNaN
32sub-8018_ses-1_accel2025-01-2223:30:0010:15:002025-01-2323:30:0010:00:002025-01-2423:30:0010:00:00...09:30:002025-01-3100:00:0009:15:00NaNNaNNaNNaNNaNNaN
33sub-8019_ses-1_accel2025-01-2823:06:0006:30:002025-01-2923:00:0006:00:002025-01-3023:17:0006:00:00...06:00:002025-02-0522:50:0006:25:00NaNNaNNaNNaNNaNNaN
34sub-8019_ses-2_accel2025-04-2323:02:0005:30:002025-04-2422:40:0006:20:002025-04-2523:25:0007:30:00...06:20:002025-04-3023:10:0006:30:002025-05-0122:55:0006:28:00NaNNaNNaN
35sub-8020_ses-1_accel2025-01-3021:30:0002:30:002025-01-3121:00:0005:00:002025-02-0119:45:0005:00:00...05:30:002025-02-0621:30:0006:00:002025-02-0722:00:0005:30:00NaNNaNNaN
36sub-8020_ses-2_accel2025-04-0919:43:0005:00:002025-04-1019:45:0005:40:002025-04-1120:53:0006:00:00...05:30:002025-04-1622:34:0004:00:002025-04-1721:30:0006:35:00NaNNaNNaN
37sub-8021_ses-1_accel2025-01-2923:19:0008:00:002025-01-3023:34:0008:01:002025-01-3123:07:0009:15:00...07:29:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
38sub-8021_ses-2_accel2025-05-2400:00:0008:20:002025-05-2523:45:0009:00:002025-05-2623:30:0006:00:00...09:00:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
39sub-8023_ses-1_accel2025-04-1023:00:0005:50:002025-04-1222:30:0009:00:002025-04-1323:00:0005:15:00...06:15:002025-04-1901:15:0008:50:00NaNNaNNaNNaNNaNNaN
40sub-8024_ses-1_accel2025-03-0821:43:0006:43:002025-03-0921:30:0005:13:002025-03-1020:40:0004:30:00...06:05:002025-03-1521:48:0006:10:002025-03-1621:30:0005:00:00NaNNaNNaN
41sub-8024_ses-2_accel2025-05-3022:30:0007:30:002025-05-3122:00:0006:00:002025-06-0123:00:0005:45:00...05:50:002025-06-0622:30:0007:00:002025-06-0723:00:0007:00:00NaNNaNNaN
42sub-8026_ses-1_accel2025-02-0420:30:0005:30:002025-02-0521:00:0006:00:002025-02-0619:30:0006:00:00...05:30:002025-02-1122:30:0006:00:002025-02-1221:00:0006:00:00NaNNaNNaN
43sub-8026_ses-2_accel2025-05-2300:00:0006:00:002025-05-2423:30:0007:50:002025-05-2523:30:0008:30:00...05:50:002025-05-3022:30:0006:01:002025-05-3123:00:0008:40:00NaNNaNNaN
44sub-8030_ses-1_accel2025-02-2121:30:0006:10:002025-02-2221:30:0006:04:002025-02-2320:30:0005:10:00...06:10:002025-02-2821:30:0004:55:002025-03-0122:00:0004:55:00NaNNaNNaN
45sub-8030_ses-2_accel2025-05-1022:40:0007:05:002025-05-1122:45:0006:17:002025-05-1222:30:0005:17:00...05:59:002025-05-1722:50:0006:32:002025-05-1823:00:0005:30:00NaNNaNNaN
46sub-8032_ses-1_accel2025-05-2220:35:0005:34:002025-05-2321:00:0006:48:002025-05-2420:40:0007:14:00...05:39:002025-05-2919:55:0005:35:002025-05-3020:40:0005:57:00NaNNaNNaN
47sub-8034_ses-1_accel2025-03-2921:30:0007:30:002025-03-3021:30:0006:00:002025-03-3122:00:0006:30:00...06:20:002025-04-0521:00:0007:50:002025-04-0621:00:0007:00:00NaNNaNNaN
48sub-8035_ses-1_accel2025-03-1921:45:0005:45:002025-03-2022:42:0006:45:002025-03-2123:50:0006:00:00...05:37:002025-03-2621:45:0005:35:002025-03-2721:30:0005:39:00NaNNaNNaN
49sub-8036_ses-1_accel2025-03-2522:30:0007:00:002025-03-2722:30:0006:00:002025-03-2821:30:0002:30:00...06:00:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
50sub-8038_ses-1_accel2025-04-2623:30:0009:50:002025-04-2723:15:0008:04:002025-04-2823:00:0008:20:00...05:44:002025-05-0423:30:0008:20:00NaNNaNNaNNaNNaNNaN
51sub-8039_ses-1_accel2025-05-2023:20:0005:55:002025-05-2223:30:0006:00:002025-05-2400:05:0006:00:00...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
52sub-8040_ses-1_accel2025-05-2022:30:0006:15:002025-05-2122:45:0006:30:002025-05-2222:45:0006:15:00...06:45:00NaNNaNNaNNaNNaNNaNNaNNaNNaN
53sub-8042_ses-1_accel2025-05-2021:17:0006:13:002025-05-2121:55:0005:38:002025-05-2222:29:0006:05:00...06:15:002025-05-2721:55:0006:15:002025-05-2822:05:0005:53:00NaNNaNNaN
54sub-8046_ses-1_accel2025-05-2822:00:0006:00:002025-05-2922:28:0006:20:002025-05-3022:20:0007:15:00...06:25:002025-06-0423:00:0006:15:002025-06-0522:30:0006:25:00NaNNaNNaN
55sub-8047_ses-1_accel2025-05-1422:45:0005:15:002025-05-1522:00:0005:55:002025-05-1622:20:0006:36:00...05:52:002025-05-2122:10:0006:00:002025-05-2222:07:0005:54:00NaNNaNNaN
56sub-8050_ses-1_accel2025-05-2100:00:0006:30:002025-05-2200:00:0006:10:002025-05-2300:20:0006:30:00...07:00:002025-05-2800:30:0006:30:002025-05-2900:00:0006:15:002025-05-3000:00:0006:45:00
57sub-8051_ses-1_accel2025-06-0501:00:0007:45:002025-06-0601:00:0008:00:002025-06-0700:15:0006:30:00...10:00:002025-06-1201:50:0009:00:002025-06-1301:00:0009:00:002025-06-1403:00:0009:00:00
58sub-8053_ses-1_accel2025-06-0423:48:0006:30:002025-06-0523:35:0007:35:002025-06-0623:15:0006:30:00...07:10:002025-06-1222:01:0005:30:00NaNNaNNaNNaNNaNNaN
59sub-8054_ses-1_accel2025-05-3000:00:0006:45:002025-05-3123:30:0006:00:002025-06-0123:40:0006:15:00...05:45:002025-06-0800:00:0006:00:00NaNNaNNaNNaNNaNNaN
\n", - "

60 rows × 31 columns

\n", - "
" - ], - "text/plain": [ - " ID D1_date D1_inbed D1_wakeup D2_date \\\n", - "0 sub-8022_ses-1_accel 2025-02-07 19:00:00 08:30:00 2025-02-08 \n", - "1 sub-8022_ses-2_accel 2025-04-17 00:00:00 06:30:00 2025-04-18 \n", - "2 sub-8001_ses-1_accel 2024-09-21 00:30:00 08:30:00 2024-09-22 \n", - "3 sub-8002_ses-1_accel 2024-09-14 22:15:00 06:45:00 2024-09-15 \n", - "4 sub-8002_ses-2_accel 2024-11-07 23:00:00 03:30:00 2024-11-08 \n", - "5 sub-8002_ses-3_accel 2025-02-26 23:00:00 06:30:00 2025-02-27 \n", - "6 sub-8002_ses-4_accel 2025-05-05 22:30:00 06:30:00 2025-05-06 \n", - "7 sub-8003_ses-1_accel 2024-10-05 22:30:00 07:30:00 2024-10-06 \n", - "8 sub-8003_ses-2_accel 2025-02-01 22:50:00 07:00:00 2025-02-02 \n", - "9 sub-8004_ses-1_accel 2024-09-26 18:45:00 05:55:00 2024-09-27 \n", - "10 sub-8004_ses-2_accel 2024-11-23 23:00:00 06:56:00 2024-11-24 \n", - "11 sub-8004_ses-3_accel 2025-03-12 21:15:00 06:45:00 2025-03-13 \n", - "12 sub-8004_ses-4_accel 2025-04-30 21:30:00 05:45:00 2025-05-01 \n", - "13 sub-8006_ses-1_accel 2024-09-21 23:00:00 07:30:00 2024-09-22 \n", - "14 sub-8006_ses-2_accel 2024-12-13 22:00:00 07:00:00 2024-12-14 \n", - "15 sub-8006_ses-3_accel 2025-04-16 23:00:00 06:22:00 2025-04-17 \n", - "16 sub-8006_ses-4_accel 2025-05-14 22:20:00 06:40:00 2025-05-15 \n", - "17 sub-8005_ses-1_accel 2024-10-31 23:00:00 07:30:00 2024-11-01 \n", - "18 sub-8005_ses-2_accel 2025-01-16 22:30:00 06:45:00 2025-01-17 \n", - "19 sub-8005_ses-3_accel 2025-05-22 23:00:00 07:15:00 2025-05-23 \n", - "20 sub-8008_ses-1_accel 2024-11-05 00:00:00 08:00:00 2024-11-06 \n", - "21 sub-8008_ses-2_accel 2025-01-10 03:46:00 09:30:00 2025-01-11 \n", - "22 sub-8011_ses-1_accel 2024-12-07 00:00:00 07:30:00 2024-12-08 \n", - "23 sub-8011_ses-2_accel 2025-02-20 00:00:00 07:53:00 2025-02-21 \n", - "24 sub-8012_ses-1_accel 2025-05-09 23:00:00 07:00:00 2025-05-10 \n", - "25 sub-8012_ses-2_accel 2025-01-09 20:45:00 06:00:00 2025-01-10 \n", - "26 sub-8014_ses-1_accel 2025-01-15 21:15:00 03:50:00 2025-01-16 \n", - "27 sub-8014_ses-2_accel 2025-05-03 23:00:00 07:05:00 2025-05-04 \n", - "28 sub-8015_ses-1_accel 2025-01-29 22:05:00 06:00:00 2025-01-30 \n", - "29 sub-8016_ses-1_accel 2025-02-19 21:53:00 05:30:00 2025-02-20 \n", - "30 sub-8016_ses-2_accel 2025-04-07 22:50:00 05:00:00 2025-04-08 \n", - "31 sub-8017_ses-1_accel 2025-04-09 22:20:00 06:37:00 2025-04-10 \n", - "32 sub-8018_ses-1_accel 2025-01-22 23:30:00 10:15:00 2025-01-23 \n", - "33 sub-8019_ses-1_accel 2025-01-28 23:06:00 06:30:00 2025-01-29 \n", - "34 sub-8019_ses-2_accel 2025-04-23 23:02:00 05:30:00 2025-04-24 \n", - "35 sub-8020_ses-1_accel 2025-01-30 21:30:00 02:30:00 2025-01-31 \n", - "36 sub-8020_ses-2_accel 2025-04-09 19:43:00 05:00:00 2025-04-10 \n", - "37 sub-8021_ses-1_accel 2025-01-29 23:19:00 08:00:00 2025-01-30 \n", - "38 sub-8021_ses-2_accel 2025-05-24 00:00:00 08:20:00 2025-05-25 \n", - "39 sub-8023_ses-1_accel 2025-04-10 23:00:00 05:50:00 2025-04-12 \n", - "40 sub-8024_ses-1_accel 2025-03-08 21:43:00 06:43:00 2025-03-09 \n", - "41 sub-8024_ses-2_accel 2025-05-30 22:30:00 07:30:00 2025-05-31 \n", - "42 sub-8026_ses-1_accel 2025-02-04 20:30:00 05:30:00 2025-02-05 \n", - "43 sub-8026_ses-2_accel 2025-05-23 00:00:00 06:00:00 2025-05-24 \n", - "44 sub-8030_ses-1_accel 2025-02-21 21:30:00 06:10:00 2025-02-22 \n", - "45 sub-8030_ses-2_accel 2025-05-10 22:40:00 07:05:00 2025-05-11 \n", - "46 sub-8032_ses-1_accel 2025-05-22 20:35:00 05:34:00 2025-05-23 \n", - "47 sub-8034_ses-1_accel 2025-03-29 21:30:00 07:30:00 2025-03-30 \n", - "48 sub-8035_ses-1_accel 2025-03-19 21:45:00 05:45:00 2025-03-20 \n", - "49 sub-8036_ses-1_accel 2025-03-25 22:30:00 07:00:00 2025-03-27 \n", - "50 sub-8038_ses-1_accel 2025-04-26 23:30:00 09:50:00 2025-04-27 \n", - "51 sub-8039_ses-1_accel 2025-05-20 23:20:00 05:55:00 2025-05-22 \n", - "52 sub-8040_ses-1_accel 2025-05-20 22:30:00 06:15:00 2025-05-21 \n", - "53 sub-8042_ses-1_accel 2025-05-20 21:17:00 06:13:00 2025-05-21 \n", - "54 sub-8046_ses-1_accel 2025-05-28 22:00:00 06:00:00 2025-05-29 \n", - "55 sub-8047_ses-1_accel 2025-05-14 22:45:00 05:15:00 2025-05-15 \n", - "56 sub-8050_ses-1_accel 2025-05-21 00:00:00 06:30:00 2025-05-22 \n", - "57 sub-8051_ses-1_accel 2025-06-05 01:00:00 07:45:00 2025-06-06 \n", - "58 sub-8053_ses-1_accel 2025-06-04 23:48:00 06:30:00 2025-06-05 \n", - "59 sub-8054_ses-1_accel 2025-05-30 00:00:00 06:45:00 2025-05-31 \n", - "\n", - " D2_inbed D2_wakeup D3_date D3_inbed D3_wakeup ... D7_wakeup \\\n", - "0 23:45:00 07:30:00 2025-02-09 23:55:00 07:00:00 ... 07:00:00 \n", - "1 23:10:00 07:40:00 2025-04-20 02:45:00 07:30:00 ... 08:00:00 \n", - "2 00:15:00 07:40:00 2024-09-23 05:20:00 09:30:00 ... 09:00:00 \n", - "3 23:00:00 06:45:00 2024-09-16 22:51:00 06:45:00 ... 07:00:00 \n", - "4 21:30:00 05:30:00 2024-11-09 21:30:00 05:30:00 ... 06:15:00 \n", - "5 23:00:00 06:30:00 2025-02-28 23:00:00 07:30:00 ... 07:00:00 \n", - "6 22:30:00 06:30:00 2025-05-07 23:00:00 07:00:00 ... 06:45:00 \n", - "7 21:30:00 06:00:00 2024-10-07 22:00:00 06:00:00 ... NaN \n", - "8 22:00:00 06:15:00 2025-02-03 22:30:00 05:30:00 ... 07:15:00 \n", - "9 22:00:00 07:01:00 2024-09-28 21:57:00 06:12:00 ... NaN \n", - "10 21:43:00 05:51:00 2024-11-25 20:55:00 05:26:00 ... 06:04:00 \n", - "11 21:00:00 06:15:00 2025-03-14 21:15:00 07:30:00 ... 06:10:00 \n", - "12 22:00:00 06:00:00 2025-05-02 20:45:00 06:00:00 ... 06:15:00 \n", - "13 23:00:00 05:30:00 2024-09-23 22:30:00 06:00:00 ... 07:00:00 \n", - "14 21:00:00 07:00:00 2024-12-15 23:00:00 06:00:00 ... 05:25:00 \n", - "15 23:00:00 06:00:00 2025-04-18 18:00:00 07:00:00 ... 06:20:00 \n", - "16 22:30:00 06:30:00 2025-05-16 23:30:00 06:30:00 ... 06:50:00 \n", - "17 23:30:00 07:45:00 2024-11-02 23:25:00 08:15:00 ... 08:05:00 \n", - "18 23:40:00 08:38:00 2025-01-18 23:50:00 08:50:00 ... 07:50:00 \n", - "19 23:00:00 08:00:00 2025-05-24 23:15:00 08:00:00 ... 07:50:00 \n", - "20 22:30:00 09:00:00 2024-11-07 23:30:00 08:00:00 ... 09:00:00 \n", - "21 02:00:00 10:30:00 2025-01-12 03:00:00 11:00:00 ... 04:30:00 \n", - "22 23:38:00 06:31:00 2024-12-09 22:47:00 06:47:00 ... 07:08:00 \n", - "23 00:23:00 06:30:00 2025-02-22 22:42:00 08:00:00 ... 06:11:00 \n", - "24 23:15:00 06:25:00 2025-05-12 22:00:00 06:25:00 ... 07:45:00 \n", - "25 22:30:00 06:15:00 2025-01-12 20:30:00 06:15:00 ... 05:55:00 \n", - "26 21:00:00 03:50:00 2025-01-17 21:00:00 04:50:00 ... 03:50:00 \n", - "27 21:15:00 03:50:00 2025-05-05 20:25:00 02:50:00 ... 06:15:00 \n", - "28 22:00:00 06:00:00 2025-01-31 22:30:00 07:54:00 ... 06:05:00 \n", - "29 22:07:00 05:30:00 2025-02-21 22:40:00 08:50:00 ... 08:30:00 \n", - "30 22:00:00 05:00:00 2025-04-10 23:15:00 09:15:00 ... 09:15:00 \n", - "31 22:24:00 06:32:00 2025-04-11 22:10:00 08:17:00 ... 06:17:00 \n", - "32 23:30:00 10:00:00 2025-01-24 23:30:00 10:00:00 ... 09:30:00 \n", - "33 23:00:00 06:00:00 2025-01-30 23:17:00 06:00:00 ... 06:00:00 \n", - "34 22:40:00 06:20:00 2025-04-25 23:25:00 07:30:00 ... 06:20:00 \n", - "35 21:00:00 05:00:00 2025-02-01 19:45:00 05:00:00 ... 05:30:00 \n", - "36 19:45:00 05:40:00 2025-04-11 20:53:00 06:00:00 ... 05:30:00 \n", - "37 23:34:00 08:01:00 2025-01-31 23:07:00 09:15:00 ... 07:29:00 \n", - "38 23:45:00 09:00:00 2025-05-26 23:30:00 06:00:00 ... 09:00:00 \n", - "39 22:30:00 09:00:00 2025-04-13 23:00:00 05:15:00 ... 06:15:00 \n", - "40 21:30:00 05:13:00 2025-03-10 20:40:00 04:30:00 ... 06:05:00 \n", - "41 22:00:00 06:00:00 2025-06-01 23:00:00 05:45:00 ... 05:50:00 \n", - "42 21:00:00 06:00:00 2025-02-06 19:30:00 06:00:00 ... 05:30:00 \n", - "43 23:30:00 07:50:00 2025-05-25 23:30:00 08:30:00 ... 05:50:00 \n", - "44 21:30:00 06:04:00 2025-02-23 20:30:00 05:10:00 ... 06:10:00 \n", - "45 22:45:00 06:17:00 2025-05-12 22:30:00 05:17:00 ... 05:59:00 \n", - "46 21:00:00 06:48:00 2025-05-24 20:40:00 07:14:00 ... 05:39:00 \n", - "47 21:30:00 06:00:00 2025-03-31 22:00:00 06:30:00 ... 06:20:00 \n", - "48 22:42:00 06:45:00 2025-03-21 23:50:00 06:00:00 ... 05:37:00 \n", - "49 22:30:00 06:00:00 2025-03-28 21:30:00 02:30:00 ... 06:00:00 \n", - "50 23:15:00 08:04:00 2025-04-28 23:00:00 08:20:00 ... 05:44:00 \n", - "51 23:30:00 06:00:00 2025-05-24 00:05:00 06:00:00 ... NaN \n", - "52 22:45:00 06:30:00 2025-05-22 22:45:00 06:15:00 ... 06:45:00 \n", - "53 21:55:00 05:38:00 2025-05-22 22:29:00 06:05:00 ... 06:15:00 \n", - "54 22:28:00 06:20:00 2025-05-30 22:20:00 07:15:00 ... 06:25:00 \n", - "55 22:00:00 05:55:00 2025-05-16 22:20:00 06:36:00 ... 05:52:00 \n", - "56 00:00:00 06:10:00 2025-05-23 00:20:00 06:30:00 ... 07:00:00 \n", - "57 01:00:00 08:00:00 2025-06-07 00:15:00 06:30:00 ... 10:00:00 \n", - "58 23:35:00 07:35:00 2025-06-06 23:15:00 06:30:00 ... 07:10:00 \n", - "59 23:30:00 06:00:00 2025-06-01 23:40:00 06:15:00 ... 05:45:00 \n", - "\n", - " D8_date D8_inbed D8_wakeup D9_date D9_inbed D9_wakeup \\\n", - "0 2025-02-15 01:00:00 09:00:00 NaN NaN NaN \n", - "1 NaN NaN NaN NaN NaN NaN \n", - "2 2024-09-28 00:30:00 08:45:00 2024-09-29 00:30:00 08:15:00 \n", - "3 2024-09-21 22:30:00 06:45:00 2024-09-22 22:45:00 06:45:00 \n", - "4 2024-11-14 22:45:00 06:15:00 2024-11-15 22:30:00 07:00:00 \n", - "5 2025-03-05 22:30:00 06:30:00 2025-03-06 23:00:00 06:30:00 \n", - "6 2025-05-12 23:15:00 07:00:00 2025-05-13 22:30:00 06:45:00 \n", - "7 NaN NaN NaN NaN NaN NaN \n", - "8 2025-02-08 23:00:00 07:00:00 2025-02-09 22:30:00 06:15:00 \n", - "9 NaN NaN NaN NaN NaN NaN \n", - "10 2024-11-30 19:30:00 06:20:00 2024-12-01 20:30:00 05:40:00 \n", - "11 2025-03-19 20:30:00 06:45:00 2025-03-20 21:00:00 06:00:00 \n", - "12 2025-05-07 21:15:00 06:15:00 2025-05-08 21:30:00 06:00:00 \n", - "13 2024-09-28 21:30:00 06:30:00 2024-09-29 23:00:00 05:30:00 \n", - "14 2024-12-20 23:00:00 08:00:00 2024-12-21 22:00:00 07:10:00 \n", - "15 2025-04-23 21:45:00 06:17:00 2025-04-24 20:00:00 06:30:00 \n", - "16 2025-05-21 21:45:00 06:11:00 2025-05-22 22:00:00 06:40:00 \n", - "17 2024-11-08 00:30:00 08:30:00 2024-11-09 00:15:00 09:15:00 \n", - "18 2025-01-25 00:10:00 07:50:00 NaN NaN NaN \n", - "19 2025-05-30 00:00:00 07:50:00 NaN NaN NaN \n", - "20 2024-11-13 00:00:00 07:30:00 2024-11-14 00:00:00 11:00:00 \n", - "21 NaN NaN NaN NaN NaN NaN \n", - "22 2024-12-15 00:13:00 07:45:00 2024-12-16 00:01:00 06:40:00 \n", - "23 2025-03-01 00:56:00 07:18:00 NaN NaN NaN \n", - "24 2025-05-17 23:30:00 08:45:00 NaN NaN NaN \n", - "25 2025-01-17 21:45:00 07:00:00 NaN NaN NaN \n", - "26 2025-01-22 21:15:00 03:50:00 2025-01-23 21:15:00 03:50:00 \n", - "27 2025-05-10 23:30:00 06:15:00 2025-05-11 21:05:00 02:50:00 \n", - "28 2025-02-06 22:35:00 05:49:00 NaN NaN NaN \n", - "29 2025-02-26 21:00:00 05:50:00 2025-02-27 21:45:00 05:15:00 \n", - "30 2025-04-16 00:30:00 06:20:00 NaN NaN NaN \n", - "31 2025-04-16 22:01:00 06:35:00 2025-04-17 22:20:00 05:30:00 \n", - "32 2025-01-31 00:00:00 09:15:00 NaN NaN NaN \n", - "33 2025-02-05 22:50:00 06:25:00 NaN NaN NaN \n", - "34 2025-04-30 23:10:00 06:30:00 2025-05-01 22:55:00 06:28:00 \n", - "35 2025-02-06 21:30:00 06:00:00 2025-02-07 22:00:00 05:30:00 \n", - "36 2025-04-16 22:34:00 04:00:00 2025-04-17 21:30:00 06:35:00 \n", - "37 NaN NaN NaN NaN NaN NaN \n", - "38 NaN NaN NaN NaN NaN NaN \n", - "39 2025-04-19 01:15:00 08:50:00 NaN NaN NaN \n", - "40 2025-03-15 21:48:00 06:10:00 2025-03-16 21:30:00 05:00:00 \n", - "41 2025-06-06 22:30:00 07:00:00 2025-06-07 23:00:00 07:00:00 \n", - "42 2025-02-11 22:30:00 06:00:00 2025-02-12 21:00:00 06:00:00 \n", - "43 2025-05-30 22:30:00 06:01:00 2025-05-31 23:00:00 08:40:00 \n", - "44 2025-02-28 21:30:00 04:55:00 2025-03-01 22:00:00 04:55:00 \n", - "45 2025-05-17 22:50:00 06:32:00 2025-05-18 23:00:00 05:30:00 \n", - "46 2025-05-29 19:55:00 05:35:00 2025-05-30 20:40:00 05:57:00 \n", - "47 2025-04-05 21:00:00 07:50:00 2025-04-06 21:00:00 07:00:00 \n", - "48 2025-03-26 21:45:00 05:35:00 2025-03-27 21:30:00 05:39:00 \n", - "49 NaN NaN NaN NaN NaN NaN \n", - "50 2025-05-04 23:30:00 08:20:00 NaN NaN NaN \n", - "51 NaN NaN NaN NaN NaN NaN \n", - "52 NaN NaN NaN NaN NaN NaN \n", - "53 2025-05-27 21:55:00 06:15:00 2025-05-28 22:05:00 05:53:00 \n", - "54 2025-06-04 23:00:00 06:15:00 2025-06-05 22:30:00 06:25:00 \n", - "55 2025-05-21 22:10:00 06:00:00 2025-05-22 22:07:00 05:54:00 \n", - "56 2025-05-28 00:30:00 06:30:00 2025-05-29 00:00:00 06:15:00 \n", - "57 2025-06-12 01:50:00 09:00:00 2025-06-13 01:00:00 09:00:00 \n", - "58 2025-06-12 22:01:00 05:30:00 NaN NaN NaN \n", - "59 2025-06-08 00:00:00 06:00:00 NaN NaN NaN \n", - "\n", - " D10_date D10_inbed D10_wakeup \n", - "0 NaN NaN NaN \n", - "1 NaN NaN NaN \n", - "2 2024-09-30 00:20:00 08:30:00 \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - "5 NaN NaN NaN \n", - "6 NaN NaN NaN \n", - "7 NaN NaN NaN \n", - "8 NaN NaN NaN \n", - "9 NaN NaN NaN \n", - "10 NaN NaN NaN \n", - "11 NaN NaN NaN \n", - "12 NaN NaN NaN \n", - "13 NaN NaN NaN \n", - "14 NaN NaN NaN \n", - "15 NaN NaN NaN \n", - "16 NaN NaN NaN \n", - "17 NaN NaN NaN \n", - "18 NaN NaN NaN \n", - "19 NaN NaN NaN \n", - "20 NaN NaN NaN \n", - "21 NaN NaN NaN \n", - "22 NaN NaN NaN \n", - "23 NaN NaN NaN \n", - "24 NaN NaN NaN \n", - "25 NaN NaN NaN \n", - "26 NaN NaN NaN \n", - "27 NaN NaN NaN \n", - "28 NaN NaN NaN \n", - "29 NaN NaN NaN \n", - "30 NaN NaN NaN \n", - "31 NaN NaN NaN \n", - "32 NaN NaN NaN \n", - "33 NaN NaN NaN \n", - "34 NaN NaN NaN \n", - "35 NaN NaN NaN \n", - "36 NaN NaN NaN \n", - "37 NaN NaN NaN \n", - "38 NaN NaN NaN \n", - "39 NaN NaN NaN \n", - "40 NaN NaN NaN \n", - "41 NaN NaN NaN \n", - "42 NaN NaN NaN \n", - "43 NaN NaN NaN \n", - "44 NaN NaN NaN \n", - "45 NaN NaN NaN \n", - "46 NaN NaN NaN \n", - "47 NaN NaN NaN \n", - "48 NaN NaN NaN \n", - "49 NaN NaN NaN \n", - "50 NaN NaN NaN \n", - "51 NaN NaN NaN \n", - "52 NaN NaN NaN \n", - "53 NaN NaN NaN \n", - "54 NaN NaN NaN \n", - "55 NaN NaN NaN \n", - "56 2025-05-30 00:00:00 06:45:00 \n", - "57 2025-06-14 03:00:00 09:00:00 \n", - "58 NaN NaN NaN \n", - "59 NaN NaN NaN \n", - "\n", - "[60 rows x 31 columns]" - ] - }, - "execution_count": 82, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "updated" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "id": "728b50a2-ac17-4ba0-9026-3046b5249994", - "metadata": {}, - "outputs": [], - "source": [ - "updated.to_csv('./sleep_w_nonwear.csv')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9193f3fa-e715-4555-a9da-2480056b407a", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/code/tests/non-wear/sleep_w_nonwear.csv b/code/tests/non-wear/sleep_w_nonwear.csv deleted file mode 100644 index e0f7b95..0000000 --- a/code/tests/non-wear/sleep_w_nonwear.csv +++ /dev/null @@ -1,61 +0,0 @@ -,ID,D1_date,D1_inbed,D1_wakeup,D2_date,D2_inbed,D2_wakeup,D3_date,D3_inbed,D3_wakeup,D4_date,D4_inbed,D4_wakeup,D5_date,D5_inbed,D5_wakeup,D6_date,D6_inbed,D6_wakeup,D7_date,D7_inbed,D7_wakeup,D8_date,D8_inbed,D8_wakeup,D9_date,D9_inbed,D9_wakeup,D10_date,D10_inbed,D10_wakeup -0,sub-8022_ses-1_accel,2025-02-07,19:00:00,08:30:00,2025-02-08,23:45:00,07:30:00,2025-02-09,23:55:00,07:00:00,2025-02-10,23:40:00,06:45:00,2025-02-11,23:15:00,06:45:00,2025-02-12,22:00:00,06:45:00,2025-02-13,23:05:00,07:00:00,2025-02-15,01:00:00,09:00:00,,,,,, -1,sub-8022_ses-2_accel,2025-04-17,00:00:00,06:30:00,2025-04-18,23:10:00,07:40:00,2025-04-20,02:45:00,07:30:00,2025-04-21,00:19:00,06:45:00,2025-04-22,22:00:00,06:40:00,2025-04-24,22:30:00,06:40:00,2025-04-26,00:57:00,08:00:00,,,,,,,,, -2,sub-8001_ses-1_accel,2024-09-21,00:30:00,08:30:00,2024-09-22,00:15:00,07:40:00,2024-09-23,05:20:00,09:30:00,2024-09-24,01:00:00,07:20:00,2024-09-25,00:00:00,06:40:00,2024-09-26,00:30:00,07:30:00,2024-09-27,01:00:00,09:00:00,2024-09-28,00:30:00,08:45:00,2024-09-29,00:30:00,08:15:00,2024-09-30,00:20:00,08:30:00 -3,sub-8002_ses-1_accel,2024-09-14,22:15:00,06:45:00,2024-09-15,23:00:00,06:45:00,2024-09-16,22:51:00,06:45:00,2024-09-17,22:45:00,06:15:00,2024-09-18,22:40:00,06:40:00,2024-09-19,23:00:00,06:45:00,2024-09-20,22:45:00,07:00:00,2024-09-21,22:30:00,06:45:00,2024-09-22,22:45:00,06:45:00,,, -4,sub-8002_ses-2_accel,2024-11-07,23:00:00,03:30:00,2024-11-08,21:30:00,05:30:00,2024-11-09,21:30:00,05:30:00,2024-11-10,22:45:00,06:30:00,2024-11-11,22:30:00,06:00:00,2024-11-12,22:30:00,06:00:00,2024-11-13,22:30:00,06:15:00,2024-11-14,22:45:00,06:15:00,2024-11-15,22:30:00,07:00:00,,, -5,sub-8002_ses-3_accel,2025-02-26,23:00:00,06:30:00,2025-02-27,23:00:00,06:30:00,2025-02-28,23:00:00,07:30:00,2025-03-01,23:30:00,07:30:00,2025-03-02,23:00:00,06:45:00,2025-03-03,23:00:00,07:00:00,2025-03-04,23:30:00,07:00:00,2025-03-05,22:30:00,06:30:00,2025-03-06,23:00:00,06:30:00,,, -6,sub-8002_ses-4_accel,2025-05-05,22:30:00,06:30:00,2025-05-06,22:30:00,06:30:00,2025-05-07,23:00:00,07:00:00,2025-05-08,22:57:00,07:00:00,2025-05-09,23:30:00,06:45:00,2025-05-10,22:00:00,07:00:00,2025-05-11,23:30:00,06:45:00,2025-05-12,23:15:00,07:00:00,2025-05-13,22:30:00,06:45:00,,, -7,sub-8003_ses-1_accel,2024-10-05,22:30:00,07:30:00,2024-10-06,21:30:00,06:00:00,2024-10-07,22:00:00,06:00:00,2024-10-08,22:00:00,06:00:00,2024-10-09,21:30:00,06:00:00,2024-10-10,21:00:00,06:00:00,,,,,,,,,,,, -8,sub-8003_ses-2_accel,2025-02-01,22:50:00,07:00:00,2025-02-02,22:00:00,06:15:00,2025-02-03,22:30:00,05:30:00,2025-02-04,20:45:00,09:00:00,2025-02-05,21:30:00,06:45:00,2025-02-06,22:30:00,07:00:00,2025-02-07,23:00:00,07:15:00,2025-02-08,23:00:00,07:00:00,2025-02-09,22:30:00,06:15:00,,, -9,sub-8004_ses-1_accel,2024-09-26,18:45:00,05:55:00,2024-09-27,22:00:00,07:01:00,2024-09-28,21:57:00,06:12:00,2024-09-29,22:02:00,06:13:00,,,,,,,,,,,,,,,,,, -10,sub-8004_ses-2_accel,2024-11-23,23:00:00,06:56:00,2024-11-24,21:43:00,05:51:00,2024-11-25,20:55:00,05:26:00,2024-11-26,23:06:00,06:40:00,2024-11-27,20:52:00,07:02:00,2024-11-28,20:45:00,06:55:00,2024-11-29,20:45:00,06:04:00,2024-11-30,19:30:00,06:20:00,2024-12-01,20:30:00,05:40:00,,, -11,sub-8004_ses-3_accel,2025-03-12,21:15:00,06:45:00,2025-03-13,21:00:00,06:15:00,2025-03-14,21:15:00,07:30:00,2025-03-15,21:00:00,07:00:00,2025-03-16,20:34:00,06:45:00,2025-03-17,22:30:00,06:30:00,2025-03-18,20:30:00,06:10:00,2025-03-19,20:30:00,06:45:00,2025-03-20,21:00:00,06:00:00,,, -12,sub-8004_ses-4_accel,2025-04-30,21:30:00,05:45:00,2025-05-01,22:00:00,06:00:00,2025-05-02,20:45:00,06:00:00,2025-05-03,20:45:00,07:45:00,2025-05-04,22:00:00,06:00:00,2025-05-05,21:00:00,05:45:00,2025-05-06,21:15:00,06:15:00,2025-05-07,21:15:00,06:15:00,2025-05-08,21:30:00,06:00:00,,, -13,sub-8006_ses-1_accel,2024-09-21,23:00:00,07:30:00,2024-09-22,23:00:00,05:30:00,2024-09-23,22:30:00,06:00:00,2024-09-24,23:00:00,06:00:00,2024-09-25,23:30:00,06:00:00,2024-09-26,22:30:00,05:00:00,2024-09-27,22:00:00,07:00:00,2024-09-28,21:30:00,06:30:00,2024-09-29,23:00:00,05:30:00,,, -14,sub-8006_ses-2_accel,2024-12-13,22:00:00,07:00:00,2024-12-14,21:00:00,07:00:00,2024-12-15,23:00:00,06:00:00,2024-12-16,21:20:00,06:20:00,2024-12-17,23:00:00,06:20:00,2024-12-18,22:00:00,06:40:00,2024-12-19,22:30:00,05:25:00,2024-12-20,23:00:00,08:00:00,2024-12-21,22:00:00,07:10:00,,, -15,sub-8006_ses-3_accel,2025-04-16,23:00:00,06:22:00,2025-04-17,23:00:00,06:00:00,2025-04-18,18:00:00,07:00:00,2025-04-19,20:30:00,06:30:00,2025-04-20,21:00:00,06:00:00,2025-04-21,22:00:00,06:40:00,2025-04-22,22:00:00,06:20:00,2025-04-23,21:45:00,06:17:00,2025-04-24,20:00:00,06:30:00,,, -16,sub-8006_ses-4_accel,2025-05-14,22:20:00,06:40:00,2025-05-15,22:30:00,06:30:00,2025-05-16,23:30:00,06:30:00,2025-05-17,22:30:00,08:45:00,2025-05-18,22:20:00,06:30:00,2025-05-19,21:30:00,06:45:00,2025-05-20,23:05:00,06:50:00,2025-05-21,21:45:00,06:11:00,2025-05-22,22:00:00,06:40:00,,, -17,sub-8005_ses-1_accel,2024-10-31,23:00:00,07:30:00,2024-11-01,23:30:00,07:45:00,2024-11-02,23:25:00,08:15:00,2024-11-04,00:35:00,08:00:00,2024-11-05,00:45:00,08:00:00,2024-11-06,03:15:00,08:00:00,2024-11-07,00:15:00,08:05:00,2024-11-08,00:30:00,08:30:00,2024-11-09,00:15:00,09:15:00,,, -18,sub-8005_ses-2_accel,2025-01-16,22:30:00,06:45:00,2025-01-17,23:40:00,08:38:00,2025-01-18,23:50:00,08:50:00,2025-01-19,23:25:00,07:15:00,2025-01-20,23:11:00,08:20:00,2025-01-22,23:50:00,06:55:00,2025-01-23,23:05:00,07:50:00,2025-01-25,00:10:00,07:50:00,,,,,, -19,sub-8005_ses-3_accel,2025-05-22,23:00:00,07:15:00,2025-05-23,23:00:00,08:00:00,2025-05-24,23:15:00,08:00:00,2025-05-25,23:40:00,08:10:00,2025-05-26,23:00:00,06:50:00,2025-05-27,23:30:00,06:55:00,2025-05-28,23:45:00,07:50:00,2025-05-30,00:00:00,07:50:00,,,,,, -20,sub-8008_ses-1_accel,2024-11-05,00:00:00,08:00:00,2024-11-06,22:30:00,09:00:00,2024-11-07,23:30:00,08:00:00,2024-11-09,01:00:00,08:00:00,2024-11-10,00:00:00,10:00:00,2024-11-11,00:00:00,08:30:00,2024-11-12,00:00:00,09:00:00,2024-11-13,00:00:00,07:30:00,2024-11-14,00:00:00,11:00:00,,, -21,sub-8008_ses-2_accel,2025-01-10,03:46:00,09:30:00,2025-01-11,02:00:00,10:30:00,2025-01-12,03:00:00,11:00:00,2025-01-13,23:50:00,03:00:00,2025-01-15,23:00:00,09:30:00,2025-01-16,23:00:00,07:30:00,2025-01-17,23:00:00,04:30:00,,,,,,,,, -22,sub-8011_ses-1_accel,2024-12-07,00:00:00,07:30:00,2024-12-08,23:38:00,06:31:00,2024-12-09,22:47:00,06:47:00,2024-12-10,23:55:00,07:26:00,2024-12-11,21:30:00,07:40:00,2024-12-12,23:30:00,06:18:00,2024-12-14,00:30:00,07:08:00,2024-12-15,00:13:00,07:45:00,2024-12-16,00:01:00,06:40:00,,, -23,sub-8011_ses-2_accel,2025-02-20,00:00:00,07:53:00,2025-02-21,00:23:00,06:30:00,2025-02-22,22:42:00,08:00:00,2025-02-24,00:18:00,06:43:00,2025-02-25,22:38:00,07:08:00,2025-02-26,22:26:00,06:01:00,2025-02-27,22:12:00,06:11:00,2025-03-01,00:56:00,07:18:00,,,,,, -24,sub-8012_ses-1_accel,2025-05-09,23:00:00,07:00:00,2025-05-10,23:15:00,06:25:00,2025-05-12,22:00:00,06:25:00,2025-05-13,22:55:00,06:45:00,2025-05-14,23:00:00,07:00:00,2025-05-15,23:25:00,07:00:00,2025-05-16,23:25:00,07:45:00,2025-05-17,23:30:00,08:45:00,,,,,, -25,sub-8012_ses-2_accel,2025-01-09,20:45:00,06:00:00,2025-01-10,22:30:00,06:15:00,2025-01-12,20:30:00,06:15:00,2025-01-13,21:00:00,06:30:00,2025-01-14,22:50:00,06:10:00,2025-01-15,22:15:00,06:40:00,2025-01-16,23:24:00,05:55:00,2025-01-17,21:45:00,07:00:00,,,,,, -26,sub-8014_ses-1_accel,2025-01-15,21:15:00,03:50:00,2025-01-16,21:00:00,03:50:00,2025-01-17,21:00:00,04:50:00,2025-01-18,21:25:00,04:50:00,2025-01-19,21:00:00,02:50:00,2025-01-20,21:05:00,03:50:00,2025-01-21,21:30:00,03:50:00,2025-01-22,21:15:00,03:50:00,2025-01-23,21:15:00,03:50:00,,, -27,sub-8014_ses-2_accel,2025-05-03,23:00:00,07:05:00,2025-05-04,21:15:00,03:50:00,2025-05-05,20:25:00,02:50:00,2025-05-06,21:00:00,02:50:00,2025-05-07,20:50:00,02:50:00,2025-05-08,21:05:00,02:50:00,2025-05-09,22:30:00,06:15:00,2025-05-10,23:30:00,06:15:00,2025-05-11,21:05:00,02:50:00,,, -28,sub-8015_ses-1_accel,2025-01-29,22:05:00,06:00:00,2025-01-30,22:00:00,06:00:00,2025-01-31,22:30:00,07:54:00,2025-02-02,23:15:00,06:00:00,2025-02-03,22:37:00,06:05:00,2025-02-04,21:30:00,06:13:00,2025-02-05,23:00:00,06:05:00,2025-02-06,22:35:00,05:49:00,,,,,, -29,sub-8016_ses-1_accel,2025-02-19,21:53:00,05:30:00,2025-02-20,22:07:00,05:30:00,2025-02-21,22:40:00,08:50:00,2025-02-22,22:30:00,09:30:00,2025-02-23,22:25:00,06:00:00,2025-02-24,22:15:00,03:30:00,2025-02-25,21:30:00,08:30:00,2025-02-26,21:00:00,05:50:00,2025-02-27,21:45:00,05:15:00,,, -30,sub-8016_ses-2_accel,2025-04-07,22:50:00,05:00:00,2025-04-08,22:00:00,05:00:00,2025-04-10,23:15:00,09:15:00,2025-04-11,22:45:00,05:20:00,2025-04-12,22:20:00,05:30:00,2025-04-13,21:45:00,06:25:00,2025-04-14,21:30:00,09:15:00,2025-04-16,00:30:00,06:20:00,,,,,, -31,sub-8017_ses-1_accel,2025-04-09,22:20:00,06:37:00,2025-04-10,22:24:00,06:32:00,2025-04-11,22:10:00,08:17:00,2025-04-12,22:25:00,07:05:00,2025-04-13,22:30:00,06:27:00,2025-04-14,22:35:00,06:35:00,2025-04-15,22:35:00,06:17:00,2025-04-16,22:01:00,06:35:00,2025-04-17,22:20:00,05:30:00,,, -32,sub-8018_ses-1_accel,2025-01-22,23:30:00,10:15:00,2025-01-23,23:30:00,10:00:00,2025-01-24,23:30:00,10:00:00,2025-01-26,00:00:00,10:00:00,2025-01-27,00:30:00,10:10:00,2025-01-28,23:00:00,08:00:00,2025-01-29,23:45:00,09:30:00,2025-01-31,00:00:00,09:15:00,,,,,, -33,sub-8019_ses-1_accel,2025-01-28,23:06:00,06:30:00,2025-01-29,23:00:00,06:00:00,2025-01-30,23:17:00,06:00:00,2025-01-31,23:17:00,08:00:00,2025-02-01,22:45:00,07:30:00,2025-02-03,22:45:00,06:00:00,2025-02-04,23:00:00,06:00:00,2025-02-05,22:50:00,06:25:00,,,,,, -34,sub-8019_ses-2_accel,2025-04-23,23:02:00,05:30:00,2025-04-24,22:40:00,06:20:00,2025-04-25,23:25:00,07:30:00,2025-04-26,23:30:00,08:50:00,2025-04-27,23:00:00,06:30:00,2025-04-28,22:40:00,06:15:00,2025-04-29,23:04:00,06:20:00,2025-04-30,23:10:00,06:30:00,2025-05-01,22:55:00,06:28:00,,, -35,sub-8020_ses-1_accel,2025-01-30,21:30:00,02:30:00,2025-01-31,21:00:00,05:00:00,2025-02-01,19:45:00,05:00:00,2025-02-02,21:30:00,05:30:00,2025-02-03,21:30:00,05:30:00,2025-02-04,22:30:00,05:30:00,2025-02-05,21:30:00,05:30:00,2025-02-06,21:30:00,06:00:00,2025-02-07,22:00:00,05:30:00,,, -36,sub-8020_ses-2_accel,2025-04-09,19:43:00,05:00:00,2025-04-10,19:45:00,05:40:00,2025-04-11,20:53:00,06:00:00,2025-04-12,23:57:00,06:13:00,2025-04-13,21:00:00,05:41:00,2025-04-14,21:00:00,06:00:00,2025-04-15,21:30:00,05:30:00,2025-04-16,22:34:00,04:00:00,2025-04-17,21:30:00,06:35:00,,, -37,sub-8021_ses-1_accel,2025-01-29,23:19:00,08:00:00,2025-01-30,23:34:00,08:01:00,2025-01-31,23:07:00,09:15:00,2025-02-02,00:00:00,11:30:00,2025-02-03,22:29:00,07:45:00,2025-02-04,23:22:00,08:03:00,2025-02-06,23:17:00,07:29:00,,,,,,,,, -38,sub-8021_ses-2_accel,2025-05-24,00:00:00,08:20:00,2025-05-25,23:45:00,09:00:00,2025-05-26,23:30:00,06:00:00,2025-05-30,00:01:00,08:00:00,2025-05-31,00:00:00,08:00:00,2025-06-01,00:00:00,08:00:00,2025-06-02,00:00:00,09:00:00,,,,,,,,, -39,sub-8023_ses-1_accel,2025-04-10,23:00:00,05:50:00,2025-04-12,22:30:00,09:00:00,2025-04-13,23:00:00,05:15:00,2025-04-14,23:00:00,05:15:00,2025-04-15,22:45:00,07:30:00,2025-04-16,23:00:00,06:00:00,2025-04-17,23:00:00,06:15:00,2025-04-19,01:15:00,08:50:00,,,,,, -40,sub-8024_ses-1_accel,2025-03-08,21:43:00,06:43:00,2025-03-09,21:30:00,05:13:00,2025-03-10,20:40:00,04:30:00,2025-03-11,20:45:00,04:40:00,2025-03-12,21:40:00,04:38:00,2025-03-13,21:30:00,04:43:00,2025-03-14,22:00:00,06:05:00,2025-03-15,21:48:00,06:10:00,2025-03-16,21:30:00,05:00:00,,, -41,sub-8024_ses-2_accel,2025-05-30,22:30:00,07:30:00,2025-05-31,22:00:00,06:00:00,2025-06-01,23:00:00,05:45:00,2025-06-02,23:00:00,05:40:00,2025-06-03,23:30:00,05:40:00,2025-06-04,22:30:00,05:50:00,2025-06-05,22:45:00,05:50:00,2025-06-06,22:30:00,07:00:00,2025-06-07,23:00:00,07:00:00,,, -42,sub-8026_ses-1_accel,2025-02-04,20:30:00,05:30:00,2025-02-05,21:00:00,06:00:00,2025-02-06,19:30:00,06:00:00,2025-02-07,20:30:00,06:00:00,2025-02-08,19:00:00,08:30:00,2025-02-09,22:00:00,07:30:00,2025-02-10,21:00:00,05:30:00,2025-02-11,22:30:00,06:00:00,2025-02-12,21:00:00,06:00:00,,, -43,sub-8026_ses-2_accel,2025-05-23,00:00:00,06:00:00,2025-05-24,23:30:00,07:50:00,2025-05-25,23:30:00,08:30:00,2025-05-26,23:30:00,05:30:00,2025-05-27,23:00:00,06:00:00,2025-05-28,21:30:00,06:05:00,2025-05-29,21:45:00,05:50:00,2025-05-30,22:30:00,06:01:00,2025-05-31,23:00:00,08:40:00,,, -44,sub-8030_ses-1_accel,2025-02-21,21:30:00,06:10:00,2025-02-22,21:30:00,06:04:00,2025-02-23,20:30:00,05:10:00,2025-02-24,21:35:00,06:10:00,2025-02-25,22:10:00,06:07:00,2025-02-26,21:35:00,05:39:00,2025-02-27,21:45:00,06:10:00,2025-02-28,21:30:00,04:55:00,2025-03-01,22:00:00,04:55:00,,, -45,sub-8030_ses-2_accel,2025-05-10,22:40:00,07:05:00,2025-05-11,22:45:00,06:17:00,2025-05-12,22:30:00,05:17:00,2025-05-13,22:40:00,06:50:00,2025-05-14,22:45:00,05:45:00,2025-05-15,22:00:00,06:00:00,2025-05-16,22:50:00,05:59:00,2025-05-17,22:50:00,06:32:00,2025-05-18,23:00:00,05:30:00,,, -46,sub-8032_ses-1_accel,2025-05-22,20:35:00,05:34:00,2025-05-23,21:00:00,06:48:00,2025-05-24,20:40:00,07:14:00,2025-05-25,21:17:00,07:10:00,2025-05-26,20:30:00,05:33:00,2025-05-27,20:30:00,05:44:00,2025-05-28,21:00:00,05:39:00,2025-05-29,19:55:00,05:35:00,2025-05-30,20:40:00,05:57:00,,, -47,sub-8034_ses-1_accel,2025-03-29,21:30:00,07:30:00,2025-03-30,21:30:00,06:00:00,2025-03-31,22:00:00,06:30:00,2025-04-01,22:30:00,07:00:00,2025-04-02,21:00:00,06:30:00,2025-04-03,22:30:00,06:00:00,2025-04-04,21:00:00,06:20:00,2025-04-05,21:00:00,07:50:00,2025-04-06,21:00:00,07:00:00,,, -48,sub-8035_ses-1_accel,2025-03-19,21:45:00,05:45:00,2025-03-20,22:42:00,06:45:00,2025-03-21,23:50:00,06:00:00,2025-03-22,22:00:00,05:49:00,2025-03-23,22:00:00,05:30:00,2025-03-24,22:00:00,05:30:00,2025-03-25,22:15:00,05:37:00,2025-03-26,21:45:00,05:35:00,2025-03-27,21:30:00,05:39:00,,, -49,sub-8036_ses-1_accel,2025-03-25,22:30:00,07:00:00,2025-03-27,22:30:00,06:00:00,2025-03-28,21:30:00,02:30:00,2025-03-29,21:30:00,06:30:00,2025-03-31,22:30:00,04:00:00,2025-04-01,22:45:00,06:00:00,2025-04-02,23:05:00,06:00:00,,,,,,,,, -50,sub-8038_ses-1_accel,2025-04-26,23:30:00,09:50:00,2025-04-27,23:15:00,08:04:00,2025-04-28,23:00:00,08:20:00,2025-04-30,00:45:00,08:19:00,2025-05-01,22:45:00,08:27:00,2025-05-02,23:15:00,05:33:00,2025-05-03,23:00:00,05:44:00,2025-05-04,23:30:00,08:20:00,,,,,, -51,sub-8039_ses-1_accel,2025-05-20,23:20:00,05:55:00,2025-05-22,23:30:00,06:00:00,2025-05-24,00:05:00,06:00:00,2025-05-25,23:50:00,05:45:00,2025-05-26,23:00:00,05:45:00,2025-05-28,23:15:00,06:00:00,,,,,,,,,,,, -52,sub-8040_ses-1_accel,2025-05-20,22:30:00,06:15:00,2025-05-21,22:45:00,06:30:00,2025-05-22,22:45:00,06:15:00,2025-05-24,23:30:00,07:45:00,2025-05-26,22:45:00,06:15:00,2025-05-27,22:45:00,07:00:00,2025-05-28,22:45:00,06:45:00,,,,,,,,, -53,sub-8042_ses-1_accel,2025-05-20,21:17:00,06:13:00,2025-05-21,21:55:00,05:38:00,2025-05-22,22:29:00,06:05:00,2025-05-23,22:00:00,07:22:00,2025-05-24,23:03:00,08:00:00,2025-05-25,22:09:00,08:09:00,2025-05-26,22:00:00,06:15:00,2025-05-27,21:55:00,06:15:00,2025-05-28,22:05:00,05:53:00,,, -54,sub-8046_ses-1_accel,2025-05-28,22:00:00,06:00:00,2025-05-29,22:28:00,06:20:00,2025-05-30,22:20:00,07:15:00,2025-05-31,23:50:00,08:50:00,2025-06-01,22:15:00,06:15:00,2025-06-02,22:20:00,06:30:00,2025-06-03,23:00:00,06:25:00,2025-06-04,23:00:00,06:15:00,2025-06-05,22:30:00,06:25:00,,, -55,sub-8047_ses-1_accel,2025-05-14,22:45:00,05:15:00,2025-05-15,22:00:00,05:55:00,2025-05-16,22:20:00,06:36:00,2025-05-17,23:00:00,06:15:00,2025-05-18,22:20:00,05:56:00,2025-05-19,21:50:00,05:52:00,2025-05-20,22:00:00,05:52:00,2025-05-21,22:10:00,06:00:00,2025-05-22,22:07:00,05:54:00,,, -56,sub-8050_ses-1_accel,2025-05-21,00:00:00,06:30:00,2025-05-22,00:00:00,06:10:00,2025-05-23,00:20:00,06:30:00,2025-05-24,00:30:00,08:30:00,2025-05-25,01:00:00,08:10:00,2025-05-26,01:10:00,07:00:00,2025-05-27,01:15:00,07:00:00,2025-05-28,00:30:00,06:30:00,2025-05-29,00:00:00,06:15:00,2025-05-30,00:00:00,06:45:00 -57,sub-8051_ses-1_accel,2025-06-05,01:00:00,07:45:00,2025-06-06,01:00:00,08:00:00,2025-06-07,00:15:00,06:30:00,2025-06-08,01:10:00,08:30:00,2025-06-09,00:53:00,07:56:00,2025-06-10,01:35:00,07:00:00,2025-06-11,01:00:00,10:00:00,2025-06-12,01:50:00,09:00:00,2025-06-13,01:00:00,09:00:00,2025-06-14,03:00:00,09:00:00 -58,sub-8053_ses-1_accel,2025-06-04,23:48:00,06:30:00,2025-06-05,23:35:00,07:35:00,2025-06-06,23:15:00,06:30:00,2025-06-08,00:07:00,06:10:00,2025-06-09,23:00:00,05:50:00,2025-06-10,23:35:00,05:50:00,2025-06-11,22:00:00,07:10:00,2025-06-12,22:01:00,05:30:00,,,,,, -59,sub-8054_ses-1_accel,2025-05-30,00:00:00,06:45:00,2025-05-31,23:30:00,06:00:00,2025-06-01,23:40:00,06:15:00,2025-06-02,23:00:00,05:50:00,2025-06-04,22:30:00,06:30:00,2025-06-05,23:00:00,05:45:00,2025-06-06,23:00:00,05:45:00,2025-06-08,00:00:00,06:00:00,,,,,, diff --git a/code/tests/pipeline/test_save_symlinks.py b/code/tests/pipeline/test_save_symlinks.py deleted file mode 100644 index 2c6507f..0000000 --- a/code/tests/pipeline/test_save_symlinks.py +++ /dev/null @@ -1,69 +0,0 @@ -import os -from pathlib import Path - -import pytest - -from code.utils.save import Save - - -def _build_subject_accel(tmp_path: Path, study_root: str, subject_id: str): - base_dir = tmp_path / study_root - subject_accel_dir = base_dir / f"sub-{subject_id}" / "accel" - session_one = subject_accel_dir / "ses-1" - session_two_nested = subject_accel_dir / "ses-2" / "nested" - - session_one.mkdir(parents=True, exist_ok=True) - session_two_nested.mkdir(parents=True, exist_ok=True) - - csv_one = session_one / f"sub-{subject_id}_ses-1_accel.csv" - csv_two = session_two_nested / f"sub-{subject_id}_ses-2_accel.csv" - csv_three = session_two_nested / f"sub-{subject_id}_ses-2_accel-extra.csv" - - csv_one.write_text("run-1", encoding="utf-8") - csv_two.write_text("run-2", encoding="utf-8") - csv_three.write_text("run-2-extra", encoding="utf-8") - - return base_dir, subject_accel_dir, [csv_one, csv_two, csv_three] - - -@pytest.mark.parametrize( - ("study_root", "subject_id"), - (("int-study", "8001"), ("obs-study", "7050")), -) -def test_refresh_subject_symlinks_creates_subject_all_directory(tmp_path, study_root, subject_id): - _, subject_accel_dir, csv_paths = _build_subject_accel(tmp_path, study_root, subject_id) - - saver = Save.__new__(Save) - saver._refresh_subject_symlinks(str(csv_paths[0])) - - all_dir = subject_accel_dir / "all" - assert all_dir.is_dir(), "Expected per-subject accel/all directory to be created" - - expected_rel_paths = {os.path.relpath(str(path), str(subject_accel_dir)) for path in csv_paths} - - for relative in expected_rel_paths: - symlink_path = all_dir / relative - assert symlink_path.is_symlink(), f"Missing symlink for {relative}" - assert os.path.samefile(symlink_path, subject_accel_dir / relative) - - assert not (all_dir / "all").exists(), "Symlink tree should not duplicate itself recursively" - - -def test_remove_symlink_directories_cleans_up_subject_symlinks(tmp_path): - int_base, int_accel_dir, int_csvs = _build_subject_accel(tmp_path, "int-study", "8001") - obs_base, obs_accel_dir, obs_csvs = _build_subject_accel(tmp_path, "obs-study", "7050") - - saver = Save.__new__(Save) - for csv_path in int_csvs + obs_csvs: - saver._refresh_subject_symlinks(str(csv_path)) - - assert (int_accel_dir / "all").exists() - assert (obs_accel_dir / "all").exists() - - Save.remove_symlink_directories([str(int_base), str(obs_base)]) - - assert not (int_accel_dir / "all").exists() - assert not (obs_accel_dir / "all").exists() - - for csv_path in int_csvs + obs_csvs: - assert csv_path.exists(), "Cleanup should leave original CSV artefacts in place" diff --git a/code/tests/pipeline/test_vosslnxft_pipeline.py b/code/tests/pipeline/test_vosslnxft_pipeline.py deleted file mode 100644 index 107c665..0000000 --- a/code/tests/pipeline/test_vosslnxft_pipeline.py +++ /dev/null @@ -1,141 +0,0 @@ -import os -from pathlib import Path - -import pytest - -from code.core.gg import GG -from code.utils.group import Group -from code.utils.pipe import Pipe -from code.utils.save import Save - - -@pytest.fixture -def fake_vosslnxft_paths(tmp_path, monkeypatch): - """Provide isolated filesystem mounts for the vosslnxft system.""" - original = dict(Pipe._SYSTEM_PATHS["vosslnxft"]) - - int_dir = tmp_path / "act-int-final-test-1" - obs_dir = tmp_path / "act-obs-test" - rdss_dir = tmp_path / "rdss" - - for path in (int_dir, obs_dir, rdss_dir): - path.mkdir(parents=True, exist_ok=True) - - # Ensure derivatives directories exist so Group() can list them. - (int_dir / "derivatives" / "GGIR-3.2.6").mkdir(parents=True, exist_ok=True) - (obs_dir / "derivatives" / "GGIR-3.2.6").mkdir(parents=True, exist_ok=True) - - monkeypatch.setitem( - Pipe._SYSTEM_PATHS, - "vosslnxft", - { - "INT_DIR": str(int_dir), - "OBS_DIR": str(obs_dir), - "RDSS_DIR": str(rdss_dir), - }, - ) - - yield { - "INT_DIR": str(int_dir), - "OBS_DIR": str(obs_dir), - "RDSS_DIR": str(rdss_dir), - } - - monkeypatch.setitem(Pipe._SYSTEM_PATHS, "vosslnxft", original) - - -def test_move_files_copies_into_final_test_root(tmp_path, fake_vosslnxft_paths): - """Save._move_files should copy artefacts into the vosslnxft intervention root.""" - save = Save.__new__(Save) - save.RDSS_DIR = fake_vosslnxft_paths["RDSS_DIR"] - save.INT_DIR = fake_vosslnxft_paths["INT_DIR"] - save.OBS_DIR = fake_vosslnxft_paths["OBS_DIR"] - - rdss_file = Path(fake_vosslnxft_paths["RDSS_DIR"]) / "sub-8001-run1.csv" - rdss_file.write_text("synthetic-data", encoding="utf-8") - - destination = ( - Path(fake_vosslnxft_paths["INT_DIR"]) - / "sub-8001" - / "accel" - / "ses-1" - / "sub-8001_ses-1_accel.csv" - ) - matches = { - "8001": [ - { - "filename": rdss_file.name, - "file_path": str(destination), - } - ] - } - - save._move_files(matches) - - assert destination.exists(), "Expected file to be copied into new intervention root" - assert destination.read_text(encoding="utf-8") == "synthetic-data" - - -def test_determine_location_builds_final_test_paths(fake_vosslnxft_paths): - """Save._determine_location should target the new derivatives roots when configured for vosslnxft.""" - save = Save.__new__(Save) - save.INT_DIR = fake_vosslnxft_paths["INT_DIR"] - save.OBS_DIR = fake_vosslnxft_paths["OBS_DIR"] - - matches = { - "8001": [ - {"study": "int", "run": 1}, - ], - "7050": [ - {"study": "obs", "run": 2}, - ], - } - - save._determine_location(matches) - - expected_int_path = ( - Path(fake_vosslnxft_paths["INT_DIR"]) - / "sub-8001" - / "accel" - / "ses-1" - / "sub-8001_ses-1_accel.csv" - ) - expected_obs_path = ( - Path(fake_vosslnxft_paths["OBS_DIR"]) - / "sub-7050" - / "accel" - / "ses-2" - / "sub-7050_ses-2_accel.csv" - ) - - assert matches["8001"][0]["file_path"] == str(expected_int_path) - assert matches["7050"][0]["file_path"] == str(expected_obs_path) - - -def test_gg_derivative_path_for_final_test(fake_vosslnxft_paths): - """GG should point at the unified derivatives directory.""" - gg = GG( - matched={}, - intdir=fake_vosslnxft_paths["INT_DIR"], - obsdir=fake_vosslnxft_paths["OBS_DIR"], - system="vosslnxft", - ) - - assert gg.DERIVATIVES == "derivatives/GGIR-3.2.6/" - assert gg.INTDIR == fake_vosslnxft_paths["INT_DIR"] + "/" - assert gg.OBSDIR == fake_vosslnxft_paths["OBS_DIR"] + "/" - - -def test_group_paths_point_to_final_test_derivatives(fake_vosslnxft_paths): - """Group plotting logic should scan the new derivatives folders.""" - group = Group(system="vosslnxft") - - expected_obs = os.path.join( - fake_vosslnxft_paths["OBS_DIR"], "derivatives", "GGIR-3.2.6" - ) - expected_int = os.path.join( - fake_vosslnxft_paths["INT_DIR"], "derivatives", "GGIR-3.2.6" - ) - - assert expected_obs in group.paths - assert expected_int in group.paths diff --git a/code/tests/sleep/.create_new_test_plots.py.swp b/code/tests/sleep/.create_new_test_plots.py.swp deleted file mode 100644 index da695d8..0000000 Binary files a/code/tests/sleep/.create_new_test_plots.py.swp and /dev/null differ diff --git a/code/tests/sleep/create_new_test_plots.py b/code/tests/sleep/create_new_test_plots.py deleted file mode 100644 index 308f69b..0000000 --- a/code/tests/sleep/create_new_test_plots.py +++ /dev/null @@ -1,236 +0,0 @@ -import os -import glob -import pandas as pd -import plotly.graph_objects as go - -class NewGroup: - def __init__(self): - self.obs_path = "/mnt/lss/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test" - self.int_path = "/mnt/lss/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test" - - self.paths = [ - os.path.join(self.obs_path, 'derivatives', 'GGIR-3.2.6'), - os.path.join(self.int_path, 'derivatives', 'GGIR-3.2.6') - ] - - self.path = './plots' - - def _parse_person_file(self, file_path): - print(f"\n[PARSE DEBUG] Opening file: {file_path}") - try: - df = pd.read_csv(file_path) - except Exception as e: - print(f"[PARSE ERROR] pd.read_csv failed: {e}") - return None - - print(f"[PARSE DEBUG] Columns: {df.columns.tolist()}") - print(f"[PARSE DEBUG] First few rows:\n{df.head(2)}") - - if df.empty: - print(f"[PARSE WARNING] DataFrame is empty.") - return None - - # your existing extraction logic… - try: - sleep = df["dur_spt_min_pla"].iloc[0] - inactivity = df["dur_day_total_IN_min_pla"].iloc[0] - light = df["dur_day_total_LIG_min_pla"].iloc[0] - mod = df["dur_day_total_MOD_min_pla"].iloc[0] - vig = df["dur_day_total_VIG_min_pla"].iloc[0] - except KeyError as ke: - print(f"[PARSE ERROR] Missing column: {ke}") - return None - - mvpa = mod + vig - total = sleep + inactivity + light + mvpa - print(f"[PARSE DEBUG] Totals → sleep={sleep}, inact={inactivity}, light={light}, mvpa={mvpa}, total={total}") - - if total == 0: - print(f"[PARSE WARNING] Total is zero, skipping.") - return None - - session = df.get("filename", [""])[0].split("_")[-2] if "filename" in df else "unknown" - return { - "Sleep": sleep / total * 1440, - "Inactivity": inactivity / total * 1440, - "Light": light / total * 1440, - "MVPA": mvpa / total * 1440, - "Session": session - } - def plot_person(self): - durations = [] - - for base_dir in self.paths: - print(f"\n[DEBUG] Checking base_dir: {base_dir!r}") - print(" exists:", os.path.isdir(base_dir)) - try: - entries = sorted(os.listdir(base_dir)) - except Exception as e: - print(" ERROR listing directory:", e) - continue - - print(" entries found:", entries) - - for entry in entries: - print(f" entry: {entry}") - if not entry.startswith("sub-"): - print(" ➔ skipping, not a sub- folder") - continue - - # --- use glob instead of fixed filename --- - results_dir = os.path.join( - base_dir, entry, - "accel", "output_accel", "results" - ) - pattern = os.path.join(results_dir, "part5_personsummary_MM*.csv") - matches = glob.glob(pattern) - - print(f" looking in {results_dir!r}, found: {matches}") - if not matches: - continue - - for person_file in matches: - print(f" parsing file: {person_file!r}") - values = self._parse_person_file(person_file) - print(" parsed values:", values) - if not values: - continue - - values["Subject"] = entry - durations.append(values) - - print(f"\n[DEBUG] Total records collected: {len(durations)}") - if durations: - print("Sample record:", durations[0]) - - df_all = pd.DataFrame(durations) - print("[DEBUG] df_all columns:", df_all.columns.tolist()) - - if not df_all.empty and "Subject" in df_all.columns: - df_all = df_all[~df_all["Subject"].str.startswith("sub-6")].reset_index(drop=True) - df_all = df_all.sort_values("Subject").reset_index(drop=True) - else: - print("WARNING: No valid data found — skipping Subject filtering.") - return # bail out early so you don’t try to plot an empty df - - self._plot_stacked_bar( - df_all, - title="Normalized Average Activity Composition by Subject (All Sessions)", - filename="avg_plot_all.html" - ) - - def plot_session(self): - durations = [] - - for base_dir in self.paths: - print(f"\n[DEBUG] Checking base_dir: {base_dir!r}") - print(" exists:", os.path.isdir(base_dir)) - try: - entries = sorted(os.listdir(base_dir)) - except Exception as e: - print(" ERROR listing directory:", e) - continue - - print(" entries found:", entries) - - for entry in entries: - print(f" entry: {entry}") - if not entry.startswith("sub-"): - print(" ➔ skipping, not a sub- folder") - continue - - subject_path = os.path.join(base_dir, entry, "accel") - print(f" subject_path: {subject_path!r}, exists:", os.path.isdir(subject_path)) - if not os.path.isdir(subject_path): - continue - - for session_folder in sorted(os.listdir(subject_path)): - print(f" session_folder: {session_folder}") - if not session_folder.startswith("ses"): - print(" ➔ skipping, not a ses- folder") - continue - - results_dir = os.path.join( - subject_path, - session_folder, - f"output_{session_folder}", - "results" - ) - pattern = os.path.join(results_dir, "part5_personsummary_MM*.csv") - matches = glob.glob(pattern) - - print(f" looking in {results_dir!r}, found: {matches}") - if not matches: - continue - - for person_file in matches: - print(f" parsing file: {person_file!r}") - values = self._parse_person_file(person_file) - print(" parsed values:", values) - if not values: - continue - - values["Subject"] = entry - values["Session"] = session_folder - durations.append(values) - - print(f"\n[DEBUG] Total records collected for sessions: {len(durations)}") - if durations: - print("Sample record:", durations[0]) - - df_all = pd.DataFrame(durations) - print("[DEBUG] df_all columns:", df_all.columns.tolist()) - - if not df_all.empty and {"Subject", "Session"}.issubset(df_all.columns): - df_all = df_all[~df_all["Subject"].str.startswith("sub-6")].reset_index(drop=True) - df_all = df_all.sort_values(["Session", "Subject"]).reset_index(drop=True) - else: - print("WARNING: No valid data found — skipping Subject/Session filtering.") - return - - for session, group_df in df_all.groupby("Session"): - print(f"[DEBUG] Plotting session: {session}, {len(group_df)} records") - self._plot_stacked_bar( - group_df, - title=f"Average Activity Composition — Session {session.upper()}", - y_key="Subject", - filename=f"avg_plot_{session}.html" - ) - def _plot_stacked_bar(self, df, title, filename, y_key="Subject"): - if df.empty: - print("WARNING: No data to plot.") - return - - activities = ["Sleep", "Inactivity", "Light", "MVPA"] - colors = { - "Sleep": "#A8DADC", - "Inactivity": "#F1FAEE", - "Light": "#FFD6A5", - "MVPA": "#FF9F1C" - } - - fig = go.Figure() - for activity in activities: - fig.add_trace(go.Bar( - y=df[y_key], - x=df[activity], - name=activity, - orientation='h', - marker_color=colors[activity], - hovertemplate=df[y_key] + f" - {activity} = " + - (df[activity] / 60).round(2).astype(str) + " hr" - )) - - fig.update_layout( - barmode='stack', - title=title, - xaxis=dict(title="Hours (normalized to 24)"), - yaxis=dict(title=y_key), - height=30 * len(df), - margin=dict(l=20, r=20, t=40, b=20), - showlegend=True, - autosize=True - ) - os.makedirs(self.path, exist_ok=True) - print(f"Writing plot to {os.path.join(self.path, filename)}") - fig.write_html(os.path.join(self.path, filename)) diff --git a/code/tests/sleep/log_creation.py b/code/tests/sleep/log_creation.py deleted file mode 100644 index 86447d3..0000000 --- a/code/tests/sleep/log_creation.py +++ /dev/null @@ -1,352 +0,0 @@ -import pandas as pd -import os -import requests -import sys -from io import StringIO -from datetime import datetime, timedelta - - -''' -This script is designed to create a sleep log file for the group analysis of accelerometer data. -It reads the individual participant files by first matching labID with studyID, then builds path to individual files on the RDSS -Aggregates the sleep data by participant and session (with _accel suffix) and saves it to a CSV file. -''' - -token = 'DE4E2DB72778DACA9B8848574107D2F5' -INT_DIR = '/Volumes/vosslabhpc/Projects/BOOST/InterventionStudy/3-experiment/data/act-int-test' -OBS_DIR = '/Volumes/vosslabhpc/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test' -rdss_dir = '/Volumes/VossLab/Repositories/Accelerometer_Data/Sleep' - -def compare_ids(rdss_dir, token, daysago=350): - """ - Pulls all files from RDSS - Pulls the list from RedCap - Compares IDs and returns a dictionary with two keys: - - 'matches': normal matches mapping boost_id to a list of dicts (filename, labID, date) - - 'duplicates': a list of dictionaries each with lab_id, boost_id, filenames (list), and dates (list) - """ - # Retrieve the RedCap report and duplicates from report - report, report_duplicates = _return_report(token) - # Retrieve the full RDSS file list and duplicate files merged with duplicates from report - rdss, file_duplicates = _rdss_file_list(report_duplicates) - - # Initialize the result dictionary for normal (non-duplicate) matches - result = {} - - # Iterate over the rows in the cleaned RedCap report - for _, row in report.iterrows(): - boost_id = str(row['boost_id']) - lab_id = str(row['lab_id']) - - # Find matching files in the RDSS list - rdss_matches = rdss[rdss['ID'] == lab_id] - if not rdss_matches.empty: - if boost_id not in result: - result[boost_id] = [] - for _, match_row in rdss_matches.iterrows(): - result[boost_id].append({ - 'filename': match_row['filename'], - 'labID': lab_id, - 'date': match_row['Date'] - }) - - # Process duplicates into the desired structure. - duplicates_dict = [] - if not file_duplicates.empty: - # Group by lab_id and boost_id; each group represents one duplicate combination. - grouped = file_duplicates.groupby(['lab_id', 'boost_id']) - for (lab_id, boost_id), group in grouped: - duplicates_dict.append({ - 'lab_id': lab_id, - 'boost_id': boost_id, - 'filenames': group['filename'].tolist(), - 'dates': group['Date'].tolist() - }) - else: - print("Found no duplicates.") - - return {'matches': result, 'duplicates': duplicates_dict} - -def _return_report(token): - """ - pulls the id report from the rdss via redcap api. - reads the report as a dataframe. - checks for boost_ids that are associated with multiple lab_ids, logs a critical error, - and removes these rows from the dataframe. - separates duplicate rows (based on any column) from the cleaned data. - - returns: - df_cleaned: dataframe with duplicates removed and problematic boost_ids excluded - duplicate_rows: dataframe of duplicate rows - """ - url = 'https://redcap.icts.uiowa.edu/redcap/api/' - data = { - 'token': token, - 'content': 'report', - 'report_id': 43327, - 'format': 'csv' - } - r = requests.post(url, data=data) - if r.status_code != 200: - print(f"error! status code is {r.status_code}") - sys.exit(1) - - df = pd.read_csv(StringIO(r.text)) - - # identify boost_ids associated with multiple lab_ids. - boost_id_counts = df.groupby('boost_id')['lab_id'].nunique() - problematic_boost_ids = boost_id_counts[boost_id_counts > 1].index.tolist() - - if problematic_boost_ids: - print(f"found boost_id(s) with multiple lab_ids: {', '.join(map(str, problematic_boost_ids))}. " - "these entries will be removed from processing.") - df = df[~df['boost_id'].isin(problematic_boost_ids)] - - # identify and separate duplicate rows based on any column. - duplicate_rows = df[df.duplicated(keep=False)] - df_cleaned = df.drop_duplicates(keep=False) - - if not duplicate_rows.empty: - print(f"duplicate rows found:\n{duplicate_rows}") - - return df_cleaned, duplicate_row - -def _rdss_file_list(duplicates, daysago=None): - """ - extracts the first string before the space and the date from filenames ending with .csv - in the specified folder and stores them in a dataframe. - - Also, merges the file list with duplicate report entries based on lab_id. - - Returns: - df: DataFrame of all file entries - merged_df: DataFrame of file entries that match duplicate lab_ids from the report - """ - extracted_data = [] - - # Loop through all files in the rdss_dir folder. - for filename in os.listdir(rdss_dir): - if filename.endswith('.csv'): - try: - # Handle both old and new filename formats - if '_' in filename and filename.endswith('.csv'): - # New format: 1288_4-26-2025_Sleep.csv - parts = filename.replace('.csv', '').split('_') - if len(parts) >= 3: - base_name = parts[0] # lab_id - date_part = parts[1] # date - extracted_data.append({'ID': base_name, 'Date': date_part, 'filename': filename}) - else: - print(f"Skipping file with unexpected format: {filename}") - else: - try: - base_name = filename.split(' ')[0] # Extract lab_id (old format) - date_part = filename.split('(')[1].split(')')[0] # Extract date (old format) - extracted_data.append({'ID': base_name, 'Date': date_part, 'filename': filename}) - except IndexError: - print(f"Skipping file with unexpected format: {filename}") - except IndexError: - print(f"Skipping file with unexpected format: {filename}") - - df = pd.DataFrame(extracted_data) - - if not df.empty: - df['Date'] = pd.to_datetime(df['Date'], errors='coerce') - - if daysago: - cutoff_date = datetime.today() - timedelta(days=daysago) - df = df[df['Date'] >= cutoff_date] # Filter files within the last `daysago` days - else: - df = df[df['Date'] >= '2024-08-05'] # Filter out rows before the threshold date - - # Filter the file list to only include rows where ID is in the duplicate report (if any) - if not duplicates.empty: - matched_df = df[df['ID'].isin(duplicates['lab_id'])] - # Merge with the duplicates to bring in boost_id information from the report - merged_df = matched_df.merge(duplicates, left_on='ID', right_on='lab_id') - else: - merged_df = pd.DataFrame() - - return df, merged_df - -matches = compare_ids(rdss_dir, token, daysago=None) -# Print the matches and duplicates for verification -print("Matches:") -for boost_id, files in matches['matches'].items(): - print(f"Boost ID: {boost_id}") - for file_info in files: - print(f" - {file_info['filename']} (Lab ID: {file_info['labID']}, Date: {file_info['date']})") -print("\nDuplicates:") -for dup in matches['duplicates']: - print(f"Lab ID: {dup['lab_id']}, Boost ID: {dup['boost_id']}") - print(f" Filenames: {', '.join(dup['filenames'])}") - print(f" Dates: {', '.join(map(str, dup['dates']))}") -# The above code is a complete script that compares IDs from RDSS and RedCap, identifies matches and duplicates, and prints the results. - -''' -Below we create the sessions, where if the same subject ID has multiple files, we will create a session for each file ordered by date. -this will now be stored as a dataframe with the columns: - # 'subject_id', 'session_id', 'filename', 'date' - # where subject_id is 'sub-', session_id is 'ses-', filename is the file name with full path, and date is the date of the file. -''' -def create_sessions(matches): - """ - Create sessions from the matches dictionary. - - Args: - matches (dict): Dictionary containing matches with boost_id as keys and list of file info as values. - - Returns: - pd.DataFrame: DataFrame with columns 'subject_id', 'session_id', 'filename', 'date'. - """ - sessions = [] - - for boost_id, files in matches['matches'].items(): - subject_id = f'sub-{boost_id}' - for i, file_info in enumerate(files): - session_id = f'ses-{i + 1}' # Session number starts from 1 - sessions.append({ - 'subject_id': subject_id, - 'session_id': session_id, - 'filename': os.path.join(rdss_dir, file_info['filename']), - 'date': file_info['date'] - }) - - return pd.DataFrame(sessions) - -# Create sessions from the Matches -sessions_df = create_sessions(matches) -# Print the sessions DataFrame for verification -print("\nSessions DataFrame:") -print(sessions_df) - - -''' -Iterate through the files in the sessions file list and build the sleep log file. Files are have the format: - -Sleep Algorithm,In Bed Date,In Bed Time,Out Bed Date,Out Bed Time,Onset Date,Onset Time,Latency,Total Counts,Efficiency,Total Minutes in Bed,Total Sleep Time (TST),Wake After Sleep Onset (WASO),Number of Awakenings,Average Awakening Length,Movement Index,Fragmentation Index,Sleep Fragmentation Index -Cole-Kripke,4/12/2023,12:00 AM,4/12/2023,6:00 AM,4/12/2023,12:00 AM,0,34862,84.44,360,304,56,10,5.6,8.889,10,18.889 -Cole-Kripke,4/12/2023,11:09 PM,4/13/2023,7:00 AM,4/12/2023,11:19 PM,10,54263,87.05,471,410,51,13,3.92,12.951,7.692,20.643 - -They need to have the following format: -ID D1_date D1_wakeup D1_inbed D1_nap_start D1_nap_end D1_nonwear1_off D1_nonwear1_on D2_date … -123 2015-03-30 09:00:00 22:00:00 11:15:00 11:45:00 13:35:00 14:10:00 31/03/2015 … -567 2015-04-20 08:30:00 23:15:00 - -where ID should be sub-{subject_id}_ses-{session_id}_accel and D1_date is the first date of the file, D1_wakeup is the first wakeup time, D1_inbed is the second in-bed time (skipping the first in-bed time). Naps and non-wear will be skipped for now. -complete for all dates in the file - -''' - -def create_sleep_log(sessions_df): - """ - Create a sleep log file from the sessions DataFrame. - - Args: - sessions_df (pd.DataFrame): DataFrame with columns 'subject_id', 'session_id', 'filename', 'date'. - - Returns: - pd.DataFrame: DataFrame with sleep log entries in wide format. - """ - # List to store the final entries (one per subject/session) - final_entries = [] - - for _, row in sessions_df.iterrows(): - subject_id = row['subject_id'] - session_id = row['session_id'] - filename = row['filename'] - - try: - # Skip first 5 rows and first column - sleep_data = pd.read_csv(filename, skiprows=5, usecols=lambda x: x != 'Unnamed: 0') - if sleep_data.empty: - print(f"No data found in file {filename}. Skipping.") - continue - - # Create a base entry for this subject/session - entry = {'ID': f'{subject_id}_{session_id}_accel'} - - # Convert In Bed Date to datetime for sorting - sleep_data['In_Bed_Date_DT'] = pd.to_datetime(sleep_data['In Bed Date'], format='%m/%d/%Y', errors='coerce') - sleep_data = sleep_data.sort_values('In_Bed_Date_DT') # Sort by date - - # Group by date and keep only the last entry for each date - date_groups = {} - for _, data in sleep_data.iterrows(): - in_bed_date_str = data['In Bed Date'] - date_key = pd.to_datetime(in_bed_date_str, format='%m/%d/%Y').strftime('%Y-%m-%d') - date_groups[date_key] = data - - # Process each day's data - for day_num, (date_key, data) in enumerate(sorted(date_groups.items()), 1): - day_prefix = f'D{day_num}_' - - # Extract date and time information - in_bed_date = pd.to_datetime(data['In Bed Date'], format='%m/%d/%Y').strftime('%Y-%m-%d') - in_bed_time = pd.to_datetime(data['In Bed Time'], format='%I:%M %p').strftime('%H:%M:%S') - out_bed_date = pd.to_datetime(data['Out Bed Date'], format='%m/%d/%Y').strftime('%Y-%m-%d') - out_bed_time = pd.to_datetime(data['Out Bed Time'], format='%I:%M %p').strftime('%H:%M:%S') - - # Store only date and time information for this day - entry[f'{day_prefix}date'] = in_bed_date - entry[f'{day_prefix}inbed'] = in_bed_time - entry[f'{day_prefix}wakeup'] = out_bed_time - - final_entries.append(entry) - - except Exception as e: - print(f"Error processing file {filename}: {e}") - - return pd.DataFrame(final_entries) - - -# Create the sleep log dataframe -sleep_log_df = create_sleep_log(sessions_df) -# Print the sleep log DataFrame for verification -print("\nSleep Log DataFrame:") -print(sleep_log_df) - - - -''' -Split the dataframes into two parst, intervention and observational -where if subject ID starts with sub-7*, it is an observational study subject, otherwise it is an intervention study subject. -then clean up the dataframes by removing any extra columns that are unused - -''' - -def split_and_clean_dataframes(sleep_log_df): - """ - Split the sleep log DataFrame into intervention and observational study DataFrames, - and clean up by removing unused columns. - - Args: - sleep_log_df (pd.DataFrame): DataFrame with sleep log entries. - - Returns: - tuple: Two DataFrames, one for intervention study and one for observational study. - """ - # Split the DataFrame based on subject ID - obs_df = sleep_log_df[sleep_log_df['ID'].str.startswith('sub-7')] - # Intervention study DataFrame contains all other subjects (doesn't start with sub-7 or sub-6) - int_df = sleep_log_df[~sleep_log_df['ID'].str.startswith('sub-7')] - int_df = int_df[~int_df['ID'].str.startswith('sub-6')] - # Clean up by removing unused columns (if any) - int_df = int_df.reset_index(drop=True) - obs_df = obs_df.reset_index(drop=True) - - return int_df, obs_df - -# Split and clean the DataFrames -int_df, obs_df = split_and_clean_dataframes(sleep_log_df) -# Print the intervention and observational DataFrames for verification -print("\nIntervention Study DataFrame:") -print(int_df.head()) -print("\nObservational Study DataFrame:") -print(obs_df.head()) - -# save the DataFrames to CSV files -int_df.to_csv(os.path.join(INT_DIR, 'sleep_log_intervention.csv'), index=False) -obs_df.to_csv(os.path.join(OBS_DIR, 'sleep_log_observational.csv'), index=False) - - diff --git a/code/tests/sleep/plots/avg_plot_all.html b/code/tests/sleep/plots/avg_plot_all.html deleted file mode 100644 index 0d62e3b..0000000 --- a/code/tests/sleep/plots/avg_plot_all.html +++ /dev/null @@ -1,3885 +0,0 @@ - - - -
-
- - \ No newline at end of file diff --git a/code/tests/sleep/plots/avg_plot_ses-1.html b/code/tests/sleep/plots/avg_plot_ses-1.html deleted file mode 100644 index f1ac243..0000000 --- a/code/tests/sleep/plots/avg_plot_ses-1.html +++ /dev/null @@ -1,3885 +0,0 @@ - - - -
-
- - \ No newline at end of file diff --git a/code/tests/sleep/plots/avg_plot_ses-2.html b/code/tests/sleep/plots/avg_plot_ses-2.html deleted file mode 100644 index d6813f7..0000000 --- a/code/tests/sleep/plots/avg_plot_ses-2.html +++ /dev/null @@ -1,3885 +0,0 @@ - - - -
-
- - \ No newline at end of file diff --git a/code/tests/sleep/plots/avg_plot_ses-5.html b/code/tests/sleep/plots/avg_plot_ses-5.html deleted file mode 100644 index c3b7857..0000000 --- a/code/tests/sleep/plots/avg_plot_ses-5.html +++ /dev/null @@ -1,3885 +0,0 @@ - - - -
-
- - \ No newline at end of file diff --git a/code/tests/sleep/sleep_acc.R b/code/tests/sleep/sleep_acc.R deleted file mode 100644 index 01b33a5..0000000 --- a/code/tests/sleep/sleep_acc.R +++ /dev/null @@ -1,132 +0,0 @@ -#!/usr/bin/env Rscript - -# The following code is used for testing sleep logs in GGIR. -# Sleep logs are in the root folder of the accel directory, -# a better place is needed but for testing purposes it will do. -library(GGIR) - -# first test on intervention - since there are less subjects -ProjectDir <- "/Shared/vosslabhpc/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/" -ProjectDerivDir <- "derivatives/GGIR-3.2.6/" - -# Extract final folder name -last_folder <- basename(ProjectDir) - -# Determine correct filename -if (grepl("act-obs", last_folder, fixed = TRUE)) { - SleepLog <- file.path(ProjectDir, "sleep_log_observational.csv") -} else if (grepl("act-int", last_folder, fixed = TRUE)) { - SleepLog <- file.path(ProjectDir, "sleep_log_intervention.csv") -} else { - stop("Unrecognized project directory. Exiting.") -} - -# Print values to verify -print(paste("Project Directory:", ProjectDir)) -print(paste("Derivatives Directory:", ProjectDerivDir)) -print(paste("SleepLog Location")) - - -# Helper functions -SubjectGGIRDeriv <- function(x) { -a <- dirname(x) -paste0(ProjectDir, ProjectDerivDir, a) -} - -datadirname <- function(x) { -b <- dirname(x) -paste0(ProjectDir, b) -} - -# Gather subject directories -directories <- list.dirs(ProjectDir, recursive = FALSE) -subdirs <- directories[grepl("sub-*", directories)] -print(paste("subdirs: ", subdirs)) - -# Create project-specific derivatives GGIR folder if it doesn't exist -if (!dir.exists(paste0(ProjectDir, ProjectDerivDir))) { -dir.create(paste0(ProjectDir, ProjectDerivDir)) -} - -# List accel.csv files -filepattern <- "*accel.csv" -GGIRfiles <- list.files(subdirs, pattern = filepattern, recursive = TRUE, - include.dirs = TRUE, full.names = TRUE, no.. = TRUE) -print(paste("GGIR Files before splitting: ", GGIRfiles)) - -# Adjust path formatting -GGIRfiles <- sapply(strsplit(GGIRfiles, "//", fixed = TRUE), function(x) paste(x[2])) -print(paste("GGIR Files after splitting: ", GGIRfiles)) - -# Ensure directory structure exists -for (i in GGIRfiles) { -if (!dir.exists(SubjectGGIRDeriv(i))) { - dir.create(SubjectGGIRDeriv(i), recursive = TRUE) -} -} - -for (r in GGIRfiles) { - if (dir.exists(paste0(SubjectGGIRDeriv(r), "/output_beh"))) { - next - } else { - datadir <- normalizePath(datadirname(r), mustWork = FALSE) - outputdir <- SubjectGGIRDeriv(r) - print(paste("datadir: ", datadir)) - print(paste("outputdir: ", outputdir)) - if (!dir.exists(datadir)) { - stop(paste("Error: datadir does not exist ->", datadir)) - } - - assign("datadir", datadir, envir = .GlobalEnv) - assign("outputdir", outputdir, envir = .GlobalEnv) - - try({ - GGIR( - # ==== Initialization ==== - mode = 1:6, - datadir = datadir, - outputdir = outputdir, - studyname = "boost", - overwrite = FALSE, - desiredtz = "America/Chicago", - print.filename = TRUE, - idloc = 6, # six is the dot character, needed for use of sleep logs - - # ==== Part 1: Data loading and basic signal processing ==== - do.report = c(2, 4, 5, 6), - epochvalues2csv = TRUE, - do.ENMO = TRUE, - acc.metric = "ENMO", - windowsizes = c(5, 900, 3600), - - # ==== Part 2: Non-wear detection ==== - ignorenonwear = TRUE, - - # ==== Part 3: Sleep detection ==== - # Uncomment the below if using external sleep log: - loglocation = "/Shared/vosslabhpc/Projects/BOOST/ObservationalStudy/3-experiment/data/act-obs-test/sleep_log_observational.csv", - - colid = 1, - coln1 = 2, - sleepwindowType = "TimeInBed", - - # ==== Part 4: Physical activity summaries ==== - timewindow = c("WW", "MM", "OO"), - - # ==== Part 5: Day-level summaries ==== - hrs.del.start = 4, - hrs.del.end = 3, - maxdur = 9, - threshold.lig = 44.8, - threshold.mod = 100.6, - threshold.vig = 428.8, - - # ==== Part 6: CR and other metrics ==== - part6CR = TRUE, - visualreport = TRUE, - old_visualreport = FALSE - ) - }) - } -} - diff --git a/code/utils/db.py b/code/utils/db.py deleted file mode 100644 index 527a800..0000000 --- a/code/utils/db.py +++ /dev/null @@ -1,15 +0,0 @@ -import psycopg -import os -import sys -import logging - -class db: - - def __init__(self) -> None: - pass - - def query_db(self): - return None - - def insert_db(self): - return None diff --git a/features/FEATURE-testing-suite/FEATURE-SPEC.md b/features/FEATURE-testing-suite/FEATURE-SPEC.md new file mode 100644 index 0000000..22dcbfc --- /dev/null +++ b/features/FEATURE-testing-suite/FEATURE-SPEC.md @@ -0,0 +1,126 @@ +# Feature Spec -> Testing Suite +--- + +## Goal +Create a reliable, Python-first testing and linting suite that protects the core BOOST pipeline behaviors (ingest, save/session ordering, and signatures) while keeping GGIR/R validation lightweight and out of primary CI gating. + +## Project Intent (Constitution Alignment) +- Prioritize logic in `act/` Python modules (`main.py`, `utils/`, `core/gg.py`) as the main automation surface. +- Preserve deterministic output conventions (for example `sub-####_ses-#_accel.csv`) and session ordering behavior enforced by save logic. +- Keep tests safe for CI by avoiding hard dependencies on production mounts (`/mnt`) and live secrets. +- Use repo-standard tooling and style guidance (pytest for tests, flake8 linting, PEP 8 conventions). + +## Scope +### In scope +- `pytest`-based suite for Python code across pipeline orchestration and utility modules. +- `flake8` lint checks for the Python codebase, explicitly excluding `E502`. +- Robust unit/integration tests for save/session edge cases. +- Reusable fixtures for signature logic and filesystem-heavy behaviors. +- GitHub Actions workflow on pull requests targeting `main`. + +### Out of scope +- Full GGIR/R correctness validation as a required CI gate. +- Any CI trigger other than pull requests to `main`. +- Production filesystem writes or use of real REDCap tokens in CI. +- Do not write code that relies on mounts, these will not be available in CI - can be used for local testing, however. + +## Functional Requirements +### 1) Test framework and layout +- Use `pytest` as the canonical test runner. +- Place tests under `act/tests/` using `test_*.py` naming. +- Organize by module concern (for example: `tests/utils/`, `tests/pipeline/`, `tests/save/`) while preserving existing repo patterns. + +### 2) Python-first coverage +- Tests must primarily cover Python code paths. +- R scripts and GGIR internals are not required for high coverage and should be mocked/stubbed where invoked from Python. +- CI must enforce a minimum **90% Python coverage** for scoped, testable Python modules. + +### 3) Save/session edge-case behavior +The suite must explicitly validate the save logic around session/date ordering, including at minimum: +- **Earlier-date insertion case**: if a newly discovered session date is earlier than current `ses-1`, existing sessions are renamed/re-indexed so ordering remains chronological. +- Session labels remain contiguous and deterministic after re-indexing. +- Output filenames and target paths preserve required naming conventions after renaming. +- Behavior is validated for both intervention and observational-style paths where applicable. + +### 4) Signature fixtures +- Provide reusable fixtures for signature-related logic (input signatures, identity matching, or equivalent pipeline signature checks used in this repo). +- Fixtures must support both “known-good” and mismatch/edge scenarios. +- Fixture design should minimize duplication and be shareable across multiple test modules. + +### 5) Linting +- Add/standardize `flake8` linting for project Python files. +- Configure lint checks to ignore `E502`. +- Linting failures block PR workflow success. + +## CI/CD Requirements (GitHub Actions) +### Trigger policy +- Run CI on `pull_request` events targeting `main` only. + +### Required PR checks +- Install dependencies and run `flake8` (with `E502` excluded). +- Run `pytest` with coverage and fail if below 90%. +- Run a **PR smoke e2e** test that exercises pipeline flow with mocked/local test inputs (no real mounts/secrets). + +### E2E interpretation +- Within PR-only workflow policy, e2e is defined as a lightweight smoke integration path. +- A heavier full e2e may exist as non-required local/manual process, but it is not a required GitHub Actions trigger in this feature. + +## Non-Functional Requirements +- Tests should be deterministic, parallel-safe where possible, and not depend on wall-clock timing. +- Use temporary directories and mocks rather than writing to real `/mnt` targets. +- Keep runtime practical for PR feedback (fast unit tests + one smoke e2e path). + +## Acceptance Criteria +- A contributor can run lint + tests locally with documented commands and get identical pass/fail behavior to CI. +- PR to `main` fails when: + - flake8 fails (except `E502`), + - pytest fails, + - coverage is `< 90%`, or + - smoke e2e check fails. +- Save/session tests demonstrate verified renaming/re-indexing for earlier-date insertion. +- Signature fixtures are present and used by multiple tests. + +## Suggested Local Commands +- `pytest -q --cov=act --cov-report=term-missing --cov-fail-under=90` + +## Implementation Plan + +***Checkpoint 1: Testing Scaffolding & Config*** +- [x] Add/standardize pytest configuration in `pyproject.toml` for discovery under `act/tests/` and `test_*.py` patterns. +- [x] Add/standardize flake8 configuration in `pyproject.toml` (or `.flake8`) for project linting with `E501` ignored. +- [x] Add baseline test dependencies to `act/requirements.txt` (or documented dev install path) for `pytest`, coverage plugin, and linting tools. +- [x] A test: run local command parity check (`flake8` + `pytest --collect-only`) to confirm discovery/lint wiring works end-to-end. + +***Checkpoint 2: Shared Fixtures & Test Utilities*** +- [x] Create reusable fixtures in `act/tests/conftest.py` for temporary filesystem roots (no `/mnt` dependency). +- [x] Add fixture factories for representative subject/session file naming and path generation (`sub-####_ses-#_accel.csv`). +- [x] Add signature-oriented fixtures for known-good and mismatch edge cases, reusable across modules. +- [x] A test: add fixture sanity tests in `act/tests/test_fixtures.py` validating fixture outputs, determinism, and reuse. + +***SKIPPING CHECKPOINT 3*** + +***Checkpoint 4: Additional Save Edge Cases*** +- [x] Add tests for observational/intervention-style directory variants used by current save logic. +- [x] Add tests for duplicate-date/no-op behavior to ensure deterministic handling without accidental session drift. +- [x] Add error-path tests for partial write/rename failures using mocks to verify safe failure semantics. +- [x] A test: implement `test_save_edge_cases_matrix()` parameterized across path style and edge-case scenarios. + +***Checkpoint 5: Pipeline Smoke Integration (Python-first e2e)*** +- [x] Add lightweight integration test(s) targeting Python orchestration path (`act/main.py` + `act/utils/pipe.py`) with external systems mocked. +- [x] Stub GGIR/R boundaries (`act/core/gg.py` calls) so CI validates orchestration flow without full GGIR execution. +- [x] Validate key outputs/logical side effects (manifest write, expected calls, and no mount dependence). +- [x] A test: implement `test_pipeline_smoke_mocked_dependencies()` as PR smoke e2e gate. + +***Checkpoint 6: CI Workflow on PR to main*** +- [x] Add GitHub Actions workflow under `.github/workflows/` triggered on `pull_request` to `main` only. +- [x] Configure workflow jobs for lint (`flake8` with `E502` excluded), tests, and coverage fail-under 90%. +- [x] Include smoke e2e test execution in required PR checks and keep runtime bounded for fast feedback. +- [x] A test: validate workflow config with a PR dry run by intentionally failing/passing lint and test stages in separate commits. + +***Checkpoint 7: Documentation & Contributor UX*** +- [ ] Update `README.md` Testing & QA section with exact local commands and CI expectations. +- [ ] Document where fixtures live, how to add save-edge cases, and smoke e2e constraints (no real mounts/secrets). +- [ ] Add short contributor notes in `AGENTS.md`-aligned style for test naming and commit granularity. +- [ ] A test: run documented commands from a clean environment to confirm docs are executable and accurate. + + diff --git a/flake.nix b/flake.nix index b6fe161..c0025e6 100644 --- a/flake.nix +++ b/flake.nix @@ -58,7 +58,10 @@ ps.pyyaml ps.pyarrow ps.pytest - ] ++ [ catppuccin-jupyterlab ] + ps.pytest-cov + ps.flake8 + ps.black + ] #++ [ catppuccin-jupyterlab ] ); in { default = pkgs.mkShellNoCC { diff --git a/pyproject.toml b/pyproject.toml index 4acc7cc..9782b67 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -8,6 +8,10 @@ readme = "README.md" [tool.poetry.dependencies] python = "^3.11" +[tool.pytest.ini_options] +testpaths = ["act/tests"] +python_files = ["test_*.py"] + [build-system] requires = ["poetry-core"] diff --git a/run.job b/run.job index 5481085..a0ffe28 100644 --- a/run.job +++ b/run.job @@ -4,8 +4,8 @@ #$ -q VOSSHBC #$ -m bea #$ -M zjgilliam@uiowa.edu -#$ -o $HOME/boost-act/code/logs/myjob.out # Standard output log -#$ -e $HOME/boost-act/code/logs/myjob.err # Standard error log +#$ -o $HOME/boost-act/act/logs/myjob.out # Standard output log +#$ -e $HOME/boost-act/act/logs/myjob.err # Standard error log export GIT_SSH_COMMAND="ssh -i $HOME/.ssh/id_ed25519 -o IdentitiesOnly=yes" git config --global push.default simple @@ -37,7 +37,7 @@ conda activate act-newer || { } # === Run R Script === -Rscript "$HOME/boost-act/code/tests/sleep/sleep_acc.R" || { +Rscript "$HOME/boost-act/act/tests/sleep/sleep_acc.R" || { echo "❌ R script failed." exit 1 }