Update app.py

app.py

@@ -46,11 +46,9 @@ def parse_torrent(raw: bytes) -> Dict:
 
     # files
     files = []
-    total_len = 0
     if b"files" in info:
         for f in info[b"files"]:
             length = int(f.get(b"length", 0))
-            total_len += length
             parts = []
             for pe in f.get(b"path", []):
                 parts.append((pe.decode("utf-8", "replace")) if isinstance(pe,(bytes,bytearray)) else str(pe))
@@ -58,7 +56,6 @@ def parse_torrent(raw: bytes) -> Dict:
             files.append({"path": rel, "length": length})
     else:
         length = int(info.get(b"length", 0))
-        total_len = length
         rel = name or "(unnamed)"
         files.append({"path": rel, "length": length})
 
@@ -87,18 +84,47 @@ def join_url(base: str, *segs: str) -> str:
         parts.append(enc)
     return "/".join(parts)
 
+def _head_or_peek(url: str, timeout: int = 20) -> Tuple[bool, Optional[int]]:
+    # Try HEAD
+    try:
+        r = requests.head(url, timeout=timeout, allow_redirects=True)
+        if r.status_code < 400:
+            size = r.headers.get("Content-Length")
+            return True, (int(size) if size and size.isdigit() else None)
+    except Exception:
+        pass
+    # Fallback tiny GET (first chunk)
+    try:
+        r = requests.get(url, stream=True, timeout=timeout, allow_redirects=True)
+        if r.status_code < 400:
+            size = r.headers.get("Content-Length")
+            try:
+                next(r.iter_content(chunk_size=1024))
+            except Exception:
+                pass
+            r.close()
+            return True, (int(size) if size and size.isdigit() else None)
+    except Exception:
+        pass
+    return False, None
+
 def supports_range_and_size(url: str, timeout: int = 30) -> Tuple[bool, Optional[int]]:
-    r = requests.head(url, timeout=timeout, allow_redirects=True)
-    if r.status_code >= 400:
+    try:
+        r = requests.head(url, timeout=timeout, allow_redirects=True)
+        if r.status_code < 400:
+            size = int(r.headers.get("Content-Length","0") or 0)
+            return (("bytes" in r.headers.get("Accept-Ranges","").lower()) or size>0, size if size>0 else None)
+    except Exception:
+        pass
+    try:
         r = requests.get(url, stream=True, timeout=timeout, allow_redirects=True)
         r.raise_for_status()
         size = int(r.headers.get("Content-Length","0") or 0)
-        accept_ranges = r.headers.get("Accept-Ranges","")
         try: r.close()
         except: pass
-        return ("bytes" in accept_ranges.lower() or size>0, size if size>0 else None)
-    size = int(r.headers.get("Content-Length","0") or 0)
-    return (("bytes" in r.headers.get("Accept-Ranges","").lower()) or size>0, size if size>0 else None)
+        return ("bytes" in r.headers.get("Accept-Ranges","").lower() or size>0, size if size>0 else None)
+    except Exception:
+        return False, None
 
 def download_with_resume(url: str, dest_path: pathlib.Path, timeout: int = 120):
     dest_path.parent.mkdir(parents=True, exist_ok=True)
@@ -142,6 +168,40 @@ def preview_path(path_str: str, max_bytes: int = 250_000) -> Tuple[str, Optional
     except Exception as e:
         return f"Error previewing file: {type(e).__name__}: {e}", None
 
+# ---------- NEW: base inference when no web seeds ----------
+
+def infer_bases_from_torrent_url(torrent_url: str) -> List[str]:
+    """
+    For URLs like:
+      https://data.ddosecrets.com/Collection/Collection.torrent
+    return:
+      ["https://data.ddosecrets.com/Collection"]
+    """
+    u = torrent_url.strip()
+    if "/" not in u:
+        return []
+    base = u.rsplit("/", 1)[0]
+    return [base]
+
+def resolve_download_url(bases: List[str], root_name: str, rel_path: str) -> Optional[str]:
+    """
+    Try both:
+      base/root_name/rel_path
+      base/rel_path
+    Return the first that exists.
+    """
+    candidates = []
+    for b in bases:
+        candidates.append(join_url(b, root_name, rel_path))
+        candidates.append(join_url(b, rel_path))
+    tried = []
+    for c in candidates:
+        ok, _ = _head_or_peek(c)
+        tried.append((c, ok))
+        if ok:
+            return c
+    return None
+
 # -------------------------
 # The single action
 # -------------------------
@@ -153,20 +213,24 @@ def run_pipeline(torrent_url: str):
     # Parse torrent
     raw = fetch_bytes(torrent_url.strip())
     meta = parse_torrent(raw)
-    if not meta["web_seeds"]:
-        raise gr.Error("This .torrent does not advertise HTTP web seeds (BEP-19 url-list). "
-                       "On Spaces we cannot use BitTorrent; please use a .torrent with web seeds "
-                       "or host the .7z via HTTPS and download it directly.")
+
+    # seed list: web seeds if present, else infer from torrent URL folder (DDoSecrets-friendly)
+    seeds = list(meta["web_seeds"])
+    if not seeds:
+        seeds = infer_bases_from_torrent_url(torrent_url)
 
     infohash = meta["infohash"]
     root_name = meta["name"]
-    seed = meta["web_seeds"][0]  # keep it simple: first seed
 
     # We expect .7z payloads
     sevenz_files = [f for f in meta["files"] if f["path"].lower().endswith(".7z")]
     if not sevenz_files:
         raise gr.Error("No .7z files listed in the torrent.")
 
+    if not seeds:
+        raise gr.Error("No HTTP source found. Tried to infer base from the .torrent URL but failed. "
+                       "If this is DDoSecrets, host likely at the same folder as the torrent.")
+
     # Work dirs
     base_dir = pathlib.Path("/mnt/data/work") / infohash
     dl_dir = base_dir / "downloads"
@@ -177,15 +241,22 @@ def run_pipeline(torrent_url: str):
     logs = []
     saved_archives = []
 
-    # Download each .7z over HTTP using <seed>/<root_name>/<relative path>
+    # Download each .7z over HTTP
     for f in sevenz_files:
         rel = f["path"]
-        url = join_url(seed, root_name, rel)
+        # resolve against any seed/base
+        final_url = None
+        for seed in seeds:
+            final_url = resolve_download_url([seed], root_name, rel)
+            if final_url:
+                break
+        if not final_url:
+            raise gr.Error(f"Could not resolve an HTTP URL for {rel} from bases {seeds}.")
         dest = dl_dir / rel
-        logs.append(f"Downloading: {url}")
-        download_with_resume(url, dest)
+        logs.append(f"Downloading: {final_url}")
+        download_with_resume(final_url, dest)
         if not dest.exists():
-            raise gr.Error(f"Download failed: {url}")
+            raise gr.Error(f"Download failed: {final_url}")
         logs.append(f"Saved: {dest} ({human_bytes(dest.stat().st_size)})")
         saved_archives.append(str(dest))
 
@@ -203,7 +274,6 @@ def run_pipeline(torrent_url: str):
     else:
         logs.append(f"Extracted files: {len(extracted)}")
 
-    # For the UI: return a short log, a list of files, and default selection
     log_md = "### Run log\n" + "\n".join(f"- {l}" for l in logs)
     return log_md, extracted, (extracted[0] if extracted else "")
 
@@ -219,12 +289,13 @@ with gr.Blocks(title="Torrent → 7z → View (HTTP only)") as demo:
     gr.Markdown(
         """
 # Torrent → 7z → View (HTTP only)
-Paste a **.torrent URL** that includes **HTTP web seeds**.  
-The app will download the `.7z` file(s), extract them, and let you preview text/csv/json files.
+Paste a **.torrent URL**.  
+If it has web seeds, great. If not, we'll auto-guess the HTTPS folder from the URL (works for DDoSecrets layouts).  
+The app downloads `.7z` file(s), extracts them, and lets you preview text/csv/json.
         """
     )
 
-    url_in = gr.Textbox(label=".torrent URL", placeholder="https://.../something.torrent")
+    url_in = gr.Textbox(label=".torrent URL", placeholder="https://data.ddosecrets.com/Collection/Collection.torrent")
     go_btn = gr.Button("Download, Extract & List")
     log_out = gr.Markdown()
     files_dd = gr.Dropdown(label="Extracted files", choices=[], interactive=True)
@@ -247,5 +318,5 @@ if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=int(os.environ.get("PORT", 7860)),
-        allowed_paths=["/mnt/data"]  # allow returning files from work dir if needed later
+        allowed_paths=["/mnt/data"]
     )