intervalssync 0.9.3__py3-none-any.whl

intervalssync/igpsport/core.py

@@ -0,0 +1,520 @@
+"""Pure sync logic for moving activities from iGPSPORT to intervals.icu.
+
+This module contains no UI and no module-level side effects — it is driven by
+the CLI and the GUI alike. Progress is surfaced through a callback so each
+front-end can render it however it likes.
+
+Flow (see CLAUDE.md for the full API notes):
+  1. Log in to iGPSPORT via the mobile auth API; reuse access_token as Bearer.
+  2. List activities via queryMyActivity (camelCase rideId / title / startTime).
+  3. Resolve the FIT download URL: try queryActivityDetail, fall back to
+     getDownloadUrl.
+  4. Download the .fit file and upload it to intervals.icu (basic auth with the
+     literal username "API_KEY").
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, datetime, timedelta
+from pathlib import Path
+from typing import Callable
+
+import requests
+
+from ..dropbox_client import (
+    DEFAULT_DROPBOX_FOLDER,
+    list_dropbox_fit_names,
+    upload_to_dropbox,
+)
+from ..intervals_icu import (
+    fetch_uploaded_external_ids as icu_fetch_uploaded_external_ids,
+    set_activity_type,
+    upload_fit_file,
+)
+
+from .region import INTERNATIONAL, IgpRegionConfig, resolve_region
+
+LOGIN_URL = INTERNATIONAL.login_url
+GATEWAY = INTERNATIONAL.gateway_base
+# iGPSPORT usually reports start times as "YYYY-MM-DD HH:MM:SS", but some
+# accounts/regions return date-only dotted forms like "2026.07.19".
+IGP_TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+IGP_TIME_FORMATS = (
+    IGP_TIME_FORMAT,
+    "%Y-%m-%d",
+    "%Y.%m.%d %H:%M:%S",
+    "%Y.%m.%d",
+)
+
+
+def parse_igp_start_time(value: str) -> datetime | None:
+    """Parse an iGPSPORT activity start time; return None if unrecognised."""
+    if not value or not isinstance(value, str):
+        return None
+    text = value.strip()
+    for fmt in IGP_TIME_FORMATS:
+        try:
+            return datetime.strptime(text, fmt)
+        except ValueError:
+            continue
+    return None
+
+# iGPSPORT exports every ride as the generic "Ride". intervals.icu doesn't take
+# a sport on upload, so we PUT the desired type afterwards. An empty activity
+# type means "leave the uploaded sport untouched" (do nothing). Any non-empty
+# value — including "Ride" — is applied via PUT.
+ACTIVITY_TYPE_KEEP = ""
+
+# Cycling subset of the intervals.icu SportInfo enum (api_value, label). The API
+# does NOT validate the string, so only ever send values from this list.
+CYCLING_ACTIVITY_TYPES: list[tuple[str, str]] = [
+    ("Ride", "Ride"),
+    ("MountainBikeRide", "Mountain Bike Ride"),
+    ("GravelRide", "Gravel Ride"),
+    ("VirtualRide", "Virtual Ride"),
+    ("EBikeRide", "E-Bike Ride"),
+    ("EMountainBikeRide", "E-Mountain Bike Ride"),
+    ("TrackRide", "Track Ride"),
+    ("Cyclocross", "Cyclocross"),
+    ("Handcycle", "Handcycle"),
+    ("Velomobile", "Velomobile"),
+]
+
+
+def external_id_for(ride_id: int) -> str:
+    """The intervals.icu external_id we assign to an iGPSPORT ride."""
+    return f"igpsport_{ride_id}"
+
+
+def dropbox_filename_for(activity: "Activity", use_date: bool = True) -> str:
+    """Return the Dropbox filename for an activity."""
+    fallback = f"{external_id_for(activity.ride_id)}.fit"
+    if not use_date:
+        return fallback
+    start = parse_igp_start_time(activity.start_time)
+    if start is None:
+        return fallback
+    return f"ride-0-{start:%Y-%m-%d-%H-%M-%S}.fit"
+
+
+class SyncError(Exception):
+    """Base class for errors the front-ends can show as friendly messages."""
+
+
+class AuthError(SyncError):
+    """Raised when iGPSPORT login fails or returns no usable token."""
+
+
+@dataclass
+class Activity:
+    ride_id: int
+    title: str
+    start_time: str
+
+
+@dataclass
+class SyncResult:
+    listed: int = 0
+    downloaded: int = 0
+    uploaded: int = 0
+    uploaded_dropbox: int = 0
+    skipped: int = 0
+    skipped_dropbox: int = 0
+    failed: int = 0
+    failed_dropbox: int = 0
+    activities: list[Activity] = field(default_factory=list)
+
+
+# A progress callback receives short, human-readable status events. It is
+# optional everywhere; the default is a no-op so core stays silent by itself.
+Progress = Callable[[str], None]
+
+
+def _noop(_message: str) -> None:
+    pass
+
+
+def login(
+    session: requests.Session,
+    user: str,
+    password: str,
+    region: IgpRegionConfig | str | None = None,
+) -> dict[str, str]:
+    """Authenticate and return auth headers carrying the Bearer token."""
+    cfg = resolve_region(region.name if isinstance(region, IgpRegionConfig) else region)
+    try:
+        return _login_bearer_token(session, cfg.login_url, user, password)
+    except AuthError as exc:
+        if cfg.name == "international":
+            raise AuthError(f"{exc}{_INTL_LOGIN_RETRY_HINT}") from exc
+        raise
+
+
+_CHINA_REGION_HINT = (
+    " If your account is registered on app.igpsport.cn, set region to China in Settings."
+)
+
+_INTL_LOGIN_RETRY_HINT = (
+    " Check your email and password (international accounts use your email)."
+    + _CHINA_REGION_HINT
+)
+
+
+def _login_bearer_token(
+    session: requests.Session,
+    login_url: str,
+    user: str,
+    password: str,
+) -> dict[str, str]:
+    """Mobile API login; returns Bearer headers from access_token JSON field."""
+    resp = session.post(
+        login_url,
+        json={"appId": "igpsport-web", "username": user, "password": password},
+    )
+    try:
+        body = resp.json()
+    except ValueError as exc:
+        raise AuthError(f"iGPSPORT login failed: HTTP {resp.status_code}, non-JSON body") from exc
+
+    if not isinstance(body, dict):
+        raise AuthError("iGPSPORT login returned an unexpected response")
+
+    data = body.get("data") or {}
+    token = data.get("access_token") if isinstance(data, dict) else None
+    if not token:
+        message = body.get("message") or f"HTTP {resp.status_code}"
+        raise AuthError(f"iGPSPORT login failed: {message}")
+
+    auth_headers = {"Authorization": f"Bearer {token}"}
+    session.headers.update(auth_headers)
+    return auth_headers
+
+
+def list_activities(
+    session: requests.Session,
+    max_activities: int,
+    region: IgpRegionConfig | str | None = None,
+) -> list[Activity]:
+    """Return the most recent activities, newest first, capped at max_activities."""
+    cfg = resolve_region(region.name if isinstance(region, IgpRegionConfig) else region)
+    return _list_activities_query(session, max_activities, cfg)
+
+
+def _list_activities_query(
+    session: requests.Session,
+    max_activities: int,
+    region: IgpRegionConfig,
+) -> list[Activity]:
+    """queryMyActivity across pages until max is reached or no more rows exist."""
+    # API responses are effectively paged in chunks of up to 20 items.
+    page_size = min(max_activities, 20)
+    activities: list[Activity] = []
+    page_no = 1
+
+    while len(activities) < max_activities:
+        resp = session.get(
+            region.activity_query_url,
+            params={
+                "pageNo": str(page_no),
+                "pageSize": str(page_size),
+                "sort": "1",
+                "reqType": "0",
+            },
+        )
+        resp.raise_for_status()
+
+        body = resp.json()
+        data = body.get("data") if isinstance(body, dict) else {}
+        rows = (data.get("rows") if isinstance(data, dict) else None) or []
+        if not rows:
+            break
+
+        for item in rows:
+            if len(activities) >= max_activities:
+                break
+            if not isinstance(item, dict):
+                continue
+            ride_id = item.get("rideId")
+            if ride_id is None:
+                ride_id = item.get("RideId")
+            if ride_id is None:
+                continue
+            activities.append(
+                Activity(
+                    ride_id=int(ride_id),
+                    title=item.get("title") or item.get("Title") or f"iGPSPORT {ride_id}",
+                    start_time=(
+                        item.get("startTime")
+                        or item.get("StartTime")
+                        or item.get("startTimeString")
+                        or item.get("StartTimeString")
+                        or "unknown date"
+                    ),
+                )
+            )
+
+        if len(rows) < page_size:
+            break
+
+        page_no += 1
+
+    return activities
+
+
+def resolve_fit_url(
+    session: requests.Session,
+    auth_headers: dict[str, str],
+    ride_id: int,
+    region: IgpRegionConfig | str | None = None,
+) -> str | None:
+    """Resolve a FIT download URL: try queryActivityDetail, then getDownloadUrl."""
+    cfg = resolve_region(region.name if isinstance(region, IgpRegionConfig) else region)
+    gateway = cfg.gateway_base
+
+    detail = session.get(
+        f"{gateway}/queryActivityDetail/{ride_id}", headers=auth_headers
+    )
+    if detail.ok:
+        fit_url = detail.json().get("data", {}).get("fitUrl")
+        if fit_url:
+            return fit_url
+
+    fallback = session.get(
+        f"{gateway}/getDownloadUrl/{ride_id}", headers=auth_headers
+    )
+    if fallback.ok:
+        return fallback.json().get("data")
+
+    return None
+
+
+def download_fit(fit_url: str, dest_path: Path) -> Path:
+    """Download a .fit file to dest_path and return the path."""
+    resp = requests.get(fit_url)
+    resp.raise_for_status()
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+    dest_path.write_bytes(resp.content)
+    return dest_path
+
+
+def upload_to_intervals(
+    fit_path: Path, title: str, ride_id: int, api_key: str
+) -> str | None:
+    """Upload a .fit file to intervals.icu; return the new activity id or None."""
+    return upload_fit_file(
+        fit_path, title, external_id_for(ride_id), api_key
+    )
+
+
+def fetch_uploaded_external_ids(
+    api_key: str, oldest: date, newest: date
+) -> set[str]:
+    """Return external_ids for rides already on intervals.icu in a date range."""
+    return icu_fetch_uploaded_external_ids(api_key, oldest, newest)
+
+
+def _activity_date_range(activities: list[Activity]) -> tuple[date, date]:
+    """Date window covering the activities, padded a day each side.
+
+    Falls back to a wide window if start times can't be parsed.
+    """
+    dates: list[date] = []
+    for act in activities:
+        start = parse_igp_start_time(act.start_time)
+        if start is not None:
+            dates.append(start.date())
+
+    if not dates:
+        today = date.today()
+        return today - timedelta(days=365), today + timedelta(days=1)
+
+    return min(dates) - timedelta(days=1), max(dates) + timedelta(days=1)
+
+
+@dataclass
+class SyncConfig:
+    igp_user: str
+    igp_password: str
+    intervals_api_key: str | None
+    igp_region: str = "international"
+    dropbox_refresh_token: str | None = None
+    dropbox_app_key: str | None = None
+    max_activities: int = 5
+    download_dir: Path = Path("downloads")
+    delete_after_upload: bool = True
+    # When False (default), skip activities already uploaded to intervals.icu.
+    # When True, re-download and re-upload them regardless.
+    force_resync: bool = False
+    # Sport to set on uploaded activities (intervals.icu doesn't accept it on
+    # upload). Empty string = leave the uploaded sport untouched.
+    activity_type: str = ACTIVITY_TYPE_KEEP
+    list_activities: bool = True
+    get_download_url: bool = False
+    download_fit: bool = False
+    upload_intervals: bool = False
+    upload_dropbox: bool = False
+    dropbox_folder: str = DEFAULT_DROPBOX_FOLDER
+    dropbox_date_filenames: bool = True
+
+
+def sync(config: SyncConfig, progress: Progress | None = None) -> SyncResult:
+    """Run the configured steps end-to-end, reporting progress via the callback."""
+    report = progress or _noop
+    result = SyncResult()
+
+    session = requests.Session()
+    region = resolve_region(config.igp_region)
+    report("Logging in to iGPSPORT…")
+    auth_headers = login(session, config.igp_user, config.igp_password, region)
+    report("Logged in.")
+
+    activities = list_activities(session, config.max_activities, region)
+    result.activities = activities
+    result.listed = len(activities)
+
+    if config.list_activities:
+        report(f"Found {len(activities)} activities.")
+        for act in activities:
+            report(f"  • {act.ride_id} | {act.start_time} | {act.title}")
+
+    needs_url = (
+        config.get_download_url
+        or config.download_fit
+        or config.upload_intervals
+        or config.upload_dropbox
+    )
+    if not needs_url:
+        return result
+
+    # Figure out which activities are already on intervals.icu so we can skip
+    # re-downloading them. Only relevant when uploading and not forcing a resync.
+    already_uploaded: set[str] = set()
+    if config.upload_intervals and not config.force_resync and config.intervals_api_key:
+        oldest, newest = _activity_date_range(activities)
+        try:
+            already_uploaded = fetch_uploaded_external_ids(
+                config.intervals_api_key, oldest, newest
+            )
+            report(
+                f"{len(already_uploaded)} activities already on intervals.icu "
+                f"in {oldest.isoformat()}…{newest.isoformat()}."
+            )
+        except requests.RequestException as exc:
+            report(f"⚠ Could not check intervals.icu (will process all): {exc}")
+
+    # Validate Dropbox prerequisites once, before processing any activity, so a
+    # misconfiguration fails fast instead of part-way through the loop.
+    dropbox_uploaded_names: set[str] = set()
+    if config.upload_dropbox:
+        if not config.dropbox_app_key:
+            raise SyncError("Dropbox app key is required for Dropbox upload.")
+        if not config.dropbox_refresh_token:
+            raise SyncError("Connect Dropbox in Settings before syncing.")
+
+        # Skip-tracking for Dropbox is independent of intervals.icu: list the
+        # FIT files already present in the folder so we don't re-upload them.
+        if not config.force_resync:
+            try:
+                dropbox_uploaded_names = list_dropbox_fit_names(
+                    config.dropbox_folder,
+                    config.dropbox_refresh_token,
+                    config.dropbox_app_key,
+                )
+                report(f"{len(dropbox_uploaded_names)} activities already in Dropbox.")
+            except Exception as exc:  # noqa: BLE001 — non-fatal; process all
+                report(f"⚠ Could not check Dropbox (will process all): {exc}")
+
+    download_dir = Path(config.download_dir)
+
+    any_upload_enabled = config.upload_intervals or config.upload_dropbox
+
+    for act in activities:
+        ext = external_id_for(act.ride_id)
+        fit_path = download_dir / f"{ext}.fit"
+        dropbox_filename = dropbox_filename_for(act, config.dropbox_date_filenames)
+
+        # Each target tracks its own "already there" state, so an activity can
+        # be uploaded to one target while being skipped on the other.
+        intervals_needs_it = config.upload_intervals and ext not in already_uploaded
+        dropbox_needs_it = (
+            config.upload_dropbox and dropbox_filename not in dropbox_uploaded_names
+        )
+
+        if config.upload_intervals and not intervals_needs_it:
+            report(f"↷ Skipping {act.ride_id} — already on intervals.icu.")
+            result.skipped += 1
+        if config.upload_dropbox and not dropbox_needs_it:
+            report(f"↷ Skipping {act.ride_id} — already in Dropbox.")
+            result.skipped_dropbox += 1
+
+        # Nothing left to do once every enabled upload target already has it.
+        if any_upload_enabled and not intervals_needs_it and not dropbox_needs_it:
+            continue
+
+        fit_url = resolve_fit_url(session, auth_headers, act.ride_id, region)
+        if not fit_url:
+            report(f"⚠ Could not resolve FIT URL for {act.ride_id}; skipping.")
+            result.failed += 1
+            continue
+
+        if config.get_download_url and not (
+            config.download_fit or config.upload_intervals or config.upload_dropbox
+        ):
+            report(f"FIT URL for {act.ride_id}: {fit_url}")
+            continue
+
+        report(f"Downloading {act.ride_id}…")
+        download_fit(fit_url, fit_path)
+        result.downloaded += 1
+
+        intervals_ok = True
+        if intervals_needs_it:
+            if not config.intervals_api_key:
+                raise SyncError("intervals.icu API key is required for upload.")
+
+            activity_id = upload_to_intervals(
+                fit_path, act.title, act.ride_id, config.intervals_api_key
+            )
+            if activity_id:
+                report(f"✓ Uploaded {act.ride_id}: {act.title}")
+                result.uploaded += 1
+
+                if config.activity_type:
+                    if set_activity_type(
+                        activity_id, config.activity_type, config.intervals_api_key
+                    ):
+                        report(f"↻ Set {act.ride_id} → {config.activity_type}")
+                    else:
+                        report(f"⚠ Could not set activity type for {act.ride_id}.")
+            else:
+                report(f"✗ Failed to upload {act.ride_id}.")
+                result.failed += 1
+                intervals_ok = False
+
+        dropbox_ok = True
+        if dropbox_needs_it:
+            report(f"Uploading {act.ride_id} to Dropbox…")
+            try:
+                upload_to_dropbox(
+                    fit_path,
+                    dropbox_filename,
+                    config.dropbox_refresh_token,
+                    config.dropbox_app_key,
+                    config.dropbox_folder,
+                )
+            except Exception as exc:  # noqa: BLE001 — surface provider failures
+                dropbox_ok = False
+                result.failed_dropbox += 1
+                report(f"⚠ Dropbox upload failed for {act.ride_id}: {exc}")
+            else:
+                result.uploaded_dropbox += 1
+                report(f"✓ Uploaded {act.ride_id} to Dropbox")
+
+        # Remove the local file only once every enabled target is satisfied, so
+        # a failure on either target keeps the file for a later retry.
+        if config.delete_after_upload and any_upload_enabled and intervals_ok and dropbox_ok:
+            fit_path.unlink(missing_ok=True)
+            report(f"  Removed local file {fit_path.name}")
+
+    return result