Update index.js

index.js

@@ -1,200 +1,135 @@
-const express = require('express');
-const fetch = require('node-fetch');
-
-const app = express();
-const PORT = process.env.PORT || 7860;
-
-app.use((req, res, next) => {
-  res.header('Access-Control-Allow-Origin', '*');
-  res.header('Access-Control-Allow-Headers', '*');
-  res.header('Access-Control-Allow-Methods', 'GET, OPTIONS');
-  if (req.method === 'OPTIONS') return res.sendStatus(200);
-  next();
-});
-
-const UPSTREAM_URLS = [
-  'https://torrentio.strem.fun',
-  'https://thepiratebay-plus.strem.fun/'
-];
-
-const MIN_SEEDERS = 1;
-const ALLOWED_QUALITIES = ['480p', '576p', '720p', '1080p', 'webrip', 'webdl', 'bluray'];
-const MAX_SIZE_GB = 4;
-
-const SOURCE_CONFIG = [
-  { name: 'yts', display: 'YTS', order: 1 },
-  { name: 'yify', display: 'YTS', order: 1 },
-  { name: 'eztv', display: 'EZTV', order: 2 },
-  { name: 'nyaasi', display: 'Nyaa', order: 3 },
-  { name: 'thepiratebay', display: 'TPB', order: 4 },
-  { name: 'piratebay', display: 'TPB', order: 4 },
-  { name: 'the piratebay', display: 'TPB', order: 4 },
-  { name: 'tpb', display: 'TPB', order: 4 },
-  { name: '1337x', display: '1337x', order: 5 },
-  { name: 'torrentgalaxy', display: 'TGx', order: 6 },
-  { name: 'rarbg', display: 'RARBG', order: 7 },
-  { name: 'rutor', display: 'Rutor', order: 8 },
-  { name: 'rutracker', display: 'Rutracker', order: 9 }
-];
-
-const QUALITY_RANK = {
-  '1080p': 1,
-  '720p': 2,
-  'webdl': 3,
-  'webrip': 4,
-  '576p': 5,
-  '480p': 6,
-  'bluray': 7
-};
-
-const LINKS_PER_QUALITY = 5;
-
-function getQuality(title = '') {
-  const lower = title.toLowerCase();
-  if (lower.includes('1080p')) return '1080p';
-  if (lower.includes('720p')) return '720p';
-  if (lower.includes('480p')) return '480p';
-  if (lower.includes('576p')) return '576p';
-  if (lower.includes('webrip')) return 'webrip';
-  if (lower.includes('webdl') || lower.includes('web-dl')) return 'webdl';
-  if (lower.includes('bluray')) return 'bluray';
-  return null;
-}
-
-function getSeeders(stream) {
-  if (stream.behaviorHints?.seeders) return stream.behaviorHints.seeders;
-  const match = stream.title?.match(/👤\s*(\d+)/);
-  return match ? parseInt(match[1], 10) : 0;
-}
-
-function getSizeInGB(stream) {
-  const title = stream.title || '';
-  const sizeMatch = title.match(/💾\s*([\d.]+)\s*(GB|MB)/i) || 
-                    title.match(/([\d.]+)\s*(GB|MB)/i);
-  if (!sizeMatch) return null;
-  
-  const value = parseFloat(sizeMatch[1]);
-  const unit = sizeMatch[2].toUpperCase();
-  
-  if (unit === 'GB') return value;
-  if (unit === 'MB') return value / 1024;
-  return null;
-}
-
-function detectSource(title = '') {
-  const lower = title.toLowerCase();
-  for (const src of SOURCE_CONFIG) {
-    if (lower.includes(src.name)) return src.name;
-  }
-  return null;
-}
-
-function getSourceOrder(sourceName) {
-  const config = SOURCE_CONFIG.find(c => c.name === sourceName);
-  return config ? config.order : 999;
-}
-
-function filterStream(stream) {
-  const title = stream.title || '';
-  if (!stream.url && !stream.infoHash) return false;
-  
-  const quality = getQuality(title);
-  if (!ALLOWED_QUALITIES.includes(quality)) return false;
-  
-  if (getSeeders(stream) < MIN_SEEDERS) return false;
-  
-  if (!detectSource(title)) return false;
-  
-  const sizeGB = getSizeInGB(stream);
-  if (sizeGB !== null && sizeGB > MAX_SIZE_GB) return false;
-  
-  return true;
-}
-
-async function fetchUpstream(type, id) {
-  for (const baseUrl of UPSTREAM_URLS) {
-    try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 8000);
-      const res = await fetch(`${baseUrl}/stream/${type}/${id}.json`, { signal: controller.signal });
-      clearTimeout(timeout);
-      if (res.ok) {
-        const data = await res.json();
-        if (data.streams?.length) return data.streams;
-      }
-    } catch (e) {}
-  }
-  return [];
-}
-
-function sortAndGroup(streams) {
-  const filtered = streams.filter(filterStream);
-  
-  const byQuality = {};
-  filtered.forEach(stream => {
-    const quality = getQuality(stream.title);
-    if (!byQuality[quality]) byQuality[quality] = [];
-    byQuality[quality].push(stream);
-  });
-  
-  for (const quality in byQuality) {
-    byQuality[quality].sort((a, b) => {
-      const sourceA = detectSource(a.title);
-      const sourceB = detectSource(b.title);
-      const orderA = getSourceOrder(sourceA);
-      const orderB = getSourceOrder(sourceB);
-      if (orderA !== orderB) return orderA - orderB;
-      return getSeeders(b) - getSeeders(a);
-    });
-  }
-  
-  const result = [];
-  const sortedQualities = Object.keys(byQuality).sort((a, b) => {
-    const rankA = QUALITY_RANK[a] || 999;
-    const rankB = QUALITY_RANK[b] || 999;
-    return rankA - rankB;
-  });
-  
-  sortedQualities.forEach(quality => {
-    const topLinks = byQuality[quality].slice(0, LINKS_PER_QUALITY);
-    result.push(...topLinks);
-  });
-  
-  return result;
-}
-
-app.get('/manifest.json', (req, res) => {
-  res.json({
-    id: 'org.ghostream.platinum',
-    name: 'Ghostream 🚀',
-    description: 'Stream Everything You Want\nMade With  🤍  By Van',
-    version: '7.3.0',
-    resources: ['stream'],
-    types: ['movie', 'series'],
-    idPrefixes: ['tt'],
-    catalogs: []
-  });
-});
-
-app.get('/stream/:type/:id.json', async (req, res) => {
-  const { type, id } = req.params;
-  try {
-    const streams = await fetchUpstream(type, id);
-    const sorted = sortAndGroup(streams);
-    res.json({ streams: sorted });
-  } catch (e) {
-    res.json({ streams: [] });
-  }
-});
-
-app.get('/debug/:type/:id.json', async (req, res) => {
-  const { type, id } = req.params;
-  try {
-    const streams = await fetchUpstream(type, id);
-    res.json({ streams });
-  } catch (e) {
-    res.status(500).json({ error: e.message });
-  }
-});
-
-app.listen(PORT, () => console.log(`Ghostream 🚀 on ${PORT}`));
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, FileResponse
+import httpx
+import re
+import os
+from typing import List, Dict, Any
+
+app = FastAPI()
+
+UPSTREAM_URLS = [
+    "https://torrentio.strem.fun",
+    "https://thepiratebay-plus.strem.fun",
+]
+
+# Quality order: highest first. Exclude 4K, screeners, cam, 3D.
+QUALITY_ORDER = [
+    "1080p", "720p", "576p", "480p", "360p", "240p",
+    "1080", "720", "480", "360",
+    "hdrip", "webrip", "brrip", "hdtv", "bluray", "dvdrip",
+    # all others will be appended at the end (lowest)
+]
+
+# Blacklist keywords (case‑insensitive)
+EXCLUDE_KEYWORDS = ["4k", "2160p", "screenr", "screener", "cam", "3d"]
+
+MAX_MOVIE_SIZE_GB = 4
+MAX_SERIES_SIZE_GB = 1.5
+LINKS_PER_QUALITY = 5
+
+def parse_size_to_gb(size_str: str) -> float:
+    """Convert size string like '2.5 GB' or '800 MB' to GB float."""
+    if not size_str:
+        return None
+    match = re.match(r"([\d.]+)\s*(GB|MB|TB)", size_str, re.IGNORECASE)
+    if not match:
+        return None
+    value = float(match.group(1))
+    unit = match.group(2).upper()
+    if unit == "TB":
+        return value * 1024
+    elif unit == "GB":
+        return value
+    elif unit == "MB":
+        return value / 1024
+    return None
+
+def extract_quality(name: str) -> str:
+    """Extract a quality label like '1080p' from a stream name."""
+    # Try pattern like 1080p, 720p, etc.
+    m = re.search(r"\b(\d{3,4}p)\b", name)
+    if m:
+        return m.group(1)
+    # Fallback: look for known labels
+    name_lower = name.lower()
+    for q in QUALITY_ORDER:
+        if q in name_lower:
+            return q
+    # If nothing found, treat as 'other'
+    return "other"
+
+def quality_sort_key(quality: str) -> int:
+    """Return a sortable number for the quality."""
+    try:
+        return QUALITY_ORDER.index(quality)
+    except ValueError:
+        return len(QUALITY_ORDER)  # push unknown to the end
+
+def filter_and_sort(streams: List[Dict], is_series: bool) -> List[Dict]:
+    """Apply size, quality exclusion, per‑quality limit, and sorting."""
+    max_size_gb = MAX_SERIES_SIZE_GB if is_series else MAX_MOVIE_SIZE_GB
+    filtered = []
+
+    for s in streams:
+        # Size filter
+        size_str = s.get("title", "").split("\n")[0]  # typical format: '📦 1.2 GB' at start
+        size_match = re.search(r"💾\s*([\d.]+)\s*(GB|MB|TB)", s.get("title", ""), re.IGNORECASE)
+        if not size_match:
+            # try other common pattern: 'size: X GB'
+            size_match = re.search(r"size:\s*([\d.]+)\s*(GB|MB|TB)", s.get("title", ""), re.IGNORECASE)
+        size_gb = parse_size_to_gb(size_match.group(0) if size_match else None)
+
+        if size_gb is not None and size_gb > max_size_gb:
+            continue  # too big
+
+        # Quality exclusion
+        quality = extract_quality(s.get("title") or s.get("name", ""))
+        if any(excl in (s.get("title") + (s.get("name") or "")).lower() for excl in EXCLUDE_KEYWORDS):
+            continue  # blacklisted
+
+        s["_quality"] = quality
+        filtered.append(s)
+
+    # Group by quality, keep only LINKS_PER_QUALITY
+    groups = {}
+    for s in filtered:
+        q = s["_quality"]
+        groups.setdefault(q, []).append(s)
+    limited = []
+    for q, streams_list in groups.items():
+        limited.extend(streams_list[:LINKS_PER_QUALITY])
+
+    # Sort by quality (1080p first, etc.)
+    limited.sort(key=lambda x: quality_sort_key(x["_quality"]))
+
+    # Remove the temporary quality field
+    for s in limited:
+        s.pop("_quality", None)
+    return limited
+
+@app.get("/manifest.json")
+async def manifest():
+    return FileResponse("manifest.json")
+
+@app.get("/stream/{type}/{id}.json")
+async def stream(type: str, id: str, request: Request):
+    params = dict(request.query_params)
+    merged = []
+    async with httpx.AsyncClient(timeout=15) as client:
+        for base_url in UPSTREAM_URLS:
+            url = f"{base_url}/stream/{type}/{id}.json"
+            try:
+                resp = await client.get(url, params=params)
+                if resp.status_code == 200:
+                    data = resp.json()
+                    merged.extend(data.get("streams", []))
+            except Exception:
+                pass  # upstream fails silently
+
+    is_series = (type == "series")
+    final_streams = filter_and_sort(merged, is_series)
+    return JSONResponse({"streams": final_streams})
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))