eticu 0.2.1__py3-none-any.whl

eticu/__init__.py

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

eticu/cli.py

@@ -0,0 +1,229 @@
+"""eticu CLI — scrape / download / convert / upload / all."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+app = typer.Typer(help="Convert 80/20 Endurance workouts to intervals.icu structured workouts.")
+
+_DEFAULT_CACHE = Path("8020_cache")
+
+
+def _setup_logging(verbose: bool) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(level=level, format="%(levelname)s %(message)s", stream=sys.stderr)
+
+
+# ---------------------------------------------------------------------------
+# scrape
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def scrape(
+    verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
+) -> None:
+    """List all .FIT URLs from the 80/20 workout library (no download)."""
+    _setup_logging(verbose)
+    from eticu.scrape import scrape_workout_urls
+
+    grouped = scrape_workout_urls()
+    for sport, urls in grouped.items():
+        for url in urls:
+            typer.echo(f"{sport}\t{url}")
+    total = sum(len(v) for v in grouped.values())
+    run, ride, swim = len(grouped["Run"]), len(grouped["Ride"]), len(grouped["Swim"])
+    typer.echo(f"\nTotal: {total}  (Run={run}  Ride={ride}  Swim={swim})")
+
+
+# ---------------------------------------------------------------------------
+# download
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def download(
+    cache_dir: Annotated[Path, typer.Option("--cache-dir")] = _DEFAULT_CACHE,
+    workers: Annotated[int, typer.Option("--jobs", "-j")] = 4,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
+) -> None:
+    """Download all .FIT files to a local cache directory."""
+    _setup_logging(verbose)
+    from eticu.download import download_all
+    from eticu.scrape import scrape_workout_urls
+
+    grouped = scrape_workout_urls()
+    all_urls = [u for urls in grouped.values() for u in urls]
+    typer.echo(f"Downloading {len(all_urls)} files to {cache_dir} ...")
+    counts = download_all(all_urls, cache_dir, workers=workers, dry_run=dry_run)
+    typer.echo(f"Done. ok={counts['ok']}  skip={counts['skip']}  error={counts['error']}")
+    if counts["error"]:
+        raise typer.Exit(1)
+
+
+# ---------------------------------------------------------------------------
+# convert
+# ---------------------------------------------------------------------------
+
+
+@app.command(name="convert")
+def convert_cmd(
+    fit_file: Annotated[Path, typer.Argument(help=".FIT file to convert")],
+    cycling_power: Annotated[bool, typer.Option("--cycling-power")] = False,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
+) -> None:
+    """Convert a single .FIT workout file and print the intervals.icu text."""
+    _setup_logging(verbose)
+    from eticu.convert import convert as do_convert
+    from eticu.fit_parse import parse_fit
+
+    workout = parse_fit(fit_file)
+    typer.echo(do_convert(workout, cycling_power=cycling_power))
+
+
+# ---------------------------------------------------------------------------
+# upload
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def upload(
+    cache_dir: Annotated[Path, typer.Option("--cache-dir")] = _DEFAULT_CACHE,
+    cycling_power: Annotated[bool, typer.Option("--cycling-power")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
+) -> None:
+    """Upload converted workouts to intervals.icu workout library."""
+    _setup_logging(verbose)
+    from eticu.config import get_settings
+    from eticu.intervals_client import IntervalsClient
+    from eticu.upload import upload_workouts
+
+    settings = get_settings()
+    if not settings.intervals_api_key or not settings.intervals_athlete_id:
+        typer.echo("Error: INTERVALS_API_KEY and INTERVALS_ATHLETE_ID must be set.", err=True)
+        raise typer.Exit(1)
+
+    fit_files = sorted(set(cache_dir.rglob("*.FIT")) | set(cache_dir.rglob("*.fit")))
+    if not fit_files:
+        typer.echo(f"No .FIT files found in {cache_dir}. Run 'eticu download' first.")
+        raise typer.Exit(1)
+
+    typer.echo(f"Uploading {len(fit_files)} workout(s) ...")
+    with IntervalsClient(settings.intervals_api_key, settings.intervals_athlete_id) as client:
+        counts = upload_workouts(fit_files, client, cycling_power=cycling_power, dry_run=dry_run)
+
+    typer.echo(
+        f"Done. created={counts['created']}  updated={counts['updated']}  "
+        f"skipped={counts['skipped']}  error={counts['error']}"
+    )
+    if counts["error"]:
+        raise typer.Exit(1)
+
+
+# ---------------------------------------------------------------------------
+# upload-plan
+# ---------------------------------------------------------------------------
+
+
+@app.command(name="upload-plan")
+def upload_plan_cmd(
+    plan_csv: Annotated[Path, typer.Argument(help="CSV file containing the plan")],
+    name: Annotated[str, typer.Option("--name", "-n", help="Name of the training plan folder")],
+    pool_length: Annotated[int | None, typer.Option("--pool-length", help="Pool length in meters (e.g., 25 or 50)")] = None,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
+) -> None:
+    """Upload a training plan from a CSV to intervals.icu."""
+    _setup_logging(verbose)
+    from eticu.config import get_settings
+    from eticu.intervals_client import IntervalsClient
+    from eticu.upload import upload_plan
+
+    settings = get_settings()
+    if not dry_run and (not settings.intervals_api_key or not settings.intervals_athlete_id):
+        typer.echo("Error: INTERVALS_API_KEY and INTERVALS_ATHLETE_ID must be set.", err=True)
+        raise typer.Exit(1)
+
+    typer.echo(f"Uploading plan {name!r} from {plan_csv} ...")
+    if dry_run:
+        typer.echo("  [DRY-RUN] Will not perform actual upload.")
+
+    with IntervalsClient(settings.intervals_api_key, settings.intervals_athlete_id) as client:
+        counts = upload_plan(
+            csv_file=plan_csv,
+            plan_name=name,
+            client=client,
+            pool_length_m=pool_length,
+            dry_run=dry_run,
+        )
+
+    typer.echo(
+        f"Done. created={counts['created']}  updated={counts['updated']}  "
+        f"skipped={counts['skipped']}  error={counts['error']}  missing={counts['missing']}"
+    )
+    if counts["error"] or counts["missing"]:
+        raise typer.Exit(1)
+
+
+# ---------------------------------------------------------------------------
+# all
+# ---------------------------------------------------------------------------
+
+
+@app.command(name="all")
+def all_cmd(
+    cache_dir: Annotated[Path, typer.Option("--cache-dir")] = _DEFAULT_CACHE,
+    workers: Annotated[int, typer.Option("--jobs", "-j")] = 4,
+    cycling_power: Annotated[bool, typer.Option("--cycling-power")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
+) -> None:
+    """Run the full pipeline: scrape → download → upload."""
+    _setup_logging(verbose)
+    from eticu.config import get_settings
+    from eticu.download import download_all
+    from eticu.intervals_client import IntervalsClient
+    from eticu.scrape import scrape_workout_urls
+    from eticu.upload import upload_workouts
+
+    settings = get_settings()
+    if not dry_run and (not settings.intervals_api_key or not settings.intervals_athlete_id):
+        typer.echo("Error: INTERVALS_API_KEY and INTERVALS_ATHLETE_ID must be set.", err=True)
+        raise typer.Exit(1)
+
+    typer.echo("Step 1/3: Scraping workout URLs ...")
+    grouped = scrape_workout_urls()
+    all_urls = [u for urls in grouped.values() for u in urls]
+    typer.echo(f"  Found {len(all_urls)} URLs.")
+
+    typer.echo(f"Step 2/3: Downloading to {cache_dir} ...")
+    dl = download_all(all_urls, cache_dir, workers=workers, dry_run=dry_run)
+    typer.echo(f"  ok={dl['ok']}  skip={dl['skip']}  error={dl['error']}")
+
+    fit_files = sorted(set(cache_dir.rglob("*.FIT")) | set(cache_dir.rglob("*.fit")))
+    typer.echo(f"Step 3/3: Uploading {len(fit_files)} workout(s) ...")
+
+    if dry_run:
+        typer.echo("  [DRY-RUN] Skipping upload.")
+        return
+
+    with IntervalsClient(settings.intervals_api_key, settings.intervals_athlete_id) as client:
+        counts = upload_workouts(fit_files, client, cycling_power=cycling_power, dry_run=dry_run)
+
+    typer.echo(
+        f"  created={counts['created']}  updated={counts['updated']}  "
+        f"skipped={counts['skipped']}  error={counts['error']}"
+    )
+    if counts["error"]:
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

eticu/config.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
+
+    intervals_api_key: str = ""
+    intervals_athlete_id: str = ""
+
+    @property
+    def base_url(self) -> str:
+        return f"https://intervals.icu/api/v1/athlete/{self.intervals_athlete_id}"
+
+
+_settings: Settings | None = None
+
+
+def get_settings() -> Settings:
+    global _settings
+    if _settings is None:
+        _settings = Settings()
+    return _settings

eticu/convert.py

@@ -0,0 +1,130 @@
+"""Convert a Workout model to intervals.icu workout description text.
+
+Format notes (validated against intervals.icu documentation):
+- Steps: "- [name] [duration] [target]"
+- Time:  "5m", "30s", "1h", "5m30s"  ('m' = minutes)
+- Distance run/ride: "2.0km"  (km, rounded to 0.1 km)
+- Distance swim: "400mtr"  ('mtr' suffix for metres — 'mtr' ≠ 'm' which means minutes)
+- HR target:    "Z1 HR"  (zone number + "HR" suffix)
+- Power target: "Z1"     (bare zone, power is the default target type)
+- Repeat:       "3x" on its own line; terminated by a BLANK LINE after the
+                last step in the block — without the blank line, subsequent
+                steps are interpreted as still inside the repeat.
+
+NOTE: The ROADMAP §0.5 golden text omits the blank-line terminator.  That
+omission is corrected here based on verified intervals.icu format rules.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from eticu.models import Element, RepeatBlock, Step, Workout
+from eticu.zones import icu_zone_label, step_label
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Duration formatting
+# ---------------------------------------------------------------------------
+
+
+def _format_time(seconds: float) -> str:
+    total = int(round(seconds))
+    h, rem = divmod(total, 3600)
+    m, s = divmod(rem, 60)
+    parts: list[str] = []
+    if h:
+        parts.append(f"{h}h")
+    if m:
+        parts.append(f"{m}m")
+    if s:
+        parts.append(f"{s}s")
+    return "".join(parts) if parts else "0s"
+
+
+def _format_distance_run(metres: float) -> str:
+    """Round to nearest 0.1 km, emit as '2.0km'."""
+    km = round(metres / 1000, 1)
+    return f"{km:.1f}km"
+
+
+def _format_distance_swim(metres: float) -> str:
+    """Round to nearest 25 m, emit as '400mtr' ('mtr' ≠ 'm' = minutes)."""
+    rounded = round(metres / 25) * 25
+    return f"{int(rounded)}mtr"
+
+
+def _format_duration(step: Step, sport: str) -> str:
+    if step.kind == "time" and step.value > 0:
+        return _format_time(step.value)
+    if step.kind == "distance" and step.value > 0:
+        if sport == "Swim":
+            return _format_distance_swim(step.value)
+        return _format_distance_run(step.value)
+    return "lap"
+
+
+# ---------------------------------------------------------------------------
+# Target formatting
+# ---------------------------------------------------------------------------
+
+
+def _format_target(zone_8020: str | None, sport: str, cycling_power: bool) -> str:
+    icu_zone = icu_zone_label(zone_8020)
+    if sport == "Ride" and cycling_power:
+        return icu_zone  # Power target: bare zone
+    return f"{icu_zone} HR"  # HR target
+
+
+# ---------------------------------------------------------------------------
+# Step / block rendering
+# ---------------------------------------------------------------------------
+
+
+def _render_step(step: Step, sport: str, cycling_power: bool) -> str:
+    if step.zone_8020 is None and step.intensity not in ("rest", "recovery", "warmup", "cooldown"):
+        logger.warning("Step has no zone; defaulting to 8020/Z1 (Z1)")
+    label = step_label(step.zone_8020)
+    duration = _format_duration(step, sport)
+    target = _format_target(step.zone_8020, sport, cycling_power)
+
+    prefix = ""
+    if step.intensity and step.intensity not in ("active", "interval", "other"):
+        prefix = f"{step.intensity.capitalize()} "
+
+    return f"- {prefix}{label} {duration} {target}"
+
+
+def _render_elements(
+    elements: list[Element],
+    sport: str,
+    cycling_power: bool,
+) -> list[str]:
+    lines: list[str] = []
+    for i, elem in enumerate(elements):
+        if isinstance(elem, Step):
+            lines.append(_render_step(elem, sport, cycling_power))
+        elif isinstance(elem, RepeatBlock):
+            if i > 0 and (not lines or lines[-1] != ""):
+                lines.append("")
+            lines.append(f"{elem.count}x")
+            lines.extend(_render_elements(elem.children, sport, cycling_power))
+            # Blank line terminates the repeat block in intervals.icu format.
+            # Without it, subsequent steps are treated as inside the block.
+            if i < len(elements) - 1:
+                lines.append("")
+    return lines
+
+
+def convert(workout: Workout, cycling_power: bool = False) -> str:
+    """Render a Workout as intervals.icu workout description text.
+
+    Args:
+        workout: The parsed workout.
+        cycling_power: If True and sport is Ride, emit Power zone targets
+                       instead of HR.  Run/Swim always use HR regardless.
+    """
+    lines = _render_elements(workout.elements, workout.sport, cycling_power)
+    return "\n".join(lines)

eticu/download.py

@@ -0,0 +1,115 @@
+"""Download .FIT files to a local cache directory.
+
+Features:
+- Resumable: skips files that already exist and are non-empty.
+- Atomic writes: download to a .part file, then rename.
+- Modest concurrency with a configurable thread count.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+_HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+        "(KHTML, like Gecko) Chrome/124.0 Safari/537.36"
+    )
+}
+
+
+def local_path(url: str, cache_dir: Path) -> Path:
+    """Map a .FIT URL to a local path, preserving the sport subfolder."""
+    parts = [unquote(p) for p in urlparse(url).path.split("/") if p]
+    tail = parts[-2:] if len(parts) >= 2 else parts[-1:]
+    return cache_dir.joinpath(*tail)
+
+
+def _download_one(
+    client: httpx.Client,
+    url: str,
+    cache_dir: Path,
+    retries: int = 3,
+) -> tuple[str, str]:
+    """Download a single file; return (url, status) where status ∈ ok/skip/error:…"""
+    dest = local_path(url, cache_dir)
+    if dest.exists() and dest.stat().st_size > 0:
+        return url, "skip"
+
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    for attempt in range(1, retries + 1):
+        try:
+            with client.stream("GET", url, timeout=60) as r:
+                r.raise_for_status()
+                tmp = dest.with_suffix(dest.suffix + ".part")
+                with open(tmp, "wb") as f:
+                    for chunk in r.iter_bytes(chunk_size=64 * 1024):
+                        f.write(chunk)
+                tmp.replace(dest)
+            return url, "ok"
+        except httpx.HTTPError as exc:
+            if attempt == retries:
+                return url, f"error: {exc}"
+            time.sleep(2 * attempt)
+    return url, "error: exhausted retries"
+
+
+def download_all(
+    urls: list[str],
+    cache_dir: Path,
+    *,
+    workers: int = 4,
+    dry_run: bool = False,
+) -> dict[str, int]:
+    """Download a list of .FIT URLs into cache_dir.
+
+    Returns counts: {"ok": N, "skip": N, "error": N}.
+    """
+    counts = {"ok": 0, "skip": 0, "error": 0}
+    if not urls:
+        return counts
+
+    cache_dir.mkdir(parents=True, exist_ok=True)
+
+    if dry_run:
+        for url in urls:
+            dest = local_path(url, cache_dir)
+            status = "skip" if (dest.exists() and dest.stat().st_size > 0) else "would-download"
+            logger.info("[DRY-RUN] %s  %s", status, dest)
+
+        def _needs_download(u: str) -> bool:
+            p = local_path(u, cache_dir)
+            return not (p.exists() and p.stat().st_size > 0)
+
+        counts["ok"] = sum(1 for u in urls if _needs_download(u))
+        counts["skip"] = len(urls) - counts["ok"]
+        return counts
+
+    with (
+        httpx.Client(headers=_HEADERS, follow_redirects=True) as client,
+        ThreadPoolExecutor(max_workers=workers) as pool,
+    ):
+        futures = {pool.submit(_download_one, client, u, cache_dir): u for u in urls}
+        for i, fut in enumerate(as_completed(futures), 1):
+            url, status = fut.result()
+            dest = local_path(url, cache_dir)
+            rel = dest.relative_to(cache_dir) if dest.is_relative_to(cache_dir) else dest
+            if status == "ok":
+                counts["ok"] += 1
+                logger.info("[%4d/%d] OK   %s", i, len(urls), rel)
+            elif status == "skip":
+                counts["skip"] += 1
+                logger.debug("[%4d/%d] SKIP %s", i, len(urls), rel)
+            else:
+                counts["error"] += 1
+                logger.error("[%4d/%d] FAIL %s  (%s)", i, len(urls), rel, status)
+
+    return counts