Update scraper4.py

scraper4.py

@@ -18,17 +18,19 @@ class TorBrowserManager:
 
     @classmethod
     def get_instance(cls):
-        if cls._instance is None: cls._instance = cls()
+        if cls._instance is None:
+            cls._instance = cls()
         return cls._instance
 
     async def start(self):
         async with self._lock:
-            if self._setup_done: return
+            if self._setup_done:
+                return
             
             print("[TOR] Inicializujem prehliadač cez Tor SOCKS5...")
             self.playwright = await async_playwright().start()
             
-            # Napojíme sa na Tor (port 9050 v Docker koniteneri)
+            # Pripojenie na lokálny Tor proces (port 9050)
             self.context = await self.playwright.chromium.launch_persistent_context(
                 "/tmp/playwright_tor",
                 headless=True,
@@ -36,29 +38,109 @@ class TorBrowserManager:
                 args=["--no-sandbox", "--disable-setuid-sandbox"]
             )
             
-            # Krátka pauza, kým Tor nadviaže okruhy
-            print("[TOR] Čakám na stabilizáciu siete...")
+            # Čakáme, kým Tor nadviaže spojenie
             await asyncio.sleep(10)
             self._setup_done = True
 
     async def get_page(self):
-        if not self._setup_done: await self.start()
+        if not self._setup_done:
+            await self.start()
         return await self.context.new_page()
 
+    # Tvoja funkcia pre odolnejšie načítanie cez Tor
+    async def goto_with_fallback(self, page, url, timeout=60000):
+        for pokus in range(3):
+            try:
+                print(f"[TOR] Načítavam (Pokus {pokus+1}): {url}")
+                await page.goto(url, wait_until="domcontentloaded", timeout=timeout)
+                return True
+            except Exception as e:
+                print(f"[TOR] Pokus {pokus+1} zlyhal: {e}")
+                await asyncio.sleep(2)
+        return False
+
 manager = TorBrowserManager.get_instance()
 
 async def search_movies(query):
-    print(f"[SEARCH_TOR] Hľadám: {query}")
+    print(f"[SEARCH] Hľadám cez Tor: {query}")
     page = await manager.get_page()
     try:
         url = f"{DOMENA}/se/j/json?q={urllib.parse.quote(query)}"
-        # Tor je pomalší, tak predĺžime timeout
-        await page.goto(url, wait_until="networkidle", timeout=60000)
-        content = await page.inner_text("body")
-        return json.loads(content)
+        success = await manager.goto_with_fallback(page, url)
+        if success:
+            content = await page.inner_text("body")
+            return json.loads(content)
+    except Exception as e:
+        print(f"[SEARCH ERROR] {e}")
+    finally:
+        await page.close()
+    return []
+
+async def get_details(slug, media_type):
+    print(f"[DETAILS] Info cez Tor: {slug}")
+    page = await manager.get_page()
+    url = f"{DOMENA}/p/{slug}" if media_type in ["movie", "film"] else f"{DOMENA}/tv/{slug}/S01E01"
+    res = {"languages": [], "seasons": []}
+    try:
+        success = await manager.goto_with_fallback(page, url)
+        if not success: return res
+        
+        await asyncio.sleep(2)
+        soup = BeautifulSoup(await page.content(), "html.parser")
+        
+        kw_div = soup.find("div", class_="movie-keyword")
+        if kw_div:
+            res["languages"] = [p.get_text(strip=True) for p in kw_div.find_all(recursive=False)]
+        
+        matches = re.findall(r'Séria\s+(\d+)', soup.get_text())
+        for seria in sorted(set(matches), key=int):
+            res["seasons"].append({"season": int(seria), "episodes": 0})
     except Exception as e:
-        print(f"[TOR ERROR] {e}")
-        return []
-    finally: await page.close()
+        print(f"[DETAILS ERROR] {e}")
+    finally:
+        await page.close()
+    return res
 
-# get_details a get_stream_url zostávajú logicky rovnaké...
+async def get_stream_url(slug, media_type, season=None, episode=None, lang=None, source_idx=0):
+    print(f"[STREAM] Skenujem stream cez Tor: {slug}")
+    page = await manager.get_page()
+    
+    url = f"{DOMENA}/p/{slug}" if media_type in ["movie", "film"] else f"{DOMENA}/tv/{slug}/S{int(season):02d}E{int(episode):02d}"
+    
+    params = [f"source={source_idx}"]
+    if lang: params.append(f"lng={urllib.parse.quote(lang)}")
+    url += "?" + "&".join(params)
+    
+    found = {"stream": None, "vtt": None}
+    
+    async def zachyt_request(request):
+        if ".m3u8" in request.url and not found["stream"]:
+            found["stream"] = request.url
+        if request.url.endswith(".vtt") and not found["vtt"]:
+            found["vtt"] = request.url
+
+    page.on("request", zachyt_request)
+    
+    try:
+        # Pomalšie načítavanie cez Tor vyžaduje dlhý timeout (90s)
+        success = await manager.goto_with_fallback(page, url, timeout=90000)
+        if not success: return found
+        
+        for _ in range(25):
+            if found["stream"]: break
+            await asyncio.sleep(1)
+            
+        if not found["stream"]:
+            # Kliknutie na iframe, ak sa stream nenačítal automaticky
+            iframe = page.locator("iframe#frm, video").first
+            if await iframe.count() > 0:
+                await iframe.click(force=True)
+                for _ in range(15):
+                    if found["stream"]: break
+                    await asyncio.sleep(1)
+    except Exception as e:
+        print(f"[STREAM ERROR] {e}")
+    finally:
+        await page.close()
+    
+    return found