garmin sync first attempt

bincio/extract/garmin_sync.py

@@ -0,0 +1,196 @@
+"""Garmin Connect incremental sync — generator-based, mirrors strava_sync_iter.
+
+Sync state is stored in {user_dir}/garmin_sync.json:
+  {
+    "last_sync_at": "2026-04-12"   ← date of last successful sync (YYYY-MM-DD)
+  }
+
+We query Garmin for all activities from (last_sync_at - 1 day) to today,
+then skip any that already exist (FileExistsError from ingest_parsed).
+The -1 day buffer catches activities that were saved to Garmin slightly
+after their recorded end time crosses midnight.
+
+Each yielded dict has a ``type`` key:
+  - ``"fetching"``  — about to contact Garmin
+  - ``"progress"``  — one activity processed; keys: n, total, name, status, garmin_id
+  - ``"done"``      — final summary; keys: imported, skipped, error_count, errors
+  - ``"error"``     — fatal error; key: message
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import zipfile
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Generator
+
+_SYNC_FILE = "garmin_sync.json"
+
+
+# ── Sync state helpers ────────────────────────────────────────────────────────
+
+def _load_sync_state(user_dir: Path) -> dict:
+    p = user_dir / _SYNC_FILE
+    if not p.exists():
+        return {}
+    try:
+        return json.loads(p.read_text())
+    except Exception:
+        return {}
+
+
+def _save_sync_state(user_dir: Path, state: dict) -> None:
+    (user_dir / _SYNC_FILE).write_text(json.dumps(state, indent=2))
+
+
+# ── FIT extraction from ZIP ───────────────────────────────────────────────────
+
+def _extract_fit(zip_bytes: bytes) -> tuple[bytes, str]:
+    """Return (fit_bytes, filename) from a Garmin activity ZIP.
+
+    Garmin always packages the original FIT as the first .fit entry.
+    Raises ValueError if no FIT file is found.
+    """
+    with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
+        fit_names = [n for n in zf.namelist() if n.lower().endswith(".fit")]
+        if not fit_names:
+            raise ValueError(f"No FIT file in archive. Contents: {zf.namelist()}")
+        name = fit_names[0]
+        return zf.read(name), name
+
+
+# ── Main generator ────────────────────────────────────────────────────────────
+
+def garmin_sync_iter(
+    data_dir: Path,
+    user_dir: Path,
+) -> Generator[dict, None, None]:
+    """Fetch new activities from Garmin Connect and ingest them.
+
+    Args:
+        data_dir:  Root data directory (used for encryption key lookup).
+        user_dir:  Per-user directory (contains activities/, garmin_creds.json, etc.).
+    """
+    from bincio.extract.garmin_api import GarminError, get_client
+    from bincio.extract.ingest import ingest_parsed
+    from bincio.extract.parsers.fit import FitParser
+
+    # ── Login ──────────────────────────────────────────────────────────────────
+    try:
+        client = get_client(data_dir, user_dir)
+    except GarminError as exc:
+        yield {"type": "error", "message": str(exc)}
+        return
+
+    yield {"type": "fetching"}
+
+    # ── Determine date range ───────────────────────────────────────────────────
+    state = _load_sync_state(user_dir)
+    last = state.get("last_sync_at")
+
+    if last:
+        # Start one day before last sync to catch edge cases around midnight
+        start_dt = datetime.fromisoformat(last) - timedelta(days=1)
+    else:
+        # First sync: import everything Garmin has
+        start_dt = datetime(2000, 1, 1)
+
+    start_date = start_dt.strftime("%Y-%m-%d")
+    end_date   = datetime.now().strftime("%Y-%m-%d")
+
+    # ── Fetch activity list ────────────────────────────────────────────────────
+    try:
+        activities = client.get_activities_by_date(
+            startdate=start_date,
+            enddate=end_date,
+        )
+    except Exception as exc:
+        yield {"type": "error", "message": f"Failed to fetch activity list: {exc}"}
+        return
+
+    total      = len(activities)
+    imported   = 0
+    skipped    = 0
+    errors: list[str] = []
+    parser     = FitParser()
+
+    # ── Process each activity ──────────────────────────────────────────────────
+    for n, meta in enumerate(activities, 1):
+        garmin_id = meta.get("activityId")
+        name      = meta.get("activityName") or "Untitled"
+
+        try:
+            # Download original FIT (wrapped in a ZIP by Garmin)
+            try:
+                zip_bytes = client.download_activity(
+                    garmin_id,
+                    dl_fmt=client.ActivityDownloadFormat.ORIGINAL,
+                )
+            except Exception as exc:
+                raise RuntimeError(f"Download failed: {exc}") from exc
+
+            try:
+                fit_bytes, fit_name = _extract_fit(zip_bytes)
+            except Exception as exc:
+                raise RuntimeError(f"ZIP extraction failed: {exc}") from exc
+
+            # Parse FIT — pass a dummy Path so the parser has a filename for
+            # any format-detection logic; raw bytes are the actual data.
+            fake_path = Path(fit_name)
+            try:
+                parsed = parser.parse(fake_path, fit_bytes)
+            except Exception as exc:
+                raise RuntimeError(f"FIT parse error: {exc}") from exc
+
+            # Ingest — raises FileExistsError if already present (dedup)
+            ingest_parsed(parsed, user_dir)
+            imported += 1
+            yield {
+                "type": "progress",
+                "n": n, "total": total, "name": name,
+                "status": "imported",
+                "garmin_id": garmin_id,
+            }
+
+        except FileExistsError:
+            skipped += 1
+            yield {
+                "type": "progress",
+                "n": n, "total": total, "name": name,
+                "status": "skipped",
+                "garmin_id": garmin_id,
+            }
+
+        except Exception as exc:
+            errors.append(f"{garmin_id} ({name}): {type(exc).__name__}: {exc}")
+            yield {
+                "type": "progress",
+                "n": n, "total": total, "name": name,
+                "status": "error",
+                "garmin_id": garmin_id,
+            }
+
+    # ── Persist sync state ─────────────────────────────────────────────────────
+    state["last_sync_at"] = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    _save_sync_state(user_dir, state)
+
+    yield {
+        "type": "done",
+        "imported":    imported,
+        "skipped":     skipped,
+        "error_count": len(errors),
+        "errors":      errors[:5],
+    }
+
+
+def run_garmin_sync(data_dir: Path, user_dir: Path) -> dict:
+    """Blocking wrapper around garmin_sync_iter for non-SSE callers."""
+    result: dict = {}
+    for event in garmin_sync_iter(data_dir, user_dir):
+        if event["type"] == "done":
+            result = event
+        elif event["type"] == "error":
+            raise RuntimeError(event["message"])
+    return result