garsync 0.1.2__py3-none-any.whl

garsync/client.py

@@ -0,0 +1,169 @@
+import datetime
+import logging
+import os
+from typing import List, Optional
+
+from garminconnect import Garmin
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+from garsync.models import DailyBiometrics, NormalizedActivity, SleepData
+
+logger = logging.getLogger(__name__)
+
+
+class GarminClient:
+    """Wrapper for Garmin Connect API with token caching support."""
+
+    def __init__(self, email: str, password: str, token_store: Optional[str] = None):
+        self.email = email
+        self.password = password
+        self.token_store = token_store
+        self.client = Garmin(self.email, self.password)
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+    def login(self) -> None:
+        """Authenticate with Garmin Connect using tokens or credentials."""
+        try:
+            if self.token_store and os.path.exists(self.token_store):
+                logger.info(f"Attempting to login using tokens from {self.token_store}...")
+                self.client.login(self.token_store)
+                logger.info("Token-based authentication successful.")
+            else:
+                logger.info("Authenticating with Garmin Connect credentials...")
+                self.client.login()
+                logger.info("Authentication successful.")
+                if self.token_store:
+                    # Save tokens for next time
+                    os.makedirs(os.path.dirname(self.token_store), exist_ok=True)
+                    self.client.garth.save(self.token_store)
+                    logger.info(f"Session tokens saved to {self.token_store}")
+        except Exception as e:
+            logger.error(f"Failed to authenticate: {e}")
+            # If token login fails, try one more time with credentials (if they exist)
+            if self.token_store and os.path.exists(self.token_store):
+                logger.warning("Token login failed, falling back to credentials...")
+                try:
+                    self.client.login()
+                    if self.token_store:
+                        self.client.garth.save(self.token_store)
+                    return
+                except Exception as cred_err:
+                    logger.error(f"Fallback credential login also failed: {cred_err}")
+            raise
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+    def fetch_activities(self, start: int = 0, limit: int = 100) -> List[NormalizedActivity]:
+        logger.info(f"Fetching activities (start={start}, limit={limit})...")
+        raw_activities = self.client.get_activities(start, limit)
+        activities = []
+        for raw in raw_activities:
+            try:
+                # Convert timestamp from Garmin format
+                start_time_str = raw.get("startTimeLocal", raw.get("startTimeGMT"))
+                start_time = (
+                    datetime.datetime.fromisoformat(start_time_str) if start_time_str else None
+                )
+
+                activities.append(
+                    NormalizedActivity(
+                        activity_id=raw.get("activityId"),
+                        activity_name=raw.get("activityName"),
+                        activity_type=raw.get("activityType", {}).get("typeKey"),
+                        start_time=start_time,
+                        duration_seconds=raw.get("duration", 0.0),
+                        distance_meters=raw.get("distance"),
+                        average_heart_rate=raw.get("averageHR"),
+                        max_heart_rate=raw.get("maxHR"),
+                        calories=raw.get("calories"),
+                        raw_data=raw,
+                    )
+                )
+            except Exception as e:
+                logger.warning(f"Failed to parse activity {raw.get('activityId')}: {e}")
+        return activities
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+    def fetch_biometrics(self, date: datetime.date) -> DailyBiometrics:
+        logger.info(f"Fetching biometrics for {date}...")
+        try:
+            date_str = date.isoformat()
+            hr_data = self.client.get_heart_rates(date_str)
+            bb_data = self.client.get_body_battery(date_str)
+            stress_data = self.client.get_all_day_stress(date_str)
+            hrv_data = self.client.get_hrv_data(date_str)
+
+            # Helpers to safely extract data whether it's a list or dict
+            def get_dict(data):
+                if isinstance(data, list):
+                    return data[0] if data else {}
+                return data or {}
+
+            hr_dict = get_dict(hr_data)
+            bb_dict = get_dict(bb_data)
+            stress_dict = get_dict(stress_data)
+            hrv_dict = get_dict(hrv_data)
+
+            # Simple aggregations
+            rhr = hr_dict.get("restingHeartRate")
+
+            bb_values = [v for t, v in bb_dict.get("bodyBatteryValues", []) if v] if bb_dict else []
+            bb_highest = max(bb_values) if bb_values else None
+            bb_lowest = min(bb_values) if bb_values else None
+
+            stress_avg = stress_dict.get("averageStressLevel")
+            hrv_bal = hrv_dict.get("hrvSummary", {}).get("baselineStatus")
+
+            return DailyBiometrics(
+                date=date,
+                resting_heart_rate=rhr,
+                hrv_balance=hrv_bal,
+                body_battery_highest=bb_highest,
+                body_battery_lowest=bb_lowest,
+                stress_average=stress_avg,
+                raw_data={
+                    "hr": hr_data,
+                    "bb": bb_data,
+                    "stress": stress_data,
+                    "hrv": hrv_data,
+                },
+            )
+        except Exception as e:
+            logger.error(f"Failed to fetch biometrics for {date}: {e}")
+            raise
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
+    def fetch_sleep(self, date: datetime.date) -> SleepData:
+        logger.info(f"Fetching sleep data for {date}...")
+        try:
+            sleep_data = self.client.get_sleep_data(date.isoformat())
+
+            # Check if sleep data is available
+            daily_sleep = sleep_data.get("dailySleepDTO", {})
+            if not daily_sleep:
+                return SleepData(date=date, raw_data=sleep_data)
+
+            sleep_start = None
+            if start_timestamp := daily_sleep.get("sleepStartTimestampGMT"):
+                sleep_start = datetime.datetime.fromtimestamp(
+                    start_timestamp / 1000.0, datetime.UTC
+                )
+
+            sleep_end = None
+            if end_timestamp := daily_sleep.get("sleepEndTimestampGMT"):
+                sleep_end = datetime.datetime.fromtimestamp(end_timestamp / 1000.0, datetime.UTC)
+
+            return SleepData(
+                date=date,
+                sleep_start=sleep_start,
+                sleep_end=sleep_end,
+                total_sleep_seconds=daily_sleep.get("sleepTimeSeconds"),
+                deep_sleep_seconds=daily_sleep.get("deepSleepSeconds"),
+                light_sleep_seconds=daily_sleep.get("lightSleepSeconds"),
+                rem_sleep_seconds=daily_sleep.get("remSleepSeconds"),
+                awake_sleep_seconds=daily_sleep.get("awakeSleepSeconds"),
+                sleep_score=sleep_data.get("sleepScore", {}).get("value"),
+                raw_data=sleep_data,
+            )
+        except Exception as e:
+            logger.error(f"Failed to fetch sleep for {date}: {e}")
+            raise

garsync/db/__init__.py

@@ -0,0 +1,20 @@
+"""Database package for garsync — SQLite persistence layer."""
+
+from garsync.db.connection import get_connection
+from garsync.db.repository import (
+    ActivityRepository,
+    BiometricsRepository,
+    SleepRepository,
+    SyncLogRepository,
+)
+from garsync.db.schema import CURRENT_VERSION, init_db
+
+__all__ = [
+    "get_connection",
+    "init_db",
+    "CURRENT_VERSION",
+    "ActivityRepository",
+    "BiometricsRepository",
+    "SleepRepository",
+    "SyncLogRepository",
+]

garsync/db/connection.py

@@ -0,0 +1,19 @@
+"""SQLite connection management with WAL mode and Row factory."""
+
+import sqlite3
+
+
+def get_connection(db_path: str) -> sqlite3.Connection:
+    """Create a SQLite connection with WAL mode and Row factory.
+
+    Args:
+        db_path: Path to the database file, or ":memory:" for in-memory.
+
+    Returns:
+        Configured sqlite3.Connection.
+    """
+    conn = sqlite3.connect(db_path, check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    return conn

garsync/db/repository.py

@@ -0,0 +1,400 @@
+"""Repository classes for garsync SQLite tables.
+
+Each repository wraps a single table with upsert, query, and count operations.
+Connection is injected — the caller manages lifecycle and transactions.
+"""
+
+import sqlite3
+from typing import Any, Optional
+
+
+class ActivityRepository:
+    """CRUD operations for the activities table."""
+
+    def __init__(self, conn: sqlite3.Connection) -> None:
+        self._conn = conn
+
+    def upsert(self, row: dict[str, Any]) -> None:
+        """Insert or update an activity by activity_id."""
+        self._conn.execute(
+            """
+            INSERT INTO activities (
+                activity_id, activity_name, activity_type, start_time,
+                duration_seconds, distance_meters, average_heart_rate,
+                max_heart_rate, calories, raw_data
+            ) VALUES (
+                :activity_id, :activity_name, :activity_type, :start_time,
+                :duration_seconds, :distance_meters, :average_heart_rate,
+                :max_heart_rate, :calories, :raw_data
+            )
+            ON CONFLICT(activity_id) DO UPDATE SET
+                activity_name      = excluded.activity_name,
+                activity_type      = excluded.activity_type,
+                start_time         = excluded.start_time,
+                duration_seconds   = excluded.duration_seconds,
+                distance_meters    = excluded.distance_meters,
+                average_heart_rate = excluded.average_heart_rate,
+                max_heart_rate     = excluded.max_heart_rate,
+                calories           = excluded.calories,
+                raw_data           = excluded.raw_data,
+                updated_at         = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+            """,
+            row,
+        )
+        self._conn.commit()
+
+    def upsert_batch(self, rows: list[dict[str, Any]]) -> None:
+        """Upsert multiple activities in a single transaction."""
+        for row in rows:
+            self._conn.execute(
+                """
+                INSERT INTO activities (
+                    activity_id, activity_name, activity_type, start_time,
+                    duration_seconds, distance_meters, average_heart_rate,
+                    max_heart_rate, calories, raw_data
+                ) VALUES (
+                    :activity_id, :activity_name, :activity_type, :start_time,
+                    :duration_seconds, :distance_meters, :average_heart_rate,
+                    :max_heart_rate, :calories, :raw_data
+                )
+                ON CONFLICT(activity_id) DO UPDATE SET
+                    activity_name      = excluded.activity_name,
+                    activity_type      = excluded.activity_type,
+                    start_time         = excluded.start_time,
+                    duration_seconds   = excluded.duration_seconds,
+                    distance_meters    = excluded.distance_meters,
+                    average_heart_rate = excluded.average_heart_rate,
+                    max_heart_rate     = excluded.max_heart_rate,
+                    calories           = excluded.calories,
+                    raw_data           = excluded.raw_data,
+                    updated_at         = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+                """,
+                row,
+            )
+        self._conn.commit()
+
+    def get_by_id(self, activity_id: int) -> Optional[sqlite3.Row]:
+        """Get a single activity by ID, or None."""
+        cursor = self._conn.execute(
+            "SELECT * FROM activities WHERE activity_id = ?", (activity_id,)
+        )
+        row: Optional[sqlite3.Row] = cursor.fetchone()
+        return row
+
+    def get_all(self, limit: int = 1000) -> list[sqlite3.Row]:
+        """Get all activities, ordered by start_time DESC."""
+        cursor = self._conn.execute(
+            "SELECT * FROM activities ORDER BY start_time DESC LIMIT ?", (limit,)
+        )
+        result: list[sqlite3.Row] = cursor.fetchall()
+        return result
+
+    def count(self) -> int:
+        """Return total number of stored activities."""
+        cursor = self._conn.execute("SELECT COUNT(*) as cnt FROM activities")
+        cnt: int = cursor.fetchone()["cnt"]
+        return cnt
+
+    def get_paginated(
+        self,
+        page: int = 1,
+        limit: int = 20,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
+        activity_type: Optional[str] = None,
+    ) -> tuple[list[sqlite3.Row], int]:
+        """Get activities with pagination and optional filters.
+
+        Returns (rows, total_count).
+        """
+        where_clauses: list[str] = []
+        params: list[Any] = []
+
+        if start_date:
+            where_clauses.append("date(start_time) >= ?")
+            params.append(start_date)
+        if end_date:
+            where_clauses.append("date(start_time) <= ?")
+            params.append(end_date)
+        if activity_type:
+            where_clauses.append("activity_type = ?")
+            params.append(activity_type)
+
+        where_sql = ""
+        if where_clauses:
+            where_sql = "WHERE " + " AND ".join(where_clauses)
+
+        count_cursor = self._conn.execute(
+            f"SELECT COUNT(*) as cnt FROM activities {where_sql}",  # noqa: S608
+            params,
+        )
+        total: int = count_cursor.fetchone()["cnt"]
+
+        offset = (page - 1) * limit
+        cursor = self._conn.execute(
+            f"SELECT * FROM activities {where_sql} "  # noqa: S608
+            "ORDER BY start_time DESC LIMIT ? OFFSET ?",
+            [*params, limit, offset],
+        )
+        rows: list[sqlite3.Row] = cursor.fetchall()
+        return rows, total
+
+    def get_heatmap_data(
+        self,
+        year: int,
+        activity_type: Optional[str] = None,
+    ) -> list[sqlite3.Row]:
+        """Get per-day activity aggregates for a calendar year."""
+        params: list[Any] = [str(year)]
+        type_filter = ""
+        if activity_type:
+            type_filter = "AND activity_type = ?"
+            params.append(activity_type)
+
+        cursor = self._conn.execute(
+            f"""
+            SELECT
+                date(start_time) as date,
+                COUNT(*) as activity_count,
+                SUM(duration_seconds) as total_duration,
+                SUM(calories) as total_calories
+            FROM activities
+            WHERE strftime('%Y', start_time) = ?
+            {type_filter}
+            GROUP BY date(start_time)
+            ORDER BY date(start_time)
+            """,  # noqa: S608
+            params,
+        )
+        result: list[sqlite3.Row] = cursor.fetchall()
+        return result
+
+    def get_summary_stats(self, start_date: str, end_date: str) -> Optional[sqlite3.Row]:
+        """Get aggregate stats for a date range."""
+        cursor = self._conn.execute(
+            """
+            SELECT
+                COUNT(*) as total_activities,
+                COALESCE(SUM(duration_seconds), 0) as total_duration_seconds,
+                COALESCE(SUM(distance_meters), 0) as total_distance_meters,
+                COALESCE(SUM(calories), 0) as total_calories,
+                AVG(duration_seconds) as avg_duration_seconds,
+                AVG(distance_meters) as avg_distance_meters,
+                AVG(average_heart_rate) as avg_heart_rate
+            FROM activities
+            WHERE date(start_time) >= ? AND date(start_time) <= ?
+            """,
+            (start_date, end_date),
+        )
+        row: Optional[sqlite3.Row] = cursor.fetchone()
+        return row
+
+
+class BiometricsRepository:
+    """CRUD operations for the biometrics table."""
+
+    def __init__(self, conn: sqlite3.Connection) -> None:
+        self._conn = conn
+
+    def upsert(self, row: dict[str, Any]) -> None:
+        """Insert or update biometrics by date."""
+        self._conn.execute(
+            """
+            INSERT INTO biometrics (
+                date, resting_heart_rate, hrv_balance,
+                body_battery_highest, body_battery_lowest,
+                stress_average, raw_data
+            ) VALUES (
+                :date, :resting_heart_rate, :hrv_balance,
+                :body_battery_highest, :body_battery_lowest,
+                :stress_average, :raw_data
+            )
+            ON CONFLICT(date) DO UPDATE SET
+                resting_heart_rate   = excluded.resting_heart_rate,
+                hrv_balance          = excluded.hrv_balance,
+                body_battery_highest = excluded.body_battery_highest,
+                body_battery_lowest  = excluded.body_battery_lowest,
+                stress_average       = excluded.stress_average,
+                raw_data             = excluded.raw_data,
+                updated_at           = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+            """,
+            row,
+        )
+        self._conn.commit()
+
+    def get_by_date(self, date: str) -> Optional[sqlite3.Row]:
+        """Get biometrics for a specific date (ISO format string)."""
+        cursor = self._conn.execute("SELECT * FROM biometrics WHERE date = ?", (date,))
+        row: Optional[sqlite3.Row] = cursor.fetchone()
+        return row
+
+    def get_latest_date(self) -> Optional[str]:
+        """Return the most recent date with biometrics data, or None."""
+        cursor = self._conn.execute("SELECT date FROM biometrics ORDER BY date DESC LIMIT 1")
+        row = cursor.fetchone()
+        result: Optional[str] = row["date"] if row else None
+        return result
+
+    def count(self) -> int:
+        """Return total number of stored biometrics rows."""
+        cursor = self._conn.execute("SELECT COUNT(*) as cnt FROM biometrics")
+        cnt: int = cursor.fetchone()["cnt"]
+        return cnt
+
+    def get_by_date_range(self, start_date: str, end_date: str) -> list[sqlite3.Row]:
+        """Get biometrics rows within a date range (inclusive)."""
+        cursor = self._conn.execute(
+            "SELECT * FROM biometrics WHERE date >= ? AND date <= ? ORDER BY date",
+            (start_date, end_date),
+        )
+        result: list[sqlite3.Row] = cursor.fetchall()
+        return result
+
+    def get_avg_stats(self, start_date: str, end_date: str) -> Optional[sqlite3.Row]:
+        """Get average biometrics for a date range."""
+        cursor = self._conn.execute(
+            """
+            SELECT
+                COUNT(*) as record_count,
+                AVG(resting_heart_rate) as avg_resting_heart_rate,
+                AVG(stress_average) as avg_stress,
+                AVG(body_battery_highest) as avg_body_battery_high,
+                AVG(body_battery_lowest) as avg_body_battery_low
+            FROM biometrics
+            WHERE date >= ? AND date <= ?
+            """,
+            (start_date, end_date),
+        )
+        row: Optional[sqlite3.Row] = cursor.fetchone()
+        return row
+
+
+class SleepRepository:
+    """CRUD operations for the sleep table."""
+
+    def __init__(self, conn: sqlite3.Connection) -> None:
+        self._conn = conn
+
+    def upsert(self, row: dict[str, Any]) -> None:
+        """Insert or update sleep data by date."""
+        self._conn.execute(
+            """
+            INSERT INTO sleep (
+                date, sleep_start, sleep_end, total_sleep_seconds,
+                deep_sleep_seconds, light_sleep_seconds, rem_sleep_seconds,
+                awake_sleep_seconds, sleep_score, raw_data
+            ) VALUES (
+                :date, :sleep_start, :sleep_end, :total_sleep_seconds,
+                :deep_sleep_seconds, :light_sleep_seconds, :rem_sleep_seconds,
+                :awake_sleep_seconds, :sleep_score, :raw_data
+            )
+            ON CONFLICT(date) DO UPDATE SET
+                sleep_start         = excluded.sleep_start,
+                sleep_end           = excluded.sleep_end,
+                total_sleep_seconds = excluded.total_sleep_seconds,
+                deep_sleep_seconds  = excluded.deep_sleep_seconds,
+                light_sleep_seconds = excluded.light_sleep_seconds,
+                rem_sleep_seconds   = excluded.rem_sleep_seconds,
+                awake_sleep_seconds = excluded.awake_sleep_seconds,
+                sleep_score         = excluded.sleep_score,
+                raw_data            = excluded.raw_data,
+                updated_at          = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+            """,
+            row,
+        )
+        self._conn.commit()
+
+    def get_by_date(self, date: str) -> Optional[sqlite3.Row]:
+        """Get sleep data for a specific date (ISO format string)."""
+        cursor = self._conn.execute("SELECT * FROM sleep WHERE date = ?", (date,))
+        row: Optional[sqlite3.Row] = cursor.fetchone()
+        return row
+
+    def get_latest_date(self) -> Optional[str]:
+        """Return the most recent date with sleep data, or None."""
+        cursor = self._conn.execute("SELECT date FROM sleep ORDER BY date DESC LIMIT 1")
+        row = cursor.fetchone()
+        result: Optional[str] = row["date"] if row else None
+        return result
+
+    def count(self) -> int:
+        """Return total number of stored sleep rows."""
+        cursor = self._conn.execute("SELECT COUNT(*) as cnt FROM sleep")
+        cnt: int = cursor.fetchone()["cnt"]
+        return cnt
+
+    def get_by_date_range(self, start_date: str, end_date: str) -> list[sqlite3.Row]:
+        """Get sleep rows within a date range (inclusive)."""
+        cursor = self._conn.execute(
+            "SELECT * FROM sleep WHERE date >= ? AND date <= ? ORDER BY date",
+            (start_date, end_date),
+        )
+        result: list[sqlite3.Row] = cursor.fetchall()
+        return result
+
+    def get_avg_stats(self, start_date: str, end_date: str) -> Optional[sqlite3.Row]:
+        """Get average sleep stats for a date range."""
+        cursor = self._conn.execute(
+            """
+            SELECT
+                COUNT(*) as record_count,
+                AVG(total_sleep_seconds) as avg_sleep_seconds,
+                AVG(deep_sleep_seconds) as avg_deep_sleep_seconds,
+                AVG(light_sleep_seconds) as avg_light_sleep_seconds,
+                AVG(rem_sleep_seconds) as avg_rem_sleep_seconds,
+                AVG(sleep_score) as avg_sleep_score
+            FROM sleep
+            WHERE date >= ? AND date <= ?
+            """,
+            (start_date, end_date),
+        )
+        row: Optional[sqlite3.Row] = cursor.fetchone()
+        return row
+
+
+class SyncLogRepository:
+    """Append-only audit trail for sync operations."""
+
+    def __init__(self, conn: sqlite3.Connection) -> None:
+        self._conn = conn
+
+    def log(
+        self,
+        sync_type: str,
+        records_synced: int,
+        status: str = "success",
+        error_message: Optional[str] = None,
+    ) -> None:
+        """Append a sync log entry."""
+        self._conn.execute(
+            """
+            INSERT INTO sync_log (sync_type, records_synced, status, error_message)
+            VALUES (?, ?, ?, ?)
+            """,
+            (sync_type, records_synced, status, error_message),
+        )
+        self._conn.commit()
+
+    def get_latest(self, sync_type: Optional[str] = None) -> Optional[sqlite3.Row]:
+        """Get the most recent sync log entry, optionally filtered by type."""
+        if sync_type:
+            cursor = self._conn.execute(
+                "SELECT * FROM sync_log WHERE sync_type = ? ORDER BY id DESC LIMIT 1",
+                (sync_type,),
+            )
+        else:
+            cursor = self._conn.execute("SELECT * FROM sync_log ORDER BY id DESC LIMIT 1")
+        row: Optional[sqlite3.Row] = cursor.fetchone()
+        return row
+
+    def get_all(self, limit: int = 100) -> list[sqlite3.Row]:
+        """Get recent sync log entries."""
+        cursor = self._conn.execute("SELECT * FROM sync_log ORDER BY id DESC LIMIT ?", (limit,))
+        result: list[sqlite3.Row] = cursor.fetchall()
+        return result
+
+    def count(self) -> int:
+        """Return total number of sync log entries."""
+        cursor = self._conn.execute("SELECT COUNT(*) as cnt FROM sync_log")
+        cnt: int = cursor.fetchone()["cnt"]
+        return cnt