intervalssync 0.9.3__py3-none-any.whl

intervalssync/__init__.py

@@ -0,0 +1,3 @@
+"""intervalssync — sync cycling activities to intervals.icu."""
+
+from ._version import __version__

intervalssync/_dropbox_app_key.py

@@ -0,0 +1,7 @@
+"""Build-stamped Dropbox app key.
+
+Release builds may overwrite this file from IGPSYNC_DROPBOX_APP_KEY. Local
+development can also use the IGPSYNC_DROPBOX_APP_KEY environment variable.
+"""
+
+DROPBOX_APP_KEY = ""

intervalssync/_version.py

@@ -0,0 +1 @@
+__version__ = "0.9.3"

intervalssync/bryton/__init__.py

@@ -0,0 +1 @@
+"""Bryton Active package."""

intervalssync/bryton/api.py

@@ -0,0 +1,49 @@
+"""REST FIT download for Bryton Active (Android app API)."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import requests
+
+from .ddp import DEFAULT_HOST, BrytonSession
+
+DEFAULT_API_KEY = "UHIJdntFZFkZaVJsInRHfRcYES08Fwp0Bwkf"
+
+
+def download_fit_bytes(
+    activity_id: str,
+    session: BrytonSession,
+    *,
+    api_key: str = DEFAULT_API_KEY,
+) -> bytes:
+    """Download ride FIT bytes for activity_id."""
+    url = f"https://{session.host}/api/activity"
+    headers = {
+        "X-User-Id": session.user_id,
+        "X-Auth-Token": session.auth_token,
+        "x-api-key": api_key,
+        "User-Agent": "okhttp/4.12.0",
+        "Accept-Encoding": "gzip",
+    }
+    resp = requests.get(url, params={"id": activity_id}, headers=headers, timeout=120)
+    resp.raise_for_status()
+    data = resp.content
+    if len(data) < 14 or b".FIT" not in data[8:14]:
+        raise ValueError(
+            f"Response does not look like FIT ({len(data)} bytes, head={data[:16]!r})"
+        )
+    return data
+
+
+def download_fit_to_path(
+    activity_id: str,
+    session: BrytonSession,
+    dest_path: Path,
+    *,
+    api_key: str = DEFAULT_API_KEY,
+) -> Path:
+    """Download FIT file to dest_path."""
+    data = download_fit_bytes(activity_id, session, api_key=api_key)
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+    dest_path.write_bytes(data)
+    return dest_path

intervalssync/bryton/core.py

@@ -0,0 +1,249 @@
+"""Bryton Active → intervals.icu sync orchestration."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, datetime, timedelta, timezone
+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,
+    set_activity_type,
+    upload_fit_file,
+)
+from .api import download_fit_to_path
+from .ddp import DEFAULT_HOST, BrytonSession, list_activities, login
+from .exceptions import BrytonSyncError
+
+ACTIVITY_TYPE_KEEP = ""
+
+
+def external_id_for(activity_id: str) -> str:
+    return f"bryton_{activity_id}"
+
+
+def dropbox_filename_for(activity: "Activity", use_date: bool = True) -> str:
+    """Return the Dropbox filename for a Bryton activity."""
+    fallback = f"{external_id_for(activity.activity_id)}.fit"
+    if not use_date:
+        return fallback
+    try:
+        if activity.start_time <= 0:
+            raise ValueError("missing start time")
+        start = datetime.fromtimestamp(activity.start_time)
+    except (TypeError, ValueError, OSError):
+        return fallback
+    return f"{start:%y%m%d%H%M%S}.fit"
+
+
+@dataclass
+class Activity:
+    activity_id: str
+    title: str
+    start_time: int
+
+
+@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)
+
+
+Progress = Callable[[str], None]
+
+
+def _noop(_message: str) -> None:
+    pass
+
+
+def _activity_date_range(activities: list[Activity]) -> tuple[date, date]:
+    dates: list[date] = []
+    for act in activities:
+        try:
+            dates.append(datetime.fromtimestamp(act.start_time, tz=timezone.utc).date())
+        except (TypeError, ValueError, OSError):
+            continue
+    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:
+    bryton_email: str
+    bryton_password: str
+    intervals_api_key: str | None
+    dropbox_refresh_token: str | None = None
+    dropbox_app_key: str | None = None
+    host: str = DEFAULT_HOST
+    max_activities: int = 5
+    download_dir: Path = Path("downloads")
+    delete_after_upload: bool = True
+    force_resync: bool = False
+    activity_type: str = ACTIVITY_TYPE_KEEP
+    list_activities: bool = True
+    download_fit: bool = True
+    upload_intervals: bool = True
+    upload_dropbox: bool = False
+    dropbox_folder: str = DEFAULT_DROPBOX_FOLDER
+    dropbox_date_filenames: bool = True
+
+
+def _to_activity(doc: dict) -> Activity:
+    activity_id = doc.get("_id", "")
+    return Activity(
+        activity_id=activity_id,
+        title=doc.get("name") or doc.get("title") or f"Bryton {activity_id}",
+        start_time=int(doc.get("local_start_time") or 0),
+    )
+
+
+def sync(config: SyncConfig, progress: Progress | None = None) -> SyncResult:
+    """Download recent Bryton rides and upload to intervals.icu and/or Dropbox."""
+    report = progress or _noop
+    result = SyncResult()
+
+    report("Logging in to Bryton Active…")
+    session = login(config.bryton_email, config.bryton_password, host=config.host)
+    report("Logged in.")
+
+    raw_activities = list_activities(session, limit=config.max_activities)
+    activities = [_to_activity(doc) for doc in raw_activities]
+    result.activities = activities
+    result.listed = len(activities)
+
+    if config.list_activities:
+        report(f"Found {len(activities)} activities.")
+        for act in activities:
+            report(f"  • {act.activity_id} | {act.start_time} | {act.title}")
+
+    if not (config.download_fit or config.upload_intervals or config.upload_dropbox):
+        return result
+
+    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 "
+                "in this date range."
+            )
+        except requests.RequestException as exc:
+            report(f"⚠ Could not check intervals.icu (will process all): {exc}")
+
+    dropbox_uploaded_names: set[str] = set()
+    if config.upload_dropbox:
+        if not config.dropbox_app_key:
+            raise BrytonSyncError("Dropbox app key is required for Dropbox upload.")
+        if not config.dropbox_refresh_token:
+            raise BrytonSyncError("Connect Dropbox in Settings before syncing.")
+
+        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.activity_id)
+        fit_path = download_dir / f"{ext}.fit"
+        dropbox_filename = dropbox_filename_for(act, config.dropbox_date_filenames)
+
+        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.activity_id} — already on intervals.icu.")
+            result.skipped += 1
+        if config.upload_dropbox and not dropbox_needs_it:
+            report(f"↷ Skipping {act.activity_id} — already in Dropbox.")
+            result.skipped_dropbox += 1
+
+        if any_upload_enabled and not intervals_needs_it and not dropbox_needs_it:
+            continue
+
+        if config.download_fit or intervals_needs_it or dropbox_needs_it:
+            report(f"Downloading {act.activity_id}…")
+            try:
+                download_fit_to_path(act.activity_id, session, fit_path)
+            except (requests.RequestException, ValueError) as exc:
+                report(f"⚠ Could not download FIT for {act.activity_id}: {exc}")
+                result.failed += 1
+                continue
+            result.downloaded += 1
+
+        intervals_ok = True
+        if intervals_needs_it:
+            if not config.intervals_api_key:
+                raise BrytonSyncError("intervals.icu API key is required for upload.")
+
+            activity_id = upload_fit_file(
+                fit_path, act.title, ext, config.intervals_api_key
+            )
+            if activity_id:
+                report(f"✓ Uploaded {act.activity_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.activity_id} → {config.activity_type}")
+                    else:
+                        report(f"⚠ Could not set activity type for {act.activity_id}.")
+            else:
+                report(f"✗ Failed to upload {act.activity_id}.")
+                result.failed += 1
+                intervals_ok = False
+
+        dropbox_ok = True
+        if dropbox_needs_it:
+            report(f"Uploading {act.activity_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.activity_id}: {exc}")
+            else:
+                result.uploaded_dropbox += 1
+                report(f"✓ Uploaded {act.activity_id} to Dropbox")
+
+        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

intervalssync/bryton/ddp.py

@@ -0,0 +1,231 @@
+"""Meteor DDP login and activity listing for Bryton Active."""
+from __future__ import annotations
+
+import hashlib
+import json
+import random
+import string
+import threading
+from dataclasses import dataclass
+from typing import Any
+
+import requests
+
+from .exceptions import BrytonAuthError, BrytonDDPError
+
+DEFAULT_HOST = "m3.brytonactive.com"
+WEB_HOST = "active.brytonsport.com"
+DDP_CONNECT = {"msg": "connect", "version": "1", "support": ["1", "pre2", "pre1"]}
+
+
+@dataclass(frozen=True)
+class BrytonSession:
+    user_id: str
+    auth_token: str
+    host: str = DEFAULT_HOST
+
+
+class _DDPClient:
+    """Minimal synchronous Meteor DDP over SockJS/WebSocket."""
+
+    def __init__(self, host: str, *, timeout: float = 30.0) -> None:
+        self.host = host
+        self.timeout = timeout
+        self._ws = None
+        self._msg_id = 0
+        self._pending: dict[str, threading.Event] = {}
+        self._results: dict[str, tuple[Any, Any]] = {}
+        self._connected = threading.Event()
+        self._subs_ready: dict[str, threading.Event] = {}
+        self._collections: dict[str, dict[str, dict[str, Any]]] = {}
+        self._thread: threading.Thread | None = None
+
+    def _next_id(self) -> str:
+        self._msg_id += 1
+        return str(self._msg_id)
+
+    @staticmethod
+    def _sockjs_url(host: str) -> str:
+        requests.get(f"https://{host}/sockjs/info", timeout=20).raise_for_status()
+        server = str(random.randint(100, 999))
+        session = "".join(random.choices(string.ascii_lowercase + string.digits, k=8))
+        return f"wss://{host}/sockjs/{server}/{session}/websocket"
+
+    def _send(self, payload: dict[str, Any]) -> None:
+        frame = json.dumps([json.dumps(payload)])
+        self._ws.send(frame)
+
+    def _on_message(self, _ws: Any, message: str) -> None:
+        if message == "o":
+            self._send(DDP_CONNECT)
+            return
+        if message == "h":
+            return
+        if message.startswith("a"):
+            for item in json.loads(message[1:]):
+                self._handle(json.loads(item))
+
+    def _handle(self, msg: dict[str, Any]) -> None:
+        kind = msg.get("msg")
+        if kind == "connected":
+            self._connected.set()
+            return
+        if kind == "failed":
+            raise BrytonDDPError(f"DDP connect failed: {msg.get('reason', msg)}")
+        if kind == "result":
+            req_id = msg.get("id")
+            if req_id in self._pending:
+                self._results[req_id] = (msg.get("error"), msg.get("result"))
+                self._pending[req_id].set()
+            return
+        if kind == "added":
+            coll = msg["collection"]
+            self._collections.setdefault(coll, {})[msg["id"]] = dict(msg.get("fields", {}))
+            return
+        if kind == "ready":
+            for sub_id in msg.get("subs", []):
+                ready = self._subs_ready.get(sub_id)
+                if ready:
+                    ready.set()
+            return
+        if kind == "nosub":
+            raise BrytonDDPError(f"Subscription failed: {msg.get('id')} {msg}")
+        if kind == "removed":
+            coll = msg["collection"]
+            self._collections.get(coll, {}).pop(msg["id"], None)
+            return
+        if kind == "changed":
+            coll = msg["collection"]
+            doc = self._collections.setdefault(coll, {}).setdefault(msg["id"], {})
+            doc.update(msg.get("fields", {}))
+            for key in msg.get("unset", {}):
+                doc.pop(key, None)
+
+    def connect(self) -> None:
+        try:
+            import websocket  # type: ignore[import-untyped]
+        except ImportError as exc:
+            raise BrytonDDPError(
+                "websocket-client is required: uv pip install websocket-client"
+            ) from exc
+
+        url = self._sockjs_url(self.host)
+        self._ws = websocket.WebSocketApp(url, on_message=self._on_message)
+        self._thread = threading.Thread(
+            target=self._ws.run_forever,
+            kwargs={"ping_interval": 20, "ping_timeout": 10},
+            daemon=True,
+        )
+        self._thread.start()
+        if not self._connected.wait(self.timeout):
+            raise BrytonDDPError(f"DDP connect timed out ({self.host})")
+
+    def call(self, method: str, params: list[Any]) -> Any:
+        req_id = self._next_id()
+        event = threading.Event()
+        self._pending[req_id] = event
+        self._send({"msg": "method", "method": method, "params": params, "id": req_id})
+        if not event.wait(self.timeout):
+            raise BrytonDDPError(f"DDP method timed out: {method}")
+        error, result = self._results.pop(req_id)
+        self._pending.pop(req_id, None)
+        if error:
+            reason = error.get("reason") or error.get("message") or str(error)
+            if method == "login":
+                raise BrytonAuthError(reason)
+            raise BrytonDDPError(f"{method}: {reason}")
+        return result
+
+    def subscribe(self, name: str, params: list[Any] | None = None) -> None:
+        req_id = self._next_id()
+        ready = threading.Event()
+        self._subs_ready[req_id] = ready
+        self._send(
+            {
+                "msg": "sub",
+                "id": req_id,
+                "name": name,
+                "params": params or [],
+            }
+        )
+        if not ready.wait(self.timeout):
+            raise BrytonDDPError(f"Subscription timed out: {name}")
+        self._subs_ready.pop(req_id, None)
+
+    def close(self) -> None:
+        if self._ws:
+            self._ws.close()
+
+
+def _password_digest(password: str) -> dict[str, str]:
+    digest = hashlib.sha256(password.encode("utf-8")).hexdigest()
+    return {"digest": digest, "algorithm": "sha-256"}
+
+
+def login(email: str, password: str, *, host: str = DEFAULT_HOST) -> BrytonSession:
+    """Log in with Bryton Active email/password."""
+    client = _DDPClient(host)
+    try:
+        client.connect()
+        result = client.call(
+            "login",
+            [{"user": {"email": email}, "password": _password_digest(password)}],
+        )
+    finally:
+        client.close()
+
+    if not isinstance(result, dict) or not result.get("id") or not result.get("token"):
+        raise BrytonAuthError(f"Unexpected login response: {result!r}")
+
+    return BrytonSession(
+        user_id=result["id"],
+        auth_token=result["token"],
+        host=host,
+    )
+
+
+def _is_deleted_activity(fields: dict[str, Any]) -> bool:
+    if fields.get("_deleted"):
+        return True
+    label = fields.get("name") or fields.get("title") or ""
+    return label == "_deleted"
+
+
+def call_method(
+    session: BrytonSession,
+    method: str,
+    params: list[Any] | None = None,
+    *,
+    timeout: float = 60,
+) -> Any:
+    """Resume-login and invoke a Meteor DDP method."""
+    client = _DDPClient(session.host, timeout=timeout)
+    try:
+        client.connect()
+        client.call("login", [{"resume": session.auth_token}])
+        return client.call(method, params or [])
+    finally:
+        client.close()
+
+
+def list_activities(
+    session: BrytonSession,
+    *,
+    limit: int = 50,
+) -> list[dict[str, Any]]:
+    """Return recent activities from the activityList subscription."""
+    client = _DDPClient(session.host, timeout=60)
+    try:
+        client.connect()
+        client.call("login", [{"resume": session.auth_token}])
+        client.subscribe("activityList", [])
+        docs = client._collections.get("userActivities", {})
+        activities = [
+            {"_id": doc_id, **fields}
+            for doc_id, fields in docs.items()
+            if not _is_deleted_activity(fields)
+        ]
+        activities.sort(key=lambda a: a.get("local_start_time", 0), reverse=True)
+        return activities[:limit]
+    finally:
+        client.close()

intervalssync/bryton/exceptions.py

@@ -0,0 +1,13 @@
+"""Bryton-specific errors."""
+
+
+class BrytonSyncError(Exception):
+    """Base class for Bryton sync errors shown to users."""
+
+
+class BrytonAuthError(BrytonSyncError):
+    """Login failed."""
+
+
+class BrytonDDPError(BrytonSyncError):
+    """DDP transport or protocol failure."""