KekikStream 2.3.9__py3-none-any.whl → 2.5.3__py3-none-any.whl

KekikStream/Extractors/VidBiz.py

@@ -0,0 +1,62 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+from Kekik.Sifreleme  import Packer
+
+class VidBiz(ExtractorBase):
+    name     = "VidBiz"
+    main_url = "https://videolar.biz"
+
+    async def extract(self, url: str, referer: str = None) -> list[ExtractResult]:
+        istek = await self.httpx.get(url, headers={"Referer": referer} if referer else None)
+        text  = istek.text
+
+        # Eval script bul (kaken içeriyor olmalı)
+        eval_script = HTMLHelper(text).regex_first(r'(eval\(function[\s\S]+?)<\/script>') or \
+                      HTMLHelper(text).regex_first(r'(eval\(function[\s\S]+)')
+        if not eval_script:
+            raise ValueError(f"VidBiz: Packed script bulunamadı. {url}")
+
+        unpacked = ""
+        try:
+            unpacked = Packer.unpack(eval_script)
+        except:
+             raise ValueError("VidBiz: Unpack hatası")
+
+        # window.kaken="..."
+        kaken = HTMLHelper(unpacked).regex_first(r'window\.kaken\s*=\s*"([^"]+)"')
+        if not kaken:
+            raise ValueError("VidBiz: Kaken token bulunamadı")
+
+        # API POST
+        # Content-Type: text/plain önemli olabilir
+        resp = await self.httpx.post(
+            url     = "https://s2.videolar.biz/api/", 
+            content = kaken, # data yerine content=raw string
+            headers = {"Content-Type": "text/plain", "Referer": url}
+        )
+
+        try:
+            data = resp.json()
+        except:
+            raise ValueError("VidBiz: API yanıtı JSON değil")
+
+        if data.get("status") != "ok":
+            raise ValueError(f"VidBiz: API hatası {data}")
+
+        results = []
+        for source in data.get("sources", []):
+            file_url = source.get("file")
+            label    = source.get("label", "Unknown")
+
+            if not file_url:
+                continue
+
+            results.append(ExtractResult(
+                name       = f"{self.name} | {label}",
+                url        = self.fix_url(file_url),
+                referer    = url,
+                user_agent = self.httpx.headers.get("User-Agent", "")
+            ))
+
+        return results

KekikStream/Extractors/VidHide.py

@@ -9,7 +9,16 @@ class VidHide(ExtractorBase):
     main_url = "https://vidhidepro.com"
 
     # Birden fazla domain destekle
-    supported_domains = ["vidhidepro.com", "vidhide.com", "rubyvidhub.com"]
+    supported_domains = [
+        "vidhidepro.com", "vidhide.com", "rubyvidhub.com", 
+        "vidhidevip.com", "vidhideplus.com", "vidhidepre.com", 
+        "movearnpre.com", "oneupload.to",
+        "filelions.live", "filelions.online", "filelions.to",
+        "kinoger.be",
+        "smoothpre.com",
+        "dhtpre.com",
+        "peytonepre.com"
+    ]
 
     def can_handle_url(self, url: str) -> bool:
         return any(domain in url for domain in self.supported_domains)
@@ -21,50 +30,70 @@ class VidHide(ExtractorBase):
             return url.replace("/download/", "/v/")
         elif "/file/" in url:
             return url.replace("/file/", "/v/")
+        elif "/embed/" in url:
+            return url.replace("/embed/", "/v/")
         else:
             return url.replace("/f/", "/v/")
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
-        # Dinamik base URL kullan
         base_url = self.get_base_url(url)
-
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
         self.httpx.headers.update({
-            "Sec-Fetch-Dest" : "empty",
-            "Sec-Fetch-Mode" : "cors",
-            "Sec-Fetch-Site" : "cross-site",
-            "Origin"         : base_url,
+            "Referer" : referer or base_url,
+            "Origin"  : base_url,
         })
         
         embed_url = self.get_embed_url(url)
-        istek     = await self.httpx.get(embed_url)
-        response  = istek.text
+        istek     = await self.httpx.get(embed_url, follow_redirects=True)
+        text      = istek.text
+
+        # Silinmiş dosya kontrolü
+        if "File is no longer available" in text or "File Not Found" in text:
+             raise ValueError(f"VidHide: Video silinmiş. {url}")
+
+        # JS Redirect Kontrolü (OneUpload vb.)
+        if js_redirect := HTMLHelper(text).regex_first(r"window\.location\.replace\(['\"]([^'\"]+)['\"]\)") or \
+                          HTMLHelper(text).regex_first(r"window\.location\.href\s*=\s*['\"]([^'\"]+)['\"]"):
+            # Redirect url'i al
+            target_url = js_redirect
+            # Bazen path relative olabilir ama genelde full url
+            if not target_url.startswith("http"):
+                 # urljoin gerekebilir ama şimdilik doğrudan deneyelim veya fix_url
+                 target_url = self.fix_url(target_url) # fix_url base'e göre düzeltebilir mi? ExtractorBase.fix_url genelde şema ekler.
+                 pass
+
+            # Yeniden istek at
+            istek = await self.httpx.get(target_url, headers={"Referer": embed_url}, follow_redirects=True)
+            text  = istek.text
 
-        script = None
-        if "eval(function" in response:
+        sel       = HTMLHelper(text)
+
+        unpacked = ""
+        # Eval script bul (regex ile daha sağlam)
+        if eval_match := sel.regex_first(r'(eval\s*\(\s*function[\s\S]+?)<\/script>'):
             try:
-                unpacked = Packer.unpack(response)
+                unpacked = Packer.unpack(eval_match)
                 if "var links" in unpacked:
-                    script = unpacked.split("var links")[1]
-                else:
-                    script = unpacked
-            except Exception:
+                     unpacked = unpacked.split("var links")[1]
+            except:
                 pass
         
-        if not script:
-             script = HTMLHelper(response).regex_first(r'(?s)sources:\s*(\[.*?\])')
+        content  = unpacked or text
 
-        m3u8_url = None
-        if script:
-            # m3u8 urls could be prefixed by 'file:', 'hls2:' or 'hls4:', so we just match ':'
-            m3u8_url = HTMLHelper(script).regex_first(r':\s*"([^\"]*?m3u8[^\"]*?)"')
+        # Regex: Kotlin mantığı (: "url")
+        # Ayrıca sources: [...] mantığını da ekle
+        m3u8_url = HTMLHelper(content).regex_first(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"')
 
         if not m3u8_url:
-            # Fallback direct search in response if unpacking failed or structure changed
-            m3u8_url = HTMLHelper(response).regex_first(r'file:"(.*?\.m3u8.*?)"')
-        
+            # Genel arama (hls:, file: vb.)
+            # Kotlin Regex: :\s*"(.*?m3u8.*?)"
+            match = HTMLHelper(content).regex_first(r':\s*["\']([^"\']+\.m3u8[^"\']*)["\']')
+            if match:
+                m3u8_url = match
+
+        if not m3u8_url:
+             # Son şans: herhangi bir m3u8 linki
+             m3u8_url = HTMLHelper(content).regex_first(r'["\']([^"\']+\.m3u8[^"\']*)["\']')
+
         if not m3u8_url:
             raise ValueError(f"VidHide: Video URL bulunamadı. {url}")
 
@@ -72,6 +101,5 @@ class VidHide(ExtractorBase):
             name       = self.name,
             url        = self.fix_url(m3u8_url),
             referer    = f"{base_url}/",
-            user_agent = self.httpx.headers.get("User-Agent", ""),
-            subtitles  = []
+            user_agent = self.httpx.headers.get("User-Agent", "")
         )

KekikStream/Extractors/VidMoly.py

@@ -9,7 +9,7 @@ class VidMoly(ExtractorBase):
     main_url = "https://vidmoly.to"
 
     # Birden fazla domain destekle
-    supported_domains = ["vidmoly.to", "vidmoly.me", "vidmoly.net"]
+    supported_domains = ["vidmoly.to", "vidmoly.me", "vidmoly.net", "vidmoly.biz"]
 
     def can_handle_url(self, url: str) -> bool:
         return any(domain in url for domain in self.supported_domains)
@@ -18,112 +18,78 @@ class VidMoly(ExtractorBase):
         if referer:
             self.httpx.headers.update({"Referer": referer})
 
-        self.httpx.headers.update({
-            "Sec-Fetch-Dest" : "iframe",
-        })
-
-        if ".me" in url:
-            url = url.replace(".me", ".net")
-        if ".to" in url:
-            url = url.replace(".to", ".net")
-
-        # VidMoly bazen redirect ediyor, takip et
-        response = await self.httpx.get(url, follow_redirects=True)
-        if "Select number" in response.text:
-            secici = HTMLHelper(response.text)
-
-            op_val        = secici.select_attr("input[name='op']", "value")
-            file_code_val = secici.select_attr("input[name='file_code']", "value")
-            answer_val    = secici.select_text("div.vhint b")
-            ts_val        = secici.select_attr("input[name='ts']", "value")
-            nonce_val     = secici.select_attr("input[name='nonce']", "value")
-            ctok_val      = secici.select_attr("input[name='ctok']", "value")
-
-            response = await self.httpx.post(
-                url  = url,
-                data = {
-                    "op"        : op_val,
-                    "file_code" : file_code_val,
-                    "answer"    : answer_val,
-                    "ts"        : ts_val,
-                    "nonce"     : nonce_val,
-                    "ctok"      : ctok_val
-                },
-                follow_redirects=True
-            )
-
+        self.httpx.headers.update({"Sec-Fetch-Dest" : "iframe"})
+
+        # Domain normalleştirme
+        url = url.replace(".me", ".net").replace(".to", ".net")
+
+        resp = await self.httpx.get(url, follow_redirects=True)
+        sel  = HTMLHelper(resp.text)
+
+        # "Select number" kontrolü (Bot koruması)
+        if "Select number" in resp.text:
+            op_val        = sel.select_attr("input[name='op']", "value")
+            file_code_val = sel.select_attr("input[name='file_code']", "value")
+            answer_val    = sel.select_text("div.vhint b")
+            ts_val        = sel.select_attr("input[name='ts']", "value")
+            nonce_val     = sel.select_attr("input[name='nonce']", "value")
+            ctok_val      = sel.select_attr("input[name='ctok']", "value")
+
+            resp = await self.httpx.post(url, data={
+                "op"        : op_val,
+                "file_code" : file_code_val,
+                "answer"    : answer_val,
+                "ts"        : ts_val,
+                "nonce"     : nonce_val,
+                "ctok"      : ctok_val
+            }, follow_redirects=True)
+            sel = HTMLHelper(resp.text)
 
         # Altyazı kaynaklarını ayrıştır
         subtitles = []
-        resp_sec = HTMLHelper(response.text)
-        if subtitle_str := resp_sec.regex_first(r"tracks:\s*\[(.*?)\]", flags= re.DOTALL):
-            subtitle_data = self._add_marks(subtitle_str, "file")
-            subtitle_data = self._add_marks(subtitle_data, "label")
-            subtitle_data = self._add_marks(subtitle_data, "kind")
+        if sub_str := sel.regex_first(r"(?s)tracks:\s*\[(.*?)\]"):
+            sub_data = self._add_marks(sub_str, "file")
+            sub_data = self._add_marks(sub_data, "label")
+            sub_data = self._add_marks(sub_data, "kind")
 
             with contextlib.suppress(json.JSONDecodeError):
-                subtitle_sources = json.loads(f"[{subtitle_data}]")
+                sub_sources = json.loads(f"[{sub_data}]")
                 subtitles = [
-                    Subtitle(
-                        name = sub.get("label"),
-                        url  = self.fix_url(sub.get("file")),
-                    )
-                        for sub in subtitle_sources
-                            if sub.get("kind") == "captions"
+                    Subtitle(name=sub.get("label"), url=self.fix_url(sub.get("file")))
+                    for sub in sub_sources if sub.get("kind") == "captions"
                 ]
 
-        if "#EXTM3U" in response.text:
-            for line in response.text.splitlines():
-                line = line.strip().replace('"', '').replace("'", "")
-                if line.startswith("http"):
-                    return ExtractResult(
-                        name      = self.name,
-                        url       = line,
-                        referer   = self.main_url,
-                        subtitles = subtitles
-                    )
-
-        if script_str := resp_sec.regex_first(r"sources:\s*\[(.*?)\],", flags= re.DOTALL):
-            script_content = script_str
-            # Video kaynaklarını ayrıştır
-            video_data = self._add_marks(script_content, "file")
-            try:
-                video_sources = json.loads(f"[{video_data}]")
-                # İlk video kaynağını al
-                for source in video_sources:
-                    if file_url := source.get("file"):
-                        return ExtractResult(
-                            name      = self.name,
-                            url       = file_url,
-                            referer   = self.main_url,
-                            subtitles = subtitles
-                        )
-            except json.JSONDecodeError:
-                pass
-
-        # Fallback: Doğrudan file regex ile ara (Kotlin mantığı)
-        # file:"..." veya file: "..."
-        if file_match := resp_sec.regex_first(r'file\s*:\s*["\']([^"\']+\.m3u8[^"\']*)["\']'):
-            return ExtractResult(
-                name      = self.name,
-                url       = file_match,
-                referer   = self.main_url,
-                subtitles = subtitles
-            )
-            
-        # Fallback 2: Herhangi bir file (m3u8 olma şartı olmadan ama tercihen)
-        if file_match := resp_sec.regex_first(r'file\s*:\s*["\']([^"\']+)["\']'):
-            url_candidate = file_match
-            # Resim dosyalarını hariç tut
-            if not url_candidate.endswith(('.jpg', '.png', '.jpeg')):
-                return ExtractResult(
-                    name      = self.name,
-                    url       = url_candidate,
-                    referer   = self.main_url,
-                    subtitles = subtitles
-                )
-
-        raise ValueError("Video URL bulunamadı.")
+        # Video URL Bulma
+        video_url = None
+        if "#EXTM3U" in resp.text:
+            for line in resp.text.splitlines():
+                if line.strip().startswith("http"):
+                    video_url = line.strip().replace('"', '').replace("'", "")
+                    break
+
+        if not video_url:
+            if src_str := sel.regex_first(r"(?s)sources:\s*\[(.*?)\],"):
+                vid_data = self._add_marks(src_str, "file")
+                with contextlib.suppress(json.JSONDecodeError):
+                    vid_sources = json.loads(f"[{vid_data}]")
+                    for source in vid_sources:
+                        if source.get("file"):
+                            video_url = source.get("file")
+                            break
+
+        if not video_url:
+            video_url = sel.regex_first(r'file\s*:\s*["\']([^"\']+\.m3u8[^"\']*)["\']') or \
+                        sel.regex_first(r'file\s*:\s*["\']([^"\']+\.mp4[^"\']*)["\']')
+
+        if not video_url:
+            raise ValueError(f"VidMoly: Video URL bulunamadı. {url}")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = video_url,
+            referer   = f"{self.get_base_url(url)}/",
+            subtitles = subtitles
+        )
 
     def _add_marks(self, text: str, field: str) -> str:
         """

KekikStream/Extractors/VidMoxy.py

@@ -7,42 +7,31 @@ class VidMoxy(ExtractorBase):
     name     = "VidMoxy"
     main_url = "https://vidmoxy.com"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
         if referer:
             self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        subtitles        = []
-        subtitle_matches = HTMLHelper(istek.text).regex_all(r'captions","file":"([^\"]+)","label":"([^\"]+)"')
-        seen_subtitles   = set()
+        subtitles = []
+        for s_url, s_lang in sel.regex_all(r'captions","file":"([^\"]+)","label":"([^\"]+)"'):
+            decoded_lang = s_lang.encode().decode('unicode_escape')
+            subtitles.append(Subtitle(name=decoded_lang, url=s_url.replace("\\", "")))
 
-        for sub_url, sub_lang in subtitle_matches:
-            if sub_url in seen_subtitles:
-                continue
+        hex_data = sel.regex_first(r'file": "(.*)",')
+        if not hex_data:
+            eval_data = sel.regex_first(r'\};\s*(eval\(function[\s\S]*?)var played = \d+;')
+            if eval_data:
+                unpacked = Packer.unpack(Packer.unpack(eval_data))
+                hex_data = HTMLHelper(unpacked).regex_first(r'file":"(.*)","label')
 
-            seen_subtitles.add(sub_url)
-            decoded_lang = (
-                sub_lang.replace("\\u0131", "ı")
-                        .replace("\\u0130", "İ")
-                        .replace("\\u00fc", "ü")
-                        .replace("\\u00e7", "ç")
-            )
-            subtitles.append(Subtitle(name=decoded_lang, url=sub_url.replace("\\", "")))
-
-        escaped_hex = HTMLHelper(istek.text).regex_first(r'file": "(.*)",')
-        if not escaped_hex:
-            eval_jwsetup = HTMLHelper(istek.text).regex_first(r'\};\s*(eval\(function[\s\S]*?)var played = \d+;')
-            jwsetup      = Packer.unpack(Packer.unpack(eval_jwsetup)) if eval_jwsetup else None
-            if jwsetup:
-                escaped_hex  = HTMLHelper(jwsetup).regex_first(r'file":"(.*)","label')
-
-        m3u_link = HexCodec.decode(escaped_hex)
+        if not hex_data:
+            raise ValueError(f"VidMoxy: Hex data bulunamadı. {url}")
 
         return ExtractResult(
             name      = self.name,
-            url       = m3u_link,
+            url       = HexCodec.decode(hex_data),
             referer   = self.main_url,
             subtitles = subtitles
         )

KekikStream/Extractors/VidPapi.py

@@ -4,84 +4,54 @@ from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 
 
 class VidPapi(ExtractorBase):
-    name     = "VidApi"
+    name     = "VidPapi"
     main_url = "https://vidpapi.xyz"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        ext_ref = referer or ""
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        ref = referer or self.main_url
         
-        # URL parsing
+        # ID tespiti
         if "video/" in url:
             vid_id = url.split("video/")[-1]
         else:
             vid_id = url.split("?data=")[-1]
             
-        # 1. Altyazıları çek
-        sub_url = f"{self.main_url}/player/index.php?data={vid_id}"
-        sub_headers = {
+        headers = {
             "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
             "X-Requested-With" : "XMLHttpRequest",
-            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0",
-            "Referer"          : ext_ref or "https://kultfilmler.pro/"
+            "Referer"          : ref
         }
         
+        # 1. Altyazıları çek
         subtitles = []
         try:
-            sub_istek = await self.httpx.post(
-                url     = sub_url,
-                headers = sub_headers,
-                data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+            sub_resp = await self.httpx.post(
+                f"{self.main_url}/player/index.php?data={vid_id}",
+                headers = headers,
+                data    = {"hash": vid_id, "r": ref}
             )
-            
-            raw_subs = HTMLHelper(sub_istek.text).regex_first(r'var playerjsSubtitle\s*=\s*"([^"]*)"', flags=0)
-            if raw_subs:
-                found_subs = HTMLHelper(raw_subs).regex_all(r'\[(.*?)\](.*?)(?:,|$)')
-                for lang, sub_link in found_subs:
-                    lang = lang.strip()
-                    if "Türkçe" in lang:
-                        lang_code = "tr"
-                        lang_name = "Turkish"
-                    elif "İngilizce" in lang:
-                        lang_code = "en"
-                        lang_name = "English"
-                    else:
-                        lang_code = lang[:2].lower()
-                        lang_name = lang
-                        
-                    subtitles.append(Subtitle(
-                        name = lang_name,
-                        url  = sub_link.strip()
-                    ))
-                    
-        except Exception as e:
+            sel = HTMLHelper(sub_resp.text)
+            if raw_subs := sel.regex_first(r'var playerjsSubtitle\s*=\s*"([^"]*)"'):
+                for lang, link in HTMLHelper(raw_subs).regex_all(r'\[(.*?)\](https?://[^\s\",]+)'):
+                    subtitles.append(Subtitle(name=lang.strip(), url=link.strip()))
+        except:
             pass
 
         # 2. Videoyu çek
-        video_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
-        video_headers = sub_headers.copy()
-        
-        response = await self.httpx.post(
-            url     = video_url,
-            headers = video_headers,
-            data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+        resp = await self.httpx.post(
+            f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo",
+            headers = headers,
+            data    = {"hash": vid_id, "r": ref}
         )
-        response.raise_for_status()
-        
-        try:
-            video_data = response.json()
-        except Exception:
-            return None
+        data = resp.json()
 
-        stream_url = video_data.get("securedLink")
-        if not stream_url or not stream_url.strip():
-            stream_url = video_data.get("videoSource")
-            
+        stream_url = data.get("securedLink") or data.get("videoSource")
         if not stream_url:
-            raise ValueError("No video link found in VidPapi response")
+            raise ValueError(f"VidPapi: Video URL bulunamadı. {url}")
 
         return ExtractResult(
             name      = self.name,
             url       = stream_url,
-            referer   = ext_ref or self.main_url,
+            referer   = ref,
             subtitles = subtitles
         )

KekikStream/Extractors/VideoSeyred.py

@@ -1,4 +1,4 @@
-# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 import json
@@ -7,47 +7,26 @@ class VideoSeyred(ExtractorBase):
     name     = "VideoSeyred"
     main_url = "https://videoseyred.in"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
+    async def extract(self, url: str, referer: str = None) -> list[ExtractResult] | ExtractResult:
+        v_id = url.split("embed/")[1].split("?")[0]
+        if len(v_id) > 10:
+            resp = await self.httpx.get(url)
+            v_id = HTMLHelper(resp.text).regex_first(r"playlist\/(.*)\.json")
 
-        video_id  = url.split("embed/")[1].split("?")[0]
-        if len(video_id) > 10:
-            kontrol = await self.httpx.get(url)
-            kontrol.raise_for_status()
-
-            video_id = HTMLHelper(kontrol.text).regex_first(r"playlist\/(.*)\.json")
-
-        video_url = f"{self.main_url}/playlist/{video_id}.json"
-
-        response = await self.httpx.get(video_url)
-        response.raise_for_status()
-
-        try:
-            if response_list := json.loads(response.text):
-                response_data = response_list[0]
-            else:
-                raise ValueError("Empty response from VideoSeyred.")
-
-        except (json.JSONDecodeError, IndexError) as hata:
-            raise RuntimeError(f"Failed to parse response: {hata}") from hata
+        json_resp = await self.httpx.get(f"{self.main_url}/playlist/{v_id}.json")
+        data = json_resp.json()[0]
 
         subtitles = [
-            Subtitle(name=track["label"], url=self.fix_url(track["file"]))
-                for track in response_data.get("tracks", [])
-                    if track.get("kind") == "captions" and track.get("label")
+            Subtitle(name=t["label"], url=self.fix_url(t["file"]))
+            for t in data.get("tracks", []) if t.get("kind") == "captions"
+        ]
+
+        results = [
+            ExtractResult(name=self.name, url=self.fix_url(s["file"]), referer=self.main_url, subtitles=subtitles)
+            for s in data.get("sources", [])
         ]
 
-        if video_links := [
-            ExtractResult(
-                name      = self.name,
-                url       = self.fix_url(source["file"]),
-                referer   = self.main_url,
-                subtitles = subtitles,
-            )
-                for source in response_data.get("sources", [])
-        ]:
-            # En yüksek kaliteli videoyu döndür (varsayılan olarak ilk video)
-            return video_links[0] if len(video_links) == 1 else video_links
-        else:
-            raise ValueError("No video links found in the response.")
+        if not results:
+            raise ValueError(f"VideoSeyred: Video bulunamadı. {url}")
+
+        return results[0] if len(results) == 1 else results