intervalssync 0.9.4__tar.gz → 0.9.5__tar.gz

{intervalssync-0.9.4 → 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.4 → 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.4 → 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.4 → intervalssync-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: intervalssync
-Version: 0.9.4
+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.4 → 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.4 → 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.4 → 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.4"
+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.4 → 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)

{intervalssync-0.9.4 → 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.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.4 → intervalssync-0.9.5}/src/intervalssync/bryton/workout.py

@@ -17,13 +17,14 @@ 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,
     encoded_step_count,
     icu_workout_doc_to_bryton_fit,
 )
+from .region import INTERNATIONAL, resolve_region
 
 _CYCLING_TYPES = frozenset(
     {
@@ -95,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(
@@ -265,9 +269,9 @@ def upload_workout_fit(
     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(
@@ -283,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)

{intervalssync-0.9.4 → 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,
     )
 
 

{intervalssync-0.9.4 → intervalssync-0.9.5}/src/intervalssync/cli/main.py

@@ -93,6 +93,7 @@ def _build_bryton_sync_config(
         bryton_email=credentials.bryton_email,
         bryton_password=credentials.bryton_password,
         intervals_api_key=credentials.intervals_api_key,
+        bryton_region=credentials.bryton_region,
         max_activities=max_activities if max_activities is not None else config.max_activities,
         download_dir=Path(download_dir or config.download_dir),
         delete_after_upload=(
@@ -208,6 +209,7 @@ def _build_bryton_workout_upload_config(
         bryton_email=credentials.bryton_email,
         bryton_password=credentials.bryton_password,
         intervals_api_key=credentials.intervals_api_key,
+        bryton_region=credentials.bryton_region,
         workout_days_ahead=(
             workout_days_ahead if workout_days_ahead is not None else config.workout_days_ahead
         ),

{intervalssync-0.9.4 → intervalssync-0.9.5}/src/intervalssync/gui/config.py

@@ -30,6 +30,7 @@ class AppConfig:
     igp_user: str = ""
     igp_region: str = "international"
     bryton_user: str = ""
+    bryton_region: str = "international"
     max_activities: int = 5
     download_dir: str = field(default_factory=_default_download_dir)
     # Remove each .fit file once it has been uploaded to intervals.icu.

{intervalssync-0.9.4 → intervalssync-0.9.5}/src/intervalssync/gui/settings_view.py

@@ -96,6 +96,20 @@ async def build_settings_view(
         value=config.enable_bryton,
         active_color=colors["accent"],
     )
+    bryton_region_value = (
+        config.bryton_region
+        if config.bryton_region in ("international", "china")
+        else "international"
+    )
+    bryton_region = ft.Dropdown(
+        label="Bryton region",
+        value=bryton_region_value,
+        options=[
+            ft.dropdown.Option("international", "International"),
+            ft.dropdown.Option("china", "China"),
+        ],
+        helper_text="Use China if your account was created in the China-region Bryton app",
+    )
     bryton_user = _input_field(
         label="Bryton Active email",
         value=config.bryton_user,
@@ -519,7 +533,7 @@ async def build_settings_view(
     )
     bryton_credentials = ft.Column(
         spacing=theme.SPACE_SM,
-        controls=[bryton_user, bryton_password],
+        controls=[bryton_region, bryton_user, bryton_password],
     )
     workout_sync_section = ft.Container(
         visible=config.enable_igpsport or config.enable_bryton,
@@ -598,6 +612,7 @@ async def build_settings_view(
         config.igp_user = igp_user.value.strip()
         config.igp_region = igp_region.value or "international"
         config.bryton_user = bryton_user.value.strip()
+        config.bryton_region = bryton_region.value or "international"
         try:
             config.max_activities = max(1, int(max_activities.value))
         except (TypeError, ValueError):

{intervalssync-0.9.4 → intervalssync-0.9.5}/src/intervalssync/gui/sync_view.py

@@ -258,6 +258,7 @@ def build_sync_view(
             intervals_api_key=api_key,
             dropbox_refresh_token=dropbox_refresh_token,
             dropbox_app_key=dropbox_app_key,
+            bryton_region=config.bryton_region,
             max_activities=config.max_activities,
             download_dir=Path(config.download_dir),
             delete_after_upload=config.delete_after_upload,
@@ -335,6 +336,7 @@ def build_sync_view(
             workout_days_ahead=config.workout_days_ahead,
             uploaded_workouts=dict(config.uploaded_bryton_workouts),
             force_resync=config.force_resync,
+            bryton_region=config.bryton_region,
         )
 
         uploaded_count = 0

{intervalssync-0.9.4 → intervalssync-0.9.5}/src/intervalssync/igpsport/core.py

@@ -51,12 +51,14 @@ IGP_TIME_FORMATS = (
 )
 
 
-def parse_igp_start_time(value: str) -> datetime | None:
+def parse_igp_start_time(value: str, *, require_time: bool = False) -> 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:
+        if require_time and "%H" not in fmt:
+            continue
         try:
             return datetime.strptime(text, fmt)
         except ValueError:
@@ -95,7 +97,7 @@ def dropbox_filename_for(activity: "Activity", use_date: bool = True) -> str:
     fallback = f"{external_id_for(activity.ride_id)}.fit"
     if not use_date:
         return fallback
-    start = parse_igp_start_time(activity.start_time)
+    start = parse_igp_start_time(activity.start_time, require_time=True)
     if start is None:
         return fallback
     return f"ride-0-{start:%Y-%m-%d-%H-%M-%S}.fit"
@@ -114,6 +116,7 @@ class Activity:
     ride_id: int
     title: str
     start_time: str
+    fit_url: str | None = field(default=None, repr=False, compare=False)
 
 
 @dataclass
@@ -204,7 +207,36 @@ def list_activities(
 ) -> 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)
+    activities = _list_activities_query(session, max_activities, cfg)
+    # The list endpoint can return only YYYY.MM.DD. Enrich the shared Activity
+    # before logging, CLI JSON, date-range checks, or Dropbox skip decisions.
+    for activity in activities:
+        if parse_igp_start_time(activity.start_time, require_time=True) is not None:
+            continue
+        try:
+            detail = fetch_activity_detail(session, activity.ride_id, cfg)
+        except (requests.RequestException, ValueError):
+            # Keep the list date for date-range checks. Dropbox uses the unique
+            # ride ID when the full timestamp is unavailable, never fake midnight.
+            continue
+        start_time = detail.get("startTime") or detail.get("StartTime")
+        if parse_igp_start_time(start_time, require_time=True) is not None:
+            activity.start_time = start_time
+        activity.fit_url = detail.get("fitUrl")
+    return activities
+
+
+def fetch_activity_detail(
+    session: requests.Session, ride_id: int, region: IgpRegionConfig
+) -> dict:
+    """Fetch the full start timestamp and FIT URL from the activity detail API."""
+    response = session.get(
+        f"{region.gateway_base}/queryActivityDetail/{ride_id}", timeout=30
+    )
+    response.raise_for_status()
+    body = response.json()
+    data = body.get("data") if isinstance(body, dict) else None
+    return data if isinstance(data, dict) else {}
 
 
 def _list_activities_query(
@@ -514,7 +546,7 @@ def sync(
         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)
+        fit_url = act.fit_url or 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

intervalssync-0.9.5/tests/test_bryton_region.py

@@ -0,0 +1,85 @@
+"""Tests for Bryton regional endpoint selection."""
+
+from __future__ import annotations
+
+import pytest
+
+from intervalssync.bryton import core, workout
+from intervalssync.bryton.ddp import BrytonSession
+from intervalssync.bryton.exceptions import BrytonSyncError
+from intervalssync.bryton.region import CHINA, INTERNATIONAL, resolve_region
+
+
+def test_resolve_region_defaults_to_international():
+    assert resolve_region(None) is INTERNATIONAL
+    assert resolve_region("") is INTERNATIONAL
+    assert resolve_region("international") is INTERNATIONAL
+
+
+def test_resolve_region_china():
+    assert resolve_region("china") is CHINA
+    assert CHINA.host == "active.cn.brytonactive.com"
+    assert CHINA.web_host == "active.cn.brytonactive.com"
+
+
+def test_resolve_region_rejects_unknown_name():
+    with pytest.raises(ValueError, match="Unknown Bryton region"):
+        resolve_region("eu")
+
+
+def test_sync_logs_in_to_china_host(monkeypatch, tmp_path):
+    captured: dict[str, str] = {}
+
+    def fake_login(email, password, *, host):
+        captured["host"] = host
+        return BrytonSession(user_id="u1", auth_token="tok", host=host)
+
+    monkeypatch.setattr(core, "login", fake_login)
+    monkeypatch.setattr(core, "list_activities", lambda *a, **k: [])
+
+    cfg = core.SyncConfig(
+        bryton_email="a@b.com",
+        bryton_password="pw",
+        intervals_api_key="key",
+        bryton_region="china",
+        download_dir=tmp_path,
+        list_activities=False,
+        download_fit=False,
+        upload_intervals=False,
+    )
+    core.sync(cfg)
+
+    assert captured["host"] == CHINA.host
+
+
+def test_sync_rejects_unknown_region(tmp_path):
+    cfg = core.SyncConfig(
+        bryton_email="a@b.com",
+        bryton_password="pw",
+        intervals_api_key="key",
+        bryton_region="eu",
+        download_dir=tmp_path,
+    )
+    with pytest.raises(BrytonSyncError, match="Unknown Bryton region"):
+        core.sync(cfg)
+
+
+def test_workout_upload_uses_china_web_host(monkeypatch):
+    captured: dict[str, str] = {}
+
+    def fake_web_login(email, password, *, host=None):
+        captured["host"] = host or ""
+        raise BrytonSyncError("stop before network")
+
+    monkeypatch.setattr(workout, "web_login", fake_web_login)
+    cfg = workout.BrytonWorkoutUploadConfig(
+        bryton_email="a@b.com",
+        bryton_password="pw",
+        intervals_api_key="key",
+        bryton_region="china",
+    )
+
+    with pytest.raises(BrytonSyncError, match="stop before network"):
+        workout.upload_workouts(cfg)
+
+    assert captured["host"] == CHINA.web_host

{intervalssync-0.9.4 → intervalssync-0.9.5}/tests/test_cli.py

@@ -66,6 +66,27 @@ def test_load_igpsport_credentials_rejects_invalid_region(tmp_path):
         cli_env.load_igpsport_credentials(env_file)
 
 
+def test_load_bryton_credentials_defaults_region(tmp_path):
+    env_file = tmp_path / ".env"
+    _write_bryton_env(env_file)
+    creds = cli_env.load_bryton_credentials(env_file)
+    assert creds.bryton_region == "international"
+
+
+def test_load_bryton_credentials_china_region(tmp_path):
+    env_file = tmp_path / ".env"
+    _write_bryton_env(env_file, **{cli_env.BRYTON_REGION_KEY: "china"})
+    creds = cli_env.load_bryton_credentials(env_file)
+    assert creds.bryton_region == "china"
+
+
+def test_load_bryton_credentials_rejects_invalid_region(tmp_path):
+    env_file = tmp_path / ".env"
+    _write_bryton_env(env_file, **{cli_env.BRYTON_REGION_KEY: "eu"})
+    with pytest.raises(cli_env.CliConfigError, match="INTERVALSSYNC_BRYTON_REGION"):
+        cli_env.load_bryton_credentials(env_file)
+
+
 def test_parse_dotenv_comments_and_quotes():
     text = """
 # comment
@@ -356,13 +377,35 @@ def test_upload_workouts_json_sync_error(tmp_path: Path, monkeypatch, capsys):
     assert payload["error"] == "fetch failed"
 
 
+def test_sync_bryton_passes_region(tmp_path: Path, monkeypatch, capsys):
+    env_file = tmp_path / ".env"
+    _write_bryton_env(env_file, **{cli_env.BRYTON_REGION_KEY: "china"})
+    monkeypatch.setattr(cli_config, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(cli_config, "CONFIG_PATH", tmp_path / "config.json")
+
+    def fake_sync(config, progress=None):
+        assert config.bryton_region == "china"
+        return cli.BrytonSyncResult()
+
+    monkeypatch.setattr(cli, "bryton_sync", fake_sync)
+
+    args = cli._build_parser().parse_args(
+        ["sync", "--source", "bryton", "--env-file", str(env_file), "--json"]
+    )
+    assert cli.cmd_sync(args) == cli.EXIT_OK
+
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["source"] == "bryton"
+
+
 def test_upload_workouts_bryton_json_success(tmp_path: Path, monkeypatch, capsys):
     env_file = tmp_path / ".env"
-    _write_bryton_env(env_file)
+    _write_bryton_env(env_file, **{cli_env.BRYTON_REGION_KEY: "china"})
     monkeypatch.setattr(cli_config, "CONFIG_DIR", tmp_path)
     monkeypatch.setattr(cli_config, "CONFIG_PATH", tmp_path / "config.json")
 
     def fake_upload(config, progress=None):
+        assert config.bryton_region == "china"
         if progress:
             progress("uploading bryton")
         return bryton_workout.BrytonWorkoutUploadResult(

{intervalssync-0.9.4 → intervalssync-0.9.5}/tests/test_config.py

@@ -12,6 +12,7 @@ def test_defaults():
     assert cfg.enable_igpsport is True
     assert cfg.igp_region == "international"
     assert cfg.enable_bryton is False
+    assert cfg.bryton_region == "international"
     assert cfg.delete_after_upload is True
     assert cfg.force_resync is False
     assert cfg.activity_type == ""  # "" = leave the uploaded sport untouched
@@ -81,6 +82,7 @@ def test_save_and_load_bryton_flags(tmp_path, monkeypatch):
         enable_igpsport=False,
         enable_bryton=True,
         bryton_user="rider@example.com",
+        bryton_region="china",
     )
     config_module.save(cfg)
 
@@ -88,6 +90,7 @@ def test_save_and_load_bryton_flags(tmp_path, monkeypatch):
     assert loaded.enable_igpsport is False
     assert loaded.enable_bryton is True
     assert loaded.bryton_user == "rider@example.com"
+    assert loaded.bryton_region == "china"
     assert "activity_source" not in json.loads(path.read_text(encoding="utf-8"))
 
 

{intervalssync-0.9.4 → intervalssync-0.9.5}/tests/test_igpsport_core.py

@@ -81,6 +81,11 @@ def test_parse_igp_start_time_formats():
 
 def test_dropbox_filename_for_dotted_date():
     act = core.Activity(1, "Ride", "2026.07.19")
+    assert core.dropbox_filename_for(act) == "igpsport_1.fit"
+
+
+def test_dropbox_filename_preserves_actual_midnight():
+    act = core.Activity(1, "Ride", "2026-07-19 00:00:00")
     assert core.dropbox_filename_for(act) == "ride-0-2026-07-19-00-00-00.fit"
 
 
@@ -474,7 +479,7 @@ def test_list_activities_paginates_when_api_caps_page_size():
 
 def test_list_activities_caps_when_server_returns_extra():
     class FakeSession:
-        def get(self, url, params=None):
+        def get(self, url, params=None, **kwargs):
             rows = [{"rideId": i, "title": "", "startTime": ""} for i in range(20)]
             return FakeResponse(json_data={"data": {"rows": rows}})
 
@@ -482,6 +487,68 @@ def test_list_activities_caps_when_server_returns_extra():
     assert len(acts) == 5
 
 
+@pytest.mark.parametrize("region", ["international", "china"])
+def test_list_activities_enriches_date_only_times_from_detail(region):
+    calls = []
+
+    class FakeSession:
+        def get(self, url, params=None, **kwargs):
+            calls.append(url)
+            if "queryMyActivity" in url:
+                return FakeResponse(json_data={"data": {"rows": [
+                    {"rideId": 1, "startTime": "2026.10.27"},
+                    {"rideId": 2, "startTime": "2026.10.27"},
+                ]}})
+            ride_id = int(url.rsplit("/", 1)[1])
+            return FakeResponse(json_data={"data": {
+                "startTime": f"2026-10-27 {ride_id + 7:02}:42:08",
+                "fitUrl": f"https://fit.test/{ride_id}.fit",
+            }})
+
+    activities = core.list_activities(FakeSession(), 2, region)
+    assert [act.start_time for act in activities] == [
+        "2026-10-27 08:42:08", "2026-10-27 09:42:08",
+    ]
+    assert [core.dropbox_filename_for(act) for act in activities] == [
+        "ride-0-2026-10-27-08-42-08.fit", "ride-0-2026-10-27-09-42-08.fit",
+    ]
+    assert activities[0].fit_url == "https://fit.test/1.fit"
+    assert len(calls) == 3
+    assert all(url.startswith(core.resolve_region(region).gateway_base) for url in calls)
+
+
+@pytest.mark.parametrize("detail", [None, [], {"startTime": "2026.10.27"},
+                                       {"startTime": "invalid"}])
+def test_list_activities_keeps_date_without_inventing_time(detail):
+    class FakeSession:
+        def get(self, url, **kwargs):
+            if "queryMyActivity" in url:
+                return FakeResponse(json_data={"data": {"rows": [
+                    {"rideId": 1, "startTime": "2026.10.27"},
+                ]}})
+            return FakeResponse(json_data={"data": detail})
+
+    activity, = core.list_activities(FakeSession(), 1)
+    assert activity.start_time == "2026.10.27"
+    assert core.dropbox_filename_for(activity) == "igpsport_1.fit"
+    assert core._activity_date_range([activity]) == (date(2026, 10, 26), date(2026, 10, 28))
+
+
+@pytest.mark.parametrize("error", [core.requests.Timeout(), ValueError("bad JSON")])
+def test_list_activities_survives_unavailable_detail(error):
+    class FakeSession:
+        def get(self, url, **kwargs):
+            if "queryMyActivity" in url:
+                return FakeResponse(json_data={"data": {"rows": [
+                    {"rideId": 1, "startTime": "2026.10.27"},
+                ]}})
+            raise error
+
+    activity, = core.list_activities(FakeSession(), 1)
+    assert activity.start_time == "2026.10.27"
+    assert core.dropbox_filename_for(activity) == "igpsport_1.fit"
+
+
 # --------------------------------------------------------------------------- #
 # sync() orchestration
 # --------------------------------------------------------------------------- #
@@ -490,6 +557,7 @@ def test_list_activities_caps_when_server_returns_extra():
 def stub_sync(monkeypatch, tmp_path):
     """Replace every network leaf so sync() runs offline. Returns a recorder."""
     rec = {
+        "list_activities": core.list_activities,
         "downloaded": [],
         "uploaded": [],
         "dropbox": [],
@@ -598,6 +666,47 @@ def _config(tmp_path, **overrides):
     return core.SyncConfig(**base)
 
 
+def test_sync_uses_detail_times_for_output_and_dropbox_skip_checks(monkeypatch, stub_sync):
+    from intervalssync.cli.main import _igpsport_result_payload
+
+    class FakeSession:
+        def get(self, url, **kwargs):
+            if "queryMyActivity" in url:
+                return FakeResponse(json_data={"data": {"rows": [
+                    {"rideId": 1, "startTime": "2026.10.27"},
+                    {"rideId": 2, "startTime": "2026.10.27"},
+                ]}})
+            ride_id = int(url.rsplit("/", 1)[1])
+            return FakeResponse(json_data={"data": {
+                "startTime": f"2026-10-27 {ride_id + 7:02}:42:08",
+                "fitUrl": f"https://fit.test/{ride_id}.fit",
+            }})
+
+    monkeypatch.setattr(core.requests, "Session", FakeSession)
+    monkeypatch.setattr(core, "list_activities", stub_sync["list_activities"])
+
+    def unexpected_resolve(*args):
+        pytest.fail("The FIT URL from the detail response should be reused")
+
+    monkeypatch.setattr(core, "resolve_fit_url", unexpected_resolve)
+    stub_sync["dropbox_existing"] = {
+        "ride-0-2026-10-27-00-00-00.fit",
+        "ride-0-2026-10-27-08-42-08.fit",
+    }
+    messages = []
+    result = core.sync(_config(
+        stub_sync["tmp"], max_activities=2, list_activities=True,
+        upload_intervals=False, upload_dropbox=True,
+    ), messages.append)
+    assert result.skipped_dropbox == 1
+    assert result.uploaded_dropbox == 1
+    assert stub_sync["dropbox"][0][0] == "ride-0-2026-10-27-09-42-08.fit"
+    assert stub_sync["downloaded"] == ["igpsport_2.fit"]
+    assert any("2026-10-27 09:42:08" in message for message in messages)
+    payload = _igpsport_result_payload(result, ok=True)
+    assert payload["activities"][1]["start_time"] == "2026-10-27 09:42:08"
+
+
 def test_sync_rejects_malformed_activity_discovery_before_fit_work(monkeypatch, tmp_path):
     resolved = []
     downloaded = []

intervalssync-0.9.4/src/intervalssync/_version.py

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