intervalssync 0.9.3__py3-none-any.whl

intervalssync/gui/profile_sync_ui.py

@@ -0,0 +1,225 @@
+"""GUI helpers for iGPSPORT profile / zone sync."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Callable
+
+import flet as ft
+
+from ..igpsport.core import SyncError
+from ..igpsport.profile_sync import (
+    ProfileSyncConfig,
+    ProfileSyncResult,
+    ProfileThresholdStatus,
+    fetch_profile_threshold_status,
+    sync_profile_zones,
+)
+from . import config as config_module
+from . import secrets as secrets_module
+from . import theme
+
+
+async def credentials_ready(
+    config: config_module.AppConfig,
+    store: secrets_module.SecretStore,
+) -> tuple[str, str] | None:
+    if not config.enable_igpsport or not config.igp_user:
+        return None
+    igp_password = await store.get(secrets_module.IGP_PASSWORD)
+    api_key = await store.get(secrets_module.INTERVALS_API_KEY)
+    if not igp_password or not api_key:
+        return None
+    return igp_password, api_key
+
+
+def run_sync_profile_zones(
+    config: config_module.AppConfig,
+    igp_password: str,
+    api_key: str,
+    *,
+    progress: Callable[[str], None] | None = None,
+) -> ProfileSyncResult:
+    sync_config = ProfileSyncConfig(
+        igp_user=config.igp_user,
+        igp_password=igp_password,
+        intervals_api_key=api_key,
+        igp_region=config.igp_region,
+    )
+    return sync_profile_zones(sync_config, progress=progress)
+
+
+async def check_profile_thresholds(
+    config: config_module.AppConfig,
+    store: secrets_module.SecretStore,
+) -> ProfileThresholdStatus | None:
+    creds = await credentials_ready(config, store)
+    if creds is None:
+        return None
+    igp_password, api_key = creds
+    try:
+        return await asyncio.to_thread(
+            fetch_profile_threshold_status,
+            ProfileSyncConfig(
+                igp_user=config.igp_user,
+                igp_password=igp_password,
+                intervals_api_key=api_key,
+                igp_region=config.igp_region,
+            ),
+        )
+    except (SyncError, Exception):  # noqa: BLE001 — fail silent for background checks
+        return None
+
+
+def _should_prompt(
+    config: config_module.AppConfig,
+    status: ProfileThresholdStatus,
+) -> bool:
+    if not status.needs_sync:
+        return False
+    if (
+        config.profile_sync_declined_fingerprint
+        and status.intervals_fingerprint == config.profile_sync_declined_fingerprint
+    ):
+        return False
+    return True
+
+
+def _clear_declined_fingerprint(config: config_module.AppConfig) -> None:
+    if config.profile_sync_declined_fingerprint:
+        config.profile_sync_declined_fingerprint = ""
+        config_module.save(config)
+
+
+def _save_declined_fingerprint(
+    config: config_module.AppConfig,
+    status: ProfileThresholdStatus,
+) -> None:
+    config.profile_sync_declined_fingerprint = status.intervals_fingerprint
+    config_module.save(config)
+
+
+def _sync_success_message(result: ProfileSyncResult) -> str:
+    if result.after is None:
+        return "iGPSPORT profile updated."
+    member = result.after.get("member")
+    if not isinstance(member, dict):
+        return "iGPSPORT profile updated."
+    parts: list[str] = []
+    for key, label in (("ftp", "FTP"), ("lthr", "LTHR"), ("mhr", "max HR")):
+        if key in member:
+            parts.append(f"{label} {member[key]}")
+    if result.weight_after is not None:
+        parts.append(f"weight {result.weight_after}")
+    if parts:
+        return "iGPSPORT profile updated — " + ", ".join(parts) + "."
+    return "iGPSPORT profile updated."
+
+
+async def sync_with_feedback(
+    page: ft.Page,
+    config: config_module.AppConfig,
+    store: secrets_module.SecretStore,
+    *,
+    clear_declined: bool = True,
+) -> bool:
+    creds = await credentials_ready(config, store)
+    if creds is None:
+        page.show_dialog(
+            ft.SnackBar(
+                ft.Text("Add iGPSPORT credentials and intervals.icu API key in Settings first.")
+            )
+        )
+        page.update()
+        return False
+
+    igp_password, api_key = creds
+    page.show_dialog(ft.SnackBar(ft.Text("Updating iGPSPORT profile…")))
+    page.update()
+
+    def _run_sync() -> tuple[bool, str]:
+        try:
+            result = run_sync_profile_zones(config, igp_password, api_key)
+            return True, _sync_success_message(result)
+        except SyncError as exc:
+            return False, str(exc)
+        except Exception as exc:  # noqa: BLE001 — surface any failure to the user
+            return False, f"Unexpected error: {exc}"
+
+    ok, message = await asyncio.to_thread(_run_sync)
+    if ok and clear_declined:
+        _clear_declined_fingerprint(config)
+    page.show_dialog(ft.SnackBar(ft.Text(message)))
+    page.update()
+    return ok
+
+
+async def prompt_if_needed(
+    page: ft.Page,
+    config: config_module.AppConfig,
+    store: secrets_module.SecretStore,
+) -> None:
+    if not config.enable_igpsport:
+        return
+
+    status = await check_profile_thresholds(config, store)
+    if status is None or not _should_prompt(config, status):
+        return
+
+    colors = theme.palette(page)
+
+    async def dismiss(_: ft.ControlEvent) -> None:
+        page.pop_dialog()
+        _save_declined_fingerprint(config, status)
+        page.update()
+
+    async def update_now(_: ft.ControlEvent) -> None:
+        page.pop_dialog()
+        page.update()
+        await sync_with_feedback(page, config, store)
+
+    difference_lines = [
+        ft.Text(f"• {diff}", size=13, color=colors["text"])
+        for diff in status.differences
+    ]
+    page.show_dialog(
+        ft.AlertDialog(
+            modal=True,
+            shape=ft.RoundedRectangleBorder(radius=theme.RADIUS_MD),
+            title=theme.display_text("Update iGPSPORT profile?", size=20),
+            content=ft.Column(
+                tight=True,
+                spacing=theme.SPACE_SM,
+                controls=[
+                    ft.Text(
+                        "Your iGPSPORT profile differs from intervals.icu:",
+                        size=13,
+                        color=colors["text_muted"],
+                    ),
+                    *difference_lines,
+                    ft.Text(
+                        "Power/HR zones and weight will be updated too.",
+                        size=12,
+                        color=colors["text_muted"],
+                    ),
+                ],
+            ),
+            actions=[
+                ft.TextButton("Not now", on_click=dismiss),
+                ft.TextButton("Update now", on_click=update_now),
+            ],
+        )
+    )
+    page.update()
+
+
+def format_threshold_status(status: ProfileThresholdStatus | None) -> str:
+    if status is None:
+        return "Could not check profile status."
+    if not status.needs_sync:
+        return "In sync with intervals.icu."
+    if len(status.differences) == 1:
+        return f"Out of sync: {status.differences[0]}"
+    return "Out of sync: " + ", ".join(
+        diff.split(":")[0] for diff in status.differences
+    )

intervalssync/gui/secrets.py

@@ -0,0 +1,135 @@
+"""Secure secret storage.
+
+Secrets are kept in the operating system's native vault (Windows Credential
+Manager, macOS Keychain, Android Keystore, Linux libsecret) — never in a
+plaintext file.
+
+`SecretStore` is the async seam between the GUI and storage. Most platforms use
+`flet-secure-storage`, while macOS uses the native `security` CLI to avoid
+Flet's prebuilt desktop runner hitting Keychain entitlement errors.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+from abc import ABC, abstractmethod
+
+from flet_secure_storage import SecureStorage
+
+# Logical secret keys.
+IGP_PASSWORD = "igp_password"
+BRYTON_PASSWORD = "bryton_password"
+INTERVALS_API_KEY = "intervals_api_key"
+DROPBOX_REFRESH_TOKEN = "dropbox_refresh_token"
+MACOS_KEYCHAIN_SERVICE = "io.github.jorgehuxley.intervalssync"
+
+
+class SecretStore(ABC):
+    @abstractmethod
+    async def get(self, key: str) -> str | None: ...
+
+    @abstractmethod
+    async def set(self, key: str, value: str) -> None: ...
+
+    @abstractmethod
+    async def delete(self, key: str) -> None: ...
+
+
+class FletSecureStorage(SecretStore):
+    """Stores secrets in the OS-native vault via a flet-secure-storage service.
+
+    The `SecureStorage` service must already be registered on the page
+    (``page.services.append(storage)``) before use.
+    """
+
+    def __init__(self, storage: SecureStorage) -> None:
+        self._storage = storage
+
+    async def get(self, key: str) -> str | None:
+        return await self._storage.get(key)
+
+    async def set(self, key: str, value: str) -> None:
+        await self._storage.set(key, value)
+
+    async def delete(self, key: str) -> None:
+        await self._storage.remove(key)
+
+
+class MacOSKeychainStore(SecretStore):
+    """Stores secrets in the user's macOS login Keychain."""
+
+    def __init__(self, service: str = MACOS_KEYCHAIN_SERVICE) -> None:
+        self._service = service
+
+    async def get(self, key: str) -> str | None:
+        return await asyncio.to_thread(self._get_sync, key)
+
+    async def set(self, key: str, value: str) -> None:
+        await asyncio.to_thread(self._set_sync, key, value)
+
+    async def delete(self, key: str) -> None:
+        await asyncio.to_thread(self._delete_sync, key)
+
+    def _get_sync(self, key: str) -> str | None:
+        result = self._run_security(
+            "find-generic-password",
+            "-s",
+            self._service,
+            "-a",
+            key,
+            "-w",
+        )
+        if result.returncode == 0:
+            return result.stdout.removesuffix("\n")
+        if _is_missing_keychain_item(result):
+            return None
+        raise _keychain_error("read", key, result)
+
+    def _set_sync(self, key: str, value: str) -> None:
+        result = self._run_security(
+            "add-generic-password",
+            "-U",
+            "-s",
+            self._service,
+            "-a",
+            key,
+            "-w",
+            value,
+        )
+        if result.returncode != 0:
+            raise _keychain_error("save", key, result)
+
+    def _delete_sync(self, key: str) -> None:
+        result = self._run_security(
+            "delete-generic-password",
+            "-s",
+            self._service,
+            "-a",
+            key,
+        )
+        if result.returncode == 0 or _is_missing_keychain_item(result):
+            return
+        raise _keychain_error("delete", key, result)
+
+    def _run_security(self, *args: str) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            ["security", *args],
+            capture_output=True,
+            check=False,
+            text=True,
+        )
+
+
+def _is_missing_keychain_item(result: subprocess.CompletedProcess[str]) -> bool:
+    output = f"{result.stdout}\n{result.stderr}".lower()
+    return result.returncode == 44 or "could not be found" in output
+
+
+def _keychain_error(
+    action: str,
+    key: str,
+    result: subprocess.CompletedProcess[str],
+) -> RuntimeError:
+    detail = (result.stderr or result.stdout or f"exit code {result.returncode}").strip()
+    return RuntimeError(f"Could not {action} Keychain item {key!r}: {detail}")