intervalssync 0.9.3__py3-none-any.whl

intervalssync/bryton/fit_encode.py

@@ -0,0 +1,363 @@
+"""Encode intervals.icu workout_doc into Bryton-compatible FIT workouts.
+
+Bryton Active stores uploaded FIT files as-is. Generic FIT exports (e.g. from
+intervals.icu) parse partially in the web UI but fail on mobile and omit the
+workout chart. Bryton's own web app re-encodes imported FIT via
+``parseToEncodeData`` + ``encodeToFit`` before upload; we mirror that here by
+building Bryton-native workout steps from ``workout_doc``.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, Literal
+
+from garmin_fit_sdk import Encoder, Profile
+
+# Bryton custom target_type values (see woParser.js in Bryton web bundle).
+TARGET_FTP = 245
+TARGET_LTHR = 248
+TARGET_MHR = 249
+
+# Percentage targets (FTP, LTHR, MHR) use custom values + 100_000.
+BRYTON_FTP_OFFSET = 100_000
+
+# Bryton Active mobile ignores LTHR (248) and shows 0 % — encode HR as % MHR (249).
+# Dev toggle: set to "lthr" to restore LTHR encoding.
+_BRYTON_HR_TARGET: Literal["mhr", "lthr"] = "mhr"
+
+
+def bryton_hr_uses_mhr() -> bool:
+    return _BRYTON_HR_TARGET == "mhr"
+
+
+def _num(value: Any) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _step_name(step: dict[str, Any], index: int) -> str:
+    text = str(step.get("text") or "").strip()
+    if text:
+        return text[:16]
+    intensity = str(step.get("intensity") or "").lower()
+    if step.get("warmup") or intensity == "warmup":
+        return "Warm Up"
+    if step.get("cooldown") or intensity == "cooldown":
+        return "Cool Down"
+    if intensity in ("rest", "recovery"):
+        return "Recovery"
+    return "Work"
+
+
+def _intensity(step: dict[str, Any]) -> str:
+    intensity = str(step.get("intensity") or "").lower()
+    if step.get("warmup") or intensity == "warmup":
+        return "warmup"
+    if step.get("cooldown") or intensity == "cooldown":
+        return "cooldown"
+    if intensity in ("rest", "recovery"):
+        return "rest"
+    return "active"
+
+
+def _ftp_target_range(min_pct: int, max_pct: int) -> tuple[int, int, int]:
+    if min_pct > max_pct:
+        min_pct, max_pct = max_pct, min_pct
+    return (
+        TARGET_FTP,
+        min_pct + BRYTON_FTP_OFFSET,
+        max_pct + BRYTON_FTP_OFFSET,
+    )
+
+
+def _power_range(step: dict[str, Any]) -> tuple[int, int, int] | None:
+    """Return Bryton % FTP targets from explicit ``%ftp`` power fields."""
+    power = step.get("power")
+    resolved = step.get("_power")
+
+    if not isinstance(power, dict):
+        return None
+
+    units = str(power.get("units") or "").lower()
+    pct_start = _num(power.get("start"))
+    pct_end = _num(power.get("end"))
+    pct_value = _num(power.get("value"))
+
+    if units != "%ftp":
+        return None
+
+    min_pct: int | None
+    max_pct: int | None
+
+    if pct_start is not None and pct_end is not None:
+        min_pct = int(pct_start)
+        max_pct = int(pct_end)
+    elif pct_value is not None and isinstance(resolved, dict):
+        w_start = _num(resolved.get("start"))
+        w_end = _num(resolved.get("end"))
+        w_value = _num(resolved.get("value"))
+        if w_start is not None and w_end is not None:
+            ref = w_value
+            if ref is None or ref == 0:
+                ref = (w_start + w_end) / 2
+            if ref and ref != 0:
+                min_pct = int(round(w_start / ref * pct_value))
+                max_pct = int(round(w_end / ref * pct_value))
+            else:
+                min_pct = max_pct = int(pct_value)
+        else:
+            min_pct = max_pct = int(pct_value)
+    elif pct_value is not None:
+        min_pct = max_pct = int(pct_value)
+    else:
+        return None
+
+    return _ftp_target_range(min_pct, max_pct)
+
+
+def _power_range_from_resolved(
+    step: dict[str, Any],
+    ftp: float | None,
+) -> tuple[int, int, int] | None:
+    """Return Bryton % FTP targets from resolved watts in ``_power``.
+
+    intervals.icu provides resolved watt ranges in ``_power`` and athlete FTP
+    on the workout doc when ``resolve=true``. Covers ``power_zone`` and any
+    other non-``%ftp`` power units (mirrors ``_hr_range`` + LTHR).
+    """
+    if not ftp or ftp <= 0:
+        return None
+
+    resolved = step.get("_power")
+    if not isinstance(resolved, dict):
+        return None
+
+    start = _num(resolved.get("start"))
+    end = _num(resolved.get("end"))
+    value = _num(resolved.get("value"))
+    min_w = start if start is not None else value
+    max_w = end if end is not None else value
+    if min_w is None and max_w is None:
+        return None
+    min_w = min_w if min_w is not None else max_w
+    max_w = max_w if max_w is not None else min_w
+
+    min_pct = int(round(min_w / ftp * 100))
+    max_pct = int(round(max_w / ftp * 100))
+
+    return _ftp_target_range(min_pct, max_pct)
+
+
+def _hr_range(
+    step: dict[str, Any],
+    *,
+    lthr: float | None,
+    max_hr: float | None,
+) -> tuple[int, int, int] | None:
+    """Return (target_type, low, high) as % HR reference with Bryton offsets.
+
+    Bryton encodes HR targets as custom percentages (target_type 248 = % LTHR,
+    249 = % MHR; values + 100_000), not absolute BPM (target_type 1, + 100).
+    intervals.icu provides resolved BPM in ``_hr`` and athlete ``lthr`` /
+    ``max_hr`` on the workout doc when ``resolve=true``.
+    """
+    if _BRYTON_HR_TARGET == "lthr":
+        hr_ref = lthr
+        target_type = TARGET_LTHR
+    else:
+        hr_ref = max_hr
+        target_type = TARGET_MHR
+
+    if not hr_ref or hr_ref <= 0:
+        return None
+
+    resolved = step.get("_hr")
+    if not isinstance(resolved, dict):
+        return None
+
+    start = _num(resolved.get("start"))
+    end = _num(resolved.get("end"))
+    value = _num(resolved.get("value"))
+    min_bpm = start if start is not None else value
+    max_bpm = end if end is not None else value
+    if min_bpm is None and max_bpm is None:
+        return None
+    min_bpm = min_bpm if min_bpm is not None else max_bpm
+    max_bpm = max_bpm if max_bpm is not None else min_bpm
+    if min_bpm > max_bpm:
+        min_bpm, max_bpm = max_bpm, min_bpm
+
+    min_pct = int(round(min_bpm / hr_ref * 100))
+    max_pct = int(round(max_bpm / hr_ref * 100))
+    return (
+        target_type,
+        min_pct + BRYTON_FTP_OFFSET,
+        max_pct + BRYTON_FTP_OFFSET,
+    )
+
+
+def _target_fields(
+    step: dict[str, Any],
+    *,
+    ftp: float | None,
+    lthr: float | None,
+    max_hr: float | None,
+) -> dict[str, Any]:
+    power = _power_range(step) or _power_range_from_resolved(step, ftp)
+    if power:
+        target_type, low, high = power
+        return {
+            "target_type": target_type,
+            "target_value": 0,
+            "custom_target_value_low": low,
+            "custom_target_value_high": high,
+        }
+
+    hr = _hr_range(step, lthr=lthr, max_hr=max_hr)
+    if hr:
+        target_type, low, high = hr
+        return {
+            "target_type": target_type,
+            "target_value": 0,
+            "custom_target_value_low": low,
+            "custom_target_value_high": high,
+        }
+
+    return {
+        "target_type": "open",
+        "target_value": 0,
+    }
+
+
+def _timed_step(
+    step: dict[str, Any],
+    index: int,
+    *,
+    ftp: float | None,
+    lthr: float | None,
+    max_hr: float | None,
+    name: str | None = None,
+) -> dict[str, Any] | None:
+    if step.get("until_lap_press"):
+        mesg: dict[str, Any] = {
+            "message_index": index,
+            "wkt_step_name": name or _step_name(step, index + 1),
+            "duration_type": "open",
+            "duration_value": 0,
+            "intensity": _intensity(step),
+        }
+        mesg.update(_target_fields(step, ftp=ftp, lthr=lthr, max_hr=max_hr))
+        return mesg
+
+    duration = step.get("duration")
+    if duration is None:
+        return None
+
+    mesg = {
+        "message_index": index,
+        "wkt_step_name": name or _step_name(step, index + 1),
+        "duration_type": "time",
+        "duration_value": int(duration) * 1000,
+        "intensity": _intensity(step),
+    }
+    mesg.update(_target_fields(step, ftp=ftp, lthr=lthr, max_hr=max_hr))
+    return mesg
+
+
+def _flatten_steps(
+    raw_steps: list[Any],
+    *,
+    ftp: float | None,
+    lthr: float | None,
+    max_hr: float | None,
+) -> list[dict[str, Any]] | None:
+    """Expand intervals.icu steps (including repeats) into Bryton FIT messages."""
+    out: list[dict[str, Any]] = []
+
+    def append_repeat(start_index: int, repeat_count: int) -> None:
+        out.append(
+            {
+                "message_index": len(out),
+                "duration_type": "repeat_until_steps_cmplt",
+                "duration_value": start_index,
+                "target_value": int(repeat_count),
+            }
+        )
+
+    for step in raw_steps:
+        if not isinstance(step, dict):
+            continue
+
+        reps = step.get("reps")
+        nested = step.get("steps")
+        if reps and isinstance(nested, list) and nested:
+            start_index = len(out)
+            for child in nested:
+                if not isinstance(child, dict):
+                    continue
+                mapped = _timed_step(
+                    child, len(out), ftp=ftp, lthr=lthr, max_hr=max_hr
+                )
+                if mapped is None:
+                    return None
+                out.append(mapped)
+            if len(out) == start_index:
+                return None
+            append_repeat(start_index, int(reps))
+            continue
+
+        mapped = _timed_step(step, len(out), ftp=ftp, lthr=lthr, max_hr=max_hr)
+        if mapped is None:
+            return None
+        out.append(mapped)
+
+    return out or None
+
+
+def icu_workout_doc_to_bryton_fit(
+    name: str,
+    workout_doc: dict[str, Any],
+    *,
+    max_hr: float | None = None,
+) -> bytes | None:
+    """Build a Bryton-compatible workout FIT file from intervals.icu workout_doc."""
+    raw_steps = workout_doc.get("steps")
+    if not isinstance(raw_steps, list) or not raw_steps:
+        return None
+
+    lthr = _num(workout_doc.get("lthr"))
+    if max_hr is None:
+        max_hr = _num(workout_doc.get("max_hr"))
+    ftp = _num(workout_doc.get("ftp"))
+    steps = _flatten_steps(raw_steps, ftp=ftp, lthr=lthr, max_hr=max_hr)
+    if not steps:
+        return None
+
+    wkt_name = name.strip() or "Workout"
+    encoder = Encoder()
+    encoder.on_mesg(
+        Profile["mesg_num"]["FILE_ID"],
+        {
+            "type": "workout",
+            "manufacturer": "bryton",
+            "serial_number": 255,
+            "time_created": datetime.now(tz=timezone.utc),
+        },
+    )
+    encoder.on_mesg(
+        Profile["mesg_num"]["WORKOUT"],
+        {
+            "sport": "cycling",
+            "num_valid_steps": len(steps),
+            "wkt_name": wkt_name,
+        },
+    )
+    for step in steps:
+        encoder.on_mesg(Profile["mesg_num"]["WORKOUT_STEP"], step)
+
+    return bytes(encoder.close())

intervalssync/bryton/workout.py

@@ -0,0 +1,342 @@
+"""Upload planned workouts from intervals.icu to Bryton Active (web FIT API).
+
+Uses the Bryton Active website backend (active.brytonsport.com): map
+intervals.icu ``workout_doc`` to Bryton-native FIT and POST multipart to
+/workout/upload/{userId}.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime, timedelta
+from typing import Any, Callable
+
+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
+
+_CYCLING_TYPES = frozenset(
+    {
+        "Ride",
+        "MountainBikeRide",
+        "GravelRide",
+        "VirtualRide",
+        "EBikeRide",
+        "EMountainBikeRide",
+        "TrackRide",
+        "Cyclocross",
+        "Handcycle",
+        "Velomobile",
+    }
+)
+
+Progress = Callable[[str], None]
+
+
+def _steps_target_hr(steps: Any) -> bool:
+    if not isinstance(steps, list):
+        return False
+    for step in steps:
+        if not isinstance(step, dict):
+            continue
+        if step.get("hr") is not None:
+            return True
+        if _steps_target_hr(step.get("steps")):
+            return True
+    return False
+
+
+def workout_doc_targets_hr(workout_doc: dict[str, Any]) -> bool:
+    """Return True when intervals.icu workout_doc uses heart-rate targets."""
+    target = str(workout_doc.get("target") or "").upper()
+    if target == "HR":
+        return True
+    return _steps_target_hr(workout_doc.get("steps"))
+
+
+def _noop(_message: str) -> None:
+    pass
+
+
+@dataclass
+class BrytonWorkoutUploadResult:
+    listed: int = 0
+    uploaded: int = 0
+    skipped: int = 0
+    failed: int = 0
+    no_steps: int = 0
+    uploaded_map: dict[str, str] = field(default_factory=dict)
+    pruned_keys: list[str] = field(default_factory=list)
+
+
+def _stored_on_bryton(stored: str | None, live_ids: set[str], live_names: set[str]) -> bool:
+    if not stored:
+        return False
+    return stored in live_ids or stored in live_names
+
+
+@dataclass
+class BrytonWorkoutUploadConfig:
+    bryton_email: str
+    bryton_password: str
+    intervals_api_key: str
+    oldest: date | None = None
+    newest: date | None = None
+    workout_days_ahead: int = 1
+    uploaded_workouts: dict[str, str] = field(default_factory=dict)
+    force_resync: bool = False
+
+
+def apply_uploaded_bryton_workout_map(
+    uploaded_workouts: dict[str, str],
+    result: BrytonWorkoutUploadResult,
+) -> None:
+    """Merge upload results into config and drop entries for deleted workouts."""
+    uploaded_workouts.update(result.uploaded_map)
+    for key in result.pruned_keys:
+        uploaded_workouts.pop(key, None)
+
+
+def _file_stem(name: str) -> str:
+    stem = name[:-4] if name.lower().endswith(".fit") else name
+    return stem.strip()
+
+
+def _names_from_file_entry(entry: Any) -> set[str]:
+    names: set[str] = set()
+    if isinstance(entry, str):
+        names.add(_file_stem(entry))
+        return names
+    if not isinstance(entry, dict):
+        return names
+    for key in ("name", "filename", "title", "originalName"):
+        value = entry.get(key)
+        if isinstance(value, str) and value.strip():
+            names.add(_file_stem(value))
+    file_id = entry.get("_id") or entry.get("id")
+    if isinstance(file_id, str) and file_id.strip():
+        names.add(_file_stem(file_id))
+    return names
+
+
+def _ids_from_file_entry(entry: Any) -> set[str]:
+    ids: set[str] = set()
+    if isinstance(entry, str):
+        ids.add(entry.strip())
+        return ids
+    if not isinstance(entry, dict):
+        return ids
+    for key in ("id", "_id"):
+        value = entry.get(key)
+        if isinstance(value, str) and value.strip():
+            ids.add(value.strip())
+    url = entry.get("url")
+    if isinstance(url, str) and "/userFiles/" in url:
+        parts = url.split("/userFiles/", 1)[-1].split("/")
+        if parts and parts[0].strip():
+            ids.add(parts[0].strip())
+    return ids
+
+
+def _parse_workout_list_result(result: Any) -> list[dict[str, Any]]:
+    if isinstance(result, dict):
+        workouts = result.get("workout")
+        if isinstance(workouts, list):
+            return [entry for entry in workouts if isinstance(entry, dict)]
+    if isinstance(result, list):
+        return [entry for entry in result if isinstance(entry, dict)]
+    return []
+
+
+def _fetch_workout_library(session: BrytonSession) -> tuple[set[str], set[str]]:
+    """Return (file ids, known name stems) from Bryton's user.file.list."""
+    result = call_method(session, "user.file.list", [])
+    ids: set[str] = set()
+    names: set[str] = set()
+    for entry in _parse_workout_list_result(result):
+        entry_ids = _ids_from_file_entry(entry)
+        ids.update(entry_ids)
+        names.update(_names_from_file_entry(entry))
+        names.update(entry_ids)
+    return ids, names
+
+
+def list_workout_file_ids(session: BrytonSession) -> set[str]:
+    """Return Bryton workout file ids currently in the user's library."""
+    ids, _ = _fetch_workout_library(session)
+    return ids
+
+
+def list_workout_file_names(session: BrytonSession) -> set[str]:
+    """Return workout file name stems currently in the Bryton library."""
+    _, names = _fetch_workout_library(session)
+    return names
+
+
+def _sanitize_workout_filename(name: str, *, event_id: int) -> str:
+    cleaned = re.sub(r"[^\w\-]+", "_", name.strip())
+    cleaned = cleaned.strip("_")
+    if not cleaned:
+        cleaned = f"icu_{event_id}"
+    return cleaned[:48]
+
+
+def _auto_workout_filename() -> str:
+    now = datetime.now()
+    return (
+        f"bsWO{now.month:02d}{now.day:02d}_"
+        f"{now.hour:02d}{now.minute:02d}{now.second:02d}"
+    )
+
+
+def upload_workout_fit(
+    session: BrytonSession,
+    fit_bytes: bytes,
+    name: str,
+    *,
+    http: requests.Session | None = None,
+) -> bool:
+    """Upload a FIT workout to Bryton Active web; return True on success."""
+    stem = _file_stem(name) or _auto_workout_filename()
+    filename = f"{stem}.fit"
+    url = f"https://{session.host}/workout/upload/{session.user_id}"
+    headers = {
+        "X-User-Id": session.user_id,
+        "X-Auth-Token": session.auth_token,
+    }
+    client = http or requests.Session()
+    resp = client.post(
+        url,
+        files={"file": (filename, fit_bytes, "application/octet-stream")},
+        data={"name": filename, "provider": "bryton"},
+        headers=headers,
+        timeout=120,
+    )
+    return resp.ok
+
+
+def web_login(email: str, password: str) -> BrytonSession:
+    """Log in to the Bryton Active website backend."""
+    return login(email, password, host=WEB_HOST)
+
+
+def upload_workouts(
+    config: BrytonWorkoutUploadConfig,
+    progress: Progress | None = None,
+) -> BrytonWorkoutUploadResult:
+    """Fetch upcoming intervals.icu workouts and push FIT files to Bryton."""
+    report = progress or _noop
+    result = BrytonWorkoutUploadResult()
+
+    today = date.today()
+    oldest = config.oldest or today
+    days = max(1, config.workout_days_ahead)
+    newest = config.newest or (today + timedelta(days=days - 1))
+
+    report("Logging in to Bryton Active…")
+    session = web_login(config.bryton_email, config.bryton_password)
+    report("Logged in.")
+
+    live_ids, live_names = _fetch_workout_library(session)
+    report(f"Found {len(live_ids)} custom workouts on Bryton.")
+
+    report("Fetching planned workouts from intervals.icu…")
+    intervals_http = requests.Session()
+    try:
+        calendar = intervals_icu.fetch_calendar_workouts(
+            config.intervals_api_key,
+            oldest,
+            newest,
+            http=intervals_http,
+        )
+    except requests.RequestException as exc:
+        raise BrytonSyncError(f"Could not fetch intervals.icu workouts: {exc}") from exc
+
+    result.listed = len(calendar)
+    report(f"Found {len(calendar)} planned workouts.")
+
+    http = requests.Session()
+    cached_max_hr: float | None = None
+    max_hr_fetched = False
+    for workout in calendar:
+        event_key = str(workout.event_id)
+
+        if workout.activity_type not in _CYCLING_TYPES:
+            report(
+                f"↷ Skipping {workout.name} — unsupported type "
+                f"{workout.activity_type!r} (cycling only in v1)."
+            )
+            result.skipped += 1
+            continue
+
+        stored = config.uploaded_workouts.get(event_key)
+        on_bryton = _stored_on_bryton(stored, live_ids, live_names)
+
+        if on_bryton and not config.force_resync:
+            report(f"↷ Skipping {workout.name} — already on Bryton.")
+            result.skipped += 1
+            continue
+
+        ids_before = set(live_ids)
+
+        encode_max_hr: float | None = None
+        if bryton_hr_uses_mhr() and workout_doc_targets_hr(workout.workout_doc):
+            if not max_hr_fetched:
+                try:
+                    cached_max_hr = intervals_icu.fetch_sport_settings_max_hr(
+                        config.intervals_api_key,
+                        workout.activity_type,
+                        http=intervals_http,
+                    )
+                except requests.RequestException as exc:
+                    raise BrytonSyncError(
+                        f"Could not fetch intervals.icu max HR for {workout.activity_type}: {exc}"
+                    ) from exc
+                max_hr_fetched = True
+            encode_max_hr = cached_max_hr
+
+        fit_bytes = icu_workout_doc_to_bryton_fit(
+            workout.name,
+            workout.workout_doc,
+            max_hr=encode_max_hr,
+        )
+        if fit_bytes is None:
+            report(
+                f"⚠ Skipping {workout.name} — no structured steps "
+                "(open the workout in intervals.icu first)."
+            )
+            result.no_steps += 1
+            continue
+
+        upload_name = (
+            stored
+            if config.force_resync and on_bryton and stored
+            else _auto_workout_filename()
+        )
+
+        report(f"Uploading {workout.name}…")
+        if upload_workout_fit(session, fit_bytes, upload_name, http=http):
+            after_ids, _ = _fetch_workout_library(session)
+            new_ids = after_ids - ids_before
+            stored_value = next(iter(new_ids), upload_name)
+            report(f"✓ Uploaded {workout.name} ({upload_name}.fit)")
+            result.uploaded += 1
+            result.uploaded_map[event_key] = stored_value
+            live_ids.add(stored_value)
+            live_names.add(upload_name)
+            live_names.add(_file_stem(upload_name))
+        else:
+            report(f"✗ Failed to upload {workout.name}.")
+            result.failed += 1
+
+    for event_key, stored_value in config.uploaded_workouts.items():
+        if event_key in result.uploaded_map:
+            continue
+        if not _stored_on_bryton(stored_value, live_ids, live_names):
+            result.pruned_keys.append(event_key)
+
+    return result

intervalssync/cli/__init__.py

@@ -0,0 +1,5 @@
+"""Headless CLI for syncing activities to intervals.icu."""
+
+from .main import main
+
+__all__ = ["main"]