unit3dprep 1.0.4__py3-none-any.whl

unit3dprep/i18n.py

@@ -0,0 +1,151 @@
+"""Minimal i18n for user-facing API error messages.
+
+The UI forwards the active locale in the `X-U3DP-Lang` header on every API
+call; the backend falls back to the `U3DP_LANG` runtime setting when the
+header is absent. Only API error `detail` strings are localized here — free
+text coming from external processes (unit3dup, TMDB, hardlink OS errors) is
+always echoed back untouched.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from .web import config as _config
+
+SUPPORTED = ("it", "en")
+DEFAULT = "it"
+
+CATALOG: dict[str, dict[str, str]] = {
+    "err.path_not_found": {
+        "it": "Percorso non trovato",
+        "en": "Path not found",
+    },
+    "err.path_not_found_at": {
+        "it": "Percorso non trovato: {path}",
+        "en": "Path not found: {path}",
+    },
+    "err.path_not_allowed": {
+        "it": "Percorso non consentito",
+        "en": "Path not allowed",
+    },
+    "err.path_outside": {
+        "it": "Percorso fuori dalle directory consentite",
+        "en": "Path outside allowed directories",
+    },
+    "err.permission_denied": {
+        "it": "Permesso negato",
+        "en": "Permission denied",
+    },
+    "err.invalid_mode": {
+        "it": "Modalità non valida",
+        "en": "Invalid mode",
+    },
+    "err.invalid_kind": {
+        "it": "Tipo non valido",
+        "en": "Invalid kind",
+    },
+    "err.job_not_found": {
+        "it": "Job non trovato",
+        "en": "Job not found",
+    },
+    "err.no_active_process": {
+        "it": "Nessun processo attivo",
+        "en": "No active process",
+    },
+    "err.category_not_found": {
+        "it": "Categoria non trovata",
+        "en": "Category not found",
+    },
+    "err.item_not_found_in_category": {
+        "it": "'{name}' non trovato in {category}",
+        "en": "'{name}' not found in {category}",
+    },
+    "err.tmdb_api_key_missing": {
+        "it": "TMDB_API_KEY non impostata",
+        "en": "TMDB_API_KEY not set",
+    },
+    "err.tracker_unknown": {
+        "it": "Tracker sconosciuto '{tracker}'",
+        "en": "Unknown tracker '{tracker}'",
+    },
+    "err.reseed_not_implemented": {
+        "it": "Reseed per tracker id non implementato",
+        "en": "Reseed by tracker id not implemented",
+    },
+    "err.record_not_found": {
+        "it": "Record non trovato",
+        "en": "Record not found",
+    },
+    "err.wizard_session_expired": {
+        "it": "Sessione wizard non trovata o scaduta",
+        "en": "Wizard session not found or expired",
+    },
+    "err.episode_requires_file": {
+        "it": "Modalità episodio richiede un path di file",
+        "en": "Episode mode requires a file path",
+    },
+    "err.audio_check_not_passed": {
+        "it": "Controllo audio non superato",
+        "en": "Audio check not passed",
+    },
+    "err.tmdb_fetch_failed": {
+        "it": "Recupero TMDB fallito: {error}",
+        "en": "TMDB fetch failed: {error}",
+    },
+    "err.no_video_episode": {
+        "it": "Nessun file video trovato per modalità episodio",
+        "en": "No video file found for episode mode",
+    },
+    "err.no_video": {
+        "it": "Nessun file video trovato",
+        "en": "No video file found",
+    },
+    "err.hardlink_failed": {
+        "it": "Hardlink fallito: {error}",
+        "en": "Hardlink failed: {error}",
+    },
+    "err.invalid_password": {
+        "it": "Password non valida",
+        "en": "Invalid password",
+    },
+    "err.release_not_found": {
+        "it": "Release non trovata: {error}",
+        "en": "Release not found: {error}",
+    },
+}
+
+
+def _normalize(lang: str | None) -> str:
+    if not lang:
+        return DEFAULT
+    code = lang.strip().lower().split("-", 1)[0].split("_", 1)[0]
+    return code if code in SUPPORTED else DEFAULT
+
+
+def t(key: str, lang: str | None = None, /, **fmt: Any) -> str:
+    """Resolve a catalog key to a localized string.
+
+    Falls back to `U3DP_LANG` runtime setting then to `DEFAULT` when `lang`
+    is None/unknown. Unknown keys return the key itself (defensive: never
+    crash the API over a missing translation).
+    """
+    resolved = _normalize(lang or _config.runtime_setting("U3DP_LANG", DEFAULT))
+    entry = CATALOG.get(key)
+    if entry is None:
+        return key.format(**fmt) if fmt else key
+    text = entry.get(resolved) or entry.get(DEFAULT) or key
+    return text.format(**fmt) if fmt else text
+
+
+def get_request_lang(request: Any) -> str:
+    """Extract active locale from a FastAPI/Starlette Request.
+
+    Precedence: `X-U3DP-Lang` header → `U3DP_LANG` runtime setting → DEFAULT.
+    """
+    try:
+        hdr = request.headers.get("x-u3dp-lang") or request.headers.get("X-U3DP-Lang")
+    except Exception:
+        hdr = None
+    if hdr:
+        return _normalize(hdr)
+    return _normalize(_config.runtime_setting("U3DP_LANG", DEFAULT))

unit3dprep/media.py

@@ -0,0 +1,278 @@
+"""Library scanner for user-configured media root; categories auto-discovered."""
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .core import VIDEO_EXTENSIONS
+
+
+def media_root() -> Path:
+    """Resolve media root at call time: env → shared .env → ~/media."""
+    from .web import config
+    return Path(config.runtime_setting("U3DP_MEDIA_ROOT", default=str(Path.home() / "media")))
+
+
+def discover_categories() -> list[str]:
+    """Sorted subdirectory names of media_root(). Skips dotfiles & non-dirs."""
+    root = media_root()
+    if not root.exists() or not root.is_dir():
+        return []
+    try:
+        return sorted(
+            c.name for c in root.iterdir()
+            if c.is_dir() and not c.name.startswith(".")
+        )
+    except OSError:
+        return []
+
+
+def format_size(size_bytes: int) -> str:
+    """Human-readable file size: GB / MB / KB."""
+    if size_bytes >= 1_073_741_824:
+        return f"{size_bytes / 1_073_741_824:.2f} GB"
+    if size_bytes >= 1_048_576:
+        return f"{size_bytes / 1_048_576:.1f} MB"
+    if size_bytes >= 1_024:
+        return f"{size_bytes / 1_024:.0f} KB"
+    return f"{size_bytes} B"
+
+
+@dataclass
+class Season:
+    number: int
+    label: str  # "Season 01"
+    path: Path
+    video_files: list[Path] = field(default_factory=list)
+    already_uploaded: bool = False
+    uploaded_episode_paths: set[str] = field(default_factory=set)
+    # Lang cache fields (populated by routes)
+    available_langs: list = field(default_factory=list)
+    lang_scanned: bool = False
+
+    @property
+    def episode_count(self) -> int:
+        return len(self.video_files)
+
+    @property
+    def total_size(self) -> int:
+        total = 0
+        for f in self.video_files:
+            try:
+                total += f.stat().st_size
+            except OSError:
+                pass
+        return total
+
+    @property
+    def total_size_human(self) -> str:
+        return format_size(self.total_size)
+
+    @property
+    def has_italian(self) -> bool:
+        return "ITA" in self.available_langs
+
+    @property
+    def all_episodes_uploaded(self) -> bool:
+        episode_paths = {str(f.resolve()) for f in self.video_files}
+        return bool(episode_paths) and episode_paths.issubset(self.uploaded_episode_paths)
+
+    @property
+    def remaining_episode_count(self) -> int:
+        return max(0, self.episode_count - len(self.uploaded_episode_paths))
+
+
+@dataclass
+class MediaItem:
+    name: str
+    path: Path
+    category: str    # movies | series | anime
+    kind: str        # movie | series
+    seasons: list[Season] = field(default_factory=list)
+    video_files: list[Path] = field(default_factory=list)
+    # TMDB metadata (populated by routes from cache, not by scanner)
+    tmdb_id: str = ""
+    tmdb_kind: str = ""
+    tmdb_title: str = ""
+    tmdb_poster: str = ""
+    tmdb_overview: str = ""
+    # Upload status (populated by routes)
+    already_uploaded: bool = False
+    uploaded_season_numbers: list = field(default_factory=list)
+    # Lang cache fields (populated by routes)
+    available_langs: list = field(default_factory=list)
+    episode_langs: dict = field(default_factory=dict)  # str(filepath) -> [langs]
+    lang_scanned: bool = False
+
+    @property
+    def year(self) -> str:
+        m = re.search(r'\((\d{4})\)', self.name)
+        return m.group(1) if m else ""
+
+    @property
+    def title(self) -> str:
+        return re.sub(r'\s*\(\d{4}\)\s*$', '', self.name).strip()
+
+    @property
+    def total_files(self) -> int:
+        if self.kind == "series":
+            return sum(s.episode_count for s in self.seasons)
+        return len(self.video_files)
+
+    @property
+    def total_size(self) -> int:
+        if self.kind == "series":
+            return sum(s.total_size for s in self.seasons)
+        total = 0
+        for f in self.video_files:
+            try:
+                total += f.stat().st_size
+            except OSError:
+                pass
+        return total
+
+    @property
+    def total_size_human(self) -> str:
+        return format_size(self.total_size)
+
+    @property
+    def has_italian(self) -> bool:
+        return "ITA" in self.available_langs
+
+    @property
+    def all_seasons_uploaded(self) -> bool:
+        if self.kind != "series":
+            return self.already_uploaded
+        if not self.seasons:
+            return False
+        return all(s.already_uploaded or s.all_episodes_uploaded for s in self.seasons)
+
+
+def _iter_video(folder: Path) -> list[Path]:
+    return sorted(
+        f for f in folder.rglob("*")
+        if f.is_file() and f.suffix.lower() in VIDEO_EXTENSIONS
+    )
+
+
+def _detect_kind(folder: Path, category: str) -> str:
+    if category == "series":
+        return "series"
+    if category == "movies":
+        return "movie"
+    # anime / user-added categories: has Season XX/ subfolder → series
+    for child in folder.iterdir():
+        if child.is_dir() and re.match(r'[Ss]eason\s+\d+', child.name):
+            return "series"
+    return "movie"
+
+
+def _scan_seasons(folder: Path) -> list[Season]:
+    seasons = []
+    for child in sorted(folder.iterdir()):
+        if not child.is_dir():
+            continue
+        m = re.match(r'[Ss]eason\s+(\d+)', child.name)
+        if m:
+            num = int(m.group(1))
+            videos = _iter_video(child)
+            seasons.append(Season(
+                number=num,
+                label=child.name,
+                path=child,
+                video_files=videos,
+            ))
+    return seasons
+
+
+def scan_category(category: str) -> list[MediaItem]:
+    base = media_root() / category
+    if not base.exists():
+        return []
+    items = []
+    for item_path in sorted(base.iterdir()):
+        if item_path.is_file():
+            if item_path.suffix.lower() not in VIDEO_EXTENSIONS:
+                continue
+            items.append(MediaItem(
+                name=item_path.stem,
+                path=item_path,
+                category=category,
+                kind="movie",
+                video_files=[item_path],
+            ))
+        elif item_path.is_dir():
+            kind = _detect_kind(item_path, category)
+            if kind == "series":
+                seasons = _scan_seasons(item_path)
+                items.append(MediaItem(
+                    name=item_path.name,
+                    path=item_path,
+                    category=category,
+                    kind="series",
+                    seasons=seasons,
+                ))
+            else:
+                items.append(MediaItem(
+                    name=item_path.name,
+                    path=item_path,
+                    category=category,
+                    kind="movie",
+                    video_files=_iter_video(item_path),
+                ))
+    return items
+
+
+def get_item(category: str, item_name: str) -> MediaItem | None:
+    """Fetch single item by category + folder/file name."""
+    base = media_root() / category
+    target = base / item_name
+    if not target.exists():
+        # Try as file without extension
+        for ext in VIDEO_EXTENSIONS:
+            candidate = base / (item_name + ext)
+            if candidate.exists():
+                return MediaItem(
+                    name=candidate.stem,
+                    path=candidate,
+                    category=category,
+                    kind="movie",
+                    video_files=[candidate],
+                )
+        return None
+    if target.is_file():
+        return MediaItem(
+            name=target.stem,
+            path=target,
+            category=category,
+            kind="movie",
+            video_files=[target],
+        )
+    kind = _detect_kind(target, category)
+    if kind == "series":
+        return MediaItem(
+            name=target.name,
+            path=target,
+            category=category,
+            kind="series",
+            seasons=_scan_seasons(target),
+        )
+    return MediaItem(
+        name=target.name,
+        path=target,
+        category=category,
+        kind="movie",
+        video_files=_iter_video(target),
+    )
+
+
+def seedings_root() -> Path:
+    from .web import config
+    return Path(config.runtime_setting("U3DP_SEEDINGS_DIR", default=str(Path.home() / "seedings")))
+
+
+def scan_seedings() -> list[Path]:
+    """List top-level items in the configured seedings dir."""
+    seedings = seedings_root()
+    if not seedings.exists():
+        return []
+    return sorted(seedings.iterdir())

unit3dprep/upload.py

@@ -0,0 +1,146 @@
+"""Pre-flight helpers used by the wizard + CLI.
+
+Holds audio-check results, name-build helpers, and hardlink utilities. The
+actual upload step is handled by `unit3dprep.web.webup_orchestrator` (HTTP
+calls to Unit3DWebUp) — there is no longer any unit3dup CLI subprocess.
+
+Hardlink layout: every upload lives in its own per-job sandbox directory
+under `<seedings>/.unit3dprep/<jobid>/...`. This isolates each upload from
+the rest of the seedings tree so Unit3DWebUp's `/scan` (which always
+processes the entire SCAN_PATH) never re-scans unrelated files. The
+sandbox path is deterministic from the final name, so re-uploading the
+same item overwrites its sandbox cleanly.
+"""
+from __future__ import annotations
+
+import hashlib
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from guessit import guessit
+
+from .core import (
+    seedings_dir,
+    build_name,
+    extract_specs,
+    format_se,
+    hardlink_file,
+    hardlink_tree,
+    has_italian_audio,
+    map_source,
+)
+
+
+_SANDBOX_PARENT = ".unit3dprep"
+
+
+def _sandbox_id(key: str) -> str:
+    """Stable 8-char id derived from `key` (the final name).
+
+    Same final_name → same sandbox dir → re-uploads overwrite cleanly.
+    """
+    return hashlib.sha256(key.encode("utf-8")).hexdigest()[:8]
+
+
+def _sandbox_dir(key: str) -> Path:
+    """Resolve the per-job sandbox directory inside the configured seedings root."""
+    seed = seedings_dir()
+    return seed / _SANDBOX_PARENT / _sandbox_id(key)
+
+
+@dataclass
+class AudioResult:
+    path: Path
+    has_italian: bool
+    error: str = ""
+
+
+def check_audio_files(paths: list[Path]) -> list[AudioResult]:
+    results = []
+    for p in paths:
+        try:
+            ok = has_italian_audio(p)
+            results.append(AudioResult(path=p, has_italian=ok))
+        except Exception as e:
+            results.append(AudioResult(path=p, has_italian=False, error=str(e)))
+    return results
+
+
+def build_episode_names(
+    series_folder: Path,
+    video_files: list[Path],
+    series_title: str,
+    year: str,
+    folder_guess: dict,
+) -> dict[Path, str]:
+    """Returns mapping file_path → new_base_name (no extension)."""
+    episode_rename: dict[Path, str] = {}
+    for f in video_files:
+        g = dict(guessit(f.name))
+        season = g.get("season")
+        if isinstance(season, list):
+            season = season[0]
+        episode = g.get("episode")
+        se = format_se(season, episode)
+        if not se:
+            continue
+        specs = extract_specs(f)
+        source, src_type = map_source(g)
+        tag = g.get("release_group", "") or folder_guess.get("release_group", "") or ""
+        new_name = build_name(
+            title=series_title, year="", se=se,
+            specs=specs, source=source, src_type=src_type, tag=tag,
+        )
+        episode_rename[f] = new_name
+    return episode_rename
+
+
+def build_movie_name_from_file(
+    video_file: Path,
+    movie_title: str,
+    year: str,
+) -> str:
+    g = dict(guessit(video_file.name))
+    specs = extract_specs(video_file)
+    source, src_type = map_source(g)
+    tag = g.get("release_group", "") or ""
+    repack = "REPACK" if g.get("proper_count") else ""
+    return build_name(
+        title=movie_title, year=year, se="",
+        specs=specs, source=source, src_type=src_type, tag=tag, repack=repack,
+    )
+
+
+def do_hardlink_movie(src: Path, final_name: str) -> Path:
+    """Hardlink a single movie file into its dedicated sandbox.
+
+    Layout: `<seedings>/.unit3dprep/<jobid>/<final_name>.<ext>`.
+    SCAN_PATH for webup will be the sandbox dir; webup sees one file → one
+    Media → no concurrent scan of unrelated seedings entries.
+    """
+    sandbox = _sandbox_dir(final_name)
+    sandbox.mkdir(parents=True, exist_ok=True)
+    target = sandbox / f"{final_name}{src.suffix.lower()}"
+    hardlink_file(src, target, overwrite=True)
+    return target
+
+
+def do_hardlink_series(
+    src_dir: Path,
+    folder_name: str,
+    episode_rename: dict[Path, str],
+) -> Path:
+    """Hardlink an entire series/season pack into its dedicated sandbox.
+
+    Layout: `<seedings>/.unit3dprep/<jobid>/<folder_name>/<episodes>`.
+    SCAN_PATH for webup will be the sandbox dir; webup sees one subfolder
+    → one Media (recognized as a pack).
+    """
+    sandbox = _sandbox_dir(folder_name)
+    sandbox.mkdir(parents=True, exist_ok=True)
+    target_dir = sandbox / folder_name
+    if target_dir.exists():
+        shutil.rmtree(target_dir)
+    hardlink_tree(src_dir, target_dir, episode_rename)
+    return target_dir

unit3dprep/web/_env.py

@@ -0,0 +1,40 @@
+import logging
+import os
+from pathlib import Path
+
+log = logging.getLogger("unit3dprep.env")
+
+_warned: set[str] = set()
+
+
+def env(new_key: str, legacy_key: str | None = None, default: str | None = None) -> str | None:
+    v = os.getenv(new_key)
+    if v is not None:
+        return v
+    if legacy_key:
+        v = os.getenv(legacy_key)
+        if v is not None:
+            if legacy_key not in _warned:
+                log.warning("Using legacy env var %s; rename to %s", legacy_key, new_key)
+                _warned.add(legacy_key)
+            return v
+    return default
+
+
+_LEGACY_DOTFILES = {
+    ".itatorrents_db.json": ".unit3dprep_db.json",
+    ".itatorrents_tmdb_cache.json": ".unit3dprep_tmdb_cache.json",
+    ".itatorrents_lang_cache.json": ".unit3dprep_lang_cache.json",
+}
+
+
+def migrate_dotfiles(root: Path) -> None:
+    for old, new in _LEGACY_DOTFILES.items():
+        old_p = root / old
+        new_p = root / new
+        if old_p.exists() and not new_p.exists():
+            try:
+                old_p.rename(new_p)
+                log.warning("Migrated legacy dotfile %s -> %s", old, new)
+            except OSError as e:
+                log.error("Failed to migrate %s -> %s: %s", old, new, e)

unit3dprep/web/api/__init__.py

@@ -0,0 +1 @@
+"""JSON API routers mounted under /api."""

unit3dprep/web/api/auth.py

@@ -0,0 +1,36 @@
+"""Auth: POST /api/auth/login, POST /api/auth/logout, GET /api/me."""
+from __future__ import annotations
+
+import secrets
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+from ...i18n import get_request_lang, t
+from ..auth import login_session, logout_session, verify_password
+
+router = APIRouter(prefix="/api", tags=["auth"])
+
+
+class LoginBody(BaseModel):
+    password: str
+
+
+@router.post("/auth/login")
+async def login(request: Request, body: LoginBody):
+    if not verify_password(body.password):
+        raise HTTPException(status_code=401, detail=t("err.invalid_password", get_request_lang(request)))
+    login_session(request, secrets.token_urlsafe(16))
+    return JSONResponse({"ok": True})
+
+
+@router.post("/auth/logout")
+async def logout(request: Request):
+    logout_session(request)
+    return JSONResponse({"ok": True})
+
+
+@router.get("/me")
+async def me(request: Request):
+    return JSONResponse({"authenticated": bool(request.session.get("authenticated"))})