intervalssync 0.9.3__py3-none-any.whl

intervalssync/igpsport/zone_map.py

@@ -0,0 +1,143 @@
+"""Map intervals.icu zone definitions onto iGPSPORT fixed zone slots."""
+
+from __future__ import annotations
+
+from typing import Any
+
+POWER_INTERIOR_CAP = 1999
+POWER_LAST_ZONE_END = 2500
+# intervals.icu's open-ended top power zone (e.g. "151%+") has no real upper
+# bound; its API reports this zone's upper bound as this sentinel percentage
+# rather than omitting it.
+OPEN_ZONE_SENTINEL_PCT = 999
+
+
+def power_upper_bounds_watts(power_zones_pct: list[float], ftp: float) -> list[int]:
+    """Convert intervals % FTP upper bounds to absolute watt boundaries."""
+    if ftp <= 0 or not power_zones_pct:
+        return []
+    return [int(round(ftp * pct / 100)) for pct in power_zones_pct]
+
+
+def hr_upper_bounds_bpm(hr_zones_bpm: list[float], max_hr: float) -> list[int]:
+    """Return intervals HR zone upper bounds capped at max_hr."""
+    if max_hr <= 0 or not hr_zones_bpm:
+        return []
+    cap = int(round(max_hr))
+    bounds = [int(round(bpm)) for bpm in hr_zones_bpm]
+    bounds[-1] = min(bounds[-1], cap)
+    return bounds
+
+
+def _prepare_intervals_ends(intervals_ends: list[int], slot_count: int, cap: int) -> list[int]:
+    """Drop open-ended last intervals bound when extra iGPSPORT slots need the cap."""
+    ends = list(intervals_ends)
+    n = len(ends)
+    p = slot_count
+    pad_count = p - n
+    if pad_count > 0 and n >= 2 and ends[-1] >= cap - pad_count:
+        ends = ends[:-1]
+    return ends
+
+
+def _enforce_strictly_increasing(ends: list[int], cap: int) -> list[int]:
+    """Ensure zone end values strictly increase and the last is capped."""
+    if not ends:
+        return ends
+    out = [int(value) for value in ends]
+    for index in range(1, len(out)):
+        if out[index] <= out[index - 1]:
+            out[index] = out[index - 1] + 1
+    out[-1] = min(out[-1], cap)
+    if len(out) > 1 and out[-1] <= out[-2]:
+        index = len(out) - 2
+        while index > 0 and out[index] >= out[index + 1]:
+            out[index] = out[index + 1] - 1
+            index -= 1
+        if out[0] >= out[1]:
+            out[0] = max(0, out[1] - 1)
+    return out
+
+
+def _slot_end_values(intervals_ends: list[int], slot_count: int, cap: int) -> list[int]:
+    """Map intervals zone count onto a fixed iGPSPORT slot count."""
+    if slot_count <= 0:
+        return []
+    if not intervals_ends:
+        return list(range(cap, cap - slot_count, -1))
+
+    ends = _prepare_intervals_ends(intervals_ends, slot_count, cap)
+    n = len(ends)
+    p = slot_count
+    pad_count = p - n
+
+    if n == p:
+        result = list(ends)
+    elif n < p:
+        result = list(ends)
+        for index in range(pad_count):
+            result.append(cap - pad_count + 1 + index)
+    else:
+        result = list(ends[: p - 1])
+        result.append(ends[-1])
+
+    return _enforce_strictly_increasing(result, cap)
+
+
+def _apply_end_values(
+    end_values: list[int],
+    igpsport_zones: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Rewrite start/end on iGPSPORT zone dicts, preserving other fields."""
+    out: list[dict[str, Any]] = []
+    start = 0
+    for index, zone in enumerate(igpsport_zones):
+        if not isinstance(zone, dict):
+            continue
+        updated = dict(zone)
+        updated["start"] = start
+        updated["end"] = end_values[index]
+        start = end_values[index]
+        out.append(updated)
+    return out
+
+
+def map_power_zones(
+    intervals_pct: list[float],
+    ftp: float,
+    igpsport_zones: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Map intervals.icu power zones onto iGPSPORT power slots."""
+    if not igpsport_zones:
+        return []
+    intervals_ends = power_upper_bounds_watts(intervals_pct, ftp)
+    if (
+        intervals_pct
+        and intervals_pct[-1] >= OPEN_ZONE_SENTINEL_PCT
+        and len(intervals_ends) > 1
+    ):
+        # Drop the open-ended zone's sentinel bound; POWER_LAST_ZONE_END covers it.
+        intervals_ends = intervals_ends[:-1]
+    slot_count = len(igpsport_zones)
+    if slot_count == 1:
+        slot_ends = [POWER_LAST_ZONE_END]
+    else:
+        interior = _slot_end_values(intervals_ends, slot_count - 1, POWER_INTERIOR_CAP)
+        interior[-1] = min(interior[-1], POWER_INTERIOR_CAP)
+        interior = _enforce_strictly_increasing(interior, POWER_INTERIOR_CAP)
+        slot_ends = interior + [POWER_LAST_ZONE_END]
+    return _apply_end_values(slot_ends, igpsport_zones)
+
+
+def map_hr_zones(
+    intervals_bpm: list[float],
+    max_hr: float,
+    igpsport_zones: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Map intervals.icu HR zones onto iGPSPORT heart-rate slots."""
+    if not igpsport_zones:
+        return []
+    cap = int(round(max_hr))
+    intervals_ends = hr_upper_bounds_bpm(intervals_bpm, max_hr)
+    slot_ends = _slot_end_values(intervals_ends, len(igpsport_zones), cap)
+    return _apply_end_values(slot_ends, igpsport_zones)

intervalssync/intervals_icu.py

@@ -0,0 +1,201 @@
+"""Shared intervals.icu API helpers.
+
+Activity upload/dedup, calendar workout fetch, and sport-settings lookup.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+from pathlib import Path
+from typing import Any
+
+import requests
+
+INTERVALS_UPLOAD_URL = "https://intervals.icu/api/v1/athlete/0/activities"
+INTERVALS_ACTIVITIES_URL = "https://intervals.icu/api/v1/athlete/0/activities"
+INTERVALS_ACTIVITY_URL = "https://intervals.icu/api/v1/activity"
+INTERVALS_EVENTS_URL = "https://intervals.icu/api/v1/athlete/0/events"
+INTERVALS_SPORT_SETTINGS_URL = "https://intervals.icu/api/v1/athlete/0/sport-settings"
+INTERVALS_ATHLETE_URL = "https://intervals.icu/api/v1/athlete/0"
+
+
+@dataclass
+class CalendarWorkout:
+    event_id: int
+    name: str
+    description: str
+    activity_type: str
+    workout_doc: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class SportSettings:
+    ftp: float | None
+    lthr: float | None
+    max_hr: float | None
+    power_zones: list[float]
+    hr_zones: list[float]
+
+
+def _num(value: Any) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _num_list(value: Any) -> list[float]:
+    if not isinstance(value, list):
+        return []
+    out: list[float] = []
+    for item in value:
+        num = _num(item)
+        if num is not None:
+            out.append(num)
+    return out
+
+
+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."""
+    with fit_path.open("rb") as f:
+        resp = requests.post(
+            INTERVALS_UPLOAD_URL,
+            params={"name": title, "external_id": external_id},
+            files={"file": (fit_path.name, f, "application/octet-stream")},
+            auth=("API_KEY", api_key),
+        )
+    if resp.status_code not in (200, 201):
+        return None
+
+    data = resp.json()
+    activities = data.get("activities") or []
+    if activities and activities[0].get("id"):
+        return activities[0]["id"]
+    return data.get("id")
+
+
+def set_activity_type(activity_id: str, activity_type: str, api_key: str) -> bool:
+    """Set an activity's sport on intervals.icu."""
+    resp = requests.put(
+        f"{INTERVALS_ACTIVITY_URL}/{activity_id}",
+        json={"type": activity_type},
+        auth=("API_KEY", api_key),
+    )
+    return resp.ok
+
+
+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."""
+    resp = requests.get(
+        INTERVALS_ACTIVITIES_URL,
+        params={"oldest": oldest.isoformat(), "newest": newest.isoformat()},
+        auth=("API_KEY", api_key),
+    )
+    resp.raise_for_status()
+    return {
+        a["external_id"]
+        for a in resp.json()
+        if isinstance(a, dict) and a.get("external_id")
+    }
+
+
+def fetch_calendar_workouts(
+    api_key: str,
+    oldest: date,
+    newest: date,
+    *,
+    http: requests.Session | None = None,
+) -> list[CalendarWorkout]:
+    """Fetch planned workouts from the intervals.icu calendar."""
+    client = http or requests.Session()
+    resp = client.get(
+        INTERVALS_EVENTS_URL,
+        params={
+            "category": "WORKOUT",
+            "resolve": "true",
+            "oldest": oldest.isoformat(),
+            "newest": newest.isoformat(),
+        },
+        auth=("API_KEY", api_key),
+        timeout=30,
+    )
+    resp.raise_for_status()
+    workouts: list[CalendarWorkout] = []
+    for event in resp.json():
+        if event.get("category") != "WORKOUT":
+            continue
+        workout_doc = event.get("workout_doc")
+        if not isinstance(workout_doc, dict):
+            continue
+        workouts.append(
+            CalendarWorkout(
+                event_id=int(event["id"]),
+                name=str(event.get("name") or "Workout"),
+                description=str(event.get("description") or ""),
+                activity_type=str(event.get("type") or "Ride"),
+                workout_doc=workout_doc,
+            )
+        )
+    return workouts
+
+
+def fetch_sport_settings(
+    api_key: str,
+    sport: str = "Ride",
+    *,
+    http: requests.Session | None = None,
+) -> SportSettings:
+    """Return athlete thresholds and zone definitions from intervals.icu sport settings."""
+    client = http or requests.Session()
+    resp = client.get(
+        f"{INTERVALS_SPORT_SETTINGS_URL}/{sport}",
+        auth=("API_KEY", api_key),
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    if not isinstance(data, dict):
+        return SportSettings(None, None, None, [], [])
+    return SportSettings(
+        ftp=_num(data.get("ftp")),
+        lthr=_num(data.get("lthr")),
+        max_hr=_num(data.get("max_hr")),
+        power_zones=_num_list(data.get("power_zones")),
+        hr_zones=_num_list(data.get("hr_zones")),
+    )
+
+
+def fetch_sport_settings_max_hr(
+    api_key: str,
+    sport: str,
+    *,
+    http: requests.Session | None = None,
+) -> float | None:
+    """Return athlete max HR (bpm) from intervals.icu sport settings."""
+    return fetch_sport_settings(api_key, sport, http=http).max_hr
+
+
+def fetch_athlete_weight(
+    api_key: str,
+    *,
+    http: requests.Session | None = None,
+) -> float | None:
+    """Return athlete weight in kg from intervals.icu (`icu_weight`, else `weight`)."""
+    client = http or requests.Session()
+    resp = client.get(
+        INTERVALS_ATHLETE_URL,
+        auth=("API_KEY", api_key),
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    if not isinstance(data, dict):
+        return None
+    return _num(data.get("icu_weight")) or _num(data.get("weight"))

intervalssync-0.9.3.dist-info/METADATA

@@ -0,0 +1,179 @@
+Metadata-Version: 2.5
+Name: intervalssync
+Version: 0.9.3
+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
+Project-URL: Issues, https://github.com/jorge-huxley/intervalssync/issues
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: <3.14,>=3.13
+Requires-Dist: dropbox>=12.0.2
+Requires-Dist: flet-permission-handler==0.86.1
+Requires-Dist: flet-secure-storage==0.86.1
+Requires-Dist: flet==0.86.1
+Requires-Dist: garmin-fit-sdk>=21.208.0
+Requires-Dist: packaging>=26.2
+Requires-Dist: platformdirs>=4.0
+Requires-Dist: requests>=2.33.1
+Requires-Dist: websocket-client>=1.8.0
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="assets/icon.png" width="120" alt="Intervals Sync logo">
+</p>
+
+<h1 align="center">Intervals Sync</h1>
+
+<p align="center">
+  <strong>The missing intervals.icu sync tool for iGPSPORT and Bryton users.</strong>
+</p>
+
+<p align="center">
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/jorge-huxley/intervalssync?style=flat" alt="License: MIT" /></a>
+  <a href="https://github.com/jorge-huxley/intervalssync/releases"><img src="https://img.shields.io/github/v/release/jorge-huxley/intervalssync?style=flat&sort=semver" alt="GitHub release" /></a>
+  <a href="https://github.com/jorge-huxley/intervalssync/releases"><img src="https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Android-lightgrey?style=flat" alt="Platforms" /></a>
+  <a href="https://github.com/jorge-huxley/intervalssync/stargazers"><img src="https://img.shields.io/github/stars/jorge-huxley/intervalssync?style=flat&label=stars" alt="GitHub stars" /></a>
+
+</p>
+
+<p align="center">
+  <a href="https://ko-fi.com/jorge_huxley"><img src="https://ko-fi.com/img/githubbutton_sm.svg" alt="ko-fi" /></a>
+</p>
+
+<p align="center">
+  Enter your credentials once, press <strong>Sync</strong>, and your latest rides from
+  <strong>iGPSPORT</strong> or <strong>Bryton Active</strong> land on <strong>intervals.icu</strong>. You can also push
+  planned workouts from intervals.icu back to iGPSPORT or Bryton Active.
+  Free and open source, for <strong>Windows</strong>, <strong>macOS</strong>, and <strong>Android</strong>.
+</p>
+
+<p align="center">
+  <a href="https://github.com/jorge-huxley/intervalssync/releases/latest">Download</a> &middot;
+  <a href="docs/AGENT.md">CLI &amp; agents</a> &middot;
+  <a href="CONTRIBUTING.md">Contributing</a>
+</p>
+
+---
+
+<br>
+
+<p align="center">
+  <img src="docs/img/demo.gif" alt="Intervals Sync syncing rides to intervals.icu, skipping ones already uploaded" width="300">
+</p>
+
+<details>
+  <summary><b>More screenshots</b></summary>
+  <br>
+  <p align="center">
+    <img src="docs/img/sync.png" alt="Sync screen" width="260">
+    &nbsp;&nbsp;
+    <img src="docs/img/settings.png" alt="Settings screen with secure credential fields" width="260">
+  </p>
+</details>
+
+## Features
+
+- Syncs recent rides from **iGPSPORT** or **Bryton Active** to **intervals.icu** (original `.fit` files)
+- **Optional Dropbox upload** — mirror activities to a Dropbox folder from the GUI (iGPSPORT or Bryton sync)
+- **Upload workouts** — push planned cycling workouts from your intervals.icu calendar to iGPSPORT custom workouts or Bryton Active (sync to your head unit from the vendor app)
+- **Skips activities already uploaded** so re-running is safe — with an optional *force re-sync*
+- Lets you choose how many recent activities to process
+- **Workout upload window** in Settings — how many calendar days to upload (default: today only)
+- **Sets the intervals.icu sport type** after upload (e.g. Mountain Bike Ride / Gravel Ride) — iGPSPORT exports everything as a generic "Ride"
+- Optionally deletes the local `.fit` files after a successful upload
+- Stores your credentials in the **OS secure vault** (Windows Credential Manager / macOS Keychain / Android Keystore), never in a file
+- Lets you know when a newer version is available
+- **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)
+
+> Prefer the terminal, or want to help out? It's open source (Python + [Flet](https://flet.dev), MIT) — see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Download & run (Windows)
+
+1. Go to the [Releases](../../releases) page and download the latest `.zip`.
+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))
+   - 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).
+
+Your password and API key are stored in your operating system's **secure
+credential store** — Windows Credential Manager on Windows (the same vault
+Windows uses for its own logins) — never in a plain text file.
+
+## Download & run (macOS)
+
+1. Go to the [Releases](../../releases) page and download the latest `macos.zip`.
+2. Unzip it and move the app to **Applications** if you want.
+3. Open the app, fill in **Settings** (same fields as above), then **Sync** or **Upload to iGPSPORT** / **Upload to Bryton**.
+
+On macOS your credentials are stored in Keychain. Release builds are not
+notarized yet, so macOS may require right-clicking the app and choosing
+**Open** the first time.
+
+## Download & run (Android)
+
+1. On the [Releases](../../releases) page, download the latest `.apk`.
+2. Open it on your phone. Android will ask you to allow installing from this
+   source — accept (Settings → "Install unknown apps" for your browser/files app).
+3. Open the app, fill in **Settings** (same fields as above), then **Sync** or **Upload to iGPSPORT** / **Upload to Bryton**.
+
+On Android your credentials are stored in the **Android Keystore**. The app
+isn't on the Play Store, so the "unknown source" prompt is expected.
+
+## CLI & automation (AI agents)
+
+Headless `intervalssync` CLI — sync from iGPSPORT or Bryton, upload workouts to iGPSPORT or Bryton, sync thresholds and zones to iGPSPORT, JSON on stdout. See [Agent / headless sync](docs/AGENT.md).
+
+With [uv](https://docs.astral.sh/uv/) installed, run the latest stable release
+directly from PyPI—no clone or manual upgrade required:
+
+```bash
+uvx --python 3.13 intervalssync@latest --version
+uvx --python 3.13 intervalssync@latest sync --json
+```
+
+## Run from source
+
+Requires [uv](https://docs.astral.sh/uv/).
+
+```bash
+uv sync
+cp .env.example .env    # optional: credentials for CLI; IGPSYNC_DROPBOX_APP_KEY for Dropbox
+uv run --env-file .env intervalssync-gui
+```
+
+## Build the desktop apps
+
+```bash
+uv run flet build windows
+uv run flet build macos
+```
+
+The distributables land in `build/windows/` and `build/macos/`. (Flet downloads
+the Flutter toolchain on the first build; macOS builds require a macOS host.)
+
+## Roadmap
+
+The app is built with [Flet](https://flet.dev), so the same Python code targets
+desktop and Android today, with **iOS** (`flet build ipa`) possible from the same
+code.
+
+## Support
+
+Tips on [Ko-fi](https://ko-fi.com/jorge_huxley) help fund bug fixes, releases, and new features. Thank you!
+
+## Acknowledgements
+
+This project builds on community work around iGPSPORT activity access and
+syncing:
+
+- [kamikadzem22/igpsport-unoffical-api](https://github.com/kamikadzem22/igpsport-unoffical-api)
+  for documenting and exploring the unofficial iGPSPORT API.
+- [simple4wan/ride-sync](https://github.com/simple4wan/ride-sync) for prior
+  work on syncing ride activities between services (including China-region iGPSPORT).
+
+This app is an independent project and is not affiliated with iGPSPORT,
+intervals.icu, or the projects listed above.

intervalssync-0.9.3.dist-info/RECORD

@@ -0,0 +1,39 @@
+intervalssync/__init__.py,sha256=tfaMpqkN3HrMSDRvfJTb70ybI4Vv9clRn_61MEkLSL0,101
+intervalssync/_dropbox_app_key.py,sha256=4H1xeJzDWSU2xsPJuyZ40GIHA_-udSdm0fP3AUsXGbI,211
+intervalssync/_version.py,sha256=xKd3pzbczuMsdB08eLAOqZDUd_q1IRxwZ_ccAFL4c4A,22
+intervalssync/dropbox_client.py,sha256=_rkj_wf_cm_XmY-nfPdYav58AWeURXDIG9g26bGOybc,4685
+intervalssync/intervals_icu.py,sha256=O7E5l0EKCAzvXHkttbDjbGKoCjWxiSWux-ES7DmL2Ec,5792
+intervalssync/bryton/__init__.py,sha256=3n9KqkxkOEMxm8NCDAwjFpQbABakoHHZfPO6VIZBoH0,29
+intervalssync/bryton/api.py,sha256=D_pH1hgUqR41xz2Tt603OA-Yh8iDSGv1PhQnNlWFcJ4,1385
+intervalssync/bryton/core.py,sha256=nzucPMb_1Z2inXFTMSK81WZ6PoNzfZ8tYhS865BNrVg,8913
+intervalssync/bryton/ddp.py,sha256=BEWaYdJ1SFB9Oz0MTCgpqx4elYGOVMUioUWigAyRQ_w,7756
+intervalssync/bryton/exceptions.py,sha256=fMp244M9wy10zF_Xo0Ay7RhZ4QJHwKAgl7Qs-9z3ZDg,278
+intervalssync/bryton/fit_encode.py,sha256=i_zn5yM9JdXk4Cp-uDthOWMlb5RcEwm1uDb90r3RwME,10910
+intervalssync/bryton/workout.py,sha256=bxFiKZPT9uMbHGrnfempICLlWCD1D2y5fkUC7aE7Qas,10942
+intervalssync/cli/__init__.py,sha256=W500E5Z06b_ThlFP0aXa_S-4qNpH7qR_U7SnZ93KRxc,104
+intervalssync/cli/config.py,sha256=88dcx8rEOV0lNXEZBJL3cDLqyFXPe6EmgRdZS_lWMzw,1736
+intervalssync/cli/env.py,sha256=TlDHk7orexUgdMOBJDLFG6qHri_5EKC8ZihzzmdXDio,6187
+intervalssync/cli/main.py,sha256=f6hrmTAps4IwwPcGULh1OpLKZRb45INZKz47xEkeBFM,20752
+intervalssync/gui/__init__.py,sha256=dBeFR4kFHTFyRbuTPQgS1rks-d6fzi28C_FhTqr1Ik8,34
+intervalssync/gui/app.py,sha256=dF8AuKGI4FMz7rK5r54aySKPaRAaCjCVK_DB_qg1044,12483
+intervalssync/gui/config.py,sha256=KbxNkw8wm8SeKTglPvuph4RcWAuwm1EsFClp7V1ekbI,4000
+intervalssync/gui/profile_sync_ui.py,sha256=Mrhk6e9I_Me1Vmv3-GEN_CTz92IXHbI23USw863KMA4,6929
+intervalssync/gui/secrets.py,sha256=DehSkxpDovNaWB3cIkCs-jyX8EkwEUuM4zSAG2oh6Og,4114
+intervalssync/gui/settings_view.py,sha256=Yuknxb6xd6K2j0tau7G43VgJjIaUfxJidN0N3kAMbQ8,25858
+intervalssync/gui/support_gamification.py,sha256=tpy0YZdIpLHloina-V9gSZNb6aQ7QdjKkw3bVEFXVyI,19477
+intervalssync/gui/sync_view.py,sha256=AZzaVNCN_9pH5e2yDyhlZ5D-F7GxQFPjlWaVXaMXNss,19191
+intervalssync/gui/system.py,sha256=bEHI5weqM2jhpRtvp89mTPFVLC1YgK2FtdwbJSgvrAk,622
+intervalssync/gui/theme.py,sha256=7Ws6qY8Ym2UvCmlk9sM4y_9063WwsrBUUvprFf_x8M0,5750
+intervalssync/gui/update_check.py,sha256=BmqOEJjBmF9xNixjZ46floF475Z_cqilTl_qQ-jqyOY,1673
+intervalssync/igpsport/__init__.py,sha256=mHBTahHy1YeOIQc2Fl4J74lf2ruQPCBfhOOCW6WJaBE,60
+intervalssync/igpsport/core.py,sha256=m7CB5P88fPBQe0IBmZ4nSlCtDQcnUDxxgdWDTwu_Njk,18257
+intervalssync/igpsport/interval_info.py,sha256=v34SGmcp2fBRdk_e7CGE8xfX1mxcxoM8XyyBlhsXbiM,9558
+intervalssync/igpsport/profile_sync.py,sha256=wJBhYf3urs-4Aj38nE7fBUU3KNCX2e-lnVGghIU7X3E,12716
+intervalssync/igpsport/region.py,sha256=wInjMU2a7h5bV0lgXmP_H5rkytndB0BJJ2l74rFZQTo,2556
+intervalssync/igpsport/workout.py,sha256=zONmbRBW_OoYyBMc1p_p3FBr8fq-YHpMwmvbWEK5myc,15919
+intervalssync/igpsport/zone_map.py,sha256=pHNslrqXsE6mU5C1RtN53Apti_6A6hqV6QA0F5lehV0,4848
+intervalssync-0.9.3.dist-info/METADATA,sha256=HJMG2jZzFsOnAhgDpLyApdf07U5R2fxiebolVOS_fL8,8521
+intervalssync-0.9.3.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+intervalssync-0.9.3.dist-info/entry_points.txt,sha256=U4Qpukl4QbpkrmSTDtLx-2ji4NdZ5BW3K7qC-k8ljns,119
+intervalssync-0.9.3.dist-info/licenses/LICENSE,sha256=qiocLTBHBzicxsKt3f85zKhssp0X0NeoBF1dpoYYVPk,1068
+intervalssync-0.9.3.dist-info/RECORD,,

intervalssync-0.9.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

intervalssync-0.9.3.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+intervalssync = intervalssync.cli:main
+
+[gui_scripts]
+intervalssync-gui = intervalssync.gui.app:main

intervalssync-0.9.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jorge Silva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.