garsync 0.1.2__py3-none-any.whl

garsync/db/schema.py

@@ -0,0 +1,88 @@
+"""DDL definitions and schema migration for garsync SQLite database."""
+
+import sqlite3
+
+CURRENT_VERSION = 1
+
+_SCHEMA_V1 = """
+CREATE TABLE IF NOT EXISTS activities (
+    activity_id   INTEGER PRIMARY KEY,
+    activity_name TEXT,
+    activity_type TEXT,
+    start_time    TEXT,
+    duration_seconds REAL,
+    distance_meters  REAL,
+    average_heart_rate INTEGER,
+    max_heart_rate     INTEGER,
+    calories      REAL,
+    raw_data      TEXT,
+    created_at    TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at    TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS biometrics (
+    date               TEXT PRIMARY KEY,
+    resting_heart_rate INTEGER,
+    hrv_balance        TEXT,
+    body_battery_highest INTEGER,
+    body_battery_lowest  INTEGER,
+    stress_average     INTEGER,
+    raw_data           TEXT,
+    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS sleep (
+    date                TEXT PRIMARY KEY,
+    sleep_start         TEXT,
+    sleep_end           TEXT,
+    total_sleep_seconds INTEGER,
+    deep_sleep_seconds  INTEGER,
+    light_sleep_seconds INTEGER,
+    rem_sleep_seconds   INTEGER,
+    awake_sleep_seconds INTEGER,
+    sleep_score         INTEGER,
+    raw_data            TEXT,
+    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS sync_log (
+    id             INTEGER PRIMARY KEY AUTOINCREMENT,
+    sync_type      TEXT NOT NULL,
+    records_synced INTEGER NOT NULL DEFAULT 0,
+    status         TEXT NOT NULL DEFAULT 'success',
+    error_message  TEXT,
+    created_at     TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY
+);
+"""
+
+
+def _get_version(conn: sqlite3.Connection) -> int | None:
+    """Get current schema version, or None if table doesn't exist."""
+    try:
+        cursor = conn.execute("SELECT version FROM schema_version")
+        row = cursor.fetchone()
+        return row["version"] if row else None
+    except sqlite3.OperationalError:
+        return None
+
+
+def init_db(conn: sqlite3.Connection) -> None:
+    """Initialize database schema. Idempotent — safe to call repeatedly."""
+    current = _get_version(conn)
+    if current == CURRENT_VERSION:
+        return
+
+    conn.executescript(_SCHEMA_V1)
+
+    if current is None:
+        conn.execute(
+            "INSERT OR REPLACE INTO schema_version (version) VALUES (?)",
+            (CURRENT_VERSION,),
+        )
+        conn.commit()

garsync/exporter.py

@@ -0,0 +1,20 @@
+import logging
+from typing import TextIO
+
+from garsync.models import SyncResult
+
+logger = logging.getLogger(__name__)
+
+
+class JSONExporter:
+    @staticmethod
+    def export(result: SyncResult, output: TextIO) -> None:
+        """Export the sync result to the provided file object or stdout."""
+        try:
+            # Output using pydantic's JSON generation
+            output.write(result.model_dump_json(indent=2))
+            output.write("\n")
+            logger.info("Successfully exported sync result.")
+        except Exception as e:
+            logger.error(f"Failed to export data: {e}")
+            raise

garsync/models.py

@@ -0,0 +1,47 @@
+from datetime import date, datetime
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class NormalizedActivity(BaseModel):
+    activity_id: int
+    activity_name: Optional[str] = None
+    activity_type: Optional[str] = None
+    start_time: Optional[datetime] = None
+    duration_seconds: float
+    distance_meters: Optional[float] = None
+    average_heart_rate: Optional[int] = None
+    max_heart_rate: Optional[int] = None
+    calories: Optional[float] = None
+    raw_data: dict[str, Any] = Field(default_factory=dict, exclude=True)
+
+
+class DailyBiometrics(BaseModel):
+    date: date
+    resting_heart_rate: Optional[int] = None
+    hrv_balance: Optional[str] = None
+    body_battery_highest: Optional[int] = None
+    body_battery_lowest: Optional[int] = None
+    stress_average: Optional[int] = None
+    raw_data: dict[str, Any] = Field(default_factory=dict, exclude=True)
+
+
+class SleepData(BaseModel):
+    date: date
+    sleep_start: Optional[datetime] = None
+    sleep_end: Optional[datetime] = None
+    total_sleep_seconds: Optional[int] = None
+    deep_sleep_seconds: Optional[int] = None
+    light_sleep_seconds: Optional[int] = None
+    rem_sleep_seconds: Optional[int] = None
+    awake_sleep_seconds: Optional[int] = None
+    sleep_score: Optional[int] = None
+    raw_data: dict[str, Any] = Field(default_factory=dict, exclude=True)
+
+
+class SyncResult(BaseModel):
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    activities: list[NormalizedActivity] = Field(default_factory=list)
+    biometrics: list[DailyBiometrics] = Field(default_factory=list)
+    sleep: list[SleepData] = Field(default_factory=list)

garsync/pipeline.py

@@ -0,0 +1,128 @@
+"""Core synchronization pipeline logic."""
+
+import json
+import logging
+import sqlite3
+from datetime import date
+from typing import Any, Optional
+
+from garsync.client import GarminClient
+from garsync.db import (
+    ActivityRepository,
+    BiometricsRepository,
+    SleepRepository,
+    SyncLogRepository,
+)
+from garsync.models import DailyBiometrics, NormalizedActivity, SleepData
+
+logger = logging.getLogger(__name__)
+
+
+def activity_to_row(activity: NormalizedActivity) -> dict[str, Any]:
+    """Convert activity model to DB row dict."""
+    return {
+        "activity_id": activity.activity_id,
+        "activity_name": activity.activity_name,
+        "activity_type": activity.activity_type,
+        "start_time": activity.start_time.isoformat() if activity.start_time else None,
+        "duration_seconds": activity.duration_seconds,
+        "distance_meters": activity.distance_meters,
+        "average_heart_rate": activity.average_heart_rate,
+        "max_heart_rate": activity.max_heart_rate,
+        "calories": activity.calories,
+        "raw_data": json.dumps(activity.raw_data),
+    }
+
+
+def biometrics_to_row(bio: DailyBiometrics) -> dict[str, Any]:
+    """Convert biometrics model to DB row dict."""
+    return {
+        "date": bio.date.isoformat(),
+        "resting_heart_rate": bio.resting_heart_rate,
+        "hrv_balance": bio.hrv_balance,
+        "body_battery_highest": bio.body_battery_highest,
+        "body_battery_lowest": bio.body_battery_lowest,
+        "stress_average": bio.stress_average,
+        "raw_data": json.dumps(bio.raw_data),
+    }
+
+
+def sleep_to_row(sleep: SleepData) -> dict[str, Any]:
+    """Convert sleep model to DB row dict."""
+    return {
+        "date": sleep.date.isoformat(),
+        "sleep_start": sleep.sleep_start.isoformat() if sleep.sleep_start else None,
+        "sleep_end": sleep.sleep_end.isoformat() if sleep.sleep_end else None,
+        "total_sleep_seconds": sleep.total_sleep_seconds,
+        "deep_sleep_seconds": sleep.deep_sleep_seconds,
+        "light_sleep_seconds": sleep.light_sleep_seconds,
+        "rem_sleep_seconds": sleep.rem_sleep_seconds,
+        "awake_sleep_seconds": sleep.awake_sleep_seconds,
+        "sleep_score": sleep.sleep_score,
+        "raw_data": json.dumps(sleep.raw_data),
+    }
+
+
+class SyncService:
+    """Orchestrates the synchronization process between Garmin and SQLite."""
+
+    def __init__(self, client: GarminClient, db_conn: sqlite3.Connection):
+        self.client = client
+        self.db_conn = db_conn
+        self.activity_repo = ActivityRepository(db_conn)
+        self.biometrics_repo = BiometricsRepository(db_conn)
+        self.sleep_repo = SleepRepository(db_conn)
+        self.sync_log_repo = SyncLogRepository(db_conn)
+
+    def sync_range(self, dates: list[date], activities_limit: int = 100) -> dict[str, int]:
+        """Run a full sync for the given range of dates."""
+        results = {
+            "activities": 0,
+            "biometrics": 0,
+            "sleep": 0,
+            "errors": 0,
+        }
+
+        # 1. Activities (usually fetched in bulk, not per day)
+        try:
+            activities = self.client.fetch_activities(limit=activities_limit)
+            for activity in activities:
+                self.activity_repo.upsert(activity_to_row(activity))
+            results["activities"] = len(activities)
+            self.sync_log_repo.log("activities", len(activities), "success")
+        except Exception as e:
+            logger.error(f"Failed to sync activities: {e}")
+            self.sync_log_repo.log("activities", 0, "error", str(e))
+            results["errors"] += 1
+
+        # 2. Daily metrics (Biometrics and Sleep)
+        for d in dates:
+            date_str = d.isoformat()
+
+            # Biometrics
+            try:
+                bio = self.client.fetch_biometrics(d)
+                self.biometrics_repo.upsert(biometrics_to_row(bio))
+                results["biometrics"] += 1
+                self.sync_log_repo.log("biometrics", 1, "success")
+            except Exception as e:
+                logger.warning(f"Failed to sync biometrics for {date_str}: {e}")
+                self.sync_log_repo.log("biometrics", 0, "error", f"{date_str}: {e}")
+                results["errors"] += 1
+
+            # Sleep
+            try:
+                sleep = self.client.fetch_sleep(d)
+                self.sleep_repo.upsert(sleep_to_row(sleep))
+                results["sleep"] += 1
+                self.sync_log_repo.log("sleep", 1, "success")
+            except Exception as e:
+                logger.warning(f"Failed to sync sleep for {date_str}: {e}")
+                self.sync_log_repo.log("sleep", 0, "error", f"{date_str}: {e}")
+                results["errors"] += 1
+
+        return results
+
+    def get_latest_synced_date(self) -> Optional[str]:
+        """Get the most recent date present in the biometrics table."""
+        return self.biometrics_repo.get_latest_date()

garsync-0.1.2.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: garsync
+Version: 0.1.2
+Summary: 
+Author: Manu
+Author-email: mlorentedev@gmail.com
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: fastapi (>=0.115.0,<1.0.0)
+Requires-Dist: garminconnect (>=0.2.38,<0.3.0)
+Requires-Dist: pandas (<3)
+Requires-Dist: plotly (>=6.5.2,<7.0.0)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Requires-Dist: rich (>=14.3.3,<15.0.0)
+Requires-Dist: streamlit (>=1.54.0,<2.0.0)
+Requires-Dist: tenacity (>=9.1.4,<10.0.0)
+Requires-Dist: typer (>=0.24.1,<0.25.0)
+Requires-Dist: uvicorn[standard] (>=0.34.0,<1.0.0)
+Description-Content-Type: text/markdown
+
+# GarSync
+
+[![CI](https://github.com/mlorentedev/garsync/actions/workflows/ci.yml/badge.svg)](https://github.com/mlorentedev/garsync/actions)
+[![Docs](https://img.shields.io/badge/docs-live-brightgreen.svg)](https://mlorentedev.github.io/garsync/)
+[![Python](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/release/python-3120/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Personal fitness data pipeline that syncs Garmin Connect data to a local SQLite database and visualizes it through a modern Astro dashboard.
+
+> **Explore the full documentation at: [mlorentedev.github.io/garsync](https://mlorentedev.github.io/garsync/)**
+
+## The Problem
+
+Garmin Connect provides great data, but it's locked in a proprietary cloud.
+- **Data Silos:** Hard to export full history for custom analysis.
+- **Limited Visualization:** You are stuck with the official app's charts.
+- **No Local Ownership:** If you lose access or the service is down, your training history is gone.
+
+## Value Proposition
+
+| Feature | Garmin Connect App | GarSync |
+|---|---|---|
+| **Data Ownership** | Proprietary Cloud | Local SQLite (Full Control) |
+| **Customization** | Fixed Dashboards | Extensible Astro + Chart.js |
+| **Access** | Web/Mobile Only | REST API + SQL + CLI |
+| **Automation** | Manual Export | Scheduled Incremental Sync |
+
+## Quick Start
+
+### 1. Prerequisites
+- Python 3.12+ and [Poetry](https://python-poetry.org/)
+- Node.js 22+ (for the dashboard)
+- [SOPS](https://github.com/getsops/sops) + [Age](https://github.com/FiloSottile/age) (for secrets)
+
+### 2. Setup
+```bash
+make setup
+```
+
+### 3. Configure Secrets
+Edit your Garmin credentials using SOPS:
+```bash
+sops secrets.env.enc
+```
+
+### 4. Sync & Launch
+```bash
+make sync DAYS=30
+make dev
+```
+Visit `http://localhost:4321` (Dev UI).
+
+## Architecture
+
+```
+Garmin Connect Cloud → GarSync CLI → SQLite DB → FastAPI → Astro Dashboard
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+

garsync-0.1.2.dist-info/RECORD

@@ -0,0 +1,25 @@
+garsync/__init__.py,sha256=N4JzTlVpYSC8_19wA5Wvy2EiaFN3RFVazgKXt2kNTQk,54
+garsync/__main__.py,sha256=c7_Wqc0333GCquhDzrJlasL1w276YskcIrpN_FxnL48,66
+garsync/api/__init__.py,sha256=g1bknUtmuhDLueNqTbAVMFRmqnsQ1oKS7d0zTBfuJlA,114
+garsync/api/deps.py,sha256=8TIYd1uZLI1ZmupPzZQ4DgFnM7Vv5oJu_6k2Afx1gwI,1027
+garsync/api/main.py,sha256=vc6bVGb9hDwcl-nV0fO8zSPHMqQ090VuejlN8fCbzyc,2600
+garsync/api/routes/__init__.py,sha256=Y-_8J4QUygHeUp-gG7-xTsU9MQqX7sxdavkgXD2gYtk,41
+garsync/api/routes/activities.py,sha256=dMuyDs9F540o7mmmVUiQXsTe-RshSG-fK8Z6EK0q-Rs,1206
+garsync/api/routes/biometrics.py,sha256=fnVhrdIC4VEP8wnpm9eyTi8y5sTtw_RJtCFYlZXdp0c,845
+garsync/api/routes/sleep.py,sha256=NBGDbM58zFK1ThAtknX4Z5grwfyiUM1cvHvgNttjkJ0,791
+garsync/api/routes/stats.py,sha256=36ztYdPV_wdtxQeIaIjtNHmsN4AH4_EPiS_WzInRJi4,4398
+garsync/api/routes/sync.py,sha256=a2X-LjtgJAxg3K_oeJd4YsCzEhPHeSLahDSu1psZ9I0,1212
+garsync/api/schemas.py,sha256=i8gUUu0tPLuKQtjGbGPK1cx_I9HcEPtW7RX1rlH62VI,2884
+garsync/cli.py,sha256=OYSkns9LaUEsTN6pW83r_BYjdu2AVPhc8Rl6U71nH3E,4021
+garsync/client.py,sha256=0HUOOB_2mUdVD6CJIW3CYLUSym7ABVzz3PxqIm9-bfo,7518
+garsync/db/__init__.py,sha256=El1UnEtMRWJspbTAAJ-ryk1eh2ATgHG_mKex42Hc850,479
+garsync/db/connection.py,sha256=vLvu2WPIRnE9KtcpyE8EjK_rUTVjDAv0y2w7u0dYKIA,549
+garsync/db/repository.py,sha256=4pprxqNUMYYmM1iPKCR31CdtZJe81ZfCwtC8yZBiDQc,15973
+garsync/db/schema.py,sha256=jAFRTbKOhzQsJKRKw55Bqh1a7DhaOmzYzVqpPqi3BTc,2755
+garsync/exporter.py,sha256=hSa7jpmWV5LW3MDy6GP4xGDp6K1wiZpWy1LMVcvQBOU,618
+garsync/models.py,sha256=eAoNDHvrujg5v2Qxo_1CUhcaaVD3O_ihpHltk7b_jzs,1658
+garsync/pipeline.py,sha256=Fl5Q7o6WfKDdlvObXWGGqeQvFkVieJ08I3TFBsjqHOY,4919
+garsync-0.1.2.dist-info/METADATA,sha256=eBhAcJ6Ujed6wjITYrdyHRC1tRKyxEyK4sg9G7QwL5g,2785
+garsync-0.1.2.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+garsync-0.1.2.dist-info/entry_points.txt,sha256=42438UHL-jkL4CYPs09g_kZ90MYjQou1XAQ0yxasjIE,43
+garsync-0.1.2.dist-info/RECORD,,

garsync-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.3.1
+Root-Is-Purelib: true
+Tag: py3-none-any

garsync-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+garsync=garsync.cli:app
+