KekikStream 1.6.4__tar.gz → 1.7.7__tar.gz

{kekikstream-1.6.4 → kekikstream-1.7.7}/KekikStream/Core/Extractor/ExtractorBase.py

@@ -1,8 +1,9 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from abc              import ABC, abstractmethod
-from httpx            import AsyncClient, Timeout
+from curl_cffi        import AsyncSession
 from cloudscraper     import CloudScraper
+from httpx            import AsyncClient
 from typing           import Optional
 from .ExtractorModels import ExtractResult
 from urllib.parse     import urljoin
@@ -11,18 +12,27 @@ class ExtractorBase(ABC):
     # Çıkarıcının temel özellikleri
     name     = "Extractor"
     main_url = ""
+    requires_cffi = False
 
     def __init__(self):
-        # HTTP istekleri için oturum oluştur
+        # cloudscraper - for bypassing Cloudflare
+        self.cloudscraper = CloudScraper()
+
+        # httpx - lightweight and safe for most HTTP requests
         self.httpx = AsyncClient(
-            headers = {
-                "User-Agent" : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5)",
-                "Accept"     : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-            },
-            timeout = Timeout(10.0)
+            timeout          = 3,
+            follow_redirects = True,
         )
-        # CloudFlare korumalı siteler için scraper ayarla
-        self.cloudscraper  = CloudScraper()
+        self.httpx.headers.update(self.cloudscraper.headers)
+        self.httpx.cookies.update(self.cloudscraper.cookies)
+
+        # curl_cffi - only initialize if needed for anti-bot bypass
+        self.cffi = None
+
+        if self.requires_cffi:
+            self.cffi = AsyncSession(impersonate="firefox135")
+            self.cffi.cookies.update(self.cloudscraper.cookies)
+            self.cffi.headers.update({"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:135.0) Gecko/20100101 Firefox/135.0"})
 
     def can_handle_url(self, url: str) -> bool:
         # URL'nin bu çıkarıcı tarafından işlenip işlenemeyeceğini kontrol et
@@ -34,8 +44,10 @@ class ExtractorBase(ABC):
         pass
 
     async def close(self):
-        # HTTP oturumunu güvenli bir şekilde kapat
+        """Close both HTTP clients if they exist."""
         await self.httpx.aclose()
+        if self.cffi:
+            await self.cffi.close()
 
     def fix_url(self, url: str) -> str:
         # Eksik URL'leri düzelt ve tam URL formatına çevir

{kekikstream-1.6.4 → kekikstream-1.7.7}/KekikStream/Core/Plugin/PluginBase.py

@@ -1,8 +1,9 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from abc                          import ABC, abstractmethod
-from httpx                        import AsyncClient, Timeout
+from curl_cffi                    import AsyncSession
 from cloudscraper                 import CloudScraper
+from httpx                        import AsyncClient
 from .PluginModels                import MainPageResult, SearchResult, MovieInfo
 from ..Media.MediaHandler         import MediaHandler
 from ..Extractor.ExtractorManager import ExtractorManager
@@ -16,6 +17,8 @@ class PluginBase(ABC):
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "No description provided."
 
+    requires_cffi = False
+
     main_page   = {}
 
     async def url_update(self, new_url: str):
@@ -24,23 +27,32 @@ class PluginBase(ABC):
         self.main_url  = new_url
 
     def __init__(self):
+        # cloudscraper - for bypassing Cloudflare
+        self.cloudscraper = CloudScraper()
+
+        # httpx - lightweight and safe for most HTTP requests
         self.httpx = AsyncClient(
-            headers = {
-                "User-Agent" : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5)",
-                "Accept"     : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-            },
-            timeout = Timeout(10.0),
+            timeout          = 3,
+            follow_redirects = True,
         )
-        self.media_handler = MediaHandler()
-        self.cloudscraper  = CloudScraper()
-        self.ex_manager    = ExtractorManager()
         self.httpx.headers.update(self.cloudscraper.headers)
         self.httpx.cookies.update(self.cloudscraper.cookies)
 
-    # @abstractmethod
-    # async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
-    #     """Ana sayfadaki popüler içerikleri döndürür."""
-    #     pass
+        # curl_cffi - only initialize if needed for anti-bot bypass
+        self.cffi = None
+
+        if self.requires_cffi:
+            self.cffi = AsyncSession(impersonate="firefox135")
+            self.cffi.cookies.update(self.cloudscraper.cookies)
+            self.cffi.headers.update({"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:135.0) Gecko/20100101 Firefox/135.0"})
+
+        self.media_handler = MediaHandler()
+        self.ex_manager    = ExtractorManager()
+
+    @abstractmethod
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        """Ana sayfadaki popüler içerikleri döndürür."""
+        pass
 
     @abstractmethod
     async def search(self, query: str) -> list[SearchResult]:
@@ -78,7 +90,10 @@ class PluginBase(ABC):
         pass
 
     async def close(self):
+        """Close both HTTP clients if they exist."""
         await self.httpx.aclose()
+        if self.cffi:
+            await self.cffi.close()
 
     def fix_url(self, url: str) -> str:
         if not url:

{kekikstream-1.6.4 → kekikstream-1.7.7}/KekikStream/Core/Plugin/PluginModels.py

@@ -66,6 +66,7 @@ class SeriesInfo(BaseModel):
     rating       : Optional[str]           = None
     year         : Optional[str]           = None
     actors       : Optional[str]           = None
+    duration     : Optional[int]           = None
     episodes     : Optional[List[Episode]] = None
 
     @field_validator("tags", "actors", mode="before")

{kekikstream-1.6.4 → kekikstream-1.7.7}/KekikStream/Extractors/CloseLoad.py

@@ -18,7 +18,6 @@ class CloseLoadExtractor(ExtractorBase):
         eval_func = re.compile(r'\s*(eval\(function[\s\S].*)\s*').findall(istek.text)[0]
         m3u_link  = StreamDecoder.extract_stream_url(Packer.unpack(eval_func))
 
-        await self.close()
         return ExtractResult(
             name      = self.name,
             url       = m3u_link,

kekikstream-1.7.7/KekikStream/Extractors/DzenRu.py

@@ -0,0 +1,39 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+import re
+
+class DzenRu(ExtractorBase):
+    name     = "DzenRu"
+    main_url = "https://dzen.ru"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        video_key = url.split("/")[-1]
+        video_url = f"{self.main_url}/embed/{video_key}"
+
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        istek = await self.httpx.get(video_url)
+        istek.raise_for_status()
+
+        # okcdn.ru linklerini bul
+        matches = re.findall(r'https://vd\d+\.okcdn\.ru/\?[^"\'\\\s]+', istek.text)
+
+        if not matches:
+            raise ValueError("DzenRu video link not found")
+
+        # Benzersiz linkleri al, son kaliteyi kullan
+        unique_links = list(set(matches))
+        best_link    = unique_links[-1] if unique_links else None
+
+        if not best_link:
+            raise ValueError("No valid video URL found")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = best_link,
+            referer   = self.main_url,
+            headers   = {},
+            subtitles = []
+        )

kekikstream-1.7.7/KekikStream/Extractors/ExPlay.py

@@ -0,0 +1,54 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re
+from urllib.parse import urlparse, parse_qs
+
+class ExPlay(ExtractorBase):
+    name     = "ExPlay"
+    main_url = "https://explay.store"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref = referer or ""
+        
+        # URL parsing for partKey
+        parsed = urlparse(url)
+        params = parse_qs(parsed.query)
+        part_key = params.get("partKey", [""])[0]
+        clean_url = url.split("?partKey=")[0]
+
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        istek = await self.httpx.get(clean_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("\\", "")
+
+        # 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]
+
+        # title çıkar
+        title_match = re.search(r'title":"([^",]+)"', istek.text)
+        title = title_match[1].split(".")[-1] if title_match else "Unknown"
+        
+        if part_key and "turkce" in part_key.lower():
+             title = part_key # Or nicer formatting like SetPlay
+
+        # M3U8 link oluştur
+        m3u_link = f"{self.main_url}{video_url}?s={video_server}"
+
+        return ExtractResult(
+            name      = f"{self.name} - {title}",
+            url       = m3u_link,
+            referer   = clean_url, 
+            headers   = {},
+            subtitles = []
+        )

kekikstream-1.7.7/KekikStream/Extractors/FirePlayer.py

@@ -0,0 +1,61 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from Kekik.Sifreleme  import Packer
+import re
+
+class FirePlayer(ExtractorBase):
+    name     = "FirePlayer"
+    main_url = "https://Player.filmizle.in"
+
+    def can_handle_url(self, url: str) -> bool:
+        return "filmizle.in" in url or "fireplayer" in url.lower()
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        if not referer:
+            referer = "https://sinezy.site/"
+            
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "Referer": referer
+        }
+
+        istek  = await self.httpx.get(url, headers=headers)
+        
+        # Unpack usage similar to VidMoxy / suggestion
+        # Find the packed code block
+        match = re.search(r'(eval\(function\(p,a,c,k,e,d\)[\s\S]+?)\s*</script>', istek.text)
+        if match:
+            packed_code = match.group(1)
+            unpacked    = Packer.unpack(packed_code)
+        else:
+            unpacked = istek.text
+
+        # Normalize escaped slashes
+        unpacked = unpacked.replace(r"\/", "/")
+        
+        video_url = None
+        
+        # Look for .mp4 or .m3u8 urls directly first
+        url_match = re.search(r'(https?://[^"\'\s]+\.(?:mp4|m3u8))', unpacked)
+        if url_match:
+             video_url = url_match.group(1)
+        
+        if not video_url:
+             # Fallback: find all 'file': '...' and pick best
+             files = re.findall(r'file\s*:\s*["\']([^"\']+)["\']', unpacked)
+             for f in files:
+                 if f.strip() and not f.endswith(".jpg") and not f.endswith(".png") and not f.endswith(".vtt"):
+                     video_url = f
+                     break
+
+        if not video_url:
+             raise ValueError("Could not find video URL in unpacked content")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = video_url,
+            referer   = url,
+            headers   = headers
+        )
+

kekikstream-1.7.7/KekikStream/Extractors/HDPlayerSystem.py

@@ -0,0 +1,42 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+
+class HDPlayerSystem(ExtractorBase):
+    name     = "HDPlayerSystem"
+    main_url = "https://hdplayersystem.com"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref = referer or ""
+
+        if "video/" in url:
+            vid_id = url.split("video/")[-1]
+        else:
+            vid_id = url.split("?data=")[-1]
+
+        post_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
+
+        response = await self.httpx.post(
+            url     = post_url,
+            data    = {"hash": vid_id, "r": ext_ref},
+            headers = {
+                "Referer"          : ext_ref,
+                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+                "X-Requested-With" : "XMLHttpRequest"
+            }
+        )
+        response.raise_for_status()
+
+        video_data = response.json()
+        m3u_link   = video_data.get("securedLink")
+
+        if not m3u_link:
+            raise ValueError("securedLink not found in response")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = url,
+            headers   = {},
+            subtitles = []
+        )

kekikstream-1.7.7/KekikStream/Extractors/JetTv.py

@@ -0,0 +1,46 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re, json
+
+class JetTv(ExtractorBase):
+    name     = "JetTv"
+    main_url = "https://jetv.xyz"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        istek    = await self.httpx.get(url)
+        document = istek.text
+
+        # 1. Yöntem: API üzerinden alma
+        master_url = ""
+        final_ref  = f"{self.main_url}/"
+
+        if "id=" in url:
+            vid_id = url.split("id=")[-1]
+            api_url = f"https://jetv.xyz/apollo/get_video.php?id={vid_id}"
+            try:
+                # Referer olarak video sayfasının kendisi gönderilmeli
+                api_resp = await self.httpx.get(api_url, headers={"Referer": url})
+                api_json = api_resp.json()
+                
+                if api_json.get("success"):
+                     master_url = api_json.get("masterUrl", "")
+                     final_ref  = api_json.get("referrerUrl") or final_ref
+            except Exception:
+                pass
+
+        # 2. Yöntem: Regex Fallback
+        if not master_url:
+             if match := re.search(r"file: '([^']*)'", document, re.IGNORE_CASE):
+                 master_url = match.group(1)
+        
+        if not master_url:
+            raise ValueError(f"JetTv: Video kaynağı bulunamadı. {url}")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = master_url,
+            referer   = final_ref,
+            headers   = {},
+            subtitles = []
+        )

{kekikstream-1.6.4 → kekikstream-1.7.7}/KekikStream/Extractors/MailRu.py

@@ -30,7 +30,6 @@ class MailRuExtractor(ExtractorBase):
         if video_url.startswith("//"):
             video_url = f"https:{video_url}"
 
-        await self.close()
         return ExtractResult(
             name      = self.name,
             url       = video_url,

kekikstream-1.7.7/KekikStream/Extractors/MixTiger.py

@@ -0,0 +1,61 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+
+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 ""
+
+        response = await self.httpx.post(
+            url     = post_url,
+            data    = {"hash": vid_id, "r": ext_ref, "s": ""},
+            headers = {
+                "Referer"          : ext_ref,
+                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+                "X-Requested-With" : "XMLHttpRequest"
+            }
+        )
+        response.raise_for_status()
+
+        video_data = response.json()
+
+        # 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")
+
+        # disk.yandex için referer boş olmalı
+        final_referer = "" if "disk.yandex" in m3u_link else ext_ref
+
+        # Recursive extraction check
+        try:
+            from KekikStream.Core.Extractor.ExtractorManager import ExtractorManager
+            # Import inside method to avoid circular dependency
+            manager = ExtractorManager()
+            if nested_extractor := manager.find_extractor(m3u_link):
+                # Use recursive extraction
+                return await nested_extractor.extract(m3u_link, referer=final_referer)
+        except Exception:
+            # If recursion fails, fallback to standard result
+            pass
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = final_referer,
+            headers   = {},
+            subtitles = []
+        )

{kekikstream-1.6.4 → kekikstream-1.7.7}/KekikStream/Extractors/Odnoklassniki.py

@@ -8,16 +8,20 @@ class Odnoklassniki(ExtractorBase):
     main_url = "https://odnoklassniki.ru"
 
     async def extract(self, url, referer=None) -> ExtractResult:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
-        self.httpx.headers.update({
-            "User-Agent": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Mobile Safari/537.36"
-        })
-
         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()
@@ -80,8 +84,8 @@ class Odnoklassniki(ExtractorBase):
         return ExtractResult(
             name      = self.name,
             url       = best_video,
-            referer   = self.main_url,
-            headers   = {},
+            referer   = referer,
+            headers   = headers,
             subtitles = []
         )
 

{kekikstream-1.6.4 → kekikstream-1.7.7}/KekikStream/Extractors/PixelDrain.py

@@ -19,7 +19,6 @@ class PixelDrain(ExtractorBase):
         download_link = f"{self.main_url}/api/file/{pixel_id}?download"
         referer_link  = f"{self.main_url}/u/{pixel_id}?download"
 
-        await self.close()
         return ExtractResult(
             name      = f"{self.name} - {pixel_id}",
             url       = download_link,

kekikstream-1.7.7/KekikStream/Extractors/PlayerFilmIzle.py

@@ -0,0 +1,62 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re, json
+
+class PlayerFilmIzle(ExtractorBase):
+    name     = "PlayerFilmIzle"
+    main_url = "https://player.filmizle.in"
+
+    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})
+        
+        istek     = await self.httpx.get(url)
+        video_req = istek.text
+
+        subtitles = []
+        if sub_match := re.search(r'playerjsSubtitle = "([^"]*)"', video_req, re.IGNORE_CASE):
+            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))
+
+        # Data yakalama: FirePlayer|DATA|...
+        data_match = re.search(r'FirePlayer\|([^|]+)\|', video_req, re.IGNORE_CASE)
+        data_val   = data_match.group(1) if data_match else None
+        
+        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.IGNORE_CASE):
+            m3u8_url = url_yakala.group(1)
+
+        if not m3u8_url:
+            raise ValueError("PlayerFilmIzle: M3U8 linki bulunamadı")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u8_url,
+            referer   = ext_ref,
+            headers   = dict(self.httpx.headers),
+            subtitles = subtitles
+        )

{kekikstream-1.6.4 → kekikstream-1.7.7}/KekikStream/Extractors/RapidVid.py

@@ -45,7 +45,6 @@ class RapidVid(ExtractorBase):
         except Exception as hata:
             raise RuntimeError(f"Extraction failed: {hata}") from hata
 
-        await self.close()
         return ExtractResult(
             name      = self.name,
             url       = decoded_url,

kekikstream-1.7.7/KekikStream/Extractors/SetPlay.py

@@ -0,0 +1,58 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+import re
+
+class SetPlay(ExtractorBase):
+    name     = "SetPlay"
+    main_url = "https://setplay.cfd"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref = referer or ""
+
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        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("\\", "")
+
+        # 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]
+
+        # title çıkar (opsiyonel)
+        title_match = re.search(r'title":"([^",]+)"', istek.text)
+        title_base = title_match[1].split(".")[-1] if title_match else "Unknown"
+        
+        # partKey logic
+        from urllib.parse import urlparse, parse_qs
+        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ı"
+        else:
+            name_suffix = title_base
+
+        # M3U8 link oluştur
+        m3u_link = f"{self.main_url}{video_url}?s={video_server}"
+
+        return ExtractResult(
+            name      = f"{self.name} - {name_suffix}",
+            url       = m3u_link,
+            referer   = url,
+            headers   = {},
+            subtitles = []
+        )