unit3dprep 1.0.4__py3-none-any.whl

unit3dprep/web/api/quickupload.py

@@ -0,0 +1,153 @@
+"""Quick upload (UploadModal flow) — wraps Unit3DWebUp without the full wizard.
+
+Takes a path + mode (u|f|scan), drives the webup HTTP API, streams logs via SSE.
+No audio check, no hardlink: for power users who already staged files in
+their seeding path. DB record is created on start; exit code updated on done.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import secrets
+import time
+from pathlib import Path
+from typing import Any, AsyncGenerator
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from sse_starlette.sse import EventSourceResponse
+
+from ...i18n import get_request_lang, t
+from ..db import update_exit_code
+from ..logbuf import emit as log_emit
+from ..webup_orchestrator import stream_webup, stream_webup_batch
+
+router = APIRouter(prefix="/api", tags=["quickupload"])
+
+_jobs: dict[str, dict[str, Any]] = {}
+_created: dict[str, float] = {}
+_TTL = 3600
+
+
+def _cleanup():
+    now = time.time()
+    for j in [j for j, ct in _created.items() if now - ct > _TTL]:
+        _jobs.pop(j, None)
+        _created.pop(j, None)
+
+
+class QuickBody(BaseModel):
+    path: str
+    mode: str = "u"            # u|f|scan
+    tracker: str = "ITT"
+    tmdb_id: str = ""
+    skip_tmdb: bool = False
+    skip_youtube: bool = False
+    anon: bool = False
+    webp: bool = False
+    screenshots: bool = True
+
+
+@router.post("/upload/quick")
+async def create(request: Request, body: QuickBody):
+    lang = get_request_lang(request)
+    p = Path(body.path).resolve()
+    if not p.exists():
+        raise HTTPException(404, t("err.path_not_found", lang))
+    if body.mode not in {"u", "f", "scan"}:
+        raise HTTPException(400, t("err.invalid_mode", lang))
+    _cleanup()
+    job_id = secrets.token_urlsafe(16)
+    _jobs[job_id] = {
+        "path": str(p),
+        "mode": body.mode,
+        "tmdb_id": body.tmdb_id,
+    }
+    _created[job_id] = time.time()
+    return JSONResponse({"job": job_id})
+
+
+@router.get("/upload/{job}/stream")
+async def stream(request: Request, job: str):
+    state = _jobs.get(job)
+    if state is None:
+        raise HTTPException(404, t("err.job_not_found", get_request_lang(request)))
+    path: str = state["path"]
+    mode: str = state["mode"]
+    tmdb_id: str = state.get("tmdb_id", "")
+    app = request.app
+
+    async def gen() -> AsyncGenerator[dict, None]:
+        if mode == "scan":
+            async for ev in stream_webup_batch(
+                client=app.state.webup,
+                ws=app.state.webup_ws,
+                scan_lock=app.state.webup_scan_lock,
+                folder=path,
+            ):
+                et = ev["type"]
+                if et == "log":
+                    ev_kind = ev.get("kind", "info")
+                    event_slug = ev.get("event")
+                    log_emit(ev_kind, ev["data"], "webup", source="webup", event=event_slug)
+                    yield {"event": "log", "data": ev["data"]}
+                elif et == "job_done":
+                    job_path = ev.get("path") or ""
+                    if job_path:
+                        await update_exit_code(job_path, ev.get("exit_code", -1))
+                    yield {"event": "job_done", "data": json.dumps(ev)}
+                elif et == "error":
+                    log_emit("error", ev["data"], "webup", source="webup")
+                    yield {"event": "error", "data": ev["data"]}
+                elif et == "done":
+                    code = ev.get("exit_code", -1)
+                    state["exit_code"] = code
+                    log_emit(
+                        "ok" if code == 0 else "error",
+                        f"webup batch exit {code} (ok={ev.get('ok',0)} fail={ev.get('fail',0)})",
+                        "quickupload",
+                    )
+                    yield {"event": "done", "data": json.dumps({
+                        "exit_code": code,
+                        "ok": ev.get("ok", 0),
+                        "fail": ev.get("fail", 0),
+                    })}
+            return
+
+        kind = "series" if mode == "f" else "movie"
+        async for ev in stream_webup(
+            client=app.state.webup,
+            ws=app.state.webup_ws,
+            scan_lock=app.state.webup_scan_lock,
+            seeding_path=path,
+            kind=kind,
+            tmdb_id=tmdb_id,
+        ):
+            et = ev["type"]
+            if et == "log":
+                ev_kind = ev.get("kind", "info")
+                event_slug = ev.get("event")
+                log_emit(ev_kind, ev["data"], "webup", source="webup", event=event_slug)
+                yield {"event": "log", "data": ev["data"]}
+            elif et == "progress":
+                yield {"event": "progress", "data": json.dumps({
+                    "phase": ev.get("phase"),
+                    "label": ev.get("label"),
+                    "pct": ev.get("pct", 0),
+                    "sub_pct": ev.get("sub_pct", 0),
+                })}
+            elif et == "error":
+                log_emit("error", ev["data"], "webup", source="webup")
+                yield {"event": "error", "data": ev["data"]}
+            elif et == "done":
+                code = ev.get("exit_code", -1)
+                state["exit_code"] = code
+                await update_exit_code(state["path"], code)
+                log_emit(
+                    "ok" if code == 0 else "error",
+                    f"webup exit {code}", "quickupload",
+                )
+                yield {"event": "done", "data": json.dumps({"exit_code": code})}
+
+    return EventSourceResponse(gen())

unit3dprep/web/api/search.py

@@ -0,0 +1,40 @@
+"""Tracker search + reseed triggers."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+
+from ...i18n import get_request_lang, t
+from .. import config, trackers
+
+router = APIRouter(prefix="/api", tags=["search"])
+
+
+def _build():
+    return trackers.build_trackers(config.load())
+
+
+@router.get("/search")
+async def search(request: Request, q: str, tracker: str = "ITT"):
+    if not q.strip():
+        return JSONResponse({"results": [], "tracker": tracker})
+    trk_map = _build()
+    trk = trk_map.get(tracker.upper())
+    if trk is None:
+        raise HTTPException(404, t("err.tracker_unknown", get_request_lang(request), tracker=tracker))
+    try:
+        results = await trk.search(q)
+    except NotImplementedError as e:
+        raise HTTPException(501, str(e))
+    except Exception as e:
+        raise HTTPException(502, str(e))
+    return JSONResponse({
+        "tracker": tracker.upper(),
+        "results": [r.to_dict() for r in results],
+    })
+
+
+@router.post("/reseed/{tracker}/{torrent_id}")
+async def reseed(request: Request, tracker: str, torrent_id: int):
+    # Placeholder: trigger a unit3dup reseed run for a known torrent id.
+    raise HTTPException(501, t("err.reseed_not_implemented", get_request_lang(request)))

unit3dprep/web/api/settings.py

@@ -0,0 +1,77 @@
+"""Shared .env read/write + runtime U3DP_* env view + filesystem checks."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+
+from .. import config
+from ...media import media_root, seedings_root
+
+router = APIRouter(prefix="/api", tags=["settings"])
+
+
+@router.get("/settings")
+async def get_settings():
+    cfg = config.load()
+    env_path = config.config_path()
+    return JSONResponse({
+        "config": config.mask_secrets(cfg),
+        "env": config.env_runtime(),
+        "config_path": str(env_path),
+        "env_path": str(env_path),
+        "webup_envpath_dir": str(config.webup_envpath_dir()),
+    })
+
+
+@router.put("/settings")
+async def put_settings(incoming: dict):
+    existing = config.load()
+    merged = {**existing, **config.merge_secrets(existing, incoming)}
+    config.save(merged)
+    return JSONResponse({"ok": True, "config": config.mask_secrets(merged)})
+
+
+def _closest_existing(p: Path) -> Path | None:
+    cur: Path | None = p
+    while cur is not None:
+        if cur.exists():
+            return cur
+        parent = cur.parent
+        if parent == cur:
+            return None
+        cur = parent
+    return None
+
+
+@router.get("/settings/fs-check")
+async def settings_fs_check():
+    """Return whether MEDIA_ROOT and SEEDINGS_DIR are on the same filesystem.
+
+    Walks up missing paths so a freshly-configured seedings dir still reports
+    the parent filesystem it would live on.
+    """
+    media = media_root()
+    seed = seedings_root()
+    media_real = _closest_existing(media)
+    seed_real = _closest_existing(seed)
+    try:
+        media_dev = os.stat(media_real).st_dev if media_real else None
+    except OSError:
+        media_dev = None
+    try:
+        seed_dev = os.stat(seed_real).st_dev if seed_real else None
+    except OSError:
+        seed_dev = None
+    same = (media_dev is not None) and (media_dev == seed_dev)
+    return JSONResponse({
+        "media_root": str(media),
+        "seedings_dir": str(seed),
+        "media_exists": media.exists(),
+        "seedings_exists": seed.exists(),
+        "media_dev": media_dev,
+        "seedings_dev": seed_dev,
+        "same_fs": same,
+    })

unit3dprep/web/api/tmdb.py

@@ -0,0 +1,77 @@
+"""TMDB search + manual cache set/clear."""
+from __future__ import annotations
+
+import asyncio
+import os
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+from ...core import tmdb_fetch_bilingual, tmdb_poster_url, tmdb_search, tmdb_year
+from ...i18n import get_request_lang, t
+from ..tmdb_cache import delete_cache, set_cache
+
+TMDB_API_KEY = os.environ.get("TMDB_API_KEY", "")
+
+router = APIRouter(prefix="/api", tags=["tmdb"])
+
+
+@router.get("/tmdb/search")
+async def search(request: Request, q: str, year: str = "", kind: str = "movie"):
+    lang = get_request_lang(request)
+    if not TMDB_API_KEY:
+        raise HTTPException(400, t("err.tmdb_api_key_missing", lang))
+    loop = asyncio.get_event_loop()
+    try:
+        results = await loop.run_in_executor(
+            None, tmdb_search, kind, q, year, TMDB_API_KEY
+        )
+    except Exception as e:
+        raise HTTPException(502, str(e))
+    return JSONResponse({"results": results})
+
+
+class SetBody(BaseModel):
+    source_path: str
+    tmdb_id: str
+    tmdb_kind: str = "movie"
+
+
+@router.post("/tmdb/set")
+async def set_manual(request: Request, body: SetBody):
+    if not TMDB_API_KEY:
+        raise HTTPException(400, t("err.tmdb_api_key_missing", get_request_lang(request)))
+    loop = asyncio.get_event_loop()
+    try:
+        data = await loop.run_in_executor(
+            None, tmdb_fetch_bilingual, body.tmdb_kind, body.tmdb_id, TMDB_API_KEY
+        )
+    except Exception as e:
+        raise HTTPException(502, str(e))
+    title = data.get("title") or ""
+    year = tmdb_year(data, body.tmdb_kind)
+    poster = tmdb_poster_url(data)
+    await set_cache(
+        body.source_path,
+        tmdb_id=body.tmdb_id,
+        tmdb_kind=body.tmdb_kind,
+        title=title,
+        title_en=data.get("title_en", ""),
+        original_title=data.get("original_title", ""),
+        year=year,
+        poster=poster,
+        overview=(data.get("overview") or "")[:300],
+        overview_en=(data.get("overview_en") or "")[:300],
+    )
+    return JSONResponse({"ok": True, "title": title, "year": year, "poster": poster})
+
+
+class ClearBody(BaseModel):
+    source_path: str
+
+
+@router.post("/tmdb/clear")
+async def clear(body: ClearBody):
+    await delete_cache(body.source_path)
+    return JSONResponse({"ok": True})

unit3dprep/web/api/trackers.py

@@ -0,0 +1,30 @@
+"""Tracker status (for sidebar online/offline indicators)."""
+from __future__ import annotations
+
+import asyncio
+
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+
+from .. import config
+from ..trackers import build_trackers
+
+router = APIRouter(prefix="/api", tags=["trackers"])
+
+
+@router.get("/trackers/status")
+async def status():
+    trk_map = build_trackers(config.load())
+    names = list(trk_map.keys())
+    statuses = await asyncio.gather(
+        *(trk_map[n].status() for n in names), return_exceptions=True
+    )
+    out = []
+    for name, s in zip(names, statuses):
+        trk = trk_map[name]
+        out.append({
+            "name": name,
+            "online": bool(s) if not isinstance(s, Exception) else False,
+            "configured": bool(getattr(trk, "configured", False)),
+        })
+    return JSONResponse({"trackers": out})

unit3dprep/web/api/uploaded.py

@@ -0,0 +1,26 @@
+"""Upload history JSON endpoints."""
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+
+from ...i18n import get_request_lang, t
+from ..db import delete_record, list_uploads
+
+router = APIRouter(prefix="/api", tags=["uploaded"])
+
+
+@router.get("/uploaded")
+async def list_all():
+    records = await list_uploads()
+    return JSONResponse({"records": records})
+
+
+@router.delete("/uploaded/{record_id}")
+async def delete_by_id(request: Request, record_id: int):
+    records = await list_uploads()
+    target = next((r for r in records if r.get("id") == record_id), None)
+    if target is None:
+        raise HTTPException(404, t("err.record_not_found", get_request_lang(request)))
+    await delete_record(target["seeding_path"])
+    return JSONResponse({"ok": True})