garsync 0.1.2__tar.gz

garsync-0.1.2/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,61 @@
+# 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/pyproject.toml

@@ -0,0 +1,62 @@
+[project]
+name = "garsync"
+version = "0.1.2"
+description = ""
+authors = [
+    {name = "Manu",email = "mlorentedev@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "garminconnect (>=0.2.38,<0.3.0)",
+    "pydantic (>=2.12.5,<3.0.0)",
+    "tenacity (>=9.1.4,<10.0.0)",
+    "typer (>=0.24.1,<0.25.0)",
+    "rich (>=14.3.3,<15.0.0)",
+    "pandas (<3)",
+    "streamlit (>=1.54.0,<2.0.0)",
+    "plotly (>=6.5.2,<7.0.0)",
+    "fastapi (>=0.115.0,<1.0.0)",
+    "uvicorn[standard] (>=0.34.0,<1.0.0)",
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[project.scripts]
+garsync = "garsync.cli:app"
+
+[dependency-groups]
+dev = [
+    "typer (>=0.24.1,<0.25.0)",
+    "rich (>=14.3.3,<15.0.0)",
+    "pydantic (>=2.12.5,<3.0.0)",
+    "pytest (>=9.0.2,<10.0.0)",
+    "pytest-cov (>=7.0.0,<8.0.0)",
+    "mypy (>=1.19.1,<2.0.0)",
+    "ruff (>=0.15.4,<0.16.0)",
+    "pytest-mock (>=3.0.0,<4.0.0)",
+    "httpx (>=0.28.0,<1.0.0)"
+]
+
+[tool.mypy]
+strict = true
+
+[[tool.mypy.overrides]]
+module = "garminconnect.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "garsync.client"
+disallow_untyped_calls = false
+disallow_untyped_defs = false
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100

garsync-0.1.2/src/garsync/__init__.py

@@ -0,0 +1,3 @@
+"""Garmin Sync Microservice"""
+
+__version__ = "0.1.2"

garsync-0.1.2/src/garsync/__main__.py

@@ -0,0 +1,4 @@
+from garsync.cli import app
+
+if __name__ == "__main__":
+    app()

garsync-0.1.2/src/garsync/api/__init__.py

@@ -0,0 +1,5 @@
+"""FastAPI application package for garsync."""
+
+from garsync.api.main import create_app
+
+__all__ = ["create_app"]

garsync-0.1.2/src/garsync/api/deps.py

@@ -0,0 +1,38 @@
+"""FastAPI dependency injection for database and repositories."""
+
+import sqlite3
+
+from fastapi import Request
+
+from garsync.db.repository import (
+    ActivityRepository,
+    BiometricsRepository,
+    SleepRepository,
+    SyncLogRepository,
+)
+
+
+def get_db(request: Request) -> sqlite3.Connection:
+    """Get the SQLite connection from app state."""
+    conn: sqlite3.Connection = request.app.state.db
+    return conn
+
+
+def get_activity_repo(request: Request) -> ActivityRepository:
+    """Factory for ActivityRepository."""
+    return ActivityRepository(get_db(request))
+
+
+def get_biometrics_repo(request: Request) -> BiometricsRepository:
+    """Factory for BiometricsRepository."""
+    return BiometricsRepository(get_db(request))
+
+
+def get_sleep_repo(request: Request) -> SleepRepository:
+    """Factory for SleepRepository."""
+    return SleepRepository(get_db(request))
+
+
+def get_sync_log_repo(request: Request) -> SyncLogRepository:
+    """Factory for SyncLogRepository."""
+    return SyncLogRepository(get_db(request))

garsync-0.1.2/src/garsync/api/main.py

@@ -0,0 +1,83 @@
+"""FastAPI application factory for garsync."""
+
+import os
+import sqlite3
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI, Request, Response, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from garsync.api.routes import activities, biometrics, sleep, stats, sync
+from garsync.db.connection import get_connection
+from garsync.db.schema import init_db
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Manage database connection lifecycle."""
+    db_path = os.environ.get("GARSYNC_DB_PATH", "data/garsync.db")
+    conn = get_connection(db_path)
+    init_db(conn)
+    app.state.db = conn
+    yield
+    conn.close()
+
+
+def create_app(conn: sqlite3.Connection | None = None) -> FastAPI:
+    """Create and configure the FastAPI application.
+
+    Args:
+        conn: Optional pre-configured connection (for testing).
+             If provided, lifespan is skipped.
+    """
+    if conn is not None:
+        app = FastAPI(title="GarSync API", version="0.1.0")
+        app.state.db = conn
+    else:
+        app = FastAPI(title="GarSync API", version="0.1.0", lifespan=lifespan)
+
+    # API Key Middleware
+    # API Key Middleware
+    api_key = os.environ.get("GARSYNC_API_KEY", "dev_key")
+
+    @app.middleware("http")
+    async def api_key_auth(request: Request, call_next: Any) -> Response:
+        if request.url.path.startswith("/api/"):
+            request_key = request.headers.get("X-API-KEY")
+            if request_key != api_key:
+                # Direct response for middleware
+                from fastapi.responses import JSONResponse
+
+                return JSONResponse(
+                    status_code=status.HTTP_403_FORBIDDEN,
+                    content={"detail": "Invalid or missing API Key"},
+                )
+        res: Response = await call_next(request)
+        return res
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.include_router(activities.router)
+    app.include_router(biometrics.router)
+    app.include_router(sleep.router)
+    app.include_router(stats.router)
+    app.include_router(sync.router)
+
+    static_dir = Path(__file__).resolve().parents[3] / "frontend" / "dist"
+    if static_dir.is_dir():
+        app.mount("/", StaticFiles(directory=str(static_dir), html=True), name="static")
+
+    return app
+
+
+app = create_app()

garsync-0.1.2/src/garsync/api/routes/__init__.py

@@ -0,0 +1 @@
+"""Route modules for the garsync API."""

garsync-0.1.2/src/garsync/api/routes/activities.py

@@ -0,0 +1,38 @@
+"""Activity endpoints."""
+
+from typing import Optional
+
+from fastapi import APIRouter, Depends, Query
+
+from garsync.api.deps import get_activity_repo
+from garsync.api.schemas import ActivityItem, PaginatedActivities
+from garsync.db.repository import ActivityRepository
+
+router = APIRouter(prefix="/api", tags=["activities"])
+
+
+@router.get("/activities", response_model=PaginatedActivities)
+def list_activities(
+    page: int = Query(default=1, ge=1),
+    limit: int = Query(default=20, ge=1, le=100),
+    start_date: Optional[str] = Query(default=None),
+    end_date: Optional[str] = Query(default=None),
+    activity_type: Optional[str] = Query(default=None),
+    repo: ActivityRepository = Depends(get_activity_repo),
+) -> PaginatedActivities:
+    """List activities with pagination and optional filters."""
+    rows, total = repo.get_paginated(
+        page=page,
+        limit=limit,
+        start_date=start_date,
+        end_date=end_date,
+        activity_type=activity_type,
+    )
+    items = [ActivityItem(**dict(row)) for row in rows]
+    return PaginatedActivities(
+        items=items,
+        total=total,
+        page=page,
+        limit=limit,
+        has_more=(page * limit) < total,
+    )

garsync-0.1.2/src/garsync/api/routes/biometrics.py

@@ -0,0 +1,26 @@
+"""Biometrics endpoints."""
+
+from fastapi import APIRouter, Depends, Query
+
+from garsync.api.deps import get_biometrics_repo
+from garsync.api.schemas import BiometricItem, BiometricsResponse
+from garsync.db.repository import BiometricsRepository
+
+router = APIRouter(prefix="/api", tags=["biometrics"])
+
+
+@router.get("/biometrics", response_model=BiometricsResponse)
+def list_biometrics(
+    start_date: str = Query(),
+    end_date: str = Query(),
+    repo: BiometricsRepository = Depends(get_biometrics_repo),
+) -> BiometricsResponse:
+    """List biometrics within a date range."""
+    rows = repo.get_by_date_range(start_date, end_date)
+    metrics = [BiometricItem(**dict(row)) for row in rows]
+    return BiometricsResponse(
+        metrics=metrics,
+        start_date=start_date,
+        end_date=end_date,
+        count=len(metrics),
+    )

garsync-0.1.2/src/garsync/api/routes/sleep.py

@@ -0,0 +1,26 @@
+"""Sleep endpoints."""
+
+from fastapi import APIRouter, Depends, Query
+
+from garsync.api.deps import get_sleep_repo
+from garsync.api.schemas import SleepItem, SleepResponse
+from garsync.db.repository import SleepRepository
+
+router = APIRouter(prefix="/api", tags=["sleep"])
+
+
+@router.get("/sleep", response_model=SleepResponse)
+def list_sleep(
+    start_date: str = Query(),
+    end_date: str = Query(),
+    repo: SleepRepository = Depends(get_sleep_repo),
+) -> SleepResponse:
+    """List sleep sessions within a date range."""
+    rows = repo.get_by_date_range(start_date, end_date)
+    sessions = [SleepItem(**dict(row)) for row in rows]
+    return SleepResponse(
+        sleep_sessions=sessions,
+        start_date=start_date,
+        end_date=end_date,
+        count=len(sessions),
+    )

garsync-0.1.2/src/garsync/api/routes/stats.py

@@ -0,0 +1,124 @@
+"""Stats endpoints — summary and heatmap."""
+
+from datetime import date, timedelta
+from typing import Optional
+
+from fastapi import APIRouter, Depends, Query
+
+from garsync.api.deps import get_activity_repo, get_biometrics_repo, get_sleep_repo
+from garsync.api.schemas import (
+    HeatmapDay,
+    HeatmapResponse,
+    HeatmapStatistics,
+    SummaryStats,
+)
+from garsync.db.repository import (
+    ActivityRepository,
+    BiometricsRepository,
+    SleepRepository,
+)
+
+router = APIRouter(prefix="/api/stats", tags=["stats"])
+
+
+def _resolve_dates(
+    period: str,
+    start_date: Optional[str],
+    end_date: Optional[str],
+) -> tuple[str, str]:
+    """Resolve start/end dates from period or explicit params."""
+    today = date.today()
+    if start_date and end_date:
+        return start_date, end_date
+    if period == "week":
+        start = today - timedelta(days=7)
+    elif period == "month":
+        start = today - timedelta(days=30)
+    else:
+        start = today - timedelta(days=30)
+    return start.isoformat(), today.isoformat()
+
+
+@router.get("/summary", response_model=SummaryStats)
+def summary(
+    period: str = Query(default="week"),
+    start_date: Optional[str] = Query(default=None),
+    end_date: Optional[str] = Query(default=None),
+    activity_repo: ActivityRepository = Depends(get_activity_repo),
+    biometrics_repo: BiometricsRepository = Depends(get_biometrics_repo),
+    sleep_repo: SleepRepository = Depends(get_sleep_repo),
+) -> SummaryStats:
+    """Get aggregated stats for a period."""
+    sd, ed = _resolve_dates(period, start_date, end_date)
+
+    activity_stats = activity_repo.get_summary_stats(sd, ed)
+    bio_stats = biometrics_repo.get_avg_stats(sd, ed)
+    sleep_stats = sleep_repo.get_avg_stats(sd, ed)
+
+    return SummaryStats(
+        period=period,
+        start_date=sd,
+        end_date=ed,
+        total_activities=activity_stats["total_activities"] if activity_stats else 0,
+        total_duration_seconds=activity_stats["total_duration_seconds"] if activity_stats else 0.0,
+        total_distance_meters=activity_stats["total_distance_meters"] if activity_stats else 0.0,
+        total_calories=activity_stats["total_calories"] if activity_stats else 0.0,
+        avg_duration_seconds=activity_stats["avg_duration_seconds"] if activity_stats else None,
+        avg_distance_meters=activity_stats["avg_distance_meters"] if activity_stats else None,
+        avg_heart_rate=activity_stats["avg_heart_rate"] if activity_stats else None,
+        avg_resting_heart_rate=bio_stats["avg_resting_heart_rate"] if bio_stats else None,
+        avg_stress=bio_stats["avg_stress"] if bio_stats else None,
+        avg_body_battery_high=bio_stats["avg_body_battery_high"] if bio_stats else None,
+        avg_sleep_seconds=sleep_stats["avg_sleep_seconds"] if sleep_stats else None,
+        avg_sleep_score=sleep_stats["avg_sleep_score"] if sleep_stats else None,
+    )
+
+
+def _compute_intensity(count: int, max_count: int) -> int:
+    """Map activity count to 0-5 intensity level."""
+    if count == 0 or max_count == 0:
+        return 0
+    ratio = count / max_count
+    if ratio <= 0.2:
+        return 1
+    if ratio <= 0.4:
+        return 2
+    if ratio <= 0.6:
+        return 3
+    if ratio <= 0.8:
+        return 4
+    return 5
+
+
+@router.get("/heatmap", response_model=HeatmapResponse)
+def heatmap(
+    year: Optional[int] = Query(default=None),
+    activity_type: Optional[str] = Query(default=None),
+    repo: ActivityRepository = Depends(get_activity_repo),
+) -> HeatmapResponse:
+    """Get activity heatmap data for a year."""
+    target_year = year or date.today().year
+    rows = repo.get_heatmap_data(target_year, activity_type)
+
+    max_count = max((row["activity_count"] for row in rows), default=0)
+    days = [
+        HeatmapDay(
+            date=row["date"],
+            activity_count=row["activity_count"],
+            total_duration=row["total_duration"],
+            total_calories=row["total_calories"],
+            intensity_level=_compute_intensity(row["activity_count"], max_count),
+        )
+        for row in rows
+    ]
+
+    total_activities = sum(d.activity_count for d in days)
+    return HeatmapResponse(
+        year=target_year,
+        days=days,
+        statistics=HeatmapStatistics(
+            total_active_days=len(days),
+            total_activities=total_activities,
+            max_daily_count=max_count,
+        ),
+    )

garsync-0.1.2/src/garsync/api/routes/sync.py

@@ -0,0 +1,38 @@
+"""Sync status endpoint."""
+
+from fastapi import APIRouter, Depends
+
+from garsync.api.deps import (
+    get_activity_repo,
+    get_biometrics_repo,
+    get_sleep_repo,
+    get_sync_log_repo,
+)
+from garsync.api.schemas import SyncStatus
+from garsync.db.repository import (
+    ActivityRepository,
+    BiometricsRepository,
+    SleepRepository,
+    SyncLogRepository,
+)
+
+router = APIRouter(prefix="/api", tags=["sync"])
+
+
+@router.get("/sync/status", response_model=SyncStatus)
+def sync_status(
+    activity_repo: ActivityRepository = Depends(get_activity_repo),
+    biometrics_repo: BiometricsRepository = Depends(get_biometrics_repo),
+    sleep_repo: SleepRepository = Depends(get_sleep_repo),
+    sync_log_repo: SyncLogRepository = Depends(get_sync_log_repo),
+) -> SyncStatus:
+    """Get current sync status and record counts."""
+    latest = sync_log_repo.get_latest()
+    return SyncStatus(
+        last_sync_time=latest["created_at"] if latest else None,
+        last_sync_status=latest["status"] if latest else None,
+        total_activities=activity_repo.count(),
+        total_biometrics=biometrics_repo.count(),
+        total_sleep=sleep_repo.count(),
+        total_sync_logs=sync_log_repo.count(),
+    )