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

KekikStream/Extractors/MixTiger.py

@@ -6,52 +6,29 @@ class MixTiger(ExtractorBase):
     name     = "MixTiger"
     main_url = "https://www.mixtiger.com"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        ext_ref  = referer or ""
-        post_url = f"{url}?do=getVideo"
-        vid_id   = url.split("video/")[-1] if "video/" in url else ""
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        ref = referer or self.main_url
+        v_id = url.split("video/")[-1] if "video/" in url else ""
 
-        response = await self.httpx.post(
-            url     = post_url,
-            data    = {"hash": vid_id, "r": ext_ref, "s": ""},
+        resp = await self.httpx.post(
+            f"{url}?do=getVideo",
+            data    = {"hash": v_id, "r": ref, "s": ""},
             headers = {
-                "Referer"          : ext_ref,
-                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
-                "X-Requested-With" : "XMLHttpRequest"
+                "Referer": ref,
+                "X-Requested-With": "XMLHttpRequest"
             }
         )
-        response.raise_for_status()
+        data = resp.json()
 
-        video_data = response.json()
+        m3u8_url = data.get("videoSrc")
+        if not m3u8_url and data.get("videoSources"):
+            m3u8_url = data["videoSources"][-1].get("file")
 
-        # videoSrc varsa doğrudan kullan
-        if video_data.get("videoSrc"):
-            m3u_link = video_data["videoSrc"]
-        # videoSources listesi varsa son elemanı al
-        elif video_data.get("videoSources"):
-            sources  = video_data["videoSources"]
-            m3u_link = sources[-1].get("file") if sources else None
-        else:
-            m3u_link = None
-
-        if not m3u_link:
-            raise ValueError("Video URL not found in response")
-
-        # Recursive extraction check - başka extractor kullanılabilir mi?
-        try:
-            from KekikStream.Core.Extractor.ExtractorManager import ExtractorManager
-            manager = ExtractorManager()
-            if nested_extractor := manager.find_extractor(m3u_link):
-                # Nested extractor ile çıkar
-                return await nested_extractor.extract(m3u_link, referer=ext_ref)
-        except Exception:
-            # Recursive extraction başarısız olursa standart sonucu döndür
-            pass
+        if not m3u8_url:
+            raise ValueError(f"MixTiger: Video linki bulunamadı. {url}")
 
         return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = None if "disk.yandex" in m3u_link else ext_ref,
-            subtitles = []
+            name    = self.name,
+            url     = m3u8_url,
+            referer = None if "disk.yandex" in m3u8_url else ref
         )
-

KekikStream/Extractors/MolyStream.py

@@ -1,7 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
-import re
 
 class MolyStream(ExtractorBase):
     name     = "MolyStream"
@@ -9,34 +8,31 @@ class MolyStream(ExtractorBase):
 
     # Birden fazla domain destekle
     supported_domains = [
-        "dbx.molystream.org",
-        "ydx.molystream.org",
-        "yd.sheila.stream",
-        "ydf.popcornvakti.net",
+        "dbx.molystream.org", "ydx.molystream.org",
+        "yd.sheila.stream", "ydf.popcornvakti.net",
     ]
 
     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:
-        if "doctype html" in url:
-            secici   = HTMLHelper(url)
-            video    = secici.select_attr("video#sheplayer source", "src")
-        else:
-            video = url
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or self.main_url})
 
-        resp_sec = HTMLHelper(url)
-        matches = resp_sec.regex_all(r"addSrtFile\(['\"]([^'\"]+\.srt)['\"]\s*,\s*['\"][a-z]{2}['\"]\s*,\s*['\"]([^'\"]+)['\"]")
+        # Eğer url zaten bir HTML kaynağıysa (doctype html içeriyorsa)
+        if "doctype html" in url.lower():
+            sel   = HTMLHelper(url)
+            v_url = sel.select_attr("video#sheplayer source", "src")
+        else:
+            v_url = url
 
-        subtitles = [
-            Subtitle(name = name, url = self.fix_url(url))
-                for url, name in matches
-        ]
+        subtitles = []
+        for s_url, s_name in HTMLHelper(url).regex_all(r"addSrtFile\(['\"]([^'\"]+\.srt)['\"]\s*,\s*['\"][a-z]{2}['\"]\s*,\s*['\"]([^'\"]+)['\"]"):
+            subtitles.append(Subtitle(name=s_name, url=self.fix_url(s_url)))
 
         return ExtractResult(
-            name       = self.name,
-            url        = video,
-            referer    = video.replace("/sheila", "") if video else None,
+            name      = self.name,
+            url       = v_url,
+            referer   = v_url.replace("/sheila", "") if v_url else None,
             user_agent = "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0",
-            subtitles  = subtitles
+            subtitles = subtitles
         )

KekikStream/Extractors/Odnoklassniki.py

@@ -1,117 +1,41 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
-import re, json
+import json
 
 class Odnoklassniki(ExtractorBase):
     name     = "Odnoklassniki"
     main_url = "https://odnoklassniki.ru"
 
-    # Birden fazla domain destekle
     supported_domains = ["odnoklassniki.ru", "ok.ru"]
 
     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:
-        if "/video/" in url:
-            url = url.replace("/video/", "/videoembed/")
-
-        headers = {
-            "Accept"         : "*/*",
-            "Connection"     : "keep-alive",
-            "Sec-Fetch-Dest" : "empty",
-            "Sec-Fetch-Mode" : "cors",
-            "Sec-Fetch-Site" : "cross-site",
-            "Origin"         : self.main_url,
-            "User-Agent"     : "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0",
-        }
-        self.httpx.headers.update(headers)
-
-        try:
-            istek = await self.fetch_with_redirects(url)
-            istek.raise_for_status()
-        except Exception as hata:
-            raise RuntimeError(f"Failed to fetch the URL: {url}, Error: {hata}") from hata
-
-        response_text = (
-            istek.text.replace("\\"", "\"")
-                      .replace("\\\\", "\\")
-                      .replace(r"\\u", "\\u")
-        )
-        response_text = re.sub(
-            r"\\u([0-9A-Fa-f]{4})", 
-            lambda match: chr(int(match[1], 16)), 
-            response_text
-        )
-
-        videos_json = HTMLHelper(response_text).regex_first(r'"videos":(\[.*?\])')
-        if not videos_json:
-            raise ValueError("No video data found in the response.")
-
-        try:
-            videos = json.loads(videos_json)
-        except json.JSONDecodeError as hata:
-            raise ValueError("Failed to parse video data.") from hata
-
-        quality_order = {
-            "ULTRA": 6,  # 4K veya daha yüksek
-            "QUAD": 5,   # 1440p
-            "FULL": 4,   # 1080p
-            "HD": 3,     # 720p
-            "SD": 2,     # 480p
-            "LOW": 1,    # 360p
-            "MOBILE": 0  # 144p
-        }
-
-        # Kaliteye göre en iyi videoyu seçme
-        best_video = None
-        best_quality_score = -1
-
-        for video in videos:
-            video_url    = video.get("url")
-            quality_name = video.get("name", "").upper()
-
-            if not video_url or not quality_name:
-                continue
-
-            # Kalite sıralamasına göre puanla
-            quality_score = quality_order.get(quality_name, -1)
-            if quality_score > best_quality_score:
-                best_quality_score = quality_score
-                best_video         = video_url
-
-        if not best_video:
-            raise ValueError("No valid video URLs found.")
-
-        if best_video.startswith("//"):
-            best_video = f"https:{best_video}"
-
-        return ExtractResult(
-            name       = self.name,
-            url        = best_video,
-            referer    = referer,
-            user_agent = headers.get("User-Agent", None),
-            subtitles  = []
-        )
-
-    async def fetch_with_redirects(self, url, max_redirects=5):
-        """Yönlendirmeleri takip eden bir fonksiyon"""
-        redirects = 0
-        while redirects < max_redirects:
-            istek = await self.httpx.get(url, follow_redirects=False)
-
-            if istek.status_code not in [301, 302]:
-                break  # Yönlendirme yoksa çık
-
-            redirected_url = istek.headers.get("Location")
-            if not redirected_url:
-                raise ValueError("Redirect location not found.")
-
-            url = redirected_url if redirected_url.startswith("http") else f"https://{redirected_url}"
-            redirects += 1
-
-        if redirects == max_redirects:
-            raise RuntimeError(f"Max redirects ({max_redirects}) reached.")
-
-        return istek
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        if "/video/" in url: url = url.replace("/video/", "/videoembed/")
+        self.httpx.headers.update({"Origin": self.main_url})
+
+        resp = await self.httpx.get(url, follow_redirects=True)
+        sel  = HTMLHelper(resp.text)
+        
+        v_data = sel.regex_first(r'"videos":(\[.*?\])')
+        if not v_data:
+            raise ValueError(f"Odnoklassniki: Video verisi bulunamadı. {url}")
+
+        # Kalite sıralaması (En yüksekten düşüğe)
+        order = ["ULTRA", "QUAD", "FULL", "HD", "SD", "LOW", "MOBILE"]
+        videos = json.loads(v_data)
+        
+        best_url = None
+        for q in order:
+            best_url = next((v.get("url") for v in videos if v.get("name", "").upper() == q), None)
+            if best_url: break
+        
+        if not best_url:
+            best_url = videos[0].get("url") if videos else None
+
+        if not best_url:
+            raise ValueError("Odnoklassniki: Geçerli video URL'si bulunamadı.")
+
+        return ExtractResult(name=self.name, url=self.fix_url(best_url), referer=referer)

KekikStream/Extractors/PeaceMakerst.py

@@ -7,57 +7,30 @@ class PeaceMakerst(ExtractorBase):
     name     = "PeaceMakerst"
     main_url = "https://peacemakerst.com"
 
-    # Birden fazla domain destekle
     supported_domains = ["peacemakerst.com", "hdstreamable.com"]
 
     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:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
         self.httpx.headers.update({
-            "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+            "Referer"          : referer or url,
             "X-Requested-With" : "XMLHttpRequest"
         })
 
-        response = await self.httpx.post(
-            url  = f"{url}?do=getVideo",
-            data = {
-                "hash" : url.split("video/")[-1],
-                "r"    : referer or "",
-                "s"    : ""
-            }
-        )
-        response.raise_for_status()
-
-        response_text = response.text
-        m3u_link      = None
-
-        if "teve2.com.tr\\/embed\\/" in response_text:
-            teve2_id = HTMLHelper(response_text).regex_first(r"teve2\.com\.tr\\\/embed\\\/(\d+)")
-            teve2_url = f"https://www.teve2.com.tr/action/media/{teve2_id}"
-
-            teve2_response = await self.httpx.get(teve2_url, headers={"Referer": f"https://www.teve2.com.tr/embed/{teve2_id}"})
-            teve2_response.raise_for_status()
-            teve2_json = teve2_response.json()
-
-            m3u_link = f"{teve2_json['Media']['Link']['ServiceUrl']}//{teve2_json['Media']['Link']['SecurePath']}"
-        else:
-            try:
-                video_response = response.json()
-                if video_sources := video_response.get("videoSources", []):
-                    m3u_link = video_sources[-1]["file"]
-            except (json.JSONDecodeError, KeyError) as hata:
-                raise ValueError("Peace response is invalid or null.") from hata
-
-        if not m3u_link:
-            raise ValueError("m3u link not found.")
-
-        return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = url,
-            subtitles = []
-        )
+        resp = await self.httpx.post(f"{url}?do=getVideo", data={"hash": url.split("video/")[-1], "r": referer or "", "s": ""})
+        data = resp.json()
+
+        m3u8_url = None
+        if "teve2.com.tr" in resp.text:
+            v_id = HTMLHelper(resp.text).regex_first(r"teve2\.com\.tr\\\/embed\\\/(\d+)")
+            t_resp = await self.httpx.get(f"https://www.teve2.com.tr/action/media/{v_id}")
+            t_data = t_resp.json()
+            m3u8_url = f"{t_data['Media']['Link']['ServiceUrl']}//{t_data['Media']['Link']['SecurePath']}"
+        elif sources := data.get("videoSources"):
+            m3u8_url = sources[-1]["file"]
+
+        if not m3u8_url:
+            raise ValueError(f"PeaceMakerst: Video linki bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=url)

KekikStream/Extractors/PixelDrain.py

@@ -6,23 +6,15 @@ class PixelDrain(ExtractorBase):
     name     = "PixelDrain"
     main_url = "https://pixeldrain.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) -> ExtractResult:
+        if referer: self.httpx.headers.update({"Referer": referer})
 
-        hp = HTMLHelper(url)
-        matches = hp.regex_all(r"/u/([^/?]+)|([^\/]+)(?=\?download)")
-        if not matches:
-            raise ValueError("PixelDrain bağlantısından ID çıkarılamadı.")
-
-        m = matches[0]
-        pixel_id = next((g for g in m if g), None)
-        download_link = f"{self.main_url}/api/file/{pixel_id}?download"
-        referer_link  = f"{self.main_url}/u/{pixel_id}?download"
+        p_id = HTMLHelper(url).regex_first(r"/u/([^/?]+)|([^\/]+)(?=\?download)")
+        if not p_id:
+            raise ValueError(f"PixelDrain: ID bulunamadı. {url}")
 
         return ExtractResult(
-            name      = f"{self.name} - {pixel_id}",
-            url       = download_link,
-            referer   = referer_link,
-            subtitles = []
+            name    = f"{self.name} - {p_id}",
+            url     = f"{self.main_url}/api/file/{p_id}?download",
+            referer = f"{self.main_url}/u/{p_id}?download"
         )

KekikStream/Extractors/PlayerFilmIzle.py

@@ -11,55 +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 = []
-        hp = HTMLHelper(video_req)
-        sub_yakala = hp.regex_first(r'(?i)playerjsSubtitle = "([^"]*)"')
-        if sub_yakala:
-            # Format örneği: [dil]url
-            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_val = HTMLHelper(unpacked).regex_first(r'(?i)FirePlayer\s*\(\s*["\']([a-f0-9]+)["\']')
+        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 = ""
-        m3u8_url = HTMLHelper(get_url).regex_first(r'(?i)"securedLink":"([^\\"]*)"') or m3u8_url
+             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

@@ -14,57 +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        = []
-        hp = HTMLHelper(istek.text)
-        subtitle_matches = hp.regex_all(r'captions\",\"file\":\"([^\"]+)\",\"label\":\"([^\"]+)\"')
-        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 := hp.regex_first(r'file": "(.*)",'):
-                escaped_hex = extracted_value
-                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 := hp.regex_first(r"av\('([^']+)'\)"):
-                decoded_url = self.decode_secret(av_encoded)
+            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

@@ -7,60 +7,35 @@ 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()
-
-        hp = HTMLHelper(istek.text)
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        # videoUrl çıkar
-        video_url = hp.regex_first(r'videoUrl":"([^",]+)"')
-        if not video_url:
-            raise ValueError("videoUrl not found")
-        video_url = video_url.replace("\\", "")
+        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}")
 
-        # videoServer çıkar
-        video_server = hp.regex_first(r'videoServer":"([^",]+)"')
-        if not video_server:
-            raise ValueError("videoServer not found")
-
-        # title çıkar (opsiyonel)
-        title_base = hp.regex_first(r'title":"([^",]+)"')
-        title_base = title_base.split(".")[-1] if title_base else "Unknown"
-        
-        # partKey logic
-        parsed = urlparse(url)
-        params = parse_qs(parsed.query)
-        part_key = params.get("partKey", [""])[0]
+        params   = parse_qs(urlparse(url).query)
+        part_key = params.get("partKey", [""])[0].lower()
         
-        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
         )