homevitals 1.0.0__tar.gz

homevitals-1.0.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Elias Sturim (eufy-sync)
+Copyright (c) 2026 Christopher Smith (HomeVitals)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

homevitals-1.0.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: homevitals
+Version: 1.0.0
+Summary: Sync your household's smart scale and blood pressure readings to each person's own Garmin Connect account. Works for Garmin Connect.
+Author: Christopher Smith
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/smithbuilt/homevitals
+Project-URL: Repository, https://github.com/smithbuilt/homevitals
+Project-URL: Issues, https://github.com/smithbuilt/homevitals/issues
+Project-URL: Changelog, https://github.com/smithbuilt/homevitals/blob/main/CHANGELOG.md
+Project-URL: Based on, https://github.com/sturimcode/eufy-sync
+Keywords: garmin connect,eufy,eufylife,smart scale,omron,omron connect,blood pressure,body composition,weight sync,household,family
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: keyring>=25.0.0
+Requires-Dist: garminconnect>=0.3.10
+Requires-Dist: curl_cffi>=0.15.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: browser
+Requires-Dist: playwright>=1.40.0; extra == "browser"
+Dynamic: license-file
+
+# HomeVitals
+
+**Works for Garmin Connect.** Sync a household's smart scale and blood pressure readings to *each person's own* Garmin Connect account.
+
+[![Tests](https://github.com/smithbuilt/homevitals/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/smithbuilt/homevitals/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/homevitals)](https://pypi.org/project/homevitals/)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+![The HomeVitals window during a sync](docs/screenshots/main-window.png)
+
+Garmin's own scales and monitors sync by themselves. Many homes use a **Eufy smart scale** and an **OMRON blood pressure monitor** instead, shared by everyone in the house. HomeVitals moves each person's readings into their own Garmin Connect account:
+
+- **Weigh-ins** from the Eufy scale (EufyLife cloud): weight and full body composition.
+- **Blood pressure readings** from the OMRON monitor, through the OMRON connect app: systolic, diastolic and pulse, with "irregular heartbeat detected" or "body movement detected" in the reading's note when the monitor flagged it.
+
+Each person keeps their own accounts. Weigh-ins only go to the person whose scale profile they are, and scale profiles not linked to anyone (the kids', a guest's) are never sent anywhere.
+
+> HomeVitals is not affiliated with, endorsed by or supported by Garmin, Eufy/Anker or OMRON. It uses the same connections their apps use, which aren't public APIs and can change without notice. It is not a medical device: always check readings on the monitor or in the manufacturer's app.
+
+## What's been tested
+
+| | |
+|---|---|
+| Windows 11 | Tested daily: window, tray icon, automatic sync, shortcuts |
+| macOS, Linux | Not tested. The command line came from [eufy-sync](https://github.com/sturimcode/eufy-sync), which supports them; the window's tray icon and taskbar parts are Windows-only |
+| Scales | A Eufy Wi-Fi smart scale through the EufyLife app's cloud |
+| Blood pressure | OMRON M7 Intelli IT (HEM-7361T) with the OMRON connect app (EU server). Other monitors that sync to OMRON connect should work; tell us if yours does |
+| People | Two adults, each with their own Garmin and OMRON connect accounts, sharing one Eufy scale that also has unlinked kids' profiles |
+
+## Install
+
+You need Python 3.12+ and [uv](https://docs.astral.sh/uv/) (or pipx).
+
+```
+uv tool install homevitals
+homevitals-gui
+```
+
+The window opens. Click **Add desktop shortcut** to open it from the desktop from then on.
+
+Update later with `uv tool upgrade homevitals`. HomeVitals never updates itself.
+
+## Setting up your household
+
+![Adding a person](docs/screenshots/person-window.png)
+
+Click **Add person**, type a name, and connect what that person uses. Each box connects on its own, checked with a real login before anything is saved, so you can add Garmin today and the scale next week. Nothing is required except a name.
+
+- **Garmin:** the person's own Garmin Connect account. Garmin may email a security code; a box asks for it.
+- **Scale (Eufy):** the Eufy account the person's weigh-ins go to, then pick their profile on the scale (shown by last weight and date). Profiles already linked to someone are greyed out. By default each person uses their own Eufy account, so nobody sees anyone else's weight; if two people really share one Eufy login, each types it in their own box.
+- **Blood pressure (OMRON connect):** the person's OMRON connect email and password, and **the country the OMRON connect account was created in**. See the OMRON note below.
+
+Then click **Sync now**, and tick **Automatic sync (every 4 hours)**. While a sync runs, each person's row shows ⋯ waiting, a turning *syncing* symbol, then ✓ 2 new, ✓ up to date or ✗ failed.
+
+**Fix problems** checks every login and setting and shows a button to fix what it can. Closing the window keeps HomeVitals running by the clock; right-click its icon there for **Quit**.
+
+## Things worth knowing
+
+**The phone apps have to see the readings first.** The scale's weigh-ins reach Eufy's cloud only after the Eufy app has picked them up, and the monitor's readings reach OMRON's cloud only after the OMRON connect app has pulled them off the monitor. If a sync says "nothing new", open the right app on the phone, wait a moment and sync again.
+
+**OMRON's country matters as much as the password.** Each country uses its own OMRON server, so the country in HomeVitals must be the one chosen when the OMRON connect account was created. A wrong country fails exactly like a wrong password, and the window says so. Some regions in the OMRON connect app keep readings on the phone only, with no cloud at all (Qatar is one); readings from such an account can't be synced, so create the account in a country with cloud sync.
+
+**Older readings.** The first sync brings in the last 7 days of weigh-ins and 30 days of blood pressure. To bring in more blood pressure history (up to 10 years, or what the monitor and app hold), open the person and click **Bring in older readings**. Nothing is ever uploaded twice: HomeVitals remembers what it sent and checks what Garmin already has.
+
+**Numbers are never changed.** Readings go to Garmin exactly as measured. One that Garmin won't accept is skipped and reported, never rounded.
+
+## Privacy and security
+
+- Everything runs on your own computer. HomeVitals talks only to Eufy, OMRON and Garmin, with the accounts you give it.
+- Passwords are kept in the system's own password store (Windows Credential Manager). They never go into the settings file, the log or the window.
+- Weights and blood pressure numbers never appear in the log file, the window's messages or notifications; only counts do.
+- Settings and sync history live in `~/.homevitals` (on Windows `C:\Users\<you>\.homevitals`). The log file `sync.log` there is safe to share when asking for help.
+
+## Advanced settings
+
+Most people never need these. They go in a person's `omron:` part of `~/.homevitals/config.yaml` (quit the window first):
+
+- `user_number`: send only that user's readings from the monitor. Leave it out and every reading in the person's OMRON connect account syncs, which is right when each person has their own account. Set it (1 to 99, the user number the monitor shows) when one account holds several people's readings.
+- `server`: pin the OMRON server (`eu`, `na`, or a full `https://` address) if a correct login keeps failing.
+
+```yaml
+users:
+  - name: Sam
+    omron:
+      email: sam@example.com
+      country: GB
+      user_number: 2
+```
+
+The command line is still there for scripts and servers: `homevitals --help`, `homevitals --doctor`.
+
+## Coming from eufy-sync or an earlier HomeVitals name
+
+HomeVitals started as a fork of [eufy-sync](https://github.com/sturimcode/eufy-sync), which syncs one person's Eufy scale. If you used eufy-sync (settings in `~/.garmin-sync`), the first start copies your settings, sync history and saved passwords over; the originals are left as they were.
+
+## Credits and licence
+
+MIT licence. Based on [eufy-sync](https://github.com/sturimcode/eufy-sync) by Elias Sturim (MIT): the Eufy and Garmin parts, the command line and the automatic sync come from there.
+
+The OMRON connect part was written from scratch, using two open-source projects as references for how OMRON's servers behave: [omramin](https://github.com/bugficks/omramin) by bugficks and [omron-connect-mcp](https://github.com/aircon-chen/omron-connect-mcp) by aircon-chen (both GPL-2.0). No code from either is included.
+
+Garmin and Garmin Connect are trademarks of Garmin Ltd. or its subsidiaries; Eufy is a trademark of Anker Innovations; OMRON and OMRON connect are trademarks of OMRON Corporation. They're named here only to say what HomeVitals works with.

homevitals-1.0.0/README.md

@@ -0,0 +1,102 @@
+# HomeVitals
+
+**Works for Garmin Connect.** Sync a household's smart scale and blood pressure readings to *each person's own* Garmin Connect account.
+
+[![Tests](https://github.com/smithbuilt/homevitals/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/smithbuilt/homevitals/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/homevitals)](https://pypi.org/project/homevitals/)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+![The HomeVitals window during a sync](docs/screenshots/main-window.png)
+
+Garmin's own scales and monitors sync by themselves. Many homes use a **Eufy smart scale** and an **OMRON blood pressure monitor** instead, shared by everyone in the house. HomeVitals moves each person's readings into their own Garmin Connect account:
+
+- **Weigh-ins** from the Eufy scale (EufyLife cloud): weight and full body composition.
+- **Blood pressure readings** from the OMRON monitor, through the OMRON connect app: systolic, diastolic and pulse, with "irregular heartbeat detected" or "body movement detected" in the reading's note when the monitor flagged it.
+
+Each person keeps their own accounts. Weigh-ins only go to the person whose scale profile they are, and scale profiles not linked to anyone (the kids', a guest's) are never sent anywhere.
+
+> HomeVitals is not affiliated with, endorsed by or supported by Garmin, Eufy/Anker or OMRON. It uses the same connections their apps use, which aren't public APIs and can change without notice. It is not a medical device: always check readings on the monitor or in the manufacturer's app.
+
+## What's been tested
+
+| | |
+|---|---|
+| Windows 11 | Tested daily: window, tray icon, automatic sync, shortcuts |
+| macOS, Linux | Not tested. The command line came from [eufy-sync](https://github.com/sturimcode/eufy-sync), which supports them; the window's tray icon and taskbar parts are Windows-only |
+| Scales | A Eufy Wi-Fi smart scale through the EufyLife app's cloud |
+| Blood pressure | OMRON M7 Intelli IT (HEM-7361T) with the OMRON connect app (EU server). Other monitors that sync to OMRON connect should work; tell us if yours does |
+| People | Two adults, each with their own Garmin and OMRON connect accounts, sharing one Eufy scale that also has unlinked kids' profiles |
+
+## Install
+
+You need Python 3.12+ and [uv](https://docs.astral.sh/uv/) (or pipx).
+
+```
+uv tool install homevitals
+homevitals-gui
+```
+
+The window opens. Click **Add desktop shortcut** to open it from the desktop from then on.
+
+Update later with `uv tool upgrade homevitals`. HomeVitals never updates itself.
+
+## Setting up your household
+
+![Adding a person](docs/screenshots/person-window.png)
+
+Click **Add person**, type a name, and connect what that person uses. Each box connects on its own, checked with a real login before anything is saved, so you can add Garmin today and the scale next week. Nothing is required except a name.
+
+- **Garmin:** the person's own Garmin Connect account. Garmin may email a security code; a box asks for it.
+- **Scale (Eufy):** the Eufy account the person's weigh-ins go to, then pick their profile on the scale (shown by last weight and date). Profiles already linked to someone are greyed out. By default each person uses their own Eufy account, so nobody sees anyone else's weight; if two people really share one Eufy login, each types it in their own box.
+- **Blood pressure (OMRON connect):** the person's OMRON connect email and password, and **the country the OMRON connect account was created in**. See the OMRON note below.
+
+Then click **Sync now**, and tick **Automatic sync (every 4 hours)**. While a sync runs, each person's row shows ⋯ waiting, a turning *syncing* symbol, then ✓ 2 new, ✓ up to date or ✗ failed.
+
+**Fix problems** checks every login and setting and shows a button to fix what it can. Closing the window keeps HomeVitals running by the clock; right-click its icon there for **Quit**.
+
+## Things worth knowing
+
+**The phone apps have to see the readings first.** The scale's weigh-ins reach Eufy's cloud only after the Eufy app has picked them up, and the monitor's readings reach OMRON's cloud only after the OMRON connect app has pulled them off the monitor. If a sync says "nothing new", open the right app on the phone, wait a moment and sync again.
+
+**OMRON's country matters as much as the password.** Each country uses its own OMRON server, so the country in HomeVitals must be the one chosen when the OMRON connect account was created. A wrong country fails exactly like a wrong password, and the window says so. Some regions in the OMRON connect app keep readings on the phone only, with no cloud at all (Qatar is one); readings from such an account can't be synced, so create the account in a country with cloud sync.
+
+**Older readings.** The first sync brings in the last 7 days of weigh-ins and 30 days of blood pressure. To bring in more blood pressure history (up to 10 years, or what the monitor and app hold), open the person and click **Bring in older readings**. Nothing is ever uploaded twice: HomeVitals remembers what it sent and checks what Garmin already has.
+
+**Numbers are never changed.** Readings go to Garmin exactly as measured. One that Garmin won't accept is skipped and reported, never rounded.
+
+## Privacy and security
+
+- Everything runs on your own computer. HomeVitals talks only to Eufy, OMRON and Garmin, with the accounts you give it.
+- Passwords are kept in the system's own password store (Windows Credential Manager). They never go into the settings file, the log or the window.
+- Weights and blood pressure numbers never appear in the log file, the window's messages or notifications; only counts do.
+- Settings and sync history live in `~/.homevitals` (on Windows `C:\Users\<you>\.homevitals`). The log file `sync.log` there is safe to share when asking for help.
+
+## Advanced settings
+
+Most people never need these. They go in a person's `omron:` part of `~/.homevitals/config.yaml` (quit the window first):
+
+- `user_number`: send only that user's readings from the monitor. Leave it out and every reading in the person's OMRON connect account syncs, which is right when each person has their own account. Set it (1 to 99, the user number the monitor shows) when one account holds several people's readings.
+- `server`: pin the OMRON server (`eu`, `na`, or a full `https://` address) if a correct login keeps failing.
+
+```yaml
+users:
+  - name: Sam
+    omron:
+      email: sam@example.com
+      country: GB
+      user_number: 2
+```
+
+The command line is still there for scripts and servers: `homevitals --help`, `homevitals --doctor`.
+
+## Coming from eufy-sync or an earlier HomeVitals name
+
+HomeVitals started as a fork of [eufy-sync](https://github.com/sturimcode/eufy-sync), which syncs one person's Eufy scale. If you used eufy-sync (settings in `~/.garmin-sync`), the first start copies your settings, sync history and saved passwords over; the originals are left as they were.
+
+## Credits and licence
+
+MIT licence. Based on [eufy-sync](https://github.com/sturimcode/eufy-sync) by Elias Sturim (MIT): the Eufy and Garmin parts, the command line and the automatic sync come from there.
+
+The OMRON connect part was written from scratch, using two open-source projects as references for how OMRON's servers behave: [omramin](https://github.com/bugficks/omramin) by bugficks and [omron-connect-mcp](https://github.com/aircon-chen/omron-connect-mcp) by aircon-chen (both GPL-2.0). No code from either is included.
+
+Garmin and Garmin Connect are trademarks of Garmin Ltd. or its subsidiaries; Eufy is a trademark of Anker Innovations; OMRON and OMRON connect are trademarks of OMRON Corporation. They're named here only to say what HomeVitals works with.

homevitals-1.0.0/homevitals/__init__.py

@@ -0,0 +1,18 @@
+"""Sync Eufy smart scale body composition data to Garmin Connect and Strava."""
+
+__version__ = "1.0.0"
+
+# Public API for programmatic use
+from homevitals.eufy_client import EufyClient, EufyMeasurement
+from homevitals.garmin_auth import GarminAuth
+from homevitals.strava_client import StravaClient
+from homevitals.transform import GarminBodyComposition, transform
+
+__all__ = [
+    "GarminAuth",
+    "EufyClient",
+    "EufyMeasurement",
+    "GarminBodyComposition",
+    "StravaClient",
+    "transform",
+]

homevitals-1.0.0/homevitals/__main__.py

@@ -0,0 +1,5 @@
+"""python -m homevitals runs the command-line tool (the GUI's Sync now uses this)."""
+from homevitals.cli import main
+
+if __name__ == "__main__":
+    main()

homevitals-1.0.0/homevitals/bp_sync.py

@@ -0,0 +1,212 @@
+"""The Omron -> Garmin blood pressure step of a sync run.
+
+Runs after the scale step, only for a person with an omron section, and fails
+on its own: a problem here never stops the scale sync, and the other way
+round (cli/app.py gives each step its own try/except).
+
+Health data rules: values go to Garmin exactly as OMRON reported them; a
+reading Garmin would refuse is skipped and counted, never rounded or
+clamped. Logs and results carry counts only, never a reading's values.
+"""
+from __future__ import annotations
+
+import logging
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import TypeVar
+
+from garminconnect import (
+    GarminConnectAuthenticationError,
+    GarminConnectConnectionError,
+    GarminConnectTooManyRequestsError,
+)
+
+from homevitals import state as state_module
+from homevitals.config import UserConfig
+from homevitals.garmin_client import GarminClient
+from homevitals.network import is_transient_network_error
+from homevitals.omron_client import BloodPressureReading, OmronClient, OmronError
+from homevitals.state import SyncState
+from homevitals.sync import MAX_RETRIES, RETRY_BASE_DELAY, PermanentSyncError, _is_permanent
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+BP_TARGET = state_module.BP_TARGET
+FIRST_SYNC_BACKFILL_DAYS = 30
+REFETCH_OVERLAP_DAYS = 7
+GARMIN_SAME_TIME_TOLERANCE_SECONDS = 2
+# Mirrors garminconnect 0.3.17 set_blood_pressure's own range checks.
+GARMIN_BP_LIMITS = {"systolic": (70, 260), "diastolic": (40, 150), "pulse": (20, 250)}
+NOTES_DEVICE = "Omron M7"
+SKIPPED_OUT_OF_RANGE_RESPONSE = '{"skipped": "outside_garmin_range"}'
+
+
+@dataclass
+class BpSyncResult:
+    """Counts for one person's run. Holds no readings, so its repr is safe to log."""
+
+    fetched: int = 0
+    uploaded: int = 0                # in a dry run: would have uploaded
+    skipped_synced: int = 0
+    skipped_in_garmin: int = 0
+    skipped_out_of_range: int = 0
+    error: str | None = None         # plain text (safe_error_text) when an upload failed
+
+
+def _in_range(value, limits: tuple[int, int]) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool) and limits[0] <= value <= limits[1]
+
+
+def garmin_accepts(reading: BloodPressureReading) -> bool:
+    return (_in_range(reading.systolic, GARMIN_BP_LIMITS["systolic"])
+            and _in_range(reading.diastolic, GARMIN_BP_LIMITS["diastolic"])
+            and (reading.pulse is None or _in_range(reading.pulse, GARMIN_BP_LIMITS["pulse"])))
+
+
+def notes_for(reading: BloodPressureReading) -> str:
+    notes = NOTES_DEVICE
+    if reading.irregular_heartbeat:
+        notes += "; irregular heartbeat detected"
+    if reading.body_movement:
+        notes += "; body movement detected"
+    return notes
+
+
+def window_start(state: SyncState, user_name: str, backfill_days: int | None, now: datetime) -> datetime:
+    """How far back to ask OMRON for readings.
+
+    The first time, 30 days. After that, a week before the newest reading
+    already synced: a reading taken on Monday but only moved to the phone on
+    Thursday must not hide behind Tuesday's. The state database removes the overlap.
+    """
+    if backfill_days:
+        return now - timedelta(days=backfill_days)
+    latest = state.get_latest_sync_timestamp(user_name, BP_TARGET)
+    if latest is None:
+        logger.info("No prior blood pressure syncs for %s, backfilling %d days", user_name, FIRST_SYNC_BACKFILL_DAYS)
+        return now - timedelta(days=FIRST_SYNC_BACKFILL_DAYS)
+    return datetime.fromtimestamp(latest, timezone.utc) - timedelta(days=REFETCH_OVERLAP_DAYS)
+
+
+def safe_error_text(exc: BaseException) -> str:
+    """A failure as text that never carries a reading's values or a server's reply."""
+    if isinstance(exc, (PermanentSyncError, OmronError)):
+        return str(exc)            # our own messages: hosts, statuses and commands only
+    if isinstance(exc, GarminConnectTooManyRequestsError):
+        return "Garmin is asking us to slow down (HTTP 429). Wait an hour and sync again."
+    if isinstance(exc, GarminConnectAuthenticationError):
+        return "Garmin session expired. Run: homevitals --reauth garmin"
+    if isinstance(exc, GarminConnectConnectionError):
+        # Garmin appends the server's detail after " - "; it can echo the values we sent.
+        return f"Garmin upload failed ({str(exc).split(' - ', 1)[0]})"
+    if is_transient_network_error(str(exc)):
+        return str(exc)
+    if isinstance(exc, ValueError):
+        text = str(exc)
+        # Our own setup errors keep their wording; anything else came from the Garmin library's range check.
+        if "OMRON connect accounts created in" in text or "timezone-aware" in text:
+            return text
+        return "Garmin rejected a value (outside its accepted range)."
+    return f"Unexpected error ({type(exc).__name__}). Details are in the log file."
+
+
+def _retry_quietly(fn: Callable[[], T], description: str) -> T:
+    """sync._retry, but its log lines carry safe_error_text instead of the raw error."""
+    for attempt in range(MAX_RETRIES):
+        try:
+            return fn()
+        except Exception as e:
+            if _is_permanent(e) or isinstance(e, ValueError) or attempt == MAX_RETRIES - 1:
+                raise
+            delay = RETRY_BASE_DELAY * (2 ** attempt)
+            logger.warning("%s failed (attempt %d/%d): %s. Retrying in %ds...",
+                           description, attempt + 1, MAX_RETRIES, safe_error_text(e), delay)
+            time.sleep(delay)
+    raise AssertionError("unreachable")
+
+
+def _record(state: SyncState, user_name: str, reading: BloodPressureReading, response: str | None) -> None:
+    state.record_sync(
+        user_name, reading.reading_id, reading.timestamp.astimezone(timezone.utc).isoformat(), None,
+        datetime.now(timezone.utc).isoformat(), target=BP_TARGET, response=response,
+    )
+
+
+def sync_blood_pressure(user: UserConfig, state: SyncState, *, headless: bool = False, dry_run: bool = False,
+                        backfill_days: int | None = None, now: datetime | None = None) -> BpSyncResult | None:
+    """Move this person's new OMRON connect readings to their own Garmin account.
+
+    None when the person has no omron section. Login and fetch failures
+    raise (the caller reports them); a failed upload stops the loop and is
+    returned in result.error with the counts so far.
+    """
+    if user.omron is None:
+        return None
+    if user.garmin is None:
+        raise PermanentSyncError(f"Blood pressure for {user.name} has nowhere to go: add a garmin section.")
+
+    now = now or datetime.now(timezone.utc)
+    since = window_start(state, user.name, backfill_days, now)
+    result = BpSyncResult()
+    omron = OmronClient(user.omron)
+    garmin = GarminClient(user.garmin)
+    try:
+        omron.authenticate()
+        readings = _retry_quietly(lambda: omron.fetch_readings(since), "OMRON connect fetch")
+        result.fetched = len(readings)
+        candidates = sorted((r for r in readings if not state.is_synced(user.name, r.reading_id, BP_TARGET)),
+                            key=lambda r: r.timestamp)
+        result.skipped_synced = result.fetched - len(candidates)
+        if not candidates:
+            logger.info("No new blood pressure readings for %s", user.name)
+            return result
+
+        garmin.authenticate(allow_interactive=not headless)
+        # One day of padding each side: a reading's own local date can differ from this machine's.
+        existing = [] if dry_run else garmin.blood_pressure_instants(since.astimezone().date() - timedelta(days=1),
+                                                                      now.astimezone().date() + timedelta(days=1))
+        for reading in candidates:
+            if not garmin_accepts(reading):
+                result.skipped_out_of_range += 1
+                if not dry_run:
+                    _record(state, user.name, reading, SKIPPED_OUT_OF_RANGE_RESPONSE)
+                continue
+            if any(abs((reading.timestamp - inst).total_seconds()) <= GARMIN_SAME_TIME_TOLERANCE_SECONDS
+                   for inst in existing):
+                result.skipped_in_garmin += 1
+                if not dry_run:
+                    _record(state, user.name, reading, state_module.SKIPPED_IN_GARMIN_RESPONSE)
+                continue
+            if dry_run:
+                result.uploaded += 1
+                continue
+            try:
+                _retry_quietly(lambda r=reading: garmin.upload_blood_pressure(r, notes_for(r)),
+                               "Garmin blood pressure upload")
+            except ValueError:
+                # The library's own range check; belt and braces. Never adjusted.
+                result.skipped_out_of_range += 1
+                _record(state, user.name, reading, SKIPPED_OUT_OF_RANGE_RESPONSE)
+                continue
+            except Exception as e:
+                result.error = safe_error_text(e)
+                logger.error("Blood pressure upload failed for %s: %s", user.name, result.error)
+                break
+            _record(state, user.name, reading, None)
+            result.uploaded += 1
+            time.sleep(1)
+
+        logger.info("Blood pressure for %s: %d uploaded, %d already synced, %d already in Garmin, "
+                    "%d outside Garmin's range", user.name, result.uploaded, result.skipped_synced,
+                    result.skipped_in_garmin, result.skipped_out_of_range)
+        return result
+    finally:
+        for client in (omron, garmin):
+            try:
+                client.close()
+            except Exception:
+                logger.debug("Closing a client failed", exc_info=True)

homevitals-1.0.0/homevitals/cli/__init__.py

@@ -0,0 +1,3 @@
+from homevitals.cli.app import main
+
+__all__ = ["main"]