unit3dprep 1.1.9__tar.gz → 1.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unit3dprep
-Version: 1.1.9
+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.9 → unit3dprep-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unit3dprep"
-version = "1.1.9"
+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.9 → 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.9 → 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.9 → 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.9 → 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("["):