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

KekikStream/Extractors/PlayerFilmIzle.py

@@ -1,8 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 from Kekik.Sifreleme  import Packer
-import re
 
 class PlayerFilmIzle(ExtractorBase):
     name     = "PlayerFilmIzle"
@@ -12,58 +11,36 @@ class PlayerFilmIzle(ExtractorBase):
         return "filmizle.in" in url or "fireplayer" in url.lower()
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
-        # Kotlin tarafında referer mainUrl olarak zorlanmış
-        ext_ref = self.main_url
-        self.httpx.headers.update({"Referer": ext_ref})
+        ref = referer or self.main_url
+        self.httpx.headers.update({"Referer": ref})
         
-        istek     = await self.httpx.get(url)
-        video_req = istek.text
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
         subtitles = []
-        if sub_match := re.search(r'playerjsSubtitle = "([^"]*)"', video_req, re.IGNORECASE):
-            sub_yakala = sub_match.group(1)
-            # Format örneği: [dil]url
-            # Kotlin kodunda: subYakala.substringAfter("]") -> url
-            # subYakala.substringBefore("]").removePrefix("[") -> lang
-            if "]" in sub_yakala:
-                sub_lang_raw, sub_url = sub_yakala.split("]", 1)
-                sub_lang = sub_lang_raw.replace("[", "")
-                subtitles.append(Subtitle(name=sub_lang, url=sub_url))
+        if raw_subs := sel.regex_first(r'playerjsSubtitle\s*=\s*"([^"]*)"'):
+            for lang, link in HTMLHelper(raw_subs).regex_all(r'\[(.*?)\](https?://[^\s\",]+)'):
+                subtitles.append(Subtitle(name=lang.strip(), url=link.strip()))
 
-        # Packed script varsa unpack et
-        unpacked = Packer.unpack(video_req) if Packer.detect_packed(video_req) else video_req
-
-        # Data yakalama: FirePlayer("DATA", ...) formatından
-        data_match = re.search(r'FirePlayer\s*\(\s*["\']([a-f0-9]+)["\']', unpacked, re.IGNORECASE)
-        data_val   = data_match.group(1) if data_match else None
+        content  = Packer.unpack(resp.text) if Packer.detect_packed(resp.text) else resp.text
+        data_val = HTMLHelper(content).regex_first(r'FirePlayer\s*\(\s*["\']([a-f0-9]+)["\']')
 
         if not data_val:
-             raise ValueError("PlayerFilmIzle: Data bulunamadı")
-
-        url_post = f"{self.main_url}/player/index.php?data={data_val}&do=getVideo"
-
-        post_headers = {
-            "Referer": ext_ref,
-            "X-Requested-With": "XMLHttpRequest"
-        }
-
-        # Kotlin'de post data: "hash" -> data, "r" -> ""
-        post_data = {"hash": data_val, "r": ""}
-
-        response = await self.httpx.post(url_post, data=post_data, headers=post_headers)
-        get_url  = response.text.replace("\\", "")
-
-        m3u8_url = ""
-        if url_yakala := re.search(r'"securedLink":"([^"]*)"', get_url, re.IGNORECASE):
-            m3u8_url = url_yakala.group(1)
+             raise ValueError(f"PlayerFilmIzle: Data bulunamadı. {url}")
 
+        resp_vid = await self.httpx.post(
+            f"{self.main_url}/player/index.php?data={data_val}&do=getVideo",
+            data    = {"hash": data_val, "r": ""},
+            headers = {"X-Requested-With": "XMLHttpRequest"}
+        )
+        
+        m3u8_url = HTMLHelper(resp_vid.text).regex_first(r'"securedLink":"([^"]+)"')
         if not m3u8_url:
-            raise ValueError("PlayerFilmIzle: M3U8 linki bulunamadı")
+            raise ValueError(f"PlayerFilmIzle: Video URL bulunamadı. {url}")
 
         return ExtractResult(
-            name       = self.name,
-            url        = m3u8_url,
-            referer    = ext_ref,
-            user_agent = self.httpx.headers.get("User-Agent", None),
-            subtitles  = subtitles
+            name      = self.name,
+            url       = m3u8_url.replace("\\", ""),
+            referer   = ref,
+            subtitles = subtitles
         )

KekikStream/Extractors/RapidVid.py

@@ -1,8 +1,8 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 from Kekik.Sifreleme  import Packer, HexCodec, StreamDecoder
-import re, base64
+import base64
 
 class RapidVid(ExtractorBase):
     name     = "RapidVid"
@@ -14,56 +14,43 @@ class RapidVid(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) -> 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 = re.findall(r'captions\",\"file\":\"([^\"]+)\",\"label\":\"([^\"]+)\"', istek.text)
-        seen_subtitles   = set()
-
-        for sub_url, sub_lang in subtitle_matches:
-            if sub_url in seen_subtitles:
-                continue
-
-            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("\\", "")))
+        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("\\", "")))
 
         try:
-            decoded_url = None
+            video_url = None
 
-            # Method 1: file": "..." pattern (HexCodec)
-            if extracted_value := re.search(r'file": "(.*)",', istek.text):
-                escaped_hex = extracted_value[1]
-                decoded_url = HexCodec.decode(escaped_hex)
+            # Method 1: HexCodec pattern
+            if hex_data := sel.regex_first(r'file": "(.*)",'):
+                video_url = HexCodec.decode(hex_data)
 
             # Method 2: av('...') pattern
-            elif av_encoded := re.search(r"av\('([^']+)'\)", istek.text):
-                decoded_url = self.decode_secret(av_encoded[1])
+            elif av_data := sel.regex_first(r"av\('([^']+)'\)"):
+                video_url = self.decode_secret(av_data)
 
-            # Method 3: Packed script with dc_* function (StreamDecoder)
-            elif Packer.detect_packed(istek.text):
-                unpacked    = Packer.unpack(istek.text)
-                decoded_url = StreamDecoder.extract_stream_url(unpacked)
+            # Method 3: Packed dc_*
+            elif Packer.detect_packed(resp.text):
+                unpacked  = Packer.unpack(resp.text)
+                video_url = StreamDecoder.extract_stream_url(unpacked)
 
-            if not decoded_url:
-                raise ValueError("No valid video URL pattern found.")
+            if not video_url:
+                raise ValueError(f"RapidVid: Video URL bulunamadı. {url}")
 
         except Exception as hata:
-            raise RuntimeError(f"Extraction failed: {hata}") from hata
+            raise RuntimeError(f"RapidVid: Extraction failed: {hata}") from hata
 
         return ExtractResult(
             name      = self.name,
-            url       = decoded_url,
+            url       = video_url,
             referer   = self.main_url,
             subtitles = subtitles
         )

KekikStream/Extractors/SetPlay.py

@@ -1,66 +1,41 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
 from urllib.parse import urlparse, parse_qs
-import re
 
 class SetPlay(ExtractorBase):
     name     = "SetPlay"
     main_url = "https://setplay.shop"
 
-    # Birden fazla domain destekle
     supported_domains = ["setplay.cfd", "setplay.shop", "setplay.site"]
 
     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) -> ExtractResult:
-        ext_ref = referer or ""
-
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
-        # Dinamik base URL kullan
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
         base_url = self.get_base_url(url)
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
-
-        # videoUrl çıkar
-        video_url_match = re.search(r'videoUrl":"([^",]+)"', istek.text)
-        if not video_url_match:
-            raise ValueError("videoUrl not found")
-        video_url = video_url_match[1].replace("\\", "")
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        # videoServer çıkar
-        video_server_match = re.search(r'videoServer":"([^",]+)"', istek.text)
-        if not video_server_match:
-            raise ValueError("videoServer not found")
-        video_server = video_server_match[1]
+        v_url = sel.regex_first(r'videoUrl":"([^",]+)"')
+        v_srv = sel.regex_first(r'videoServer":"([^",]+)"')
+        if not v_url or not v_srv:
+            raise ValueError(f"SetPlay: Video url/server bulunamadı. {url}")
 
-        # title çıkar (opsiyonel)
-        title_match = re.search(r'title":"([^",]+)"', istek.text)
-        title_base = title_match[1].split(".")[-1] if title_match else "Unknown"
+        params   = parse_qs(urlparse(url).query)
+        part_key = params.get("partKey", [""])[0].lower()
         
-        # partKey logic
-        parsed = urlparse(url)
-        params = parse_qs(parsed.query)
-        part_key = params.get("partKey", [""])[0]
-        
-        name_suffix = ""
-        if "turkcedublaj" in part_key.lower():
-            name_suffix = "Dublaj"
-        elif "turkcealtyazi" in part_key.lower():
-            name_suffix = "Altyazı"
+        suffix = "Bilinmiyor"
+        if "turkcedublaj" in part_key: suffix = "Dublaj"
+        elif "turkcealtyazi" in part_key: suffix = "Altyazı"
         else:
-            name_suffix = title_base
-
-        # M3U8 link oluştur - base_url kullan (main_url yerine)
-        m3u_link = f"{base_url}{video_url}?s={video_server}"
+            title = sel.regex_first(r'title":"([^",]+)"')
+            if title: suffix = title.split(".")[-1]
 
         return ExtractResult(
-            name      = f"{self.name} - {name_suffix}",
-            url       = m3u_link,
-            referer   = url,
-            subtitles = []
+            name      = f"{self.name} - {suffix}",
+            url       = f"{base_url}{v_url.replace('\\', '')}?s={v_srv}",
+            referer   = url
         )

KekikStream/Extractors/SetPrime.py

@@ -1,8 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
 from urllib.parse import urlparse, parse_qs
-import re
 
 class SetPrime(ExtractorBase):
     name     = "SetPrime"
@@ -25,11 +24,9 @@ class SetPrime(ExtractorBase):
         response.raise_for_status()
         
         # Links parse
-        links_match = re.search(r'Links":\["([^"\]]+)"', response.text)
-        if not links_match:
+        link_suffix = HTMLHelper(response.text).regex_first(r'Links":\["([^"\]]+)"')
+        if not link_suffix:
             raise ValueError("Links not found in SetPrime response")
-            
-        link_suffix = links_match.group(1)
         if not link_suffix.startswith("/"):
             raise ValueError("Links not valid (must start with /)")
             

KekikStream/Extractors/SibNet.py

@@ -1,28 +1,17 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult
-import re
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
 
 class SibNet(ExtractorBase):
     name     = "SibNet"
     main_url = "https://video.sibnet.ru"
 
-    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({"Referer": referer or url})
 
-        response = await self.httpx.get(url)
-        response.raise_for_status()
+        resp = await self.httpx.get(url)
+        path = HTMLHelper(resp.text).regex_first(r'player\.src\(\[\{src: "([^\"]+)"')
+        if not path:
+            raise ValueError(f"SibNet: Video yolu bulunamadı. {url}")
 
-        match = re.search(r'player\.src\(\[\{src: \"([^\"]+)\"', response.text)
-        if not match:
-            raise ValueError("m3u bağlantısı bulunamadı.")
-
-        m3u_link = f"{self.main_url}{match[1]}"
-
-        return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = url,
-            subtitles = []
-        )
+        return ExtractResult(name=self.name, url=f"{self.main_url}{path}", referer=url)

KekikStream/Extractors/Sobreatsesuyp.py

@@ -1,59 +1,37 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult
-import re, json
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+import json
 
 class Sobreatsesuyp(ExtractorBase):
     name     = "Sobreatsesuyp"
     main_url = "https://sobreatsesuyp.com"
 
-    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:
+        ref = referer or self.main_url
+        self.httpx.headers.update({"Referer": ref})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        path = HTMLHelper(resp.text).regex_first(r'file":"([^\"]+)')
+        if not path:
+            raise ValueError(f"Sobreatsesuyp: File path bulunamadı. {url}")
 
-        file_match = re.search(r'file\":\"([^\"]+)', istek.text)
-        if not file_match:
-            raise ValueError("File not found in response.")
+        post_resp = await self.httpx.post(f"{self.main_url}/{path.replace('\\', '')}")
+        data_list = post_resp.json()[1:] if isinstance(post_resp.json(), list) else []
 
-        file_path = file_match[1].replace("\\", "")
-        post_link = f"{self.main_url}/{file_path}"
-
-        post_istek = await self.httpx.post(post_link)
-        post_istek.raise_for_status()
-
-        try:
-            post_json = json.loads(post_istek.text)
-        except json.JSONDecodeError as hata:
-            raise ValueError("Failed to parse JSON response.") from hata
-
-        video_data_list = post_json[1:] if isinstance(post_json, list) else []
-
-        all_results = []
-
-        for item in video_data_list:
+        results = []
+        for item in data_list:
             title = item.get("title")
             file  = item.get("file")
-
-            if not title or not file:
-                continue
-
-            playlist_url     = f"{self.main_url}/playlist/{file.lstrip('/')}.txt"
-            playlist_request = await self.httpx.post(playlist_url, headers={"Referer": referer or self.main_url})
-            playlist_request.raise_for_status()
-
-            all_results.append(
-                ExtractResult(
-                    name      = f"{self.name} - {title}",
-                    url       = playlist_request.text,
-                    referer   = self.main_url,
-                    subtitles = []
-                )
-            )
-
-        if not all_results:
-            raise ValueError("No videos found in response.")
-
-        return all_results[0] if len(all_results) == 1 else all_results
+            if title and file:
+                playlist_resp = await self.httpx.post(f"{self.main_url}/playlist/{file.lstrip('/')}.txt")
+                results.append(ExtractResult(
+                    name    = f"{self.name} - {title}",
+                    url     = playlist_resp.text,
+                    referer = self.main_url
+                ))
+
+        if not results:
+            raise ValueError(f"Sobreatsesuyp: Video bulunamadı. {url}")
+
+        return results[0] if len(results) == 1 else results

KekikStream/Extractors/TRsTX.py

@@ -1,67 +1,37 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult
-import re, json
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+import json
 
 class TRsTX(ExtractorBase):
     name     = "TRsTX"
     main_url = "https://trstx.org"
 
-    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.main_url
+        self.httpx.headers.update({"Referer": ref})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        path = HTMLHelper(resp.text).regex_first(r'file":"([^\"]+)')
+        if not path:
+            raise ValueError(f"TRsTX: File path bulunamadı. {url}")
 
-        file_match = re.search(r'file\":\"([^\"]+)', istek.text)
-        if not file_match:
-            raise ValueError("File not found in response.")
+        post_resp = await self.httpx.post(f"{self.main_url}/{path.replace('\\', '')}")
+        data_list = post_resp.json()[1:] if isinstance(post_resp.json(), list) else []
 
-        file_path = file_match[1].replace("\\", "")
-        post_link = f"{self.main_url}/{file_path}"
-
-        post_istek = await self.httpx.post(post_link)
-        post_istek.raise_for_status()
-
-        try:
-            post_json = json.loads(post_istek.text)
-        except json.JSONDecodeError as hata:
-            raise ValueError("Failed to parse JSON response.") from hata
-
-        video_data_list = post_json[1:] if isinstance(post_json, list) else []
-
-        video_links = set()
-        all_results = []
-
-        for item in video_data_list:
+        results = []
+        for item in data_list:
             title = item.get("title")
             file  = item.get("file")
-
-            if not title or not file:
-                continue
-
-            playlist_url = f"{self.main_url}/playlist/{file.lstrip('/')}.txt"
-            playlist_request = await self.httpx.post(playlist_url, headers={"Referer": referer or self.main_url})
-            playlist_request.raise_for_status()
-
-            video_data = playlist_request.text
-
-            if video_data in video_links:
-                continue
-
-            video_links.add(video_data)
-
-            all_results.append(
-                ExtractResult(
-                    name      = f"{self.name} - {title}",
-                    url       = video_data,
-                    referer   = self.main_url,
-                    subtitles = []
-                )
-            )
-
-        if not all_results:
-            raise ValueError("No videos found in response.")
-
-        return all_results[0] if len(all_results) == 1 else all_results
+            if title and file:
+                playlist_resp = await self.httpx.post(f"{self.main_url}/playlist/{file.lstrip('/')}.txt")
+                results.append(ExtractResult(
+                    name    = f"{self.name} - {title}",
+                    url     = playlist_resp.text,
+                    referer = self.main_url
+                ))
+
+        if not results:
+            raise ValueError(f"TRsTX: Video bulunamadı. {url}")
+
+        return results[0] if len(results) == 1 else results

KekikStream/Extractors/TurboImgz.py

@@ -1,25 +1,17 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult
-import re
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
 
 class TurboImgz(ExtractorBase):
     name     = "TurboImgz"
     main_url = "https://turbo.imgz.me"
 
-    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({"Referer": referer or url})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        v_url = HTMLHelper(resp.text).regex_first(r'file: "(.*)",')
+        if not v_url:
+            raise ValueError(f"TurboImgz: Video bulunamadı. {url}")
 
-        if video_match := re.search(r'file: "(.*)",', istek.text):
-            return ExtractResult(
-                name      = self.name,
-                url       = video_match[1],
-                referer   = referer or self.main_url,
-                subtitles = []
-            )
-        else:
-            raise ValueError("File not found in response.")
+        return ExtractResult(name=self.name, url=v_url, referer=referer or self.main_url)

KekikStream/Extractors/TurkeyPlayer.py

@@ -1,7 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
-import re, json
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+import json
 
 class TurkeyPlayer(ExtractorBase):
     name     = "TurkeyPlayer"
@@ -14,11 +14,11 @@ class TurkeyPlayer(ExtractorBase):
         istek       = await self.httpx.get(url)
         page_content = istek.text
 
-        video_json_match = re.search(r'var\s+video\s*=\s*(\{.*?\});', page_content, re.DOTALL)
-        if not video_json_match:
+        video_json_str = HTMLHelper(page_content).regex_first(r'(?s)var\s+video\s*=\s*(\{.*?\});')
+        if not video_json_str:
              raise ValueError("TurkeyPlayer: Video JSON bulunamadı")
 
-        video_data = json.loads(video_json_match.group(1))
+        video_data = json.loads(video_json_str)
         
         video_id  = video_data.get("id")
         video_md5 = video_data.get("md5")

KekikStream/Extractors/VCTPlay.py

@@ -7,35 +7,17 @@ class VCTPlay(ExtractorBase):
     name     = "VCTPlay"
     main_url = "https://vctplay.site"
 
-    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:
+        v_id = url.split("/")[-1].split("?")[0]
+        params = parse_qs(urlparse(url).query)
+        part_key = params.get("partKey", [""])[0].lower()
 
-        # URL'den video ID'sini çıkar
-        # https://vctplay.site/video/2hjDGco5exdv -> 2hjDGco5exdv
-        video_id = url.split("/")[-1]
-        if "?" in video_id:
-            video_id = video_id.split("?")[0]
-
-        # Manifests URL oluştur
-        master_url = f"{self.main_url}/manifests/{video_id}/master.txt"
-
-        # partKey'den isim belirle
-        parsed   = urlparse(url)
-        params   = parse_qs(parsed.query)
-        part_key = params.get("partKey", [""])[0]
-
-        name_suffix = ""
-        if "turkcedublaj" in part_key.lower():
-            name_suffix = "Dublaj"
-        elif "turkcealtyazi" in part_key.lower():
-            name_suffix = "Altyazı"
-
-        display_name = f"{self.name} - {name_suffix}" if name_suffix else self.name
+        suffix = ""
+        if "turkcedublaj" in part_key: suffix = "Dublaj"
+        elif "turkcealtyazi" in part_key: suffix = "Altyazı"
 
         return ExtractResult(
-            name      = display_name,
-            url       = master_url,
-            referer   = f"{self.main_url}/",
-            subtitles = []
+            name    = f"{self.name} - {suffix}" if suffix else self.name,
+            url     = f"{self.main_url}/manifests/{v_id}/master.txt",
+            referer = f"{self.main_url}/"
         )