unit3dprep 1.2.0__tar.gz → 1.2.1__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unit3dprep"
-version = "1.2.0"
+version = "1.2.1"
 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.2.1/unit3dprep/web/duplicate_check.py

@@ -0,0 +1,398 @@
+"""Tracker lookups by TMDB id + content fingerprint.
+
+Two users of the same primitive:
+
+* :func:`find_duplicate` — pre-upload duplicate detection. Webup 0.0.25 does
+  not implement it (`DUPLICATE_ON` / `SKIP_DUPLICATE` are commented
+  `# Todo Not yet implemented` in its `config/settings.py`). The legacy
+  `unit3dup` CLI used to query the tracker by TMDB id and refuse the upload
+  when an existing torrent had the *exact* same file size in bytes —
+  irrespective of name/encode/etc. We replicate that as a bridge pre-flight.
+  Triggered by the `W_DUPLICATE_CHECK` runtime setting (default ON).
+* :func:`find_recent_match` — post-upload confirmation, used when webup cannot
+  tell us whether the tracker accepted the torrent.
+
+Both identify a torrent by *content* (file count, per-file byte sizes, total
+size), never by name.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+import httpx
+
+log = logging.getLogger("unit3dprep.duplicate_check")
+
+_TIMEOUT = httpx.Timeout(15.0, connect=5.0)
+
+# How far back a tracker entry may have been created and still count as "the
+# torrent we just uploaded". Generous, to absorb clock skew against the tracker.
+DEFAULT_RECENT_WINDOW = 1800.0
+
+# How long a freshly accepted torrent stays invisible to the API varies a lot:
+# measured on ITT 2026-08-01, one upload was listed within seconds while the
+# next one (two minutes later) took several minutes. Keep polling for ~6 min
+# before concluding it never landed — the alternative is a torrent published on
+# the tracker that nobody seeds.
+_RECENT_BACKOFF = (3.0, 6.0, 12.0, 20.0, 30.0, 45.0, 60.0, 60.0, 60.0, 60.0)
+
+
+def _retry_after_seconds(resp: httpx.Response) -> float:
+    """``Retry-After`` in seconds, 0 when absent or unparseable."""
+    try:
+        ra = resp.headers.get("retry-after")
+        return float(ra) if ra else 0.0
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _to_int(v: Any) -> int | None:
+    try:
+        return int(v) if v is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _entry_file_sizes(attrs: dict[str, Any]) -> list[int]:
+    """Sorted per-file byte sizes from a tracker torrent's ``files`` list."""
+    files = attrs.get("files")
+    if not isinstance(files, list):
+        return []
+    sizes: list[int] = []
+    for f in files:
+        if isinstance(f, dict):
+            s = _to_int(f.get("size"))
+            if s is not None:
+                sizes.append(s)
+    return sorted(sizes)
+
+
+def _entry_delta(
+    attrs: dict[str, Any],
+    *,
+    num_files: int | None,
+    total_size: int,
+    file_sizes: list[int] | None,
+    tolerance_bytes: int,
+) -> int | None:
+    """Absolute size delta if ``attrs`` matches the fingerprint, else ``None``.
+
+    A match requires the same file count (when both sides expose ``num_file``)
+    and a total size within ``tolerance_bytes``. In exact mode (tolerance 0)
+    the per-file size multiset must also match when both sides provide it —
+    this rules out same-total/same-count torrents with a different make-up.
+    Name/encode/release-group are irrelevant.
+    """
+    existing_size = _to_int(attrs.get("size"))
+    if existing_size is None or existing_size <= 0:
+        return None
+    existing_num = _to_int(attrs.get("num_file"))
+    if num_files and existing_num and existing_num != num_files:
+        return None
+    delta = abs(existing_size - total_size)
+    if delta > tolerance_bytes:
+        return None
+    if tolerance_bytes == 0 and file_sizes:
+        existing_sizes = _entry_file_sizes(attrs)
+        if existing_sizes and existing_sizes != sorted(file_sizes):
+            return None
+    return delta
+
+
+def _parse_created_at(value: Any) -> datetime | None:
+    """Parse a tracker ``created_at`` into an aware datetime (UTC assumed)."""
+    if not isinstance(value, str) or not value.strip():
+        return None
+    try:
+        dt = datetime.fromisoformat(value.strip().replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)
+
+
+def _summarize(entry: dict[str, Any], attrs: dict[str, Any], tmdb_int: int, delta: int) -> dict[str, Any]:
+    """Flatten a tracker entry into the dict shape the API/UI consume."""
+    return {
+        "id": entry.get("id") or attrs.get("id"),
+        "name": attrs.get("name"),
+        "size": _to_int(attrs.get("size")),
+        "num_file": _to_int(attrs.get("num_file")),
+        "type": attrs.get("type"),
+        "resolution": attrs.get("resolution"),
+        "category": attrs.get("category"),
+        "uploader": attrs.get("uploader"),
+        "seeders": attrs.get("seeders"),
+        "leechers": attrs.get("leechers"),
+        "created_at": attrs.get("created_at"),
+        "details_link": attrs.get("details_link"),
+        # Carries the rsskey — the only way to fetch the .torrent (see
+        # reseed.download_torrent_file). Saves re-querying the show endpoint.
+        "download_link": attrs.get("download_link") or "",
+        "tmdb_id": tmdb_int,
+        "size_delta": delta,
+        "approx": delta > 0,
+    }
+
+
+def _prepare(
+    tmdb_id: int | str | None, total_size: int | None, tolerance_pct: float,
+) -> tuple[int, int, int] | None:
+    """``(tmdb_id, total_bytes, tolerance_bytes)`` or ``None`` if unusable."""
+    if not tmdb_id or not total_size:
+        return None
+    try:
+        total_int = int(total_size)
+        tmdb_int = int(tmdb_id)
+    except (TypeError, ValueError):
+        return None
+    if total_int <= 0 or tmdb_int <= 0:
+        return None
+    try:
+        tol = max(0.0, float(tolerance_pct))
+    except (TypeError, ValueError):
+        tol = 0.0
+    return tmdb_int, total_int, int(round(total_int * tol / 100.0))
+
+
+async def _fetch_rows(
+    url: str, params: dict[str, str], *, throttle_retries: int = 2,
+) -> list[dict[str, Any]] | None:
+    """GET a Unit3D torrent listing. ``None`` marks a failed API call — callers
+    must not read that as "nothing on the tracker".
+
+    Unit3D throttles its API, so a 429 is waited out (honouring ``Retry-After``,
+    capped) rather than reported as a failure.
+    """
+    try:
+        async with httpx.AsyncClient(timeout=_TIMEOUT, follow_redirects=True) as client:
+            for attempt in range(throttle_retries + 1):
+                r = await client.get(url, params=params)
+                if r.status_code == 429 and attempt < throttle_retries:
+                    wait = min(_retry_after_seconds(r) or 10.0, 30.0)
+                    log.info("tracker 429 — waiting %.0fs then retrying", wait)
+                    await asyncio.sleep(wait)
+                    continue
+                r.raise_for_status()
+                payload = r.json()
+                break
+            else:  # pragma: no cover — loop always breaks or raises
+                return None
+    except (httpx.HTTPError, ValueError) as e:
+        log.warning("tracker query failed (%s): %s", url, e)
+        return None
+    items = payload.get("data") if isinstance(payload, dict) else None
+    if not isinstance(items, list):
+        return []
+    return [e for e in items if isinstance(e, dict)]
+
+
+def _bust(params: dict[str, str], nonce: str | None) -> dict[str, str]:
+    """Add a throwaway query param so a response cached against the exact query
+    string cannot be replayed to us. Unit3D ignores unknown params."""
+    if not nonce:
+        return params
+    return {**params, "_": nonce}
+
+
+async def _fetch_entries(
+    tracker_url: str, api_token: str, tmdb_int: int, *,
+    throttle_retries: int = 2, nonce: str | None = None,
+) -> list[dict[str, Any]] | None:
+    """Tracker entries for a TMDB id, via the search/filter endpoint."""
+    base = tracker_url.rstrip("/")
+    return await _fetch_rows(
+        f"{base}/api/torrents/filter",
+        _bust({"tmdbId": str(tmdb_int), "api_token": api_token, "perPage": "100"}, nonce),
+        throttle_retries=throttle_retries,
+    )
+
+
+async def _fetch_newest(
+    tracker_url: str, api_token: str, *, per_page: int = 50,
+    throttle_retries: int = 2, nonce: str | None = None,
+) -> list[dict[str, Any]] | None:
+    """The most recently uploaded torrents, newest first.
+
+    ``/api/torrents/filter`` lags badly behind a fresh upload — measured on ITT
+    2026-08-01: a torrent created at T was still missing from the filter results
+    at T+2min and only showed up around T+7min, while the plain list endpoint
+    (a straight newest-first listing) had it. So confirming a just-finished
+    upload starts here, and only falls back to the TMDB filter.
+    """
+    base = tracker_url.rstrip("/")
+    return await _fetch_rows(
+        f"{base}/api/torrents",
+        _bust({"api_token": api_token, "perPage": str(per_page)}, nonce),
+        throttle_retries=throttle_retries,
+    )
+
+
+async def find_duplicate(
+    *,
+    tracker_url: str,
+    api_token: str,
+    tmdb_id: int | str | None,
+    num_files: int | None,
+    total_size: int | None,
+    file_sizes: list[int] | None = None,
+    tolerance_pct: float = 0.0,
+) -> dict[str, Any] | None:
+    """Query the tracker for an existing torrent matching the local fingerprint.
+
+    The fingerprint is the number of video files (``num_files``), their total
+    byte size (``total_size``) and — optionally — the sorted list of per-file
+    byte sizes (``file_sizes``). ``tolerance_pct`` widens the total-size match
+    to catch near-identical re-encodes (e.g. 12.00 vs 12.02 GB); ``0`` means an
+    exact match and additionally compares the per-file size multiset.
+
+    Returns a dict with the matched torrent details (the closest one when
+    several qualify) or ``None`` when nothing matches, an input is missing, or
+    the API call fails. ``None`` is always safe to treat as "no duplicate".
+    """
+    prepared = _prepare(tmdb_id, total_size, tolerance_pct)
+    if not tracker_url or not api_token or prepared is None:
+        return None
+    tmdb_int, total_int, tolerance_bytes = prepared
+
+    entries = await _fetch_entries(tracker_url, api_token, tmdb_int)
+    if not entries:
+        return None
+
+    best: dict[str, Any] | None = None
+    best_delta = -1
+    for entry in entries:
+        attrs = entry.get("attributes") or {}
+        delta = _entry_delta(
+            attrs,
+            num_files=num_files,
+            total_size=total_int,
+            file_sizes=file_sizes,
+            tolerance_bytes=tolerance_bytes,
+        )
+        if delta is None:
+            continue
+        if best is None or delta < best_delta:
+            best_delta = delta
+            best = _summarize(entry, attrs, tmdb_int, delta)
+        if best_delta == 0:
+            break
+    return best
+
+
+def _select_recent(
+    entries: list[dict[str, Any]],
+    *,
+    num_files: int | None,
+    total_size: int,
+    file_sizes: list[int] | None,
+    tolerance_bytes: int,
+    cutoff: datetime,
+    tmdb_int: int,
+    require_tmdb: bool = True,
+) -> dict[str, Any] | None:
+    """Newest entry matching the fingerprint and created at/after ``cutoff``.
+
+    An entry without a parseable ``created_at`` is skipped: we cannot tell it
+    apart from a torrent that was already on the tracker. With ``require_tmdb``
+    an entry that advertises a different ``tmdb_id`` is skipped too — the
+    newest-uploads listing spans every title, so the fingerprint alone could in
+    principle collide with somebody else's upload in the same window.
+    """
+    newest: dict[str, Any] | None = None
+    newest_at: datetime | None = None
+    for entry in entries:
+        attrs = entry.get("attributes") or {}
+        entry_tmdb = _to_int(attrs.get("tmdb_id"))
+        if require_tmdb and entry_tmdb is not None and entry_tmdb != tmdb_int:
+            continue
+        delta = _entry_delta(
+            attrs,
+            num_files=num_files,
+            total_size=total_size,
+            file_sizes=file_sizes,
+            tolerance_bytes=tolerance_bytes,
+        )
+        if delta is None:
+            continue
+        created = _parse_created_at(attrs.get("created_at"))
+        if created is None or created < cutoff:
+            continue
+        if newest_at is None or created > newest_at:
+            newest_at = created
+            newest = _summarize(entry, attrs, tmdb_int, delta)
+    return newest
+
+
+async def find_recent_match(
+    *,
+    tracker_url: str,
+    api_token: str,
+    tmdb_id: int | str | None,
+    num_files: int | None,
+    total_size: int | None,
+    file_sizes: list[int] | None = None,
+    within_seconds: float = DEFAULT_RECENT_WINDOW,
+    backoff: tuple[float, ...] = _RECENT_BACKOFF,
+    on_attempt: Any = None,
+) -> dict[str, Any] | None:
+    """Confirm that a torrent we just sent actually reached the tracker.
+
+    Webup raises when the tracker answers the upload POST with anything other
+    than JSON (ITT replies ``200 text/html`` on success, and
+    `itt_tracker_helper._post` calls `resp.json()` unconditionally), so a
+    perfectly successful upload surfaces to us as an HTTP 500. This looks the
+    torrent up by TMDB id + exact content fingerprint instead of trusting that
+    response.
+
+    The match is exact — same file count, same per-file sizes, same total — and
+    the entry must be younger than ``within_seconds``, so an older duplicate is
+    never mistaken for our upload.
+
+    A just-accepted torrent is not immediately visible on the filter endpoint,
+    so the lookup is retried along ``backoff`` (delays in seconds between
+    attempts) before concluding the upload did not land. ``on_attempt`` is an
+    optional ``(index, total, found) -> None`` callback for progress reporting.
+    """
+    prepared = _prepare(tmdb_id, total_size, 0.0)
+    if not tracker_url or not api_token or prepared is None:
+        return None
+    tmdb_int, total_int, tolerance_bytes = prepared
+    cutoff = datetime.now(timezone.utc) - timedelta(seconds=max(0.0, within_seconds))
+
+    def _pick(entries: list[dict[str, Any]] | None) -> dict[str, Any] | None:
+        if not entries:
+            return None
+        return _select_recent(
+            entries,
+            num_files=num_files,
+            total_size=total_int,
+            file_sizes=file_sizes,
+            tolerance_bytes=tolerance_bytes,
+            cutoff=cutoff,
+            tmdb_int=tmdb_int,
+        )
+
+    delays = tuple(backoff or ())
+    total_rounds = len(delays) + 1
+    for attempt in range(total_rounds):
+        # Newest-uploads listing first — it usually carries a fresh torrent
+        # sooner than the TMDB filter (see _fetch_newest). Both get a per-attempt
+        # nonce so no cached snapshot taken before our upload can be replayed.
+        nonce = f"{time.time_ns()}"
+        match = _pick(await _fetch_newest(tracker_url, api_token, nonce=nonce))
+        if match is None:
+            match = _pick(await _fetch_entries(tracker_url, api_token, tmdb_int, nonce=nonce))
+        if on_attempt is not None:
+            try:
+                on_attempt(attempt + 1, total_rounds, match is not None)
+            except Exception:  # a progress callback must never break the lookup
+                log.debug("on_attempt callback failed", exc_info=True)
+        if match is not None:
+            return match
+        if attempt < len(delays):
+            await asyncio.sleep(delays[attempt])
+    return None

{unit3dprep-1.2.0 → unit3dprep-1.2.1}/unit3dprep/web/reseed.py

@@ -31,7 +31,7 @@ import httpx
 from ..core import VIDEO_EXTENSIONS, hardlink_file, seedings_dir
 from ..media import discover_categories, scan_category
 from .clients import get_client
-from .duplicate_check import _entry_delta, _entry_file_sizes
+from .duplicate_check import _entry_delta, _entry_file_sizes, _retry_after_seconds
 from .db import record_upload
 from .tmdb_cache import get_many
 from .trackers import _human_size, _resolution_for, _type_for
@@ -102,14 +102,6 @@ class _RateLimiter:
 _itt_rate = _RateLimiter()
 
 
-def _retry_after_seconds(resp: httpx.Response) -> float:
-    try:
-        ra = resp.headers.get("retry-after")
-        return float(ra) if ra else 0.0
-    except (TypeError, ValueError):
-        return 0.0
-
-
 async def _itt_get(
     client: httpx.AsyncClient, url: str, params: dict[str, str], *, retries: int = 3,
 ) -> httpx.Response:

{unit3dprep-1.2.0 → unit3dprep-1.2.1}/unit3dprep/web/webup_orchestrator.py

@@ -27,10 +27,22 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import time
 from pathlib import Path
 from typing import Any, AsyncGenerator
 
-from .config import runtime_setting
+from ..core import iter_video_files
+from .clients import get_client as get_qbit_client
+from .config import load as load_config, runtime_setting
+from .duplicate_check import find_recent_match
+from .logbuf import emit as log_emit
+from .reseed import (
+    _await_new_hash,
+    _poll_recheck,
+    _reseed_lock as reseed_lock,
+    download_torrent_file,
+    fetch_torrent_meta,
+)
 from .webup_client import WebupClient, compute_job_id
 from .webup_job_fix import (
     DEFAULT_TRACKER_SIGNATURE,
@@ -361,6 +373,155 @@ async def _drain_buffered(
         yield {"type": "log", "data": text, "kind": ev_kind, "event": slug}, msg
 
 
+def _content_fingerprint(path: Path) -> tuple[int | None, int | None, list[int]]:
+    """(file count, total bytes, sorted per-file sizes) of what went into the
+    torrent.
+
+    ``hardlink_tree`` packs video files only, so the tracker's ``num_file`` and
+    ``size`` mirror exactly this for both a single movie and a season pack.
+    """
+    try:
+        files = [path] if path.is_file() else list(iter_video_files(path))
+    except OSError:
+        return (None, None, [])
+    sizes: list[int] = []
+    for f in files:
+        try:
+            sizes.append(f.stat().st_size)
+        except OSError:
+            continue
+    if not sizes:
+        return (None, None, [])
+    return (len(sizes), sum(sizes), sorted(sizes))
+
+
+async def _seed_from_tracker(
+    entry: dict[str, Any], match_path: str, result: dict[str, bool],
+) -> AsyncGenerator[dict[str, Any], None]:
+    """Seed the `.torrent` the *tracker* stored, not the one webup built.
+
+    Unit3D normalizes an uploaded torrent before saving it — on ITT that means
+    rewriting ``info.source`` (``ITT`` → ``ItaTorrents``), which changes the
+    infohash. The local `.torrent` therefore announces as "InfoHash not found"
+    and never seeds, even though the upload succeeded. Downloading the
+    tracker's copy is the only way to get the infohash it registered.
+
+    The content is already hardlinked where the torrent expects it, so this
+    only adds → rechecks → resumes. Reports through ``result``:
+    ``added`` (a torrent reached qBittorrent — never fall back to webup's
+    /seed afterwards, it would add a second, dead one) and ``ok`` (seeding).
+    """
+    cfg = load_config()
+    base = (cfg.get("ITT_URL") or "").rstrip("/")
+    token = (cfg.get("ITT_APIKEY") or "").strip()
+    try:
+        torrent_id = int(entry.get("id"))
+    except (TypeError, ValueError):
+        yield {"type": "log", "kind": "warn", "data": f"webup: id torrent non valido ({entry.get('id')!r})"}
+        return
+    save_path = str(Path(match_path).parent)
+
+    async with reseed_lock:
+        try:
+            # The listing already gave us the download link (it embeds the
+            # rsskey); only ask the show endpoint when it didn't.
+            link = (entry.get("download_link") or "").strip()
+            if not link:
+                meta = await fetch_torrent_meta(base, token, torrent_id)
+                link = (meta or {}).get("download_link") or ""
+            tbytes = await download_torrent_file(link)
+            client = get_qbit_client(cfg)
+            before = {t.hash for t in await client.list()}
+            # Same qBittorrent tag webup's own /seed applies (TORRENT__TAG), so
+            # bot uploads keep showing up under one tag in the sidebar.
+            await client.add_torrent(
+                tbytes, save_path=save_path, paused=True, skip_checking=False,
+                tags=(cfg.get("TAG") or "").strip() or None,
+            )
+            new_hash = await _await_new_hash(client, before)
+            if not new_hash:
+                yield {
+                    "type": "log", "kind": "warn",
+                    "data": "webup: torrent aggiunto a qBittorrent ma non individuato "
+                            "(forse già presente) — verifica manualmente",
+                    "event": "upload.qbit",
+                }
+                return
+            result["added"] = True
+            await client.recheck(new_hash)
+            final = 0.0
+            async for prog, _state in _poll_recheck(client, new_hash):
+                final = prog
+                yield _progress_event("seed", prog * 100)
+            if final < 0.999:
+                yield {
+                    "type": "log", "kind": "error",
+                    "data": f"webup: recheck fermo al {final * 100:.1f}% — il contenuto locale non "
+                            "corrisponde al torrent del tracker; lasciato in pausa",
+                    "event": "upload.qbit",
+                }
+                return
+            await client.resume(new_hash)
+            result["ok"] = True
+            yield {
+                "type": "log", "kind": "ok",
+                "data": f"webup: in seed con il .torrent del tracker (infohash {new_hash[:12]}…)",
+                "event": "upload.qbit",
+            }
+        except Exception as exc:
+            yield {
+                "type": "log", "kind": "warn",
+                "data": f"webup: seed dal tracker fallito ({exc!r})",
+                "event": "upload.qbit",
+            }
+
+
+async def _verify_upload_on_tracker(match_path: str, tmdb_id: str) -> dict[str, Any] | None:
+    """Did the torrent we just sent actually land on the tracker?
+
+    Webup's `itt_tracker_helper._post` calls `resp.json()` without checking the
+    content type, so a tracker answering `200 text/html` — which ITT does on a
+    *successful* upload — makes webup's `/upload` raise and reach us as an HTTP
+    500. Abandoning the run there leaves a torrent published on the tracker
+    that nobody seeds, so instead of trusting that response we look the torrent
+    up by TMDB id + exact content fingerprint.
+
+    Returns the matched tracker entry, or ``None`` when we cannot confirm it —
+    in which case the caller must treat the upload as failed.
+    """
+    if not tmdb_id:
+        return None
+    num_files, total_size, file_sizes = _content_fingerprint(Path(match_path))
+    if not total_size:
+        return None
+    cfg = load_config()
+
+    # The wait can run for minutes; report into the Logs tab so it doesn't look
+    # like the upload silently hung (the SSE stream is busy awaiting this call).
+    started = time.monotonic()
+
+    def _report(index: int, total: int, found: bool) -> None:
+        if not (found or index == 1 or index % 3 == 0):
+            return
+        elapsed = int(time.monotonic() - started)
+        log_emit(
+            "ok" if found else "info",
+            f"Tracker: tentativo {index}/{total} — "
+            + ("torrent trovato" if found else f"non ancora visibile ({elapsed}s)"),
+            "webup", source="webup", event="upload.tracker_response",
+        )
+
+    return await find_recent_match(
+        tracker_url=(cfg.get("ITT_URL") or "").strip(),
+        api_token=(cfg.get("ITT_APIKEY") or "").strip(),
+        tmdb_id=tmdb_id,
+        num_files=num_files,
+        total_size=total_size,
+        file_sizes=file_sizes,
+        on_attempt=_report,
+    )
+
+
 async def stream_webup(
     *,
     client: WebupClient,
@@ -617,6 +778,7 @@ async def stream_webup(
         # WSL/dev can exercise the full pipeline without polluting the live
         # tracker. Maketorrent and seed still run, the .torrent ends up in qBit.
         dry_run = runtime_setting("U3DP_DRY_RUN_TRACKER", "0") in {"1", "true", "True", "yes"}
+        landed: dict[str, Any] | None = None
         if dry_run:
             yield _progress_event("upload", 0)
             yield {
@@ -629,70 +791,136 @@ async def stream_webup(
         else:
             yield _progress_event("upload", 0)
             yield {"type": "log", "data": "webup: /upload…"}
+            upload_error: str | None = None
             try:
-                upload_http_resp = await asyncio.wait_for(client.upload(job_id), timeout=PHASE_TIMEOUT)
+                await asyncio.wait_for(client.upload(job_id), timeout=PHASE_TIMEOUT)
             except asyncio.TimeoutError:
-                yield {"type": "error", "data": f"/upload timeout after {PHASE_TIMEOUT}s"}
-                yield {"type": "done", "exit_code": 1}
-                return
+                upload_error = f"/upload timeout after {PHASE_TIMEOUT}s"
             except Exception as e:
-                yield {"type": "error", "data": f"/upload failed: {e}"}
-                yield {"type": "done", "exit_code": 1}
-                return
-
-            # webup's /upload endpoint returns JSON null regardless of outcome
-            # (FastAPI default for endpoints with no explicit return value).
-            # The actual tracker result comes exclusively through WebSocket
-            # posterLogMessage events broadcast inside UploadUseCase.execute().
-            # Do NOT treat None here as an error — drain WS for the real status.
-
-            _log.info(
-                "upload: /upload HTTP done, ws_connected=%s queue_size=%d — draining WS",
-                ws.connected, queue.qsize(),
-            )
-
-            upload_failed = False
-            upload_succeeded = False
-            async for ev, msg in _drain_buffered(queue, job_id, window=8.0):
-                yield ev
-                if is_terminal_failure(msg):
-                    upload_failed = True
-                elif is_terminal_success(msg):
-                    upload_succeeded = True
-
-            _log.info(
-                "upload: drain done — succeeded=%s failed=%s queue_size=%d ws_connected=%s",
-                upload_succeeded, upload_failed, queue.qsize(), ws.connected,
-            )
-
-            if upload_succeeded:
-                pass  # WS confirmed success
-            elif upload_failed:
-                yield {"type": "error", "data": "/upload tracker rejected — see log above for details"}
-                yield {"type": "done", "exit_code": 1}
-                return
-            else:
-                # No posterLogMessage arrived within 8 s.
-                # This is a WS delivery issue (timing race, connection glitch)
-                # rather than a definitive upload failure — the HTTP 200 from
-                # webup means execute() completed and the tracker call was made.
-                # Log a warning and proceed to seed so the workflow still
-                # completes; the operator should verify the tracker manually.
+                upload_error = f"/upload failed: {e}"
+
+            if upload_error:
+                # webup blew up — but its own crash says nothing about what the
+                # tracker did with our POST. It raises on any non-JSON reply,
+                # and ITT answers `200 text/html` on success, so the torrent is
+                # usually already published. Ask the tracker directly; only give
+                # up when it cannot confirm the upload.
+                yield {
+                    "type": "log", "kind": "warn",
+                    "data": f"webup: {upload_error} — controllo sul tracker se il torrent "
+                            "è stato accettato (può richiedere un paio di minuti)…",
+                    "event": "upload.tracker_response",
+                }
+                try:
+                    landed = await _verify_upload_on_tracker(match_path, wanted_tmdb or webup_tmdb)
+                except Exception as exc:
+                    _log.warning("upload verification failed: %r", exc)
+                if landed is None:
+                    yield {"type": "error", "data": upload_error}
+                    yield {"type": "done", "exit_code": 1}
+                    return
                 yield {
                     "type": "log",
-                    "data": (
-                        f"webup: /upload — no WS status received within 8 s "
-                        f"(ws_connected={ws.connected}, queue_size={queue.qsize()}). "
-                        "Proceeding to seed. Check the tracker to confirm the upload succeeded."
-                    ),
                     "kind": "warn",
                     "event": "upload.tracker_response",
+                    "data": (
+                        f"webup: {upload_error} — but the torrent IS on the tracker "
+                        f"(id={landed.get('id')}, {landed.get('name')!r}). Known webup "
+                        "limitation: it cannot read a non-JSON tracker reply. Seeding it."
+                    ),
                 }
-            yield _progress_event("upload", 100)
+                yield _progress_event("upload", 100)
+            else:
+                # webup's /upload endpoint returns JSON null regardless of
+                # outcome (FastAPI default for endpoints with no explicit return
+                # value). The actual tracker result comes exclusively through
+                # WebSocket posterLogMessage events broadcast inside
+                # UploadUseCase.execute(). Do NOT treat None here as an error —
+                # drain WS for the real status.
+
+                _log.info(
+                    "upload: /upload HTTP done, ws_connected=%s queue_size=%d — draining WS",
+                    ws.connected, queue.qsize(),
+                )
+
+                upload_failed = False
+                upload_succeeded = False
+                async for ev, msg in _drain_buffered(queue, job_id, window=8.0):
+                    yield ev
+                    if is_terminal_failure(msg):
+                        upload_failed = True
+                    elif is_terminal_success(msg):
+                        upload_succeeded = True
+
+                _log.info(
+                    "upload: drain done — succeeded=%s failed=%s queue_size=%d ws_connected=%s",
+                    upload_succeeded, upload_failed, queue.qsize(), ws.connected,
+                )
+
+                if upload_succeeded:
+                    pass  # WS confirmed success
+                elif upload_failed:
+                    yield {"type": "error", "data": "/upload tracker rejected — see log above for details"}
+                    yield {"type": "done", "exit_code": 1}
+                    return
+                else:
+                    # No posterLogMessage arrived within 8 s.
+                    # This is a WS delivery issue (timing race, connection glitch)
+                    # rather than a definitive upload failure — the HTTP 200 from
+                    # webup means execute() completed and the tracker call was made.
+                    # Log a warning and proceed to seed so the workflow still
+                    # completes; the operator should verify the tracker manually.
+                    yield {
+                        "type": "log",
+                        "data": (
+                            f"webup: /upload — no WS status received within 8 s "
+                            f"(ws_connected={ws.connected}, queue_size={queue.qsize()}). "
+                            "Proceeding to seed. Check the tracker to confirm the upload succeeded."
+                        ),
+                        "kind": "warn",
+                        "event": "upload.tracker_response",
+                    }
+                yield _progress_event("upload", 100)
 
         # ---- Seed (optional) ----
         if do_seed:
             yield _progress_event("seed", 0)
+
+            # Prefer the tracker's own .torrent: Unit3D rewrites `info.source`
+            # when it stores the upload, so the locally built file has a
+            # different infohash and would announce "InfoHash not found".
+            # Fall back to webup's /seed only when the tracker entry is unknown
+            # (dry-run, missing TMDB id, tracker unreachable).
+            seeded = {"added": False, "ok": False}
+            if not dry_run:
+                if landed is None:
+                    yield {"type": "log", "data": "webup: cerco il torrent sul tracker…"}
+                    try:
+                        landed = await _verify_upload_on_tracker(match_path, wanted_tmdb or webup_tmdb)
+                    except Exception as exc:
+                        _log.warning("tracker lookup before seed failed: %r", exc)
+                if landed is None:
+                    yield {
+                        "type": "log", "kind": "warn",
+                        "data": "webup: torrent non trovato sul tracker — uso il .torrent locale "
+                                "(l'announce potrebbe rispondere 'InfoHash not found')",
+                        "event": "upload.qbit",
+                    }
+                else:
+                    async for ev in _seed_from_tracker(landed, match_path, seeded):
+                        yield ev
+
+            if seeded["ok"]:
+                yield _progress_event("seed", 100)
+                yield {"type": "done", "exit_code": 0}
+                return
+            if seeded["added"]:
+                # Something reached qBittorrent but isn't seeding — adding the
+                # local .torrent on top would just create a dead duplicate.
+                yield _progress_event("seed", 100)
+                yield {"type": "done", "exit_code": 1}
+                return
+
             yield {"type": "log", "data": "webup: /seed…"}
             try:
                 code, body = await client.seed(job_id)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unit3dprep
-Version: 1.2.0
+Version: 1.2.1
 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.2.0/unit3dprep/web/duplicate_check.py

@@ -1,168 +0,0 @@
-"""Pre-upload duplicate detection against the ITT Unit3D API.
-
-Webup 0.0.25 does not implement duplicate detection (`DUPLICATE_ON` /
-`SKIP_DUPLICATE` are commented `# Todo Not yet implemented` in its
-`config/settings.py`). The legacy `unit3dup` CLI used to query the
-tracker by TMDB id and refuse the upload when an existing torrent had
-the *exact* same file size in bytes — irrespective of name/encode/etc.
-We replicate that behaviour here as a pre-flight performed by the
-bridge before invoking webup.
-
-Triggered by the `W_DUPLICATE_CHECK` runtime setting (default ON).
-"""
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-import httpx
-
-log = logging.getLogger("unit3dprep.duplicate_check")
-
-_TIMEOUT = httpx.Timeout(15.0, connect=5.0)
-
-
-def _to_int(v: Any) -> int | None:
-    try:
-        return int(v) if v is not None else None
-    except (TypeError, ValueError):
-        return None
-
-
-def _entry_file_sizes(attrs: dict[str, Any]) -> list[int]:
-    """Sorted per-file byte sizes from a tracker torrent's ``files`` list."""
-    files = attrs.get("files")
-    if not isinstance(files, list):
-        return []
-    sizes: list[int] = []
-    for f in files:
-        if isinstance(f, dict):
-            s = _to_int(f.get("size"))
-            if s is not None:
-                sizes.append(s)
-    return sorted(sizes)
-
-
-def _entry_delta(
-    attrs: dict[str, Any],
-    *,
-    num_files: int | None,
-    total_size: int,
-    file_sizes: list[int] | None,
-    tolerance_bytes: int,
-) -> int | None:
-    """Absolute size delta if ``attrs`` matches the fingerprint, else ``None``.
-
-    A match requires the same file count (when both sides expose ``num_file``)
-    and a total size within ``tolerance_bytes``. In exact mode (tolerance 0)
-    the per-file size multiset must also match when both sides provide it —
-    this rules out same-total/same-count torrents with a different make-up.
-    Name/encode/release-group are irrelevant.
-    """
-    existing_size = _to_int(attrs.get("size"))
-    if existing_size is None or existing_size <= 0:
-        return None
-    existing_num = _to_int(attrs.get("num_file"))
-    if num_files and existing_num and existing_num != num_files:
-        return None
-    delta = abs(existing_size - total_size)
-    if delta > tolerance_bytes:
-        return None
-    if tolerance_bytes == 0 and file_sizes:
-        existing_sizes = _entry_file_sizes(attrs)
-        if existing_sizes and existing_sizes != sorted(file_sizes):
-            return None
-    return delta
-
-
-async def find_duplicate(
-    *,
-    tracker_url: str,
-    api_token: str,
-    tmdb_id: int | str | None,
-    num_files: int | None,
-    total_size: int | None,
-    file_sizes: list[int] | None = None,
-    tolerance_pct: float = 0.0,
-) -> dict[str, Any] | None:
-    """Query the tracker for an existing torrent matching the local fingerprint.
-
-    The fingerprint is the number of video files (``num_files``), their total
-    byte size (``total_size``) and — optionally — the sorted list of per-file
-    byte sizes (``file_sizes``). ``tolerance_pct`` widens the total-size match
-    to catch near-identical re-encodes (e.g. 12.00 vs 12.02 GB); ``0`` means an
-    exact match and additionally compares the per-file size multiset.
-
-    Returns a dict with the matched torrent details (the closest one when
-    several qualify) or ``None`` when nothing matches, an input is missing, or
-    the API call fails. ``None`` is always safe to treat as "no duplicate".
-    """
-    if not tracker_url or not api_token or not tmdb_id or not total_size:
-        return None
-    try:
-        total_int = int(total_size)
-        tmdb_int = int(tmdb_id)
-    except (TypeError, ValueError):
-        return None
-    if total_int <= 0 or tmdb_int <= 0:
-        return None
-
-    try:
-        tol = max(0.0, float(tolerance_pct))
-    except (TypeError, ValueError):
-        tol = 0.0
-    tolerance_bytes = int(round(total_int * tol / 100.0))
-
-    base = tracker_url.rstrip("/")
-    url = f"{base}/api/torrents/filter"
-    params = {"tmdbId": str(tmdb_int), "api_token": api_token, "perPage": "100"}
-    try:
-        async with httpx.AsyncClient(timeout=_TIMEOUT, follow_redirects=True) as client:
-            r = await client.get(url, params=params)
-            r.raise_for_status()
-            payload = r.json()
-    except (httpx.HTTPError, ValueError) as e:
-        log.warning("duplicate check failed (%s): %s", url, e)
-        return None
-
-    items = payload.get("data") if isinstance(payload, dict) else None
-    if not isinstance(items, list):
-        return None
-
-    best: dict[str, Any] | None = None
-    best_delta = -1
-    for entry in items:
-        if not isinstance(entry, dict):
-            continue
-        attrs = entry.get("attributes") or {}
-        delta = _entry_delta(
-            attrs,
-            num_files=num_files,
-            total_size=total_int,
-            file_sizes=file_sizes,
-            tolerance_bytes=tolerance_bytes,
-        )
-        if delta is None:
-            continue
-        if best is None or delta < best_delta:
-            best_delta = delta
-            best = {
-                "id": entry.get("id") or attrs.get("id"),
-                "name": attrs.get("name"),
-                "size": _to_int(attrs.get("size")),
-                "num_file": _to_int(attrs.get("num_file")),
-                "type": attrs.get("type"),
-                "resolution": attrs.get("resolution"),
-                "category": attrs.get("category"),
-                "uploader": attrs.get("uploader"),
-                "seeders": attrs.get("seeders"),
-                "leechers": attrs.get("leechers"),
-                "created_at": attrs.get("created_at"),
-                "details_link": attrs.get("details_link"),
-                "tmdb_id": tmdb_int,
-                "size_delta": delta,
-                "approx": delta > 0,
-            }
-        if best_delta == 0:
-            break
-    return best