intervalssync 0.9.3__tar.gz → 0.9.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: intervalssync
-Version: 0.9.3
+Version: 0.9.4
 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

{intervalssync-0.9.3 → intervalssync-0.9.4}/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.4"
 description = "Sync cycling activities from iGPSPORT or Bryton Active to intervals.icu"
 readme = "README.md"
 license = "MIT"

intervalssync-0.9.4/src/intervalssync/_version.py

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

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

@@ -205,10 +205,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.4}/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.3 → intervalssync-0.9.4}/src/intervalssync/bryton/workout.py

@@ -7,17 +7,23 @@ 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 .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,
+)
 
 _CYCLING_TYPES = frozenset(
     {
@@ -186,10 +192,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 +240,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,11 +251,14 @@ 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,
     )
@@ -319,7 +365,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.4}/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.4}/src/intervalssync/cli/main.py

@@ -20,6 +20,7 @@ from ..bryton.exceptions import BrytonSyncError
 from ..igpsport.core import SyncConfig as IgpSyncConfig
 from ..igpsport.core import SyncError as IgpSyncError
 from ..igpsport.core import SyncResult as IgpSyncResult
+from ..igpsport.core import apply_uploaded_activity_map
 from ..igpsport.core import sync as igpsport_sync
 from ..igpsport.profile_sync import (
     ProfileSyncConfig,
@@ -68,6 +69,7 @@ def _build_igpsport_sync_config(
             delete_after_upload if delete_after_upload is not None else config.delete_after_upload
         ),
         force_resync=force_resync if force_resync is not None else config.force_resync,
+        uploaded_activities=dict(config.uploaded_activities),
         activity_type=activity_type if activity_type is not None else config.activity_type,
         list_activities=True,
         get_download_url=True,
@@ -110,9 +112,11 @@ def _igpsport_result_payload(result: IgpSyncResult, *, ok: bool, error: str | No
         "source": "igpsport",
         "listed": result.listed,
         "uploaded": result.uploaded,
+        "linked": result.linked,
         "skipped": result.skipped,
         "failed": result.failed,
         "downloaded": result.downloaded,
+        "activity_map": result.activity_map,
         "activities": [
             {
                 "ride_id": act.ride_id,
@@ -157,6 +161,7 @@ def _emit_json(payload: dict) -> None:
 def _emit_igpsport_text_summary(result: IgpSyncResult) -> None:
     print(
         f"Done — uploaded {result.uploaded}, "
+        f"linked {result.linked}, "
         f"downloaded {result.downloaded}, "
         f"skipped {result.skipped}, "
         f"failed {result.failed}."
@@ -332,8 +337,14 @@ def cmd_sync(args: argparse.Namespace) -> int:
         download_dir=args.download_dir,
         delete_after_upload=delete_after_upload,
     )
+    def persist_activity_map(partial_result: IgpSyncResult) -> None:
+        apply_uploaded_activity_map(config.uploaded_activities, partial_result)
+        cli_config_module.save(config)
+
     try:
-        result = igpsport_sync(sync_config, progress=progress)
+        result = igpsport_sync(
+            sync_config, progress=progress, on_activity_map=persist_activity_map
+        )
     except IgpSyncError as exc:
         if use_json:
             _emit_json(_igpsport_result_payload(IgpSyncResult(), ok=False, error=str(exc)))
@@ -347,6 +358,10 @@ def cmd_sync(args: argparse.Namespace) -> int:
             print(f"✗ Unexpected error: {exc}", file=sys.stderr)
         return EXIT_SYNC_ERROR
 
+    if result.activity_map or result.pruned_keys:
+        apply_uploaded_activity_map(config.uploaded_activities, result)
+        cli_config_module.save(config)
+
     ok = result.failed == 0
     if use_json:
         _emit_json(_igpsport_result_payload(result, ok=ok))

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

@@ -51,6 +51,8 @@ class AppConfig:
     upload_dropbox: bool = False
     dropbox_folder: str = "/intervalssync-fit"
     dropbox_date_filenames: bool = True
+    # 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 file id or filename stem.

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

@@ -15,7 +15,13 @@ from ..bryton.workout import (
     apply_uploaded_bryton_workout_map,
     upload_workouts as bryton_upload_workouts,
 )
-from ..igpsport.core import SyncConfig as IgpSyncConfig, SyncError, sync as igpsport_sync
+from ..igpsport.core import (
+    SyncConfig as IgpSyncConfig,
+    SyncError,
+    SyncResult as IgpSyncResult,
+    apply_uploaded_activity_map,
+    sync as igpsport_sync,
+)
 from ..dropbox_client import get_dropbox_app_key
 from ..igpsport.workout import WorkoutUploadConfig, apply_uploaded_workout_map, upload_workouts
 from . import support_gamification
@@ -187,6 +193,7 @@ def build_sync_view(
         dropbox_app_key: str | None,
     ) -> None:
         sync_config = IgpSyncConfig(
+            uploaded_activities=dict(config.uploaded_activities),
             igp_user=config.igp_user,
             igp_password=igp_password,
             igp_region=config.igp_region,
@@ -207,12 +214,22 @@ def build_sync_view(
             dropbox_date_filenames=config.dropbox_date_filenames,
         )
 
+        def persist_activity_map(partial_result: IgpSyncResult) -> None:
+            apply_uploaded_activity_map(config.uploaded_activities, partial_result)
+            config_module.save(config)
+
         uploaded_count = 0
         try:
-            result = igpsport_sync(sync_config, progress=append_log)
+            result = igpsport_sync(
+                sync_config, progress=append_log, on_activity_map=persist_activity_map
+            )
+            if result.activity_map or result.pruned_keys:
+                apply_uploaded_activity_map(config.uploaded_activities, result)
+                config_module.save(config)
             uploaded_count = result.uploaded
             append_log(
                 f"\nDone — intervals uploaded {result.uploaded}, "
+                f"linked {result.linked}, "
                 f"Dropbox uploaded {result.uploaded_dropbox}, "
                 f"downloaded {result.downloaded}, "
                 f"skipped {result.skipped}, Dropbox skipped {result.skipped_dropbox}, "

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

@@ -28,7 +28,10 @@ from ..dropbox_client import (
     upload_to_dropbox,
 )
 from ..intervals_icu import (
-    fetch_uploaded_external_ids as icu_fetch_uploaded_external_ids,
+    ActivityIdentities,
+    ActivityUploadResult,
+    activity_exists as icu_activity_exists,
+    fetch_activity_identities as icu_fetch_activity_identities,
     set_activity_type,
     upload_fit_file,
 )
@@ -118,12 +121,15 @@ class SyncResult:
     listed: int = 0
     downloaded: int = 0
     uploaded: int = 0
+    linked: 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)
+    activity_map: dict[str, str] = field(default_factory=dict)
+    pruned_keys: list[str] = field(default_factory=list)
 
 
 # A progress callback receives short, human-readable status events. It is
@@ -300,18 +306,23 @@ def download_fit(fit_url: str, dest_path: Path) -> 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."""
+) -> ActivityUploadResult | None:
+    """Upload a .fit file to intervals.icu and return its identity result."""
     return upload_fit_file(
         fit_path, title, external_id_for(ride_id), api_key
     )
 
 
-def fetch_uploaded_external_ids(
+def fetch_activity_identities(
     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)
+) -> ActivityIdentities:
+    """Return activity IDs and external-ID links in an Intervals date range."""
+    return icu_fetch_activity_identities(api_key, oldest, newest)
+
+
+def activity_exists(api_key: str, activity_id: str) -> bool:
+    """Return whether a mapped Intervals activity still exists."""
+    return icu_activity_exists(api_key, activity_id)
 
 
 def _activity_date_range(activities: list[Activity]) -> tuple[date, date]:
@@ -346,6 +357,8 @@ class SyncConfig:
     # When False (default), skip activities already uploaded to intervals.icu.
     # When True, re-download and re-upload them regardless.
     force_resync: bool = False
+    # iGPSPORT ride id (decimal string) → intervals.icu activity id.
+    uploaded_activities: dict[str, str] = field(default_factory=dict)
     # 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
@@ -358,8 +371,27 @@ class SyncConfig:
     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."""
+def apply_uploaded_activity_map(
+    uploaded_activities: dict[str, str],
+    result: SyncResult,
+) -> None:
+    """Merge activity identities into config and remove verified deletions."""
+    for key in result.pruned_keys:
+        uploaded_activities.pop(key, None)
+    uploaded_activities.update(result.activity_map)
+
+
+def sync(
+    config: SyncConfig,
+    progress: Progress | None = None,
+    *,
+    on_activity_map: Callable[[SyncResult], None] | None = None,
+) -> SyncResult:
+    """Sync rides, checkpointing verified identities before subsequent I/O.
+
+    Front-ends can persist the cumulative identity map with on_activity_map.
+    Persistence errors propagate so we stop before doing more remote work.
+    """
     report = progress or _noop
     result = SyncResult()
 
@@ -387,21 +419,50 @@ def sync(config: SyncConfig, progress: Progress | None = None) -> SyncResult:
     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()
+    # Resolve every Intervals identity before processing any ride. This keeps a
+    # later verification failure from occurring after earlier FIT downloads.
+    intervals_skip: 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(
+            identities = fetch_activity_identities(
                 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}")
+        except (requests.RequestException, ValueError) as exc:
+            raise SyncError(f"Could not check intervals.icu activities: {exc}") from exc
+
+        report(
+            f"{len(identities.activity_ids)} activities already on intervals.icu "
+            f"in {oldest.isoformat()}…{newest.isoformat()}."
+        )
+        for act in activities:
+            ride_key = str(act.ride_id)
+            external_id = external_id_for(act.ride_id)
+            discovered_id = identities.external_ids.get(external_id)
+            if discovered_id is not None:
+                intervals_skip.add(ride_key)
+                result.activity_map[ride_key] = discovered_id
+                continue
+
+            mapped_id = config.uploaded_activities.get(ride_key)
+            if mapped_id is None:
+                continue
+            if mapped_id in identities.activity_ids:
+                intervals_skip.add(ride_key)
+                continue
+            try:
+                mapped_exists = activity_exists(config.intervals_api_key, mapped_id)
+            except requests.RequestException as exc:
+                raise SyncError(
+                    f"Could not verify intervals.icu activity {mapped_id}: {exc}"
+                ) from exc
+            if mapped_exists:
+                intervals_skip.add(ride_key)
+            else:
+                result.pruned_keys.append(ride_key)
+
+    if on_activity_map and (result.activity_map or result.pruned_keys):
+        on_activity_map(result)
 
     # Validate Dropbox prerequisites once, before processing any activity, so a
     # misconfiguration fails fast instead of part-way through the loop.
@@ -430,13 +491,14 @@ def sync(config: SyncConfig, progress: Progress | None = None) -> SyncResult:
     any_upload_enabled = config.upload_intervals or config.upload_dropbox
 
     for act in activities:
+        ride_key = str(act.ride_id)
         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
+        intervals_needs_it = config.upload_intervals and ride_key not in intervals_skip
         dropbox_needs_it = (
             config.upload_dropbox and dropbox_filename not in dropbox_uploaded_names
         )
@@ -473,14 +535,23 @@ def sync(config: SyncConfig, progress: Progress | None = None) -> SyncResult:
             if not config.intervals_api_key:
                 raise SyncError("intervals.icu API key is required for upload.")
 
-            activity_id = upload_to_intervals(
+            upload_result = 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 upload_result:
+                activity_id = upload_result.activity_id
+                result.activity_map[ride_key] = activity_id
+                if upload_result.created:
+                    report(f"✓ Uploaded {act.ride_id}: {act.title}")
+                    result.uploaded += 1
+                else:
+                    report(f"↔ Linked {act.ride_id}: {act.title}")
+                    result.linked += 1
+
+                if on_activity_map:
+                    on_activity_map(result)
+
+                if upload_result.created and config.activity_type:
                     if set_activity_type(
                         activity_id, config.activity_type, config.intervals_api_key
                     ):

{intervalssync-0.9.3 → intervalssync-0.9.4}/src/intervalssync/intervals_icu.py

@@ -27,6 +27,19 @@ class CalendarWorkout:
     description: str
     activity_type: str
     workout_doc: dict[str, Any]
+    start_date: str = ""
+
+
+@dataclass(frozen=True)
+class ActivityUploadResult:
+    activity_id: str
+    created: bool
+
+
+@dataclass
+class ActivityIdentities:
+    activity_ids: set[str]
+    external_ids: dict[str, str]
 
 
 @dataclass(frozen=True)
@@ -58,10 +71,18 @@ def _num_list(value: Any) -> list[float]:
     return out
 
 
+def _parse_activity_id(value: Any) -> str | None:
+    """Return a normalized Intervals identifier or None for unsupported values."""
+    if not isinstance(value, str):
+        return None
+    normalized = value.strip()
+    return normalized or None
+
+
 def upload_fit_file(
     fit_path: Path, title: str, external_id: str, api_key: str
-) -> str | None:
-    """Upload a .fit file; return the new activity id or None on failure."""
+) -> ActivityUploadResult | None:
+    """Upload a .fit file and classify whether Intervals created or linked it."""
     with fit_path.open("rb") as f:
         resp = requests.post(
             INTERVALS_UPLOAD_URL,
@@ -72,11 +93,28 @@ def upload_fit_file(
     if resp.status_code not in (200, 201):
         return None
 
-    data = resp.json()
+    try:
+        data = resp.json()
+    except ValueError:
+        return None
+    if not isinstance(data, dict):
+        return None
     activities = data.get("activities") or []
-    if activities and activities[0].get("id"):
-        return activities[0]["id"]
-    return data.get("id")
+    activity_id = None
+    if (
+        isinstance(activities, list)
+        and activities
+        and isinstance(activities[0], dict)
+    ):
+        activity_id = _parse_activity_id(activities[0].get("id"))
+    if activity_id is None:
+        activity_id = _parse_activity_id(data.get("id"))
+    if activity_id is None:
+        return None
+    return ActivityUploadResult(
+        activity_id=activity_id,
+        created=resp.status_code == 201,
+    )
 
 
 def set_activity_type(activity_id: str, activity_type: str, api_key: str) -> bool:
@@ -89,21 +127,61 @@ def set_activity_type(activity_id: str, activity_type: str, api_key: str) -> boo
     return resp.ok
 
 
+def fetch_activity_identities(
+    api_key: str, oldest: date, newest: date
+) -> ActivityIdentities:
+    """Return Intervals activity IDs and external-ID links in a date range."""
+    resp = requests.get(
+        INTERVALS_ACTIVITIES_URL,
+        params={"oldest": oldest.isoformat(), "newest": newest.isoformat()},
+        auth=("API_KEY", api_key),
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    if not isinstance(data, list):
+        raise ValueError("intervals.icu activities response must be a list")
+    activity_ids: set[str] = set()
+    external_ids: dict[str, str] = {}
+    for activity in data:
+        if not isinstance(activity, dict) or "id" not in activity:
+            continue
+        activity_id = _parse_activity_id(activity["id"])
+        if activity_id is None:
+            raise ValueError("intervals.icu activity id must be a nonempty string")
+        activity_ids.add(activity_id)
+        external_id = activity.get("external_id")
+        if external_id is not None:
+            external_id = _parse_activity_id(external_id)
+            if external_id is None:
+                raise ValueError("intervals.icu external_id must be a nonempty string")
+            external_ids[external_id] = activity_id
+    return ActivityIdentities(activity_ids, external_ids)
+
+
 def fetch_uploaded_external_ids(
     api_key: str, oldest: date, newest: date
 ) -> set[str]:
     """Return external_ids already on intervals.icu in a date range."""
+    return set(fetch_activity_identities(api_key, oldest, newest).external_ids)
+
+
+def activity_exists(api_key: str, activity_id: str) -> bool:
+    """Return whether an activity exists, raising if absence cannot be verified."""
     resp = requests.get(
-        INTERVALS_ACTIVITIES_URL,
-        params={"oldest": oldest.isoformat(), "newest": newest.isoformat()},
+        f"{INTERVALS_ACTIVITY_URL}/{activity_id}",
         auth=("API_KEY", api_key),
+        timeout=30,
     )
+    if resp.status_code == 404:
+        return False
+    if resp.status_code == 200:
+        return True
     resp.raise_for_status()
-    return {
-        a["external_id"]
-        for a in resp.json()
-        if isinstance(a, dict) and a.get("external_id")
-    }
+    raise requests.HTTPError(
+        f"Unexpected HTTP {resp.status_code} verifying activity {activity_id}",
+        response=resp,
+    )
 
 
 def fetch_calendar_workouts(
@@ -141,6 +219,7 @@ def fetch_calendar_workouts(
                 description=str(event.get("description") or ""),
                 activity_type=str(event.get("type") or "Ride"),
                 workout_doc=workout_doc,
+                start_date=str(event.get("start_date_local") or "")[:10],
             )
         )
     return workouts