unit3dprep 1.1.8__tar.gz → 1.2.0__tar.gz

{unit3dprep-1.1.8/unit3dprep.egg-info → unit3dprep-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unit3dprep
-Version: 1.1.8
+Version: 1.2.0
 Summary: Web UI + CLI di pre-flight per tracker Unit3D, companion di Unit3DWebUp (audio ITA, nomenclatura ItaTorrents, hardlink, upload)
 Author: Davide Sidoti
 License: GNU GENERAL PUBLIC LICENSE

{unit3dprep-1.1.8 → unit3dprep-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unit3dprep"
-version = "1.1.8"
+version = "1.2.0"
 description = "Web UI + CLI di pre-flight per tracker Unit3D, companion di Unit3DWebUp (audio ITA, nomenclatura ItaTorrents, hardlink, upload)"
 readme = "README.md"
 license = { file = "LICENSE" }

{unit3dprep-1.1.8 → unit3dprep-1.2.0}/unit3dprep/core.py

@@ -381,6 +381,37 @@ def hi10p_flag(specs: dict) -> bool:
     return ("AVC" in fmt) and (specs.get("bit_depth") == 10) and (not specs.get("hdr"))
 
 
+# Attribute keys of `media_profile`, in display order.
+PROFILE_KEYS = ("resolution", "codec", "source", "hdr", "audio", "dub", "group")
+
+
+def media_profile(specs: dict, source: str, src_type: str, tag: str = "") -> dict[str, str]:
+    """Compact, comparable summary of one file's technical make-up.
+
+    Uses the very same labels `build_name` puts in the final name, so a season
+    pack whose episodes were encoded differently (e.g. one H.264 among H.265)
+    can be spotted by comparing profiles across files. Empty string = unknown.
+    """
+    codec = vcodec_for_type(specs, src_type or source)
+    if hi10p_flag(specs):
+        codec = f"{codec} Hi10P".strip()
+    return {
+        "resolution": specs.get("resolution") or "",
+        "codec": codec,
+        "source": " ".join(p for p in (source, src_type) if p),
+        "hdr": specs.get("hdr") or "",
+        "audio": " ".join(
+            p for p in (
+                specs.get("acodec") or "",
+                specs.get("channels") or "",
+                specs.get("object") or "",
+            ) if p
+        ),
+        "dub": " ".join(specs.get("dub") or []),
+        "group": tag or "",
+    }
+
+
 # ---------------------------------------------------------------------------
 # guessit → source/type
 # ---------------------------------------------------------------------------

{unit3dprep-1.1.8 → unit3dprep-1.2.0}/unit3dprep/upload.py

@@ -29,6 +29,7 @@ from .core import (
     hardlink_tree,
     has_italian_audio,
     map_source,
+    media_profile,
 )
 
 
@@ -67,15 +68,20 @@ def check_audio_files(paths: list[Path]) -> list[AudioResult]:
     return results
 
 
-def build_episode_names(
+def build_episode_names_detailed(
     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] = {}
+) -> dict[Path, tuple[str, dict[str, str]]]:
+    """Like `build_episode_names`, but also returns each file's media profile.
+
+    The profile comes from the same mediainfo parse used to build the name, so
+    callers that want to compare episodes (odd-one-out detection) pay nothing
+    extra for it.
+    """
+    episode_rename: dict[Path, tuple[str, dict[str, str]]] = {}
     for f in video_files:
         g = dict(guessit(f.name))
         season = g.get("season")
@@ -92,24 +98,48 @@ def build_episode_names(
             title=series_title, year="", se=se,
             specs=specs, source=source, src_type=src_type, tag=tag,
         )
-        episode_rename[f] = new_name
+        episode_rename[f] = (new_name, media_profile(specs, source, src_type, tag))
     return episode_rename
 
 
-def build_movie_name_from_file(
+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)."""
+    detailed = build_episode_names_detailed(
+        series_folder, video_files, series_title, year, folder_guess
+    )
+    return {f: name for f, (name, _) in detailed.items()}
+
+
+def build_movie_name_from_file_detailed(
     video_file: Path,
     movie_title: str,
     year: str,
-) -> str:
+) -> tuple[str, dict[str, str]]:
+    """Returns `(new_base_name, media_profile)` for a single video file."""
     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(
+    name = build_name(
         title=movie_title, year=year, se="",
         specs=specs, source=source, src_type=src_type, tag=tag, repack=repack,
     )
+    return name, media_profile(specs, source, src_type, tag)
+
+
+def build_movie_name_from_file(
+    video_file: Path,
+    movie_title: str,
+    year: str,
+) -> str:
+    return build_movie_name_from_file_detailed(video_file, movie_title, year)[0]
 
 
 def do_hardlink_movie(src: Path, final_name: str) -> Path:

{unit3dprep-1.1.8 → unit3dprep-1.2.0}/unit3dprep/web/api/library.py

@@ -432,15 +432,18 @@ def _ita_first(codes: list[str]) -> list[str]:
     return (["ITA"] + rest) if has_ita else rest
 
 
-async def _scan_langs_and_subs(video_files, loop):
-    """Scan each video file once for audio + subtitle languages.
+async def _scan_langs_and_subs_stream(video_files, loop):
+    """Async-generator variant of :func:`_scan_langs_and_subs`.
 
-    Returns (merged_audio, episode_langs, merged_subs, episode_subs); audio/subs are ITA-first.
-    Yields the event loop between files so SSE streams stay responsive."""
+    Yields ``("progress", n, path)`` after each file is scanned (``n`` = 1-based
+    count of files done so far), then a terminal
+    ``("result", merged_audio, episode_langs, merged_subs, episode_subs)``.
+    Callers that only need the aggregate use :func:`_scan_langs_and_subs`."""
     episode_langs: dict[str, list[str]] = {}
     episode_subs: dict[str, list[str]] = {}
     seen: list[str] = []
     seen_subs: list[str] = []
+    done = 0
     for vf in video_files:
         try:
             langs, subs = await loop.run_in_executor(None, audio_and_subtitle_languages, vf)
@@ -454,12 +457,26 @@ async def _scan_langs_and_subs(video_files, loop):
         for sub in subs:
             if sub not in seen_subs:
                 seen_subs.append(sub)
+        done += 1
+        yield ("progress", done, str(vf))
         await asyncio.sleep(0.05)
-    return _ita_first(seen), episode_langs, _ita_first(seen_subs), episode_subs
+    yield ("result", _ita_first(seen), episode_langs, _ita_first(seen_subs), episode_subs)
+
+
+async def _scan_langs_and_subs(video_files, loop):
+    """Scan each video file once for audio + subtitle languages.
+
+    Returns (merged_audio, episode_langs, merged_subs, episode_subs); audio/subs are ITA-first.
+    Yields the event loop between files so SSE streams stay responsive."""
+    result = ([], {}, [], {})
+    async for ev in _scan_langs_and_subs_stream(video_files, loop):
+        if ev[0] == "result":
+            result = ev[1:]
+    return result
 
 
 @router.get("/library/{category}/scan-langs")
-async def library_scan_langs(request: Request, category: str):
+async def library_scan_langs(request: Request, category: str, force: bool = False):
     if category not in discover_categories():
         raise HTTPException(404, _i18n_t("err.category_not_found", get_request_lang(request)))
 
@@ -474,32 +491,46 @@ async def library_scan_langs(request: Request, category: str):
                 all_paths.append(str(item.path))
         lang_cache = await get_many_langs(all_paths)
         loop = asyncio.get_event_loop()
+
+        # Build the work list up-front (skipping items already scanned with sub
+        # support) so the client can render an accurate "done/total" counter.
+        tasks: list[tuple[str, object, object]] = []  # (kind, item, season|None)
+        # ``force`` re-scans everything, ignoring the "already scanned" skip.
         for item in items:
             if item.kind == "series":
                 for season in item.seasons:
-                    sp = str(season.path)
-                    entry = lang_cache.get(sp)
-                    if entry and "subs" in entry:  # already scanned with sub support
+                    entry = lang_cache.get(str(season.path))
+                    if not force and entry and "subs" in entry:  # already scanned with sub support
                         continue
-                    merged, episode_langs, merged_subs, episode_subs = \
-                        await _scan_langs_and_subs(season.video_files, loop)
-                    await set_lang(sp, merged, episode_langs, subs=merged_subs, episode_subs=episode_subs)
-                    yield {
-                        "event": "lang_scanned",
-                        "data": json.dumps({
-                            "source_path": str(item.path),
-                            "season_path": sp,
-                            "langs": merged,
-                            "subs": merged_subs,
-                            "has_ita": "ITA" in merged,
-                            "has_ita_sub": "ITA" in merged_subs,
-                        }),
-                    }
+                    tasks.append(("series", item, season))
             else:
-                sp = str(item.path)
-                entry = lang_cache.get(sp)
-                if entry and "subs" in entry:  # already scanned with sub support
+                entry = lang_cache.get(str(item.path))
+                if not force and entry and "subs" in entry:  # already scanned with sub support
                     continue
+                tasks.append(("movie", item, None))
+
+        total = len(tasks)
+        yield {"event": "progress", "data": json.dumps({"done": 0, "total": total})}
+        done = 0
+        for kind, item, season in tasks:
+            if kind == "series":
+                sp = str(season.path)
+                merged, episode_langs, merged_subs, episode_subs = \
+                    await _scan_langs_and_subs(season.video_files, loop)
+                await set_lang(sp, merged, episode_langs, subs=merged_subs, episode_subs=episode_subs)
+                yield {
+                    "event": "lang_scanned",
+                    "data": json.dumps({
+                        "source_path": str(item.path),
+                        "season_path": sp,
+                        "langs": merged,
+                        "subs": merged_subs,
+                        "has_ita": "ITA" in merged,
+                        "has_ita_sub": "ITA" in merged_subs,
+                    }),
+                }
+            else:
+                sp = str(item.path)
                 multi = len(item.video_files) > 1
                 merged, episode_langs, merged_subs, episode_subs = \
                     await _scan_langs_and_subs(item.video_files, loop)
@@ -520,7 +551,9 @@ async def library_scan_langs(request: Request, category: str):
                         "has_ita_sub": "ITA" in merged_subs,
                     }),
                 }
-        yield {"event": "done", "data": "{}"}
+            done += 1
+            yield {"event": "progress", "data": json.dumps({"done": done, "total": total})}
+        yield {"event": "done", "data": json.dumps({"total": total})}
 
     return EventSourceResponse(generate())
 
@@ -642,3 +675,84 @@ async def library_rescan_langs(request: Request, category: str, item_name: str):
         "ok": True, "langs": merged, "subs": merged_subs,
         "episode_langs": episode_langs, "episode_subs": episode_subs,
     })
+
+
+@router.get("/library/{category}/{item_name:path}/rescan-langs/stream")
+async def library_rescan_langs_stream(request: Request, category: str, item_name: str):
+    """SSE variant of ``rescan-langs`` for a single item. Emits ``progress``
+    events ``{done, total}`` per video file (so a series streams a per-episode
+    counter) and a terminal ``done`` carrying the same payload as the POST."""
+    lang = get_request_lang(request)
+    if category not in discover_categories():
+        raise HTTPException(404, _i18n_t("err.category_not_found", lang))
+    item = get_item(category, item_name)
+    if item is None:
+        raise HTTPException(404, _i18n_t("err.item_not_found_in_category", lang, name=item_name, category=category))
+
+    async def generate() -> AsyncGenerator[dict, None]:
+        loop = asyncio.get_event_loop()
+        if item.kind == "series":
+            total = sum(len(s.video_files) for s in item.seasons)
+            yield {"event": "progress", "data": json.dumps({"done": 0, "total": total})}
+            done = 0
+            seasons_result: dict[str, dict] = {}
+            all_series_langs: list[str] = []
+            all_series_subs: list[str] = []
+            for season in item.seasons:
+                sp = str(season.path)
+                merged, episode_langs, merged_subs, episode_subs = [], {}, [], {}
+                async for ev in _scan_langs_and_subs_stream(season.video_files, loop):
+                    if ev[0] == "progress":
+                        done += 1
+                        yield {"event": "progress", "data": json.dumps({"done": done, "total": total})}
+                    else:
+                        _, merged, episode_langs, merged_subs, episode_subs = ev
+                await set_lang(sp, merged, episode_langs, subs=merged_subs, episode_subs=episode_subs)
+                seasons_result[sp] = {
+                    "langs": merged, "subs": merged_subs,
+                    "episode_langs": episode_langs, "episode_subs": episode_subs,
+                }
+                for lg in merged:
+                    if lg not in all_series_langs:
+                        all_series_langs.append(lg)
+                for sub in merged_subs:
+                    if sub not in all_series_subs:
+                        all_series_subs.append(sub)
+            yield {
+                "event": "done",
+                "data": json.dumps({
+                    "ok": True,
+                    "langs": _ita_first(all_series_langs),
+                    "subs": _ita_first(all_series_subs),
+                    "seasons": seasons_result,
+                }),
+            }
+            return
+
+        sp = str(item.path)
+        multi = len(item.video_files) > 1
+        total = len(item.video_files)
+        yield {"event": "progress", "data": json.dumps({"done": 0, "total": total})}
+        done = 0
+        merged, episode_langs, merged_subs, episode_subs = [], {}, [], {}
+        async for ev in _scan_langs_and_subs_stream(item.video_files, loop):
+            if ev[0] == "progress":
+                done += 1
+                yield {"event": "progress", "data": json.dumps({"done": done, "total": total})}
+            else:
+                _, merged, episode_langs, merged_subs, episode_subs = ev
+        await set_lang(
+            sp, merged,
+            episode_langs if multi else None,
+            subs=merged_subs,
+            episode_subs=episode_subs if multi else None,
+        )
+        yield {
+            "event": "done",
+            "data": json.dumps({
+                "ok": True, "langs": merged, "subs": merged_subs,
+                "episode_langs": episode_langs, "episode_subs": episode_subs,
+            }),
+        }
+
+    return EventSourceResponse(generate())

{unit3dprep-1.1.8 → unit3dprep-1.2.0}/unit3dprep/web/api/wizard.py

@@ -25,8 +25,8 @@ from ...core import (
     build_name,
 )
 from ...upload import (
-    build_episode_names,
-    build_movie_name_from_file,
+    build_episode_names_detailed,
+    build_movie_name_from_file_detailed,
     do_hardlink_movie,
     do_hardlink_series,
 )
@@ -132,6 +132,7 @@ async def wizard_start(request: Request, body: StartBody):
         "tmdb_poster": "",
         "tmdb_overview": "",
         "final_names": {},
+        "file_specs": {},
         "folder_name": "",
         "seeding_path": "",
         "upload_done": False,
@@ -263,25 +264,34 @@ async def wizard_tmdb(request: Request, tok: str, body: TmdbBody):
             "poster": state["tmdb_poster"],
         },
         "proposed": proposed,
+        "file_specs": state["file_specs"],
         "folder_name": state["folder_name"],
     })
 
 
 async def _build_proposed_names(state: dict[str, Any]) -> dict[str, str]:
+    """Propose a final name per video file and record each file's media profile.
+
+    `state["file_specs"]` maps file path → technical profile (resolution, codec,
+    source, …) so the names step can flag the odd file out inside a pack.
+    """
     from guessit import guessit as _guessit
     loop = asyncio.get_event_loop()
     path = Path(state["path"])
     kind = state["kind"]
     title = state["tmdb_title"]
     year = state["tmdb_year"]
+    specs_map: dict[str, dict[str, str]] = {}
+    state["file_specs"] = specs_map
     if kind == "movie":
         files = [path] if path.is_file() else list(iter_video_files(path))
         proposed: dict[str, str] = {}
         for vf in files:
-            name = await loop.run_in_executor(
-                None, build_movie_name_from_file, vf, title, year
+            name, profile = await loop.run_in_executor(
+                None, build_movie_name_from_file_detailed, vf, title, year
             )
             proposed[str(vf)] = name
+            specs_map[str(vf)] = profile
         return proposed
     if kind == "episode":
         files = [path] if path.is_file() else list(iter_video_files(path))
@@ -290,27 +300,32 @@ async def _build_proposed_names(state: dict[str, Any]) -> dict[str, str]:
         episode_file = files[0]
         season_folder = episode_file.parent
         folder_guess = dict(_guessit(season_folder.name))
-        result = await loop.run_in_executor(
+        detailed = await loop.run_in_executor(
             None,
-            lambda: {str(k): v for k, v in build_episode_names(
+            lambda: {str(k): v for k, v in build_episode_names_detailed(
                 season_folder, [episode_file], title, year, folder_guess
             ).items()},
         )
+        result = {k: name for k, (name, _) in detailed.items()}
+        specs_map.update({k: profile for k, (_, profile) in detailed.items()})
         if not result:
-            fallback = await loop.run_in_executor(
-                None, build_movie_name_from_file, episode_file, title, ""
+            fallback, profile = await loop.run_in_executor(
+                None, build_movie_name_from_file_detailed, episode_file, title, ""
             )
             result = {str(episode_file): fallback}
+            specs_map[str(episode_file)] = profile
         return result
     # series
     folder_guess = dict(_guessit(path.name))
     files = list(iter_video_files(path))
-    result = await loop.run_in_executor(
+    detailed = await loop.run_in_executor(
         None,
-        lambda: {str(k): v for k, v in build_episode_names(
+        lambda: {str(k): v for k, v in build_episode_names_detailed(
             path, files, title, year, folder_guess
         ).items()},
     )
+    result = {k: name for k, (name, _) in detailed.items()}
+    specs_map.update({k: profile for k, (_, profile) in detailed.items()})
     if files:
         first = files[0]
         g = dict(_guessit(first.name))
@@ -342,18 +357,44 @@ async def wizard_names(tok: str, body: NamesBody):
     return JSONResponse({"ok": True})
 
 
-def _primary_source_size(state: dict[str, Any]) -> int | None:
-    """Bytes of the file we're about to upload (None for season packs)."""
-    if state["kind"] not in {"movie", "episode"}:
-        return None
+def _source_fingerprint(state: dict[str, Any]) -> tuple[int | None, int | None, list[int]]:
+    """(file_count, total_bytes, sorted per-file sizes) of what we'll upload.
+
+    Movie/episode → the single video file. Series (season pack / full series)
+    → every video file that ``hardlink_tree`` will place in the torrent, so the
+    fingerprint mirrors the packaged content. ``(None, None, [])`` when nothing
+    usable is found.
+    """
     path = Path(state["path"])
-    src = path if path.is_file() else next(iter(iter_video_files(path)), None)
-    if src is None:
-        return None
+    if state["kind"] in {"movie", "episode"}:
+        src = path if path.is_file() else next(iter(iter_video_files(path)), None)
+        if src is None:
+            return (None, None, [])
+        try:
+            sz = src.stat().st_size
+        except OSError:
+            return (None, None, [])
+        return (1, sz, [sz])
+    if state["kind"] == "series":
+        sizes: list[int] = []
+        for f in iter_video_files(path):
+            try:
+                sizes.append(f.stat().st_size)
+            except OSError:
+                continue
+        if not sizes:
+            return (None, None, [])
+        return (len(sizes), sum(sizes), sorted(sizes))
+    return (None, None, [])
+
+
+def _duplicate_tolerance_pct(cfg: dict[str, Any]) -> float:
+    """Configured size-match tolerance (%), clamped to a sane range."""
     try:
-        return src.stat().st_size
-    except OSError:
-        return None
+        v = float(cfg.get("W_DUPLICATE_SIZE_TOLERANCE_PCT", 2.0))
+    except (TypeError, ValueError):
+        v = 2.0
+    return max(0.0, min(v, 50.0))
 
 
 @router.post("/wizard/{tok}/duplicate-check")
@@ -362,10 +403,10 @@ async def wizard_duplicate_check(tok: str):
     cfg = web_config.load()
     enabled = bool(cfg.get("W_DUPLICATE_CHECK", True))
     state["duplicate"] = None
-    if not enabled or state["kind"] not in {"movie", "episode"}:
+    if not enabled:
         state["step"] = "hardlink"
         return JSONResponse({"enabled": enabled, "duplicate": None})
-    size = _primary_source_size(state)
+    num_files, total_size, file_sizes = _source_fingerprint(state)
     tmdb_id = state.get("tmdb_id", "")
     tracker_url = (cfg.get("ITT_URL") or "").strip()
     api_token = (cfg.get("ITT_APIKEY") or "").strip()
@@ -373,7 +414,10 @@ async def wizard_duplicate_check(tok: str):
         tracker_url=tracker_url,
         api_token=api_token,
         tmdb_id=tmdb_id,
-        size_bytes=size,
+        num_files=num_files,
+        total_size=total_size,
+        file_sizes=file_sizes,
+        tolerance_pct=_duplicate_tolerance_pct(cfg),
     )
     if match is None:
         state["step"] = "hardlink"

{unit3dprep-1.1.8 → unit3dprep-1.2.0}/unit3dprep/web/config.py

@@ -257,6 +257,7 @@ DEFAULT_CONFIG: dict[str, Any] = {
     "W_HARDLINK_ONLY": False,
     "W_CONFIRM_NAMES": True,
     "W_DUPLICATE_CHECK": True,
+    "W_DUPLICATE_SIZE_TOLERANCE_PCT": 2.0,
 }
 
 MASKED_KEYS = {
@@ -555,7 +556,7 @@ _GROUPS: list[tuple[str, list[str]]] = [
     ("Wizard defaults (unit3dprep)", [
         "W_AUDIO_CHECK", "W_AUTO_TMDB", "W_HIDE_UPLOADED",
         "W_HIDE_NO_ITALIAN", "W_HARDLINK_ONLY", "W_CONFIRM_NAMES",
-        "W_DUPLICATE_CHECK",
+        "W_DUPLICATE_CHECK", "W_DUPLICATE_SIZE_TOLERANCE_PCT",
     ]),
 ]
 
@@ -595,6 +596,11 @@ def _coerce_value(default_val: Any, raw: str) -> Any:
             return int(raw)
         except ValueError:
             return default_val
+    if isinstance(default_val, float):
+        try:
+            return float(raw)
+        except ValueError:
+            return default_val
     if isinstance(default_val, list):
         s = raw.strip()
         if s.startswith("["):