KekikStream 2.4.2__py3-none-any.whl → 2.4.3__py3-none-any.whl

KekikStream/Core/Extractor/ExtractorBase.py

@@ -49,6 +49,7 @@ class ExtractorBase(ABC):
             return ""
 
         if url.startswith("http") or url.startswith("{\""):
-            return url
+            return url.replace("\\", "")
 
-        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        url = f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        return url.replace("\\", "")

KekikStream/Core/HTMLHelper.py

@@ -1,7 +1,9 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from selectolax.parser import HTMLParser, Node
+from __future__ import annotations
+
 import re
+from selectolax.parser import HTMLParser, Node
 
 
 class HTMLHelper:
@@ -10,96 +12,192 @@ class HTMLHelper:
     """
 
     def __init__(self, html: str):
-        self.parser = HTMLParser(html)
         self.html   = html
+        self.parser = HTMLParser(html)
 
     # ========================
-    # TEMEL SELECTOR İŞLEMLERİ
+    # SELECTOR (CSS) İŞLEMLERİ
     # ========================
 
-    def _target(self, element: Node | None) -> Node | HTMLParser:
+    def _root(self, element: Node | None) -> Node | HTMLParser:
         """İşlem yapılacak temel elementi döndürür."""
         return element if element is not None else self.parser
 
     def select(self, selector: str, element: Node | None = None) -> list[Node]:
         """CSS selector ile tüm eşleşen elementleri döndür."""
-        return self._target(element).css(selector)
+        return self._root(element).css(selector)
 
     def select_first(self, selector: str | None, element: Node | None = None) -> Node | None:
         """CSS selector ile ilk eşleşen elementi döndür."""
         if not selector:
             return element
-
-        return self._target(element).css_first(selector)
+        return self._root(element).css_first(selector)
 
     def select_text(self, selector: str | None = None, element: Node | None = None, strip: bool = True) -> str | None:
         """CSS selector ile element bul ve text içeriğini döndür."""
         el = self.select_first(selector, element)
         if not el:
             return None
-
         val = el.text(strip=strip)
-        return val if val else None
+        return val or None
+
+    def select_texts(self, selector: str, element: Node | None = None, strip: bool = True) -> list[str]:
+        """CSS selector ile tüm eşleşen elementlerin text içeriklerini döndür."""
+        out: list[str] = []
+        for el in self.select(selector, element):
+            txt = el.text(strip=strip)
+            if txt:
+                out.append(txt)
+        return out
 
     def select_attr(self, selector: str | None, attr: str, element: Node | None = None) -> str | None:
         """CSS selector ile element bul ve attribute değerini döndür."""
         el = self.select_first(selector, element)
         return el.attrs.get(attr) if el else None
 
-    def select_all_text(self, selector: str, element: Node | None = None, strip: bool = True) -> list[str]:
-        """CSS selector ile tüm eşleşen elementlerin text içeriklerini döndür."""
-        return [
-            txt for el in self.select(selector, element)
-                if (txt := el.text(strip=strip))
-        ]
-
-    def select_all_attr(self, selector: str, attr: str, element: Node | None = None) -> list[str]:
+    def select_attrs(self, selector: str, attr: str, element: Node | None = None) -> list[str]:
         """CSS selector ile tüm eşleşen elementlerin attribute değerlerini döndür."""
-        return [
-            val for el in self.select(selector, element)
-                if (val := el.attrs.get(attr))
-        ]
-
-    # ----------------------------------------------
+        out: list[str] = []
+        for el in self.select(selector, element):
+            val = el.attrs.get(attr)
+            if val:
+                out.append(val)
+        return out
 
     def select_poster(self, selector: str = "img", element: Node | None = None) -> str | None:
         """Poster URL'sini çıkar. Önce data-src, sonra src dener."""
         el = self.select_first(selector, element)
         if not el:
             return None
-
         return el.attrs.get("data-src") or el.attrs.get("src")
 
+    def select_direct_text(self, selector: str, element: Node | None = None, strip: bool = True) -> str | None:
+        """
+        Elementin yalnızca "kendi" düz metnini döndürür (child elementlerin text'ini katmadan).
+        Selectolax sürüm farklarına göre deep=False dene, yoksa node sibling-walk ile fallback yapar.
+        """
+        el = self.select_first(selector, element)
+        if not el:
+            return None
+
+        # 1) Bazı sürümlerde var: sadece direct text
+        try:
+            val = el.text(strip=strip, deep=False)  # type: ignore[call-arg]
+            return val or None
+        except TypeError:
+            pass  # deep parametresi yok, fallback'e geç
+
+        # 2) Fallback: direct children'ı el.child + next ile dolaş
+        parts: list[str] = []
+        ch = el.child
+        while ch is not None:
+            if ch.tag == "-text":
+                t = ch.text(strip=strip)
+                if t:
+                    parts.append(t)
+            elif ch.tag == "br":
+                parts.append("\n")
+            ch = ch.next
+
+        out = "".join(parts).strip()
+        return out or None
+
+    # ========================
+    # META (LABEL -> VALUE) İŞLEMLERİ
+    # ========================
+
+    def meta_value(self, label: str, container_selector: str | None = None, strip: bool = True) -> str | None:
+        """
+        Herhangi bir container içinde: LABEL metnini içeren bir elementten SONRA gelen metni döndürür.
+        label örn: "Oyuncular", "Yapım Yılı", "IMDB"
+        """
+        needle = label.casefold()
+
+        # Belirli bir container varsa içinde ara, yoksa tüm dökümanda
+        targets = self.select(container_selector) if container_selector else [self.parser.body]
+
+        for root in targets:
+            if not root: continue
+
+            # Kalın/vurgulu elementlerde (span, strong, b, label, dt) label'ı ara
+            for label_el in self.select("span, strong, b, label, dt", root):
+                txt = (label_el.text(strip=True) or "").casefold()
+                if needle not in txt:
+                    continue
+
+                # 1) Elementin kendi içindeki text'te LABEL: VALUE formatı olabilir
+                # "Oyuncular: Brad Pitt" gibi. LABEL: sonrasını al.
+                full_txt = label_el.text(strip=strip)
+                if ":" in full_txt and needle in full_txt.split(":")[0].casefold():
+                    val = full_txt.split(":", 1)[1].strip()
+                    if val: return val
+
+                # 2) Label sonrası gelen ilk text node'u veya element'i al
+                curr = label_el.next
+                while curr:
+                    if curr.tag == "-text":
+                        val = curr.text(strip=strip).strip(" :")
+                        if val: return val
+                    elif curr.tag != "br":
+                        val = curr.text(strip=strip).strip(" :")
+                        if val: return val
+                    else: # <br> gördüysek satır bitmiştir
+                        break
+                    curr = curr.next
+
+        return None
+
+    def meta_list(self, label: str, container_selector: str | None = None, sep: str = ",") -> list[str]:
+        """meta_value(...) çıktısını veya label'ın ebeveynindeki linkleri listeye döndürür."""
+        needle = label.casefold()
+        targets = self.select(container_selector) if container_selector else [self.parser.body]
+
+        for root in targets:
+            if not root: continue
+            for label_el in self.select("span, strong, b, label, dt", root):
+                if needle in (label_el.text(strip=True) or "").casefold():
+                    # Eğer elementin ebeveyninde linkler varsa (Kutucuklu yapı), onları al
+                    links = self.select_texts("a", label_el.parent)
+                    if links: return links
+
+                    # Yoksa düz metin olarak meta_value mantığıyla al
+                    raw = self.meta_value(label, container_selector=container_selector)
+                    if not raw: return []
+                    return [x.strip() for x in raw.split(sep) if x.strip()]
+
+        return []
+
     # ========================
     # REGEX İŞLEMLERİ
     # ========================
 
-    def _source(self, target: str | int | None) -> str:
+    def _regex_source(self, target: str | int | None) -> str:
         """Regex için kaynak metni döndürür."""
         return target if isinstance(target, str) else self.html
 
-    def _flags(self, target: str | int | None, flags: int) -> int:
+    def _regex_flags(self, target: str | int | None, flags: int) -> int:
         """Regex flags değerini döndürür."""
         return target if isinstance(target, int) else flags
 
-    def regex_first(self, pattern: str, target: str | int | None = None, flags: int = 0) -> str | None:
-        """Regex ile arama yap, ilk grubu döndür (grup yoksa tamamını)."""
-        match = re.search(pattern, self._source(target), self._flags(target, flags))
+    def regex_first(self, pattern: str, target: str | int | None = None, flags: int = 0, group: int | None = 1) -> str | tuple | None:
+        """Regex ile arama yap, istenen grubu döndür (group=None ise tüm grupları tuple olarak döndür)."""
+        match = re.search(pattern, self._regex_source(target), self._regex_flags(target, flags))
         if not match:
             return None
-
-        try:
-            return match.group(1)
-        except IndexError:
-            return match.group(0)
+        
+        if group is None:
+            return match.groups()
+            
+        last_idx = match.lastindex or 0
+        return match.group(group) if last_idx >= group else match.group(0)
 
     def regex_all(self, pattern: str, target: str | int | None = None, flags: int = 0) -> list[str]:
         """Regex ile tüm eşleşmeleri döndür."""
-        return re.findall(pattern, self._source(target), self._flags(target, flags))
+        return re.findall(pattern, self._regex_source(target), self._regex_flags(target, flags))
 
     def regex_replace(self, pattern: str, repl: str, target: str | int | None = None, flags: int = 0) -> str:
         """Regex ile replace yap."""
-        return re.sub(pattern, repl, self._source(target), flags)
+        return re.sub(pattern, repl, self._regex_source(target), flags=self._regex_flags(target, flags))
 
     # ========================
     # ÖZEL AYIKLAYICILAR
@@ -108,15 +206,12 @@ class HTMLHelper:
     @staticmethod
     def extract_season_episode(text: str) -> tuple[int | None, int | None]:
         """Metin içinden sezon ve bölüm numarasını çıkar."""
-        # S01E05 formatı
         if m := re.search(r"[Ss](\d+)[Ee](\d+)", text):
             return int(m.group(1)), int(m.group(2))
 
-        # Ayrı ayrı ara
         s = re.search(r"(\d+)\.\s*[Ss]ezon|[Ss]ezon[- ]?(\d+)|-(\d+)-sezon|S(\d+)|(\d+)\.[Ss]", text, re.I)
         e = re.search(r"(\d+)\.\s*[Bb][öo]l[üu]m|[Bb][öo]l[üu]m[- ]?(\d+)|-(\d+)-bolum|[Ee](\d+)", text, re.I)
 
-        # İlk bulunan grubu al (None değilse)
         s_val = next((int(g) for g in s.groups() if g), None) if s else None
         e_val = next((int(g) for g in e.groups() if g), None) if e else None
 
@@ -131,4 +226,3 @@ class HTMLHelper:
 
         val = self.regex_first(pattern)
         return int(val) if val and val.isdigit() else None
-

KekikStream/Core/Plugin/PluginBase.py

@@ -101,9 +101,10 @@ class PluginBase(ABC):
             return ""
 
         if url.startswith("http") or url.startswith("{\""):
-            return url
+            return url.replace("\\", "")
 
-        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        url = f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        return url.replace("\\", "")
 
     async def extract(self, url: str, referer: str = None, prefix: str | None = None) -> ExtractResult | None:
         """

KekikStream/Extractors/CloseLoad.py

@@ -2,75 +2,51 @@
 
 from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 from Kekik.Sifreleme   import Packer, StreamDecoder
-import json
+import json, contextlib
 
-class CloseLoadExtractor(ExtractorBase):
+class CloseLoad(ExtractorBase):
     name     = "CloseLoad"
     main_url = "https://closeload.filmmakinesi.to"
 
-    def _extract_from_json_ld(self, html: str) -> str | None:
-        """JSON-LD script tag'inden contentUrl'i çıkar (Kotlin versiyonundaki gibi)"""
-        secici = HTMLHelper(html)
-        for script in secici.select("script[type='application/ld+json']"):
-            try:
-                data = json.loads(script.text(strip=True))
-                if content_url := data.get("contentUrl"):
-                    if content_url.startswith("http"):
-                        return content_url
-            except (json.JSONDecodeError, TypeError):
-                # Regex ile contentUrl'i çıkarmayı dene
-                if content_url := secici.regex_first(r'"contentUrl"\s*:\s*"([^\"]+)"', script.text()):
-                    if content_url.startswith("http"):
-                        return content_url
-        return None
-
-    def _extract_from_packed(self, html: str) -> str | None:
-        """Packed JavaScript'ten video URL'sini çıkar (fallback)"""
-        try:
-            packed = HTMLHelper(html).regex_all(r'\s*(eval\(function[\s\S].*)')
-            if packed:
-                return StreamDecoder.extract_stream_url(Packer.unpack(packed[0]))
-        except Exception:
-            pass
-        return None
-
-    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) -> ExtractResult:
         self.httpx.headers.update({
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0",
-            "Origin": self.main_url
+            "Referer" : referer or self.main_url,
+            "Origin"  : self.main_url
         })
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        # Önce JSON-LD'den dene (daha güvenilir - Kotlin versiyonu gibi)
-        m3u_link = self._extract_from_json_ld(istek.text)
+        # 1. JSON-LD'den Dene
+        m3u8_url = None
+        for script in sel.select("script[type='application/ld+json']"):
+            with contextlib.suppress(Exception):
+                data = json.loads(script.text(strip=True))
+                if content_url := data.get("contentUrl"):
+                    if content_url.startswith("http"):
+                        m3u8_url = content_url
+                        break
         
-        # Fallback: Packed JavaScript'ten çıkar
-        if not m3u_link:
-            m3u_link = self._extract_from_packed(istek.text)
+        # 2. Packed Script Fallback
+        if not m3u8_url:
+            if packed := sel.regex_first(r"(eval\(function\(p,a,c,k,e,d\).+?)\s*</script>"):
+                m3u8_url = StreamDecoder.extract_stream_url(Packer.unpack(packed))
 
-        if not m3u_link:
-            raise Exception("Video URL bulunamadı (ne JSON-LD ne de packed script'ten)")
+        if not m3u8_url:
+            raise ValueError(f"CloseLoad: Video URL bulunamadı. {url}")
 
-        # Subtitle'ları parse et (Kotlin referansı: track elementleri)
         subtitles = []
-        secici = HTMLHelper(istek.text)
-        for track in secici.select("track"):
-            raw_src = track.attrs.get("src") or ""
-            raw_src = raw_src.strip()
-            label   = track.attrs.get("label") or track.attrs.get("srclang") or "Altyazı"
-            
-            if raw_src:
-                full_url = raw_src if raw_src.startswith("http") else f"{self.main_url}{raw_src}"
-                subtitles.append(Subtitle(name=label, url=full_url))
+        for track in sel.select("track"):
+            src = track.attrs.get("src")
+            if src:
+                subtitles.append(Subtitle(
+                    name = track.attrs.get("label") or track.attrs.get("srclang") or "Altyazı",
+                    url  = self.fix_url(src)
+                ))
 
         return ExtractResult(
             name      = self.name,
-            url       = m3u_link,
+            url       = m3u8_url,
             referer   = self.main_url,
             subtitles = subtitles
         )

KekikStream/Extractors/ContentX.py

@@ -19,81 +19,36 @@ class ContentX(ExtractorBase):
     def can_handle_url(self, url: str) -> bool:
         return any(domain in url for domain in self.supported_domains)
 
-    async def extract(self, url, referer=None) -> list[ExtractResult]:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
+    async def extract(self, url: str, referer: str = None) -> list[ExtractResult] | ExtractResult:
+        ref = referer or self.get_base_url(url)
+        self.httpx.headers.update({"Referer": ref})
 
-        # Dinamik base URL kullan
-        base_url = self.get_base_url(url)
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
-        i_source = istek.text
-
-        i_extract_value = HTMLHelper(i_source).regex_first(r"window\.openPlayer\('([^']+)'")
-        if not i_extract_value:
-            raise ValueError("i_extract is null")
+        v_id = sel.regex_first(r"window\.openPlayer\('([^']+)'")
+        if not v_id:
+            raise ValueError(f"ContentX: ID bulunamadı. {url}")
 
         subtitles = []
-        sub_urls  = set()
-        for sub_url, sub_lang in HTMLHelper(i_source).regex_all(r'"file":"([^\"]+)","label":"([^\"]+)"'):
-
-            if sub_url in sub_urls:
-                continue
-
-            sub_urls.add(sub_url)
-            subtitles.append(
-                Subtitle(
-                    name = sub_lang.replace("\\u0131", "ı")
-                                 .replace("\\u0130", "İ")
-                                 .replace("\\u00fc", "ü")
-                                 .replace("\\u00e7", "ç")
-                                 .replace("\\u011f", "ğ")
-                                 .replace("\\u015f", "ş")
-                                 .replace("\\u011e", "Ğ")
-                                 .replace("\\u015e", "Ş"),
-                    url  = self.fix_url(sub_url.replace("\\/", "/").replace("\\", ""))
-                )
-            )
-
-        # base_url kullan (contentx.me yerine)
-        vid_source_request = await self.httpx.get(f"{base_url}/source2.php?v={i_extract_value}", headers={"Referer": referer or base_url})
-        vid_source_request.raise_for_status()
-
-        vid_source  = vid_source_request.text
-        m3u_link = HTMLHelper(vid_source).regex_first(r'file":"([^\"]+)"')
-        if not m3u_link:
-            raise ValueError("vidExtract is null")
-
-        m3u_link = m3u_link.replace("\\", "").replace("/m.php", "/master.m3u8")
-        results  = [
-            ExtractResult(
-                name      = self.name,
-                url       = m3u_link,
-                referer   = url,
-                subtitles = subtitles
-            )
-        ]
-
-        dublaj_value = HTMLHelper(i_source).regex_first(r'["\']([^"\']+)["\'],["\']Türkçe["\']')
-        if dublaj_value:
-            try:
-                dublaj_source_request = await self.httpx.get(f"{base_url}/source2.php?v={dublaj_value}", headers={"Referer": referer or base_url})
-                dublaj_source_request.raise_for_status()
-
-                dublaj_source  = dublaj_source_request.text
-                dublaj_link = HTMLHelper(dublaj_source).regex_first(r'file":"([^\"]+)"')
-                if dublaj_link:
-                    dublaj_link = dublaj_link.replace("\\", "")
-                    results.append(
-                        ExtractResult(
-                            name      = f"{self.name} Türkçe Dublaj",
-                            url       = dublaj_link,
-                            referer   = url,
-                            subtitles = []
-                        )
-                    )
-            except Exception:
-                pass
+        for s_url, s_lang in sel.regex_all(r'"file":"([^\"]+)","label":"([^\"]+)"'):
+            decoded_lang = s_lang.encode().decode('unicode_escape')
+            subtitles.append(Subtitle(name=decoded_lang, url=self.fix_url(s_url.replace("\\", ""))))
+
+        results = []
+        # Base m3u8
+        vid_resp = await self.httpx.get(f"{self.get_base_url(url)}/source2.php?v={v_id}", headers={"Referer": url})
+        if m3u8_link := HTMLHelper(vid_resp.text).regex_first(r'file":"([^\"]+)"'):
+            m3u8_link = m3u8_link.replace("\\", "").replace("/m.php", "/master.m3u8")
+            results.append(ExtractResult(name=self.name, url=m3u8_link, referer=url, subtitles=subtitles))
+
+        # Dublaj Kontrolü
+        if dub_id := sel.regex_first(r'["\']([^"\']+)["\'],["\']Türkçe["\']'):
+            dub_resp = await self.httpx.get(f"{self.get_base_url(url)}/source2.php?v={dub_id}", headers={"Referer": url})
+            if dub_link := HTMLHelper(dub_resp.text).regex_first(r'file":"([^\"]+)"'):
+                results.append(ExtractResult(name=f"{self.name} Türkçe Dublaj", url=dub_link.replace("\\", ""), referer=url))
+
+        if not results:
+            raise ValueError(f"ContentX: Video linki bulunamadı. {url}")
 
         return results[0] if len(results) == 1 else results

KekikStream/Extractors/DonilasPlay.py

@@ -2,85 +2,41 @@
 
 from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 from Kekik.Sifreleme   import AESManager
-import json
+import json, contextlib
 
 class DonilasPlay(ExtractorBase):
     name     = "DonilasPlay"
     main_url = "https://donilasplay.com"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
-        i_source = istek.text
-
-        m3u_link   = None
-        subtitles  = []
-
-        # bePlayer pattern
-        hp = HTMLHelper(i_source)
-        be_player_matches = hp.regex_all(r"bePlayer\('([^']+)',\s*'(\{[^}]+\})'\);")
-        if be_player_matches:
-            be_player_pass, be_player_data = be_player_matches[0]
-
-            try:
-                # AES decrypt
-                decrypted = AESManager.decrypt(be_player_data, be_player_pass)
-                data      = json.loads(decrypted)
-
-                m3u_link = data.get("video_location")
-
-                # Altyazıları işle
-                str_subtitles = data.get("strSubtitles", [])
-                if str_subtitles:
-                    for sub in str_subtitles:
-                        label = sub.get("label", "")
-                        file  = sub.get("file", "")
-                        # Forced altyazıları hariç tut
-                        if "Forced" in label:
-                            continue
-                        if file:
-                            # Türkçe kontrolü
-                            keywords = ["tur", "tr", "türkçe", "turkce"]
-                            language = "Turkish" if any(k in label.lower() for k in keywords) else label
-                            subtitles.append(Subtitle(
-                                name = language,
-                                url  = self.fix_url(file)
-                            ))
-            except Exception:
-                pass
-
-        # Fallback: file pattern
-        if not m3u_link:
-            file_match = hp.regex_first(r'file:"([^"]+)"')
-            if file_match:
-                m3u_link = file_match
-
-            # tracks pattern for subtitles
-            tracks_match = hp.regex_first(r'tracks:\[([^\]]+)')
-            if tracks_match:
-                try:
-                    tracks_str = f"[{tracks_match}]"
-                    tracks = json.loads(tracks_str)
-                    for track in tracks:
-                        file_url = track.get("file")
-                        label    = track.get("label", "")
-                        if file_url and "Forced" not in label:
-                            subtitles.append(Subtitle(
-                                name = label,
-                                url  = self.fix_url(file_url)
-                            ))
-                except Exception:
-                    pass
-
-        if not m3u_link:
-            raise ValueError("m3u link not found")
-
-        return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = url,
-            subtitles = subtitles
-        )
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
+
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+
+        m3u8_url  = None
+        subtitles = []
+
+        # 1. bePlayer (AES)
+        if be_match := sel.regex_first(r"bePlayer\('([^']+)',\s*'(\{[^}]+\})'\);", group=None):
+            pass_val, data_val = be_match
+            with contextlib.suppress(Exception):
+                data = json.loads(AESManager.decrypt(data_val, pass_val))
+                m3u8_url = data.get("video_location")
+                for sub in data.get("strSubtitles", []):
+                    if "Forced" not in sub.get("label", ""):
+                        subtitles.append(Subtitle(name=sub.get("label"), url=self.fix_url(sub.get("file"))))
+
+        # 2. Fallback
+        if not m3u8_url:
+            m3u8_url = sel.regex_first(r'file:"([^"]+)"')
+            if tracks_match := sel.regex_first(r'tracks:\[([^\]]+)'):
+                with contextlib.suppress(Exception):
+                    for track in json.loads(f"[{tracks_match}]"):
+                        if "Forced" not in track.get("label", ""):
+                            subtitles.append(Subtitle(name=track.get("label"), url=self.fix_url(track.get("file"))))
+
+        if not m3u8_url:
+            raise ValueError(f"DonilasPlay: Video linki bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=url, subtitles=subtitles)