intervalssync 0.9.3__tar.gz → 0.9.5__tar.gz

{intervalssync-0.9.3 → intervalssync-0.9.5}/.env.example

@@ -16,4 +16,6 @@ INTERVALSSYNC_IGPSPORT_PASSWORD=
 INTERVALSSYNC_IGPSPORT_REGION=international
 INTERVALSSYNC_BRYTON_EMAIL=
 INTERVALSSYNC_BRYTON_PASSWORD=
+# international (default) or china — use china for the China-region Bryton app
+INTERVALSSYNC_BRYTON_REGION=international
 INTERVALSSYNC_INTERVALS_API_KEY=

intervalssync-0.9.5/.github/scripts/publish_release.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+tag=${1:?usage: publish_release.sh TAG ASSET_DIRECTORY}
+asset_directory=${2:?usage: publish_release.sh TAG ASSET_DIRECTORY}
+
+if [[ ! -d "$asset_directory" ]]; then
+  echo "Asset directory does not exist: $asset_directory" >&2
+  exit 1
+fi
+
+mapfile -d '' assets < <(find "$asset_directory" -type f -print0 | sort -z)
+if (( ${#assets[@]} == 0 )); then
+  echo "No release assets found under $asset_directory" >&2
+  exit 1
+fi
+
+# Creating a draft first prevents users from seeing a release with missing
+# downloads. On a retry, reuse the existing draft and its completed assets.
+if ! gh release view "$tag" >/dev/null 2>&1; then
+  gh release create "$tag" --draft --generate-notes --verify-tag
+fi
+
+for asset in "${assets[@]}"; do
+  name=$(basename "$asset")
+
+  if gh release view "$tag" --json assets \
+    --jq '.assets[] | select(.state == "uploaded") | .name' | grep -Fxq "$name"; then
+    echo "Already uploaded: $name"
+    continue
+  fi
+
+  uploaded=false
+  for attempt in 1 2 3; do
+    echo "Uploading $name (attempt $attempt of 3)..."
+    if gh release upload "$tag" "$asset" --clobber; then
+      uploaded=true
+      break
+    fi
+
+    if (( attempt < 3 )); then
+      delay=$((attempt * 15))
+      echo "Upload failed; retrying $name in ${delay}s..." >&2
+      sleep "$delay"
+    fi
+  done
+
+  if [[ "$uploaded" != true ]]; then
+    echo "Failed to upload $name after 3 attempts." >&2
+    exit 1
+  fi
+done
+
+# Tags with a hyphen are prereleases. Publish only after every asset succeeds,
+# so a failed job remains a recoverable draft rather than a partial release.
+if [[ "$tag" == *-* ]]; then
+  gh release edit "$tag" --draft=false --prerelease --latest=false
+else
+  gh release edit "$tag" --draft=false --prerelease=false --latest
+fi

{intervalssync-0.9.3 → intervalssync-0.9.5}/.github/workflows/release.yml

@@ -214,22 +214,17 @@ jobs:
     needs: [windows, android, macos]
     runs-on: ubuntu-latest
     steps:
+      - uses: actions/checkout@v4
+
       - name: Download build artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
           path: dist
 
-      # Create (or update) the Release for this tag, attach all files, and
-      # generate the notes a single time (avoids the duplicate notes you get
-      # when each build job generates them).
-      #
-      # Tags with a hyphen (e.g. v0.3.0-rc1) are marked as pre-releases: GitHub
-      # keeps the last stable as "Latest", the in-app update check (which uses
-      # the /releases/latest API) ignores them, and they aren't offered to users.
-      - name: Publish Release
-        uses: softprops/action-gh-release@v2
-        with:
-          files: dist/**/*
-          generate_release_notes: true
-          prerelease: ${{ contains(github.ref_name, '-') }}
-          make_latest: ${{ !contains(github.ref_name, '-') }}
+      # Keep the release as a draft until every asset is uploaded. The helper
+      # uploads one file at a time and retries failures without replacing assets
+      # that already completed in an earlier attempt.
+      - name: Upload and publish Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: bash .github/scripts/publish_release.sh "${{ github.ref_name }}" dist

{intervalssync-0.9.3 → intervalssync-0.9.5}/CLAUDE.md

@@ -33,7 +33,7 @@ src/intervalssync/
   cli/main.py, env.py, config.py                 # headless CLI
   gui/app.py, views, config.py, secrets.py       # Flet UI (dual-source: iGPSPORT + Bryton)
   igpsport/core.py, workout.py                   # iGPSPORT source
-  bryton/ddp.py, api.py, core.py                 # Bryton source
+  bryton/ddp.py, api.py, core.py, region.py      # Bryton source
   intervals_icu.py, dropbox_client.py            # shared by sources
 ```
 
@@ -41,8 +41,8 @@ src/intervalssync/
 - **`igpsport/core.py`** — `sync(SyncConfig, progress)`: login → list → FIT URL → download → upload. `external_id`: `igpsport_{ride_id}`.
 - **`igpsport/profile_sync.py`** — `sync_profile_zones`: intervals.icu sport settings + athlete weight → iGPSPORT profile thresholds/zones/weight.
 - **`igpsport/workout.py`** — planned workouts intervals.icu → iGPSPORT.
-- **`bryton/ddp.py`** — Meteor DDP login + `activityList` subscription.
-- **`bryton/api.py`** — `GET https://m3.brytonactive.com/api/activity?id=…` (FIT download; Android app API).
+- **`bryton/ddp.py`** — Meteor DDP login + `activityList` subscription. `region.py` holds the international vs China endpoints.
+- **`bryton/api.py`** — `GET https://{session.host}/api/activity?id=…` (FIT download; Android app API).
 - **`bryton/core.py`** — `sync(SyncConfig, progress)`. `external_id`: `bryton_{activity_id}`.
 - **`gui/secrets.py`** — async OS vault via `flet-secure-storage`.
 - **`gui/config.py`** — GUI JSON settings: `enable_igpsport` / `enable_bryton`, per-source usernames, shared sync options.
@@ -58,9 +58,11 @@ src/intervalssync/
 
 ## Bryton API notes
 
-1. Login: Meteor DDP `login` with email + SHA-256 password digest on `m3.brytonactive.com`.
+1. Login: Meteor DDP `login` with email + SHA-256 password digest on `m3.brytonactive.com` (international) or `active.cn.brytonactive.com` (China).
 2. List: subscribe `activityList` → `userActivities` collection.
 3. FIT: REST `GET /api/activity?id={_id}` with `X-User-Id`, `X-Auth-Token`, static `x-api-key` (not the web `activity.detail.2` samples API).
+4. Workouts: POST `https://{web_host}/workout/upload/{user_id}` (`active.brytonsport.com` international, `active.cn.brytonactive.com` China).
+5. **Regions are fully separate account databases.** An account created in one region returns `User not found` in the other. GUI `bryton_region`; CLI `INTERVALSSYNC_BRYTON_REGION=international|china`.
 
 ## Flet version note
 

{intervalssync-0.9.3 → intervalssync-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: intervalssync
-Version: 0.9.3
+Version: 0.9.5
 Summary: Sync cycling activities from iGPSPORT or Bryton Active to intervals.icu
 Project-URL: Homepage, https://github.com/jorge-huxley/intervalssync
 Project-URL: Repository, https://github.com/jorge-huxley/intervalssync
@@ -87,6 +87,7 @@ Description-Content-Type: text/markdown
 - **Sync zones to iGPSPORT** — push FTP, LTHR, max HR, weight, and power/HR zones from intervals.icu into your iGPSPORT profile (Settings → iGPSPORT profile, or `intervalssync sync-zones`; the app prompts on launch when thresholds differ)
 - **Headless CLI** — activity sync, workout upload, and iGPSPORT zone/threshold sync from the terminal, with JSON output and exit codes for automation and AI agents (see [CLI & automation](#cli--automation-ai-agents))
 - **China iGPSPORT region** — accounts on [app.igpsport.cn](https://app.igpsport.cn/login) use a separate API; choose **China** in Settings (or `INTERVALSSYNC_IGPSPORT_REGION=china` in the CLI)
+- **China Bryton region** — accounts created in the China-region Bryton app use a separate backend; choose **China** in Settings (or `INTERVALSSYNC_BRYTON_REGION=china` in the CLI)
 
 > Prefer the terminal, or want to help out? It's open source (Python + [Flet](https://flet.dev), MIT) — see [CONTRIBUTING.md](CONTRIBUTING.md).
 
@@ -96,6 +97,7 @@ Description-Content-Type: text/markdown
 2. Unzip it anywhere and double-click the app (e.g. `intervalssync.exe`).
 3. On first launch, open **Settings** and enter:
    - your iGPSPORT **email** and **password** (or **phone number** for China — set region to China if you use [app.igpsport.cn](https://app.igpsport.cn/login))
+   - for Bryton Active, your **email** and **password** and the matching **region** (International or China)
    - your intervals.icu **API key** (intervals.icu → Settings → Developer)
 4. Click **Save**, then go back and press **Sync** (or **Upload to iGPSPORT** / **Upload to Bryton** for planned sessions on your intervals.icu calendar).
 

{intervalssync-0.9.3 → intervalssync-0.9.5}/README.md

@@ -66,6 +66,7 @@
 - **Sync zones to iGPSPORT** — push FTP, LTHR, max HR, weight, and power/HR zones from intervals.icu into your iGPSPORT profile (Settings → iGPSPORT profile, or `intervalssync sync-zones`; the app prompts on launch when thresholds differ)
 - **Headless CLI** — activity sync, workout upload, and iGPSPORT zone/threshold sync from the terminal, with JSON output and exit codes for automation and AI agents (see [CLI & automation](#cli--automation-ai-agents))
 - **China iGPSPORT region** — accounts on [app.igpsport.cn](https://app.igpsport.cn/login) use a separate API; choose **China** in Settings (or `INTERVALSSYNC_IGPSPORT_REGION=china` in the CLI)
+- **China Bryton region** — accounts created in the China-region Bryton app use a separate backend; choose **China** in Settings (or `INTERVALSSYNC_BRYTON_REGION=china` in the CLI)
 
 > Prefer the terminal, or want to help out? It's open source (Python + [Flet](https://flet.dev), MIT) — see [CONTRIBUTING.md](CONTRIBUTING.md).
 
@@ -75,6 +76,7 @@
 2. Unzip it anywhere and double-click the app (e.g. `intervalssync.exe`).
 3. On first launch, open **Settings** and enter:
    - your iGPSPORT **email** and **password** (or **phone number** for China — set region to China if you use [app.igpsport.cn](https://app.igpsport.cn/login))
+   - for Bryton Active, your **email** and **password** and the matching **region** (International or China)
    - your intervals.icu **API key** (intervals.icu → Settings → Developer)
 4. Click **Save**, then go back and press **Sync** (or **Upload to iGPSPORT** / **Upload to Bryton** for planned sessions on your intervals.icu calendar).
 

{intervalssync-0.9.3 → intervalssync-0.9.5}/docs/AGENT.md

@@ -43,6 +43,12 @@ echo 'INTERVALSSYNC_INTERVALS_API_KEY=your-intervals-api-key' >> ~/.hermes/.env
 chmod 600 ~/.hermes/.env
 ```
 
+For **China-region** accounts (the 百锐腾运动 app / [www.brytonsports.cn](http://www.brytonsports.cn)), add:
+
+```bash
+echo 'INTERVALSSYNC_BRYTON_REGION=china' >> ~/.hermes/.env
+```
+
 For a named Hermes profile, use `$HERMES_HOME/.env` (that profile's directory).
 
 **intervals.icu API key:** intervals.icu → Settings → Developer.
@@ -176,7 +182,7 @@ Non-secret defaults in `intervalssync-cli` `config.json` (`platformdirs`). Secre
 ### Activity sync
 
 - **iGPSPORT:** list → FIT URL → download → upload (`igpsport_{ride_id}` external_id).
-- **Bryton:** DDP login → activity list → `GET /api/activity?id=…` FIT → upload (`bryton_{id}` external_id).
+- **Bryton:** DDP login → activity list → `GET /api/activity?id=…` FIT → upload (`bryton_{id}` external_id). International uses `m3.brytonactive.com`; China uses `active.cn.brytonactive.com` (set `INTERVALSSYNC_BRYTON_REGION=china`).
 - Skips already on intervals.icu unless `--force-resync`.
 - **Dropbox** is GUI-only (Settings → connect Dropbox, enable upload). iGPSPORT
   uses `ride-0-YYYY-MM-DD-HH-MM-SS.fit` or `igpsport_{id}.fit`; Bryton uses

{intervalssync-0.9.3 → intervalssync-0.9.5}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "intervalssync"
 # Placeholder. The real version comes from the git tag, injected by CI at build
 # time (see .github/workflows/release.yml). Local/dev builds report 0.0.0+dev.
-version = "0.9.3"
+version = "0.9.5"
 description = "Sync cycling activities from iGPSPORT or Bryton Active to intervals.icu"
 readme = "README.md"
 license = "MIT"

intervalssync-0.9.5/src/intervalssync/_version.py

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

{intervalssync-0.9.3 → intervalssync-0.9.5}/src/intervalssync/bryton/core.py

@@ -19,8 +19,9 @@ from ..intervals_icu import (
     upload_fit_file,
 )
 from .api import download_fit_to_path
-from .ddp import DEFAULT_HOST, BrytonSession, list_activities, login
+from .ddp import BrytonSession, list_activities, login
 from .exceptions import BrytonSyncError
+from .region import resolve_region
 
 ACTIVITY_TYPE_KEEP = ""
 
@@ -90,7 +91,9 @@ class SyncConfig:
     intervals_api_key: str | None
     dropbox_refresh_token: str | None = None
     dropbox_app_key: str | None = None
-    host: str = DEFAULT_HOST
+    # Explicit endpoint override; normally resolved from bryton_region.
+    host: str | None = None
+    bryton_region: str = "international"
     max_activities: int = 5
     download_dir: Path = Path("downloads")
     delete_after_upload: bool = True
@@ -118,8 +121,17 @@ def sync(config: SyncConfig, progress: Progress | None = None) -> SyncResult:
     report = progress or _noop
     result = SyncResult()
 
+    try:
+        region = resolve_region(config.bryton_region)
+    except ValueError as exc:
+        raise BrytonSyncError(str(exc)) from exc
+
     report("Logging in to Bryton Active…")
-    session = login(config.bryton_email, config.bryton_password, host=config.host)
+    session = login(
+        config.bryton_email,
+        config.bryton_password,
+        host=config.host or region.host,
+    )
     report("Logged in.")
 
     raw_activities = list_activities(session, limit=config.max_activities)
@@ -205,10 +217,11 @@ def sync(config: SyncConfig, progress: Progress | None = None) -> SyncResult:
             if not config.intervals_api_key:
                 raise BrytonSyncError("intervals.icu API key is required for upload.")
 
-            activity_id = upload_fit_file(
+            upload_result = upload_fit_file(
                 fit_path, act.title, ext, config.intervals_api_key
             )
-            if activity_id:
+            if upload_result:
+                activity_id = upload_result.activity_id
                 report(f"✓ Uploaded {act.activity_id}: {act.title}")
                 result.uploaded += 1
                 if config.activity_type:

{intervalssync-0.9.3 → intervalssync-0.9.5}/src/intervalssync/bryton/ddp.py

@@ -12,9 +12,12 @@ from typing import Any
 import requests
 
 from .exceptions import BrytonAuthError, BrytonDDPError
+from .region import INTERNATIONAL
 
-DEFAULT_HOST = "m3.brytonactive.com"
-WEB_HOST = "active.brytonsport.com"
+# Backwards-compatible aliases for the international endpoints. Region-aware
+# callers should resolve a BrytonRegionConfig instead.
+DEFAULT_HOST = INTERNATIONAL.host
+WEB_HOST = INTERNATIONAL.web_host
 DDP_CONNECT = {"msg": "connect", "version": "1", "support": ["1", "pre2", "pre1"]}
 
 

{intervalssync-0.9.3 → intervalssync-0.9.5}/src/intervalssync/bryton/fit_encode.py

@@ -361,3 +361,26 @@ def icu_workout_doc_to_bryton_fit(
         encoder.on_mesg(Profile["mesg_num"]["WORKOUT_STEP"], step)
 
     return bytes(encoder.close())
+
+
+def encoded_step_count(
+    workout_doc: dict[str, Any],
+    *,
+    max_hr: float | None = None,
+) -> int:
+    """Number of steps the encoder will actually write for this workout.
+
+    Repeats expand into their children plus a repeat marker, so this differs
+    from ``len(workout_doc["steps"])``. Bryton's ``info.interval`` array is
+    per encoded step, so it has to be built from this, not the raw list.
+    """
+    raw_steps = workout_doc.get("steps")
+    if not isinstance(raw_steps, list) or not raw_steps:
+        return 0
+    steps = _flatten_steps(
+        raw_steps,
+        ftp=_num(workout_doc.get("ftp")),
+        lthr=_num(workout_doc.get("lthr")),
+        max_hr=max_hr if max_hr is not None else _num(workout_doc.get("max_hr")),
+    )
+    return len(steps or [])

intervalssync-0.9.5/src/intervalssync/bryton/region.py

@@ -0,0 +1,57 @@
+"""Bryton Active regional endpoints (international vs China).
+
+Bryton runs fully separate account databases and Meteor deployments for its
+international and China-region apps. An account that exists on one region's
+server reports ``User not found`` on the other, so the user has to pick the
+region where the account was created.
+
+The China backend was found through the regional web clients:
+``www.brytonsports.cn`` (百锐腾运动) talks to ``active.cn.brytonactive.com``,
+which serves the same DDP API, mobile FIT endpoint and workout upload route as
+the international deployment.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+BrytonRegionName = Literal["international", "china"]
+
+
+@dataclass(frozen=True)
+class BrytonRegionConfig:
+    name: BrytonRegionName
+    # Meteor DDP + mobile REST API (``GET /api/activity``).
+    host: str
+    # Web backend used for the planned-workout upload (``/workout/upload``).
+    web_host: str
+
+
+INTERNATIONAL = BrytonRegionConfig(
+    name="international",
+    host="m3.brytonactive.com",
+    web_host="active.brytonsport.com",
+)
+
+CHINA = BrytonRegionConfig(
+    name="china",
+    host="active.cn.brytonactive.com",
+    web_host="active.cn.brytonactive.com",
+)
+
+_REGIONS: dict[BrytonRegionName, BrytonRegionConfig] = {
+    "international": INTERNATIONAL,
+    "china": CHINA,
+}
+
+
+def resolve_region(name: str | None) -> BrytonRegionConfig:
+    """Return the region config for a name; default is international."""
+    if not name or name == "international":
+        return INTERNATIONAL
+    if name == "china":
+        return CHINA
+    raise ValueError(
+        f"Unknown Bryton region: {name!r} (expected 'international' or 'china')"
+    )

{intervalssync-0.9.3 → intervalssync-0.9.5}/src/intervalssync/bryton/workout.py

@@ -7,17 +7,24 @@ intervals.icu ``workout_doc`` to Bryton-native FIT and POST multipart to
 
 from __future__ import annotations
 
+import json
 import re
 from dataclasses import dataclass, field
 from datetime import date, datetime, timedelta
 from typing import Any, Callable
+from uuid import uuid4
 
 import requests
 
 from .. import intervals_icu
-from .ddp import WEB_HOST, BrytonSession, call_method, login
+from .ddp import BrytonSession, call_method, login
 from .exceptions import BrytonSyncError
-from .fit_encode import bryton_hr_uses_mhr, icu_workout_doc_to_bryton_fit
+from .fit_encode import (
+    bryton_hr_uses_mhr,
+    encoded_step_count,
+    icu_workout_doc_to_bryton_fit,
+)
+from .region import INTERNATIONAL, resolve_region
 
 _CYCLING_TYPES = frozenset(
     {
@@ -89,6 +96,9 @@ class BrytonWorkoutUploadConfig:
     workout_days_ahead: int = 1
     uploaded_workouts: dict[str, str] = field(default_factory=dict)
     force_resync: bool = False
+    bryton_region: str = "international"
+    # Explicit endpoint override; normally resolved from bryton_region.
+    web_host: str | None = None
 
 
 def apply_uploaded_bryton_workout_map(
@@ -186,10 +196,46 @@ def _sanitize_workout_filename(name: str, *, event_id: int) -> str:
 
 
 def _auto_workout_filename() -> str:
+    # Names are a fallback deduplication key, so time alone is insufficient
+    # when multiple uploads (including separate processes) share a timestamp.
     now = datetime.now()
     return (
         f"bsWO{now.month:02d}{now.day:02d}_"
-        f"{now.hour:02d}{now.minute:02d}{now.second:02d}"
+        f"{now.hour:02d}{now.minute:02d}{now.second:02d}_{uuid4().hex}"
+    )
+
+
+def build_workout_info(
+    title: str,
+    plan_date: str,
+    workout_doc: dict[str, Any] | None = None,
+    *,
+    description: str = "",
+    max_hr: float | None = None,
+) -> str:
+    """Build the ``info`` blob Bryton stores alongside a workout file.
+
+    A workout carries its schedule here, not in the FIT, and there is no
+    separate plan object in the API -- ``plan`` is the whole mechanism. An
+    upload without this blob is inert: visible and editable in the app, but
+    absent from its Training calendar and impossible to send to the head unit.
+    TrainingPeaks-sourced workouts arrive with ``plan`` populated, which is why
+    they work and plain uploads do not.
+    """
+    # One entry per ENCODED step: repeats expand in the FIT, so the raw list
+    # would be short and the app's step count would disagree with the file.
+    n_steps = encoded_step_count(workout_doc, max_hr=max_hr) if workout_doc else 0
+    interval = [{"target_type": ""} for _ in range(n_steps)]
+    return json.dumps(
+        {
+            "name": title,
+            "description": description,
+            "plan": [plan_date] if plan_date else [],
+            "provider": "bryton",
+            "interval": interval,
+            "create_time": int(datetime.now().timestamp() * 1000),
+            "ver": 5,
+        }
     )
 
 
@@ -198,6 +244,7 @@ def upload_workout_fit(
     fit_bytes: bytes,
     name: str,
     *,
+    info: str | None = None,
     http: requests.Session | None = None,
 ) -> bool:
     """Upload a FIT workout to Bryton Active web; return True on success."""
@@ -208,20 +255,23 @@ def upload_workout_fit(
         "X-User-Id": session.user_id,
         "X-Auth-Token": session.auth_token,
     }
+    payload = {"name": filename, "provider": "bryton"}
+    if info:
+        payload["info"] = info
     client = http or requests.Session()
     resp = client.post(
         url,
         files={"file": (filename, fit_bytes, "application/octet-stream")},
-        data={"name": filename, "provider": "bryton"},
+        data=payload,
         headers=headers,
         timeout=120,
     )
     return resp.ok
 
 
-def web_login(email: str, password: str) -> BrytonSession:
+def web_login(email: str, password: str, *, host: str | None = None) -> BrytonSession:
     """Log in to the Bryton Active website backend."""
-    return login(email, password, host=WEB_HOST)
+    return login(email, password, host=host or INTERNATIONAL.web_host)
 
 
 def upload_workouts(
@@ -237,8 +287,17 @@ def upload_workouts(
     days = max(1, config.workout_days_ahead)
     newest = config.newest or (today + timedelta(days=days - 1))
 
+    try:
+        region = resolve_region(config.bryton_region)
+    except ValueError as exc:
+        raise BrytonSyncError(str(exc)) from exc
+
     report("Logging in to Bryton Active…")
-    session = web_login(config.bryton_email, config.bryton_password)
+    session = web_login(
+        config.bryton_email,
+        config.bryton_password,
+        host=config.web_host or region.web_host,
+    )
     report("Logged in.")
 
     live_ids, live_names = _fetch_workout_library(session)
@@ -319,7 +378,17 @@ def upload_workouts(
         )
 
         report(f"Uploading {workout.name}…")
-        if upload_workout_fit(session, fit_bytes, upload_name, http=http):
+        # Direct attribute access, deliberately: a refactor that drops
+        # start_date must raise here rather than quietly emit plan:[], which
+        # would silently reintroduce the inert-upload bug this commit fixes.
+        info = build_workout_info(
+            workout.name,
+            workout.start_date,
+            workout.workout_doc,
+            description=workout.description,
+            max_hr=encode_max_hr,
+        )
+        if upload_workout_fit(session, fit_bytes, upload_name, info=info, http=http):
             after_ids, _ = _fetch_workout_library(session)
             new_ids = after_ids - ids_before
             stored_value = next(iter(new_ids), upload_name)

{intervalssync-0.9.3 → intervalssync-0.9.5}/src/intervalssync/cli/config.py

@@ -31,6 +31,8 @@ class CliConfig:
     delete_after_upload: bool = True
     force_resync: bool = False
     activity_type: str = ""
+    # iGPSPORT ride id (decimal string) → intervals.icu activity id.
+    uploaded_activities: dict[str, str] = field(default_factory=dict)
     # Planned workouts: intervals.icu event id → iGPSPORT workoutId.
     uploaded_workouts: dict[str, int] = field(default_factory=dict)
     # Planned workouts: intervals.icu event id → Bryton FIT filename stem.

{intervalssync-0.9.3 → intervalssync-0.9.5}/src/intervalssync/cli/env.py

@@ -14,6 +14,7 @@ IGPSPORT_PASSWORD_KEY = "INTERVALSSYNC_IGPSPORT_PASSWORD"
 IGPSPORT_REGION_KEY = "INTERVALSSYNC_IGPSPORT_REGION"
 BRYTON_EMAIL_KEY = "INTERVALSSYNC_BRYTON_EMAIL"
 BRYTON_PASSWORD_KEY = "INTERVALSSYNC_BRYTON_PASSWORD"
+BRYTON_REGION_KEY = "INTERVALSSYNC_BRYTON_REGION"
 INTERVALS_API_KEY_KEY = "INTERVALSSYNC_INTERVALS_API_KEY"
 
 IGPSPORT_REQUIRED_KEYS = (
@@ -31,12 +32,15 @@ _IGPSPORT_BODY = (
     f"  {IGPSPORT_USER_KEY}=<email>\n"
     f"  {IGPSPORT_PASSWORD_KEY}=<password>\n"
     f"  {INTERVALS_API_KEY_KEY}=<api-key>\n"
-    f"  {IGPSPORT_REGION_KEY}=international  # or china for app.igpsport.cn"
+    f"  # optional: international (default) or china for app.igpsport.cn\n"
+    f"  {IGPSPORT_REGION_KEY}=international"
 )
 _BRYTON_BODY = (
     f"  {BRYTON_EMAIL_KEY}=<email>\n"
     f"  {BRYTON_PASSWORD_KEY}=<password>\n"
-    f"  {INTERVALS_API_KEY_KEY}=<api-key>"
+    f"  {INTERVALS_API_KEY_KEY}=<api-key>\n"
+    f"  # optional: international (default) or china for the China-region Bryton app\n"
+    f"  {BRYTON_REGION_KEY}=international"
 )
 
 ENV_OVERRIDE_HINT = (
@@ -77,6 +81,7 @@ class BrytonCredentials:
     bryton_email: str
     bryton_password: str
     intervals_api_key: str
+    bryton_region: str = "international"
 
 
 def _default_hermes_env_path() -> Path:
@@ -175,10 +180,18 @@ def load_bryton_credentials(env_path: Path) -> BrytonCredentials:
     if missing:
         raise CliConfigError(_missing_keys_message(env_path, missing, source="bryton"))
 
+    region = values.get(BRYTON_REGION_KEY, "international") or "international"
+    if region not in ("international", "china"):
+        raise CliConfigError(
+            f"Invalid {BRYTON_REGION_KEY}={region!r} in {env_path} "
+            "(expected 'international' or 'china')."
+        )
+
     return BrytonCredentials(
         bryton_email=values[BRYTON_EMAIL_KEY],
         bryton_password=values[BRYTON_PASSWORD_KEY],
         intervals_api_key=values[INTERVALS_API_KEY_KEY],
+        bryton_region=region,
     )