unit3dprep 1.0.4__py3-none-any.whl

unit3dprep/web/app.py

@@ -0,0 +1,201 @@
+"""FastAPI application: JSON API under /{ROOT_PATH}/api + SPA served from /dist."""
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.sessions import SessionMiddleware
+
+from ._env import env as _env, migrate_dotfiles
+from .auth import SECRET_KEY
+from .db import init_db
+from . import logbuf
+from .webup_client import get_client as get_webup_client, shutdown_client as shutdown_webup_client
+from .webup_ws import WebupWSManager
+from .api import (
+    auth as auth_api,
+    fs as fs_api,
+    library as library_api,
+    logs as logs_api,
+    quickupload as quickupload_api,
+    queue as queue_api,
+    search as search_api,
+    settings as settings_api,
+    tmdb as tmdb_api,
+    trackers as trackers_api,
+    uploaded as uploaded_api,
+    version as version_api,
+    webup as webup_api,
+    wizard as wizard_api,
+)
+
+migrate_dotfiles(Path.home())
+
+# When the reverse proxy does NOT strip the prefix (typical Ultra.cc nginx
+# user-proxy without trailing slash on proxy_pass), routes must be registered
+# under the prefix — FastAPI's `root_path=` only helps when the proxy strips.
+ROOT_PATH = (_env("U3DP_ROOT_PATH", "ITA_ROOT_PATH", "") or "").rstrip("/")
+DIST_DIR = Path(__file__).parent / "dist"
+
+API_PREFIX = f"{ROOT_PATH}/api"
+_OPENAPI_URL = f"{ROOT_PATH}/openapi.json"
+AUTH_EXEMPT = {
+    f"{API_PREFIX}/auth/login",
+    f"{API_PREFIX}/me",
+    f"{API_PREFIX}/docs",
+    f"{API_PREFIX}/redoc",
+    _OPENAPI_URL,
+}
+
+app = FastAPI(
+    title="Unit3DPrep Web",
+    docs_url=f"{API_PREFIX}/docs",
+    redoc_url=f"{API_PREFIX}/redoc",
+    openapi_url=_OPENAPI_URL,
+)
+
+
+@app.middleware("http")
+async def _auth_guard(request: Request, call_next):
+    path = request.url.path.rstrip("/")
+    protected = path.startswith(API_PREFIX) or path == _OPENAPI_URL
+    if protected and path not in AUTH_EXEMPT:
+        if not request.session.get("authenticated"):
+            return JSONResponse({"detail": "Not authenticated"}, status_code=401)
+    return await call_next(request)
+
+
+app.add_middleware(
+    SessionMiddleware,
+    secret_key=SECRET_KEY,
+    https_only=(_env("U3DP_HTTPS_ONLY", "ITA_HTTPS_ONLY", "0") or "0") == "1",
+    same_site="lax",
+    max_age=86400 * 7,
+)
+
+
+@app.on_event("startup")
+async def _startup():
+    await init_db()
+    logbuf.install(asyncio.get_event_loop())
+    logging.getLogger("unit3dprep").info("unit3dprep-web started")
+
+    # Webup orchestration state.
+    app.state.webup = get_webup_client()
+    app.state.webup_ws = WebupWSManager()
+    app.state.webup_ws.start()
+    app.state.webup_scan_lock = asyncio.Lock()
+
+    # Best-effort runtime bridge: push the shared .env content to webup's
+    # in-memory settings via /setenv on startup, so config changes saved while
+    # webup was offline take effect without restarting it.
+    # Non-blocking; ignore failures (webup may not be running yet).
+    try:
+        from .config import bootstrap_webup_env
+        asyncio.create_task(bootstrap_webup_env(app.state.webup), name="webup-bootstrap-env")
+    except Exception:
+        logging.getLogger("unit3dprep").exception("webup bootstrap scheduling failed")
+
+
+@app.on_event("shutdown")
+async def _shutdown():
+    ws_mgr = getattr(app.state, "webup_ws", None)
+    if ws_mgr is not None:
+        try:
+            await ws_mgr.stop()
+        except Exception:
+            pass
+    try:
+        await shutdown_webup_client()
+    except Exception:
+        pass
+
+
+# Mount all JSON routers under ROOT_PATH (routers themselves already declare
+# /api/... so the final path is /{ROOT_PATH}/api/...).
+for r in (
+    auth_api.router,
+    fs_api.router,
+    library_api.router,
+    logs_api.router,
+    queue_api.router,
+    quickupload_api.router,
+    search_api.router,
+    settings_api.router,
+    tmdb_api.router,
+    trackers_api.router,
+    uploaded_api.router,
+    version_api.router,
+    webup_api.router,
+    wizard_api.router,
+):
+    app.include_router(r, prefix=ROOT_PATH)
+
+
+if (DIST_DIR / "assets").exists():
+    app.mount(
+        f"{ROOT_PATH}/assets",
+        StaticFiles(directory=str(DIST_DIR / "assets")),
+        name="assets",
+    )
+
+
+def _render_index() -> str:
+    idx = DIST_DIR / "index.html"
+    if not idx.is_file():
+        return ""
+    html = idx.read_text(encoding="utf-8")
+    inject = f'<script>window.__ROOT_PATH__={ROOT_PATH!r};</script>'
+    html = html.replace("</head>", f"{inject}</head>", 1)
+    # Vite builds with base='./' producing relative asset paths. When the
+    # page is served at /unit3dprep (no trailing slash) the browser resolves
+    # './' to '/' instead of '/unit3dprep/' — fix to absolute paths at serve time.
+    if ROOT_PATH:
+        html = html.replace('./assets/', f'{ROOT_PATH}/assets/')
+    return html
+
+
+# SPA catch-all. Serves index.html for any non-API path so a deep link to a
+# client-side route still boots the app.
+_CATCHALL = f"{ROOT_PATH}/{{full_path:path}}" if ROOT_PATH else "/{full_path:path}"
+
+
+@app.get(_CATCHALL)
+async def spa(full_path: str, request: Request):
+    if full_path.startswith("api/") or full_path.startswith("assets/"):
+        raise HTTPException(status_code=404)
+    if full_path and not full_path.endswith("/"):
+        candidate = DIST_DIR / full_path
+        if candidate.is_file():
+            return FileResponse(candidate)
+    rendered = _render_index()
+    if rendered:
+        return HTMLResponse(rendered)
+    return JSONResponse(
+        {"detail": "Frontend not built. Run `cd frontend && npm install && npm run build`."},
+        status_code=503,
+    )
+
+
+if ROOT_PATH:
+    @app.get(ROOT_PATH)
+    async def _root_alias():
+        rendered = _render_index()
+        return HTMLResponse(rendered) if rendered else JSONResponse(
+            {"detail": "Frontend not built."}, status_code=503,
+        )
+
+
+def run():
+    import uvicorn
+    host = _env("U3DP_HOST", "ITA_HOST", "127.0.0.1") or "127.0.0.1"
+    port = int(_env("U3DP_PORT", "ITA_PORT", "8765") or "8765")
+    uvicorn.run("unit3dprep.web.app:app", host=host, port=port, reload=False)
+
+
+if __name__ == "__main__":
+    run()

unit3dprep/web/auth.py

@@ -0,0 +1,41 @@
+"""Auth helpers: bcrypt password check, session management."""
+import bcrypt
+from fastapi import Request
+from starlette.responses import RedirectResponse
+
+from ._env import env as _env
+
+PASSWORD_HASH = _env("U3DP_PASSWORD_HASH", "ITA_PASSWORD_HASH", "") or ""
+SECRET_KEY = _env("U3DP_SECRET", "ITA_SECRET", "changeme-set-U3DP_SECRET") or "changeme-set-U3DP_SECRET"
+SESSION_ID_KEY = "session_id"
+AUTH_KEY = "authenticated"
+
+
+def verify_password(plain: str) -> bool:
+    if not PASSWORD_HASH:
+        return False
+    try:
+        return bcrypt.checkpw(plain.encode(), PASSWORD_HASH.encode())
+    except Exception:
+        return False
+
+
+def login_session(request: Request, session_id: str):
+    request.session[AUTH_KEY] = True
+    request.session[SESSION_ID_KEY] = session_id
+
+
+def logout_session(request: Request):
+    request.session.clear()
+
+
+def is_authenticated(request: Request) -> bool:
+    return bool(request.session.get(AUTH_KEY))
+
+
+def get_session_id(request: Request) -> str:
+    return request.session.get(SESSION_ID_KEY, "")
+
+
+def redirect_to_login(next_url: str = "/") -> RedirectResponse:
+    return RedirectResponse(f"/login?next={next_url}", status_code=303)

unit3dprep/web/clients.py

@@ -0,0 +1,167 @@
+"""Torrent-client abstraction.
+
+v1 wires up qBittorrent (Web API). Transmission/rTorrent surface as "not
+implemented" so the Settings page can advertise them without crashing the
+Queue view.
+"""
+from __future__ import annotations
+
+import base64
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+
+@dataclass
+class Torrent:
+    hash: str
+    name: str
+    size: int
+    progress: float
+    state: str       # seeding|uploading|queued|error|pending|paused|other
+    ratio: float
+    category: str
+    tracker: str
+    save_path: str
+
+
+class TorrentClient(ABC):
+    name: str = "generic"
+
+    @abstractmethod
+    async def list(self) -> list[Torrent]: ...
+
+    @abstractmethod
+    async def reseed(self, torrent_hash: str) -> None: ...
+
+    @abstractmethod
+    async def remove(self, torrent_hash: str, delete_files: bool = False) -> None: ...
+
+
+# ---------------------------------------------------------------------------
+# qBittorrent Web API (v2)
+# ---------------------------------------------------------------------------
+
+
+_QBIT_STATE_MAP = {
+    "uploading": "seeding",
+    "stalledUP": "seeding",
+    "forcedUP": "seeding",
+    "queuedUP": "queued",
+    "checkingUP": "seeding",
+    "downloading": "uploading",
+    "forcedDL": "uploading",
+    "stalledDL": "uploading",
+    "queuedDL": "queued",
+    "checkingDL": "uploading",
+    "metaDL": "uploading",
+    "pausedUP": "paused",
+    "pausedDL": "paused",
+    "error": "error",
+    "missingFiles": "error",
+    "unknown": "pending",
+    "allocating": "pending",
+    "moving": "pending",
+}
+
+
+class QBittorrentClient(TorrentClient):
+    name = "qbittorrent"
+
+    def __init__(self, host: str, port: str | int, user: str, password: str):
+        self.base = f"http://{host}:{port}"
+        self.user = user
+        self.password = password
+        self._client: httpx.AsyncClient | None = None
+        self._logged_in_at: float = 0.0
+
+    async def _http(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(base_url=self.base, timeout=15.0)
+        # Re-login every 30 min to keep cookie fresh
+        if time.time() - self._logged_in_at > 1800:
+            r = await self._client.post(
+                "/api/v2/auth/login",
+                data={"username": self.user, "password": self.password},
+                headers={"Referer": self.base},
+            )
+            if r.status_code != 200 or r.text.strip() != "Ok.":
+                raise RuntimeError(f"qBittorrent login failed: {r.status_code} {r.text!r}")
+            self._logged_in_at = time.time()
+        return self._client
+
+    async def list(self) -> list[Torrent]:
+        cli = await self._http()
+        r = await cli.get("/api/v2/torrents/info")
+        r.raise_for_status()
+        out: list[Torrent] = []
+        for t in r.json():
+            state = _QBIT_STATE_MAP.get(t.get("state", "unknown"), "pending")
+            out.append(Torrent(
+                hash=t.get("hash", ""),
+                name=t.get("name", ""),
+                size=int(t.get("size", 0) or 0),
+                progress=float(t.get("progress", 0) or 0),
+                state=state,
+                ratio=float(t.get("ratio", 0) or 0),
+                category=t.get("category", ""),
+                tracker=t.get("tracker", ""),
+                save_path=t.get("save_path", ""),
+            ))
+        return out
+
+    async def reseed(self, torrent_hash: str) -> None:
+        cli = await self._http()
+        r = await cli.post("/api/v2/torrents/recheck", data={"hashes": torrent_hash})
+        r.raise_for_status()
+        r2 = await cli.post("/api/v2/torrents/resume", data={"hashes": torrent_hash})
+        r2.raise_for_status()
+
+    async def remove(self, torrent_hash: str, delete_files: bool = False) -> None:
+        cli = await self._http()
+        r = await cli.post(
+            "/api/v2/torrents/delete",
+            data={"hashes": torrent_hash, "deleteFiles": "true" if delete_files else "false"},
+        )
+        r.raise_for_status()
+
+
+class _NotImplementedClient(TorrentClient):
+    def __init__(self, name: str):
+        self.name = name
+
+    async def list(self) -> list[Torrent]:
+        raise NotImplementedError(f"{self.name} client not implemented yet")
+
+    async def reseed(self, torrent_hash: str) -> None:
+        raise NotImplementedError(f"{self.name} client not implemented yet")
+
+    async def remove(self, torrent_hash: str, delete_files: bool = False) -> None:
+        raise NotImplementedError(f"{self.name} client not implemented yet")
+
+
+_client_cache: tuple[tuple, TorrentClient] | None = None
+
+
+def get_client(cfg: dict[str, Any]) -> TorrentClient:
+    global _client_cache
+    which = (cfg.get("TORRENT_CLIENT") or "qbittorrent").lower()
+    if which == "qbittorrent":
+        host = cfg.get("QBIT_HOST", "127.0.0.1")
+        port = cfg.get("QBIT_PORT", "15491")
+        user = cfg.get("QBIT_USER", "admin")
+        password = cfg.get("QBIT_PASS", "")
+        key = ("qbittorrent", host, str(port), user, password)
+        if _client_cache is not None and _client_cache[0] == key:
+            return _client_cache[1]
+        cli = QBittorrentClient(host=host, port=port, user=user, password=password)
+        _client_cache = (key, cli)
+        return cli
+    if which == "transmission":
+        return _NotImplementedClient("transmission")
+    if which == "rtorrent":
+        return _NotImplementedClient("rtorrent")
+    return _NotImplementedClient(which)