intervalssync 0.9.3__py3-none-any.whl

intervalssync/dropbox_client.py

@@ -0,0 +1,143 @@
+"""Dropbox OAuth and upload helpers."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import dropbox
+from dropbox import DropboxOAuth2FlowNoRedirect
+from dropbox.exceptions import ApiError
+from dropbox.files import FileMetadata, WriteMode
+from requests.exceptions import HTTPError
+
+from ._dropbox_app_key import DROPBOX_APP_KEY as BUILD_DROPBOX_APP_KEY
+
+DROPBOX_APP_KEY_ENV = "IGPSYNC_DROPBOX_APP_KEY"
+DEFAULT_DROPBOX_FOLDER = "/intervalssync-fit"
+
+def get_dropbox_app_key() -> str | None:
+    """Return the Dropbox app key from env or the build-stamped constant."""
+    return os.getenv(DROPBOX_APP_KEY_ENV) or BUILD_DROPBOX_APP_KEY or None
+
+
+def normalize_folder(folder: str) -> str:
+    """Return a leading-slash, no-trailing-slash Dropbox folder path."""
+    clean = (folder or DEFAULT_DROPBOX_FOLDER).strip()
+    if not clean.startswith("/"):
+        clean = f"/{clean}"
+    return clean.rstrip("/")
+
+
+def dropbox_path_for(folder: str, filename: str) -> str:
+    """Return the Dropbox path for a FIT filename."""
+    return f"{normalize_folder(folder)}/{filename}"
+
+
+def start_dropbox_auth(app_key: str) -> tuple[DropboxOAuth2FlowNoRedirect, str]:
+    """Start a PKCE OAuth flow and return the flow object plus auth URL."""
+    auth_flow = DropboxOAuth2FlowNoRedirect(
+        app_key,
+        use_pkce=True,
+        token_access_type="offline",
+        # files.metadata.read lets us list the folder to skip rides already there.
+        scope=[
+            "account_info.read",
+            "files.metadata.read",
+            "files.content.write",
+        ],
+    )
+    return auth_flow, auth_flow.start()
+
+
+def _friendly_auth_error(exc: HTTPError) -> str:
+    """Turn a token-exchange HTTPError into a user-facing message.
+
+    The Dropbox SDK calls ``raise_for_status()`` and drops the response body,
+    so a failed exchange surfaces only a generic "400 Client Error". The most
+    common failure with the copy-paste flow is an expired/used code
+    (``invalid_grant``) — give that a friendly hint and fall back to Dropbox's
+    raw error text for anything unexpected.
+    """
+    body = ""
+    if exc.response is not None:
+        body = exc.response.text.strip()
+    if "invalid_grant" in body:
+        return (
+            "That authorization code expired or was already used. Tap "
+            "Connect Dropbox again and paste the new code quickly."
+        )
+    return f"{exc} — {body}" if body else str(exc)
+
+
+def finish_dropbox_auth(
+    auth_flow: DropboxOAuth2FlowNoRedirect, auth_code: str
+) -> str | None:
+    """Finish OAuth and return the long-lived refresh token."""
+    try:
+        result = auth_flow.finish(auth_code.strip())
+    except HTTPError as exc:
+        raise RuntimeError(_friendly_auth_error(exc)) from exc
+    return result.refresh_token
+
+
+def upload_to_dropbox(
+    fit_path: Path,
+    filename: str,
+    refresh_token: str,
+    app_key: str,
+    folder: str = DEFAULT_DROPBOX_FOLDER,
+) -> None:
+    """Upload a FIT file to Dropbox, overwriting the ride's existing file.
+
+    Raises on failure; a normal return means the upload succeeded.
+    """
+    target = dropbox_path_for(folder, filename)
+    with dropbox.Dropbox(
+        oauth2_refresh_token=refresh_token,
+        app_key=app_key,
+        timeout=100,
+        user_agent="intervalssync",
+    ) as dbx:
+        with fit_path.open("rb") as f:
+            dbx.files_upload(
+                f.read(),
+                target,
+                mode=WriteMode.overwrite,
+                mute=True,
+            )
+
+
+def list_dropbox_fit_names(
+    folder: str, refresh_token: str, app_key: str
+) -> set[str]:
+    """Return FIT filenames already present in the folder.
+
+    Returns an empty set when the folder doesn't exist yet. Raises on other
+    Dropbox errors so the caller can decide whether to treat them as fatal.
+    """
+    base = normalize_folder(folder)
+    fit_names: set[str] = set()
+    with dropbox.Dropbox(
+        oauth2_refresh_token=refresh_token,
+        app_key=app_key,
+        timeout=100,
+        user_agent="intervalssync",
+    ) as dbx:
+        try:
+            result = dbx.files_list_folder(base)
+        except ApiError as exc:
+            if exc.error.is_path() and exc.error.get_path().is_not_found():
+                return fit_names
+            raise
+        entries = list(result.entries)
+        while result.has_more:
+            result = dbx.files_list_folder_continue(result.cursor)
+            entries.extend(result.entries)
+
+    for entry in entries:
+        if not isinstance(entry, FileMetadata):
+            continue
+        if entry.name.lower().endswith(".fit"):
+            fit_names.add(entry.name)
+    return fit_names

intervalssync/gui/__init__.py

@@ -0,0 +1 @@
+"""Flet GUI for intervalssync."""

intervalssync/gui/app.py

@@ -0,0 +1,352 @@
+"""Flet application entry point and view routing."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+
+import flet as ft
+from flet_permission_handler import Permission, PermissionHandler, PermissionStatus
+from flet_secure_storage import SecureStorage
+
+from .. import __version__
+from . import config as config_module
+from . import secrets as secrets_module
+from .update_check import RELEASES_PAGE, check_for_update
+from .settings_view import build_settings_view
+from .sync_view import build_sync_view
+from . import profile_sync_ui
+from . import support_gamification
+from . import theme
+
+
+_DESKTOP = {ft.PagePlatform.WINDOWS, ft.PagePlatform.MACOS, ft.PagePlatform.LINUX}
+_MOBILE = {ft.PagePlatform.ANDROID, ft.PagePlatform.ANDROID_TV, ft.PagePlatform.IOS}
+_PERMISSION_HANDLER_PLATFORMS = {
+    ft.PagePlatform.ANDROID,
+    ft.PagePlatform.ANDROID_TV,
+    ft.PagePlatform.IOS,
+    ft.PagePlatform.WINDOWS,
+    *([ft.PagePlatform.WEB] if hasattr(ft.PagePlatform, "WEB") else []),
+}
+# Standard public Downloads directory on Android (the filesystem name is the
+# singular "Download"). Used when the user opts in and grants storage access.
+ANDROID_DOWNLOADS = "/storage/emulated/0/Download/intervalssync-fit"
+
+APP_TITLE = "Intervals Sync"
+APP_ICON = "icon.png"
+
+
+def _assets_dir() -> str:
+    dev_assets = Path(__file__).resolve().parents[3] / "assets"
+    if dev_assets.is_dir():
+        return str(dev_assets)
+    return "assets"
+
+_TAB_SYNC = 0
+_TAB_SETTINGS = 1
+
+
+async def _has_credentials(
+    config: config_module.AppConfig,
+    store: secrets_module.SecretStore,
+) -> bool:
+    if config.enable_igpsport and config.igp_user and await store.get(secrets_module.IGP_PASSWORD):
+        return True
+    if config.enable_bryton and config.bryton_user and await store.get(secrets_module.BRYTON_PASSWORD):
+        return True
+    return False
+
+
+def _supports_permission_handler(platform: ft.PagePlatform) -> bool:
+    return platform in _PERMISSION_HANDLER_PLATFORMS
+
+
+def _secret_store_for_platform(
+    platform: ft.PagePlatform,
+) -> tuple[secrets_module.SecretStore, SecureStorage | None]:
+    if platform == ft.PagePlatform.MACOS:
+        return secrets_module.MacOSKeychainStore(), None
+
+    storage = SecureStorage()
+    return secrets_module.FletSecureStorage(storage), storage
+
+
+async def _app(page: ft.Page) -> None:
+    page.title = APP_TITLE
+    page.theme_mode = ft.ThemeMode.SYSTEM
+    theme.apply_page_theme(page)
+    page.padding = 0
+    page.bgcolor = theme.palette(page)["bg"]
+
+    if page.platform in _DESKTOP:
+        page.window.width = 600
+        page.window.height = 760
+        page.window.min_width = 400
+        page.window.min_height = 560
+
+    config = config_module.load()
+
+    store, storage = _secret_store_for_platform(page.platform)
+    perms = PermissionHandler() if _supports_permission_handler(page.platform) else None
+    if storage is not None:
+        page.services.append(storage)
+    if perms is not None:
+        page.services.append(perms)
+
+    def _private_download_dir() -> str:
+        base = os.getenv("FLET_APP_STORAGE_DATA") or tempfile.gettempdir()
+        return str(Path(base) / "intervalssync-fit")
+
+    async def apply_download_location() -> None:
+        if page.platform not in _MOBILE:
+            return
+        config.download_dir = _private_download_dir()
+        if config.save_to_downloads:
+            try:
+                status = await perms.get_status(Permission.MANAGE_EXTERNAL_STORAGE)
+            except Exception:  # noqa: BLE001 — never let this break startup
+                status = None
+            if status == PermissionStatus.GRANTED:
+                config.download_dir = ANDROID_DOWNLOADS
+
+    await apply_download_location()
+
+    body = ft.Container(expand=True)
+    header_slot = ft.Container()
+    current_tab = _TAB_SYNC
+    is_mobile = page.platform in _MOBILE
+
+    def _refresh_bg() -> None:
+        page.bgcolor = theme.palette(page)["bg"]
+
+    def _scrollable(view: ft.Control) -> ft.Control:
+        return ft.Column([view], scroll=ft.ScrollMode.AUTO, expand=True)
+
+    async def open_releases(_: ft.ControlEvent) -> None:
+        await page.launch_url(RELEASES_PAGE)
+
+    def notify_update(latest: str | None, *, quiet_when_current: bool) -> None:
+        if latest:
+            page.show_dialog(
+                ft.SnackBar(
+                    content=ft.Text(f"Update available: v{latest}"),
+                    action="View",
+                    on_action=open_releases,
+                    duration=8000,
+                )
+            )
+        elif not quiet_when_current:
+            page.show_dialog(ft.SnackBar(ft.Text("You're on the latest version.")))
+        page.update()
+
+    async def check_updates_now(_: ft.ControlEvent) -> None:
+        page.pop_dialog()
+        latest = await asyncio.to_thread(check_for_update, __version__, allow_dev=True)
+        notify_update(latest, quiet_when_current=False)
+
+    def show_about(_: ft.ControlEvent | None = None) -> None:
+        colors = theme.palette(page)
+        page.show_dialog(
+            ft.AlertDialog(
+                modal=True,
+                shape=ft.RoundedRectangleBorder(radius=theme.RADIUS_MD),
+                title=theme.display_text("About", size=22),
+                content=ft.Column(
+                    tight=True,
+                    spacing=theme.SPACE_SM,
+                    controls=[
+                        ft.Text(
+                            APP_TITLE,
+                            weight=ft.FontWeight.W_600,
+                            color=colors["text"],
+                        ),
+                        ft.Text(
+                            f"Version {__version__}",
+                            size=13,
+                            color=colors["text_muted"],
+                        ),
+                        ft.Text(
+                            "Sync rides and planned workouts between iGPSPORT, "
+                            "Bryton Active, and intervals.icu.",
+                            size=13,
+                            color=colors["text_muted"],
+                        ),
+                    ],
+                ),
+                actions=[
+                    ft.TextButton("Check for updates", on_click=check_updates_now),
+                    ft.TextButton(
+                        "GitHub",
+                        url="https://github.com/jorge-huxley/intervalssync",
+                    ),
+                    ft.TextButton("Close", on_click=lambda _: page.pop_dialog()),
+                ],
+            )
+        )
+
+    def _header() -> ft.Container:
+        colors = theme.palette(page)
+        return ft.Container(
+            content=ft.Row(
+                alignment=ft.MainAxisAlignment.SPACE_BETWEEN,
+                vertical_alignment=ft.CrossAxisAlignment.CENTER,
+                controls=[
+                    ft.Row(
+                        spacing=theme.SPACE_SM,
+                        vertical_alignment=ft.CrossAxisAlignment.CENTER,
+                        controls=[
+                            ft.Container(
+                                width=36,
+                                height=36,
+                                border_radius=theme.RADIUS_SM,
+                                clip_behavior=ft.ClipBehavior.ANTI_ALIAS,
+                                content=ft.Image(
+                                    src=APP_ICON,
+                                    width=36,
+                                    height=36,
+                                    fit=ft.BoxFit.COVER,
+                                ),
+                            ),
+                            ft.Column(
+                                spacing=0,
+                                controls=[
+                                    theme.display_text(APP_TITLE, size=18, color=colors["text"]),
+                                    ft.Text(
+                                        "iGPSPORT · Bryton · intervals.icu",
+                                        size=11,
+                                        color=colors["text_muted"],
+                                    ),
+                                ],
+                            ),
+                        ],
+                    ),
+                    ft.Row(
+                        spacing=0,
+                        controls=[
+                            support_gamification.kofi_header_button(page),
+                            ft.IconButton(
+                                icon=ft.Icons.INFO_OUTLINE,
+                                tooltip="About",
+                                icon_color=colors["text_muted"],
+                                on_click=show_about,
+                            ),
+                        ],
+                    ),
+                ],
+            ),
+            padding=ft.Padding(
+                theme.SPACE_LG,
+                theme.SPACE_MD,
+                theme.SPACE_LG,
+                theme.SPACE_MD,
+            ),
+            bgcolor=colors["bg"],
+            border=ft.Border(bottom=ft.BorderSide(1, colors["border"])),
+        )
+
+    async def show_sync(_: ft.ControlEvent | None = None) -> None:
+        nonlocal current_tab
+        current_tab = _TAB_SYNC
+        body.content = _scrollable(build_sync_view(page, config, store))
+        header_slot.content = _header()
+        _update_nav()
+        _refresh_bg()
+        page.update()
+
+    async def show_settings(_: ft.ControlEvent | None = None) -> None:
+        nonlocal current_tab
+        current_tab = _TAB_SETTINGS
+
+        async def on_profile_sync_check() -> None:
+            await profile_sync_ui.prompt_if_needed(page, config, store)
+
+        body.content = _scrollable(
+            await build_settings_view(
+                page,
+                config,
+                store,
+                on_saved=show_sync,
+                perms=perms,
+                apply_download_location=apply_download_location,
+                on_profile_sync_check=on_profile_sync_check,
+            )
+        )
+        header_slot.content = _header()
+        _update_nav()
+        _refresh_bg()
+        page.update()
+
+    sync_tab = ft.TextButton("Sync", on_click=show_sync)
+    settings_tab = ft.TextButton("Settings", on_click=show_settings)
+    desktop_tabs = ft.Container(
+        content=ft.Row(
+            alignment=ft.MainAxisAlignment.CENTER,
+            controls=[sync_tab, settings_tab],
+        ),
+        padding=ft.Padding(0, theme.SPACE_SM, 0, theme.SPACE_SM),
+    )
+
+    def _update_nav() -> None:
+        colors = theme.palette(page)
+        for idx, btn in enumerate((sync_tab, settings_tab)):
+            active = idx == current_tab
+            btn.style = ft.ButtonStyle(
+                color=colors["accent"] if active else colors["text_muted"],
+                bgcolor=colors["accent_soft"] if active else ft.Colors.TRANSPARENT,
+                shape=ft.RoundedRectangleBorder(radius=theme.RADIUS_SM),
+                padding=ft.Padding(
+                    theme.SPACE_MD, theme.SPACE_SM, theme.SPACE_MD, theme.SPACE_SM
+                ),
+            )
+
+    page.add(
+        ft.SafeArea(
+            expand=True,
+            content=ft.Column(
+                expand=True,
+                spacing=0,
+                controls=[
+                    header_slot,
+                    desktop_tabs,
+                    ft.Container(
+                        content=body,
+                        expand=True,
+                        padding=ft.Padding(
+                            theme.SPACE_LG,
+                            theme.SPACE_MD,
+                            theme.SPACE_LG,
+                            theme.SPACE_LG if not is_mobile else theme.SPACE_MD,
+                        ),
+                    ),
+                ],
+            ),
+        )
+    )
+
+    if await _has_credentials(config, store):
+        await show_sync()
+    else:
+        await show_settings()
+
+    async def auto_check_updates() -> None:
+        latest = await asyncio.to_thread(check_for_update, __version__)
+        notify_update(latest, quiet_when_current=True)
+
+    async def auto_check_profile_sync() -> None:
+        if not config.enable_igpsport or not config.profile_sync_check_on_launch:
+            return
+        await profile_sync_ui.prompt_if_needed(page, config, store)
+
+    page.run_task(auto_check_updates)
+    page.run_task(auto_check_profile_sync)
+
+
+def main() -> None:
+    ft.run(_app, assets_dir=_assets_dir())
+
+
+if __name__ == "__main__":
+    main()

intervalssync/gui/config.py

@@ -0,0 +1,102 @@
+"""Non-secret settings persisted as JSON in the per-user config directory.
+
+Secrets never live here — they go to the OS vault via `secrets.py`. This file
+holds source usernames (identifiers, not secrets), step toggles, the activity
+cap and the download directory.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+from platformdirs import user_config_dir, user_downloads_dir
+
+APP_NAME = "intervalssync"
+
+CONFIG_DIR = Path(user_config_dir(APP_NAME, appauthor=False))
+CONFIG_PATH = CONFIG_DIR / "config.json"
+
+
+def _default_download_dir() -> str:
+    return str(Path(user_downloads_dir()) / "intervalssync-fit")
+
+
+@dataclass
+class AppConfig:
+    enable_igpsport: bool = True
+    enable_bryton: bool = False
+    igp_user: str = ""
+    igp_region: str = "international"
+    bryton_user: str = ""
+    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.
+    delete_after_upload: bool = True
+    # Re-download/re-upload activities even if already on intervals.icu or Dropbox.
+    force_resync: bool = False
+    # intervals.icu sport set on uploaded activities ("" = leave as uploaded).
+    activity_type: str = ""
+    # Android only: save downloads to the public Downloads folder (needs the
+    # "all files access" permission) instead of app-private storage.
+    save_to_downloads: bool = False
+    # Step toggles (advanced). The GUI's one-click sync sets these for the user.
+    step_list_activities: bool = True
+    step_get_download_url: bool = True
+    step_download_fit: bool = True
+    step_upload_intervals: bool = True
+    # Optional secondary upload target. Off by default because most users only
+    # want intervals.icu.
+    upload_dropbox: bool = False
+    dropbox_folder: str = "/intervalssync-fit"
+    dropbox_date_filenames: bool = True
+    # 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.
+    uploaded_bryton_workouts: dict[str, str] = field(default_factory=dict)
+    # How many calendar days of planned workouts to upload (1 = today only).
+    workout_days_ahead: int = 1
+    # intervals.icu threshold fingerprint the user declined to sync; cleared after sync.
+    profile_sync_declined_fingerprint: str = ""
+    # Prompt on launch when FTP, LTHR, max HR, or weight differ from intervals.icu.
+    profile_sync_check_on_launch: bool = True
+    # Lifetime sync stats (GUI gamification).
+    lifetime_activities_uploaded: int = 0
+    lifetime_workouts_uploaded: int = 0
+    celebrated_milestones: list[int] = field(default_factory=list)
+    stats_seeded: bool = False
+
+
+def total_uploads(config: AppConfig) -> int:
+    return config.lifetime_activities_uploaded + config.lifetime_workouts_uploaded
+
+
+def any_source_enabled(config: AppConfig) -> bool:
+    return config.enable_igpsport or config.enable_bryton
+
+
+def load() -> AppConfig:
+    """Load config from disk, falling back to defaults."""
+    data: dict = {}
+    if CONFIG_PATH.exists():
+        data = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+
+    # Migrate legacy single-source picker (ignored on save going forward).
+    activity_source = data.pop("activity_source", None)
+    cfg = AppConfig(**{k: v for k, v in data.items() if k in AppConfig.__annotations__})
+    if activity_source == "bryton":
+        cfg.enable_bryton = True
+        cfg.enable_igpsport = False
+    if not cfg.stats_seeded:
+        cfg.lifetime_workouts_uploaded = len(cfg.uploaded_workouts) + len(
+            cfg.uploaded_bryton_workouts
+        )
+        cfg.stats_seeded = True
+        save(cfg)
+    return cfg
+
+
+def save(config: AppConfig) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(asdict(config), indent=2), encoding="utf-8")