trailframe 0.1.0__py3-none-any.whl

trailframe/__main__.py

@@ -0,0 +1,3 @@
+from trailframe.main import main
+
+main()

trailframe/api/about.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import ast
+from importlib.metadata import Distribution, distributions, packages_distributions
+from pathlib import Path
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/api/about", tags=["about"])
+
+_APP_ROOT = Path(__file__).resolve().parents[1]
+
+
+class PackageInfo(BaseModel):
+    name: str
+    version: str
+    license: str
+
+
+def _imported_module_names() -> set[str]:
+    names: set[str] = set()
+
+    for path in _APP_ROOT.rglob("*.py"):
+        try:
+            tree = ast.parse(path.read_text(encoding="utf-8"))
+        except (OSError, SyntaxError):
+            continue
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    names.add(alias.name.split(".", 1)[0])
+            elif isinstance(node, ast.ImportFrom) and node.level == 0 and node.module:
+                names.add(node.module.split(".", 1)[0])
+
+    return names
+
+
+def _package_license(dist: Distribution) -> str:
+    metadata = dist.metadata
+
+    for classifier in metadata.get_all("Classifier") or []:
+        if classifier.startswith("License :: OSI Approved ::"):
+            return classifier.split("::")[-1].strip()
+
+    for key in ("License-Expression", "License"):
+        value = metadata.get(key)
+        if value:
+            value = value.strip()
+            if len(value) <= 80:
+                return value
+
+    return ""
+
+
+@router.get("/packages", response_model=list[PackageInfo])
+async def list_packages() -> list[PackageInfo]:
+    installed = {dist.metadata.get("Name", "").casefold(): dist for dist in distributions()}
+    module_distributions = packages_distributions()
+
+    distribution_names: set[str] = set()
+
+    for module in _imported_module_names():
+        distribution_names.update(
+            dist_name for dist_name in module_distributions.get(module, ()) if dist_name.casefold() in installed
+        )
+
+    packages: list[PackageInfo] = []
+
+    for key in sorted(distribution_names, key=str.casefold):
+        dist = installed.get(key.casefold())
+        if dist is None:
+            continue
+
+        packages.append(
+            PackageInfo(
+                name=dist.metadata.get("Name", ""),
+                version=dist.version,
+                license=_package_license(dist),
+            )
+        )
+
+    return packages

trailframe/api/activities.py

@@ -0,0 +1,205 @@
+import re
+import tempfile
+import zipfile
+from io import BytesIO
+from pathlib import Path
+from typing import Annotated, Any
+
+from fastapi import APIRouter, File, HTTPException, UploadFile
+from fastapi.responses import FileResponse, Response
+from pydantic import BaseModel
+
+from trailframe.models.activity import Activity, ActivitySummary, GarminActivitySummary, GpxActivitySummary
+from trailframe.models.photo import Photo, PhotoDetail
+from trailframe.services.activity_service import ActivityService
+from trailframe.services.folder_service import FolderService
+from trailframe.services.garmin_connect_service import GarminConnectService
+from trailframe.services.gpx_service import GpxService
+from trailframe.services.map_service import MapService
+
+router = APIRouter(prefix="/api/activities", tags=["activities"])
+
+
+class ImportResult(BaseModel):
+    success: bool
+
+
+@router.get("", response_model=list[ActivitySummary])
+async def list_activities() -> list[ActivitySummary]:
+    return await ActivityService.list_activities()
+
+
+@router.get("/garmin", response_model=list[GarminActivitySummary])
+async def list_garmin_activities() -> list[GarminActivitySummary]:
+    return await GarminConnectService.list_summaries()
+
+
+@router.post("/garmin/sync", response_model=ImportResult)
+async def garmin_sync(credentials: dict[str, Any]) -> ImportResult:
+    success = await ActivityService.sync_garmin(credentials.get("email", ""), credentials.get("password", ""))
+
+    if not success:
+        raise HTTPException(status_code=401, detail="Garmin login failed")
+
+    return ImportResult(success=True)
+
+
+@router.get("/gpx", response_model=list[GpxActivitySummary])
+async def list_gpx_activities() -> list[GpxActivitySummary]:
+    return await GpxService.list_summaries()
+
+
+@router.post("/gpx/upload", response_model=GpxActivitySummary)
+async def upload_gpx(file: UploadFile = File(...)) -> GpxActivitySummary:
+    content = (await file.read()).decode("utf-8", errors="replace")
+
+    gpx_activity = await GpxService.save(content, file.filename or "activity.gpx")
+
+    if gpx_activity is None:
+        raise HTTPException(status_code=400, detail="Invalid GPX file")
+
+    return GpxActivitySummary(
+        id=gpx_activity.id,
+        filename=gpx_activity.filename,
+        name=gpx_activity.name,
+        activity_type=gpx_activity.activity_type,
+        start_time=gpx_activity.start_time,
+        distance=gpx_activity.distance,
+        duration=gpx_activity.duration,
+    )
+
+
+@router.post("/gpx/import/{gpx_id}", response_model=Activity)
+async def import_gpx(gpx_id: int) -> Activity:
+    activity = await ActivityService.import_gpx(gpx_id)
+
+    if activity is None:
+        raise HTTPException(status_code=404, detail="GPX activity not found")
+
+    return activity
+
+
+@router.post("/import/{activity_id}", response_model=Activity)
+async def import_activity(activity_id: int) -> Activity:
+    activity = await ActivityService.import_activity(activity_id)
+
+    if activity is None:
+        raise HTTPException(status_code=404, detail="Garmin activity not found")
+
+    return activity
+
+
+@router.get("/{activity_id}/map")
+async def activity_map(activity_id: int) -> FileResponse:
+    activity = await ActivityService.get_activity(activity_id)
+
+    if activity is None or not activity.activity_id:
+        raise HTTPException(status_code=404, detail="Activity not found")
+
+    path = MapService.get_map(activity.activity_id)
+
+    if not path.exists():
+        raise HTTPException(status_code=404, detail="Map not found")
+
+    return FileResponse(path, media_type="image/svg+xml")
+
+
+@router.get("/{activity_id}/traces")
+async def activity_traces(activity_id: int) -> FileResponse:
+    activity = await ActivityService.get_activity(activity_id)
+
+    if activity is None or not activity.activity_id:
+        raise HTTPException(status_code=404, detail="Activity not found")
+
+    path = MapService.get_trace(activity.activity_id)
+
+    if not path.exists():
+        raise HTTPException(status_code=404, detail="Trace not found")
+
+    return FileResponse(path, media_type="image/svg+xml")
+
+
+@router.get("/{activity_id}/photos", response_model=list[PhotoDetail])
+async def activity_photos(activity_id: int) -> list[PhotoDetail]:
+    photos = await ActivityService.list_activity_photos(activity_id)
+
+    return [PhotoDetail.from_photo(photo) for photo in photos]
+
+
+def _build_zip_response(activity: Activity, photos: list[Photo], overlay_path: Path | None = None) -> Response:
+    buffer = BytesIO()
+
+    with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as archive:
+        for photo in photos:
+            path = FolderService.resolve(photo.path)
+
+            if path.is_file():
+                archive.write(path, arcname=path.name)
+
+        if overlay_path is not None and overlay_path.is_file():
+            archive.write(overlay_path, arcname="map.png")
+
+    base = re.sub(r"[^A-Za-z0-9._-]+", "_", activity.name or f"activity-{activity.id}").strip("_")
+    filename = f"{base}.zip" if base else f"activity-{activity.id}.zip"
+
+    return Response(
+        content=buffer.getvalue(),
+        media_type="application/zip",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
+
+
+@router.get("/{activity_id}/zip")
+async def activity_zip(activity_id: int) -> Response:
+    activity = await ActivityService.get_activity(activity_id)
+
+    if activity is None:
+        raise HTTPException(status_code=404, detail="Activity not found")
+
+    photos = await ActivityService.list_activity_photos(activity_id)
+
+    return _build_zip_response(activity, photos)
+
+
+@router.post("/{activity_id}/zip")
+async def activity_zip_with_overlay(
+    activity_id: int,
+    overlay: Annotated[UploadFile | None, File()] = None,
+) -> Response:
+    activity = await ActivityService.get_activity(activity_id)
+
+    if activity is None:
+        raise HTTPException(status_code=404, detail="Activity not found")
+
+    photos = await ActivityService.list_activity_photos(activity_id)
+
+    overlay_path = None
+
+    if overlay is not None:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as file:
+            file.write(await overlay.read())
+            overlay_path = Path(file.name)
+
+    try:
+        return _build_zip_response(activity, photos, overlay_path)
+    finally:
+        if overlay_path is not None:
+            overlay_path.unlink(missing_ok=True)
+
+
+@router.get("/{activity_id}", response_model=Activity)
+async def get_activity(activity_id: int) -> Activity:
+    activity = await ActivityService.get_activity(activity_id)
+
+    if activity is None:
+        raise HTTPException(status_code=404, detail="Activity not found")
+
+    return activity
+
+
+@router.delete("/{activity_id}")
+async def delete_activity(activity_id: int) -> None:
+    deleted = await ActivityService.delete_activity(activity_id)
+
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Activity not found")

trailframe/api/configuration.py

@@ -0,0 +1,19 @@
+from typing import Any
+
+from fastapi import APIRouter
+
+from trailframe.services.configuration_service import ConfigurationService
+
+router = APIRouter(prefix="/api/configuration", tags=["configuration"])
+
+
+@router.get("")
+async def get_configuration() -> dict[str, Any]:
+    return ConfigurationService.to_json()
+
+
+@router.post("")
+async def update_configuration(values: dict[str, Any]) -> dict[str, Any]:
+    ConfigurationService.from_json(values)
+    ConfigurationService.save()
+    return ConfigurationService.to_json()

trailframe/api/events.py

@@ -0,0 +1,45 @@
+import asyncio
+import json
+from typing import Any
+
+from fastapi import APIRouter
+from fastapi.responses import StreamingResponse
+
+from trailframe.services.pipeline_service import PipelineService
+
+router = APIRouter(prefix="/api/events", tags=["events"])
+
+_shutting_down = False
+
+
+def stop_streams(*args) -> None:
+    global _shutting_down
+    _shutting_down = True
+
+
+def _format_sse(event: str, data: dict[str, Any]) -> str:
+    payload = json.dumps(data)
+    return f"event: {event}\ndata: {payload}\n\n"
+
+
+async def _event_stream():
+    last_message: dict[str, Any] | None = None
+
+    while not _shutting_down:
+        message = PipelineService.get_snapshot()
+
+        if message != last_message:
+            yield _format_sse("pipeline", message)
+            last_message = message
+
+        await asyncio.sleep(0.2)
+    yield _format_sse("pipeline", dict({"Text": "Server is shutting down"}))
+
+
+@router.get("")
+async def stream_events() -> StreamingResponse:
+    return StreamingResponse(
+        _event_stream(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no", "Connection": "keep-alive"},
+    )

trailframe/api/map_data.py

@@ -0,0 +1,63 @@
+from datetime import datetime
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import select
+
+from trailframe.models.activity import Activity
+from trailframe.models.photo import Photo
+from trailframe.services.database_service import DatabaseService
+
+router = APIRouter(prefix="/api/map-data", tags=["map-data"])
+
+
+class PhotoPoint(BaseModel):
+    id: int
+    lat: float
+    lon: float
+
+
+class ActivityTrace(BaseModel):
+    id: int
+    name: str | None
+    trace: list[list[float]]
+    start_time: datetime | None = None
+    distance: float | None = None
+    duration: float | None = None
+
+
+class MapData(BaseModel):
+    photos: list[PhotoPoint]
+    activities: list[ActivityTrace]
+
+
+@router.get("", response_model=MapData)
+async def get_map_data(session: AsyncSession = Depends(DatabaseService.get_session)) -> MapData:
+    photo_rows = (
+        await session.execute(
+            select(Photo.id, Photo.latitude, Photo.longitude).where(
+                Photo.latitude.is_not(None), Photo.longitude.is_not(None)
+            )
+        )
+    ).all()
+
+    activity_rows = (
+        await session.execute(select(Activity.id, Activity.name, Activity.trace, Activity.start_time, Activity.distance, Activity.duration))
+    ).all()
+
+    return MapData(
+        photos=[PhotoPoint(id=p[0], lat=p[1], lon=p[2]) for p in photo_rows],
+        activities=[
+            ActivityTrace(
+                id=a[0],
+                name=a[1],
+                trace=[[pt["lat"], pt["lon"]] for pt in (a[2] or []) if "lat" in pt and "lon" in pt],
+                start_time=a[3],
+                distance=a[4],
+                duration=a[5],
+            )
+            for a in activity_rows
+            if a[2]
+        ],
+    )

trailframe/api/models.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+
+from trailframe.services.configuration_service import ConfigurationService
+
+router = APIRouter(prefix="/api/models", tags=["models"])
+
+YOLO_MODELS = {
+    "yolo26n.pt": "Nano",
+    "yolo26s.pt": "Small",
+    "yolo26m.pt": "Medium",
+    "yolo26l.pt": "Large",
+    "yolo26x.pt": "Extra Large",
+}
+
+
+def _models_folder() -> Path:
+    return Path(ConfigurationService.root().get_path_value("general.models_folder", default_value="models"))
+
+
+@router.get("")
+async def list_models() -> list[str]:
+    folder = _models_folder()
+
+    if not folder.exists():
+        return []
+
+    return [f.name for f in folder.iterdir() if f.suffix == ".pt"]
+
+
+@router.post("/{name}/download")
+async def download_model(name: str) -> str:
+    if name not in YOLO_MODELS:
+        raise HTTPException(status_code=400, detail=f"Unknown model: {name}")
+
+    folder = _models_folder()
+    folder.mkdir(parents=True, exist_ok=True)
+    target = folder / name
+
+    if target.exists():
+        return str(target)
+
+    from ultralytics.utils import checks
+
+    url = f"https://github.com/ultralytics/assets/releases/download/v8.4.0/{name}"
+    checks.check_file(url, download_dir=str(folder))
+
+    if not target.exists():
+        raise HTTPException(status_code=500, detail=f"Download failed for {name}")
+
+    return str(target)