KekikStream 1.9.9__tar.gz → 2.1.0__tar.gz

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Core/Extractor/ExtractorBase.py

@@ -5,7 +5,7 @@ from cloudscraper     import CloudScraper
 from httpx            import AsyncClient
 from typing           import Optional
 from .ExtractorModels import ExtractResult
-from urllib.parse     import urljoin
+from urllib.parse     import urljoin, urlparse
 
 class ExtractorBase(ABC):
     # Çıkarıcının temel özellikleri
@@ -17,18 +17,23 @@ class ExtractorBase(ABC):
         self.cloudscraper = CloudScraper()
 
         # httpx - lightweight and safe for most HTTP requests
-        self.httpx = AsyncClient(
-            timeout          = 3,
-            follow_redirects = True
-        )
+        self.httpx = AsyncClient(timeout = 10)
         self.httpx.headers.update(self.cloudscraper.headers)
         self.httpx.cookies.update(self.cloudscraper.cookies)
-        self.httpx.headers.update({"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:135.0) Gecko/20100101 Firefox/135.0"})
+        self.httpx.headers.update({
+            "User-Agent" : "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:135.0) Gecko/20100101 Firefox/135.0",
+            "Accept"     : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        })
 
     def can_handle_url(self, url: str) -> bool:
         # URL'nin bu çıkarıcı tarafından işlenip işlenemeyeceğini kontrol et
         return self.main_url in url
 
+    def get_base_url(self, url: str) -> str:
+        """URL'den base URL'i çıkar (scheme + netloc)"""
+        parsed = urlparse(url)
+        return f"{parsed.scheme}://{parsed.netloc}"
+
     @abstractmethod
     async def extract(self, url: str, referer: Optional[str] = None) -> ExtractResult:
         # Alt sınıflar tarafından uygulanacak medya çıkarma fonksiyonu
@@ -46,4 +51,4 @@ class ExtractorBase(ABC):
         if url.startswith("http") or url.startswith("{\""):
             return url
 
-        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Core/Extractor/ExtractorLoader.py

@@ -19,19 +19,22 @@ class ExtractorLoader:
     def load_all(self) -> list[ExtractorBase]:
         extractors = []
 
-        # Global çıkarıcıları yükle
-        if self.global_extractors_dir.exists():
-            # konsol.log(f"[green][*] Global Extractor dizininden yükleniyor: {self.global_extractors_dir}[/green]")
-            global_extractors = self._load_from_directory(self.global_extractors_dir)
-            # konsol.log(f"[green]Global Extractor'lar: {[e.__name__ for e in global_extractors]}[/green]")
-            extractors.extend(global_extractors)
-
-        # Yerel çıkarıcıları yükle
+        # Eğer yerel dizinde Extractor varsa, sadece onları yükle (eklenti geliştirme modu)
         if self.local_extractors_dir.exists():
             # konsol.log(f"[green][*] Yerel Extractor dizininden yükleniyor: {self.local_extractors_dir}[/green]")
             local_extractors = self._load_from_directory(self.local_extractors_dir)
             # konsol.log(f"[green]Yerel Extractor'lar: {[e.__name__ for e in local_extractors]}[/green]")
-            extractors.extend(local_extractors)
+
+            if local_extractors:
+                # konsol.log("[cyan][*] Yerel Extractor bulundu, global Extractor'lar atlanıyor (eklenti geliştirme modu)[/cyan]")
+                extractors.extend(local_extractors)
+
+        # Yerel dizinde Extractor yoksa, global'leri yükle
+        if not extractors and self.global_extractors_dir.exists():
+            # konsol.log(f"[green][*] Global Extractor dizininden yükleniyor: {self.global_extractors_dir}[/green]")
+            global_extractors = self._load_from_directory(self.global_extractors_dir)
+            # konsol.log(f"[green]Global Extractor'lar: {[e.__name__ for e in global_extractors]}[/green]")
+            extractors.extend(global_extractors)
 
         # Benzersizliği sağlama (modül adı + sınıf adı bazında)
         unique_extractors = []
@@ -57,9 +60,10 @@ class ExtractorLoader:
             if file.endswith(".py") and not file.startswith("__"):
                 module_name = file[:-3] # .py uzantısını kaldır
                 # konsol.log(f"[cyan]Okunan Dosya\t\t: {module_name}[/cyan]")
-                if extractor := self._load_extractor(directory, module_name):
-                    # konsol.log(f"[magenta]Extractor Yüklendi\t: {extractor.__name__}[/magenta]")
-                    extractors.append(extractor)
+                module_extractors = self._load_extractor(directory, module_name)
+                if module_extractors:
+                    # konsol.log(f"[magenta]Extractor Yüklendi\t: {[e.__name__ for e in module_extractors]}[/magenta]")
+                    extractors.extend(module_extractors)
 
         # konsol.log(f"[yellow]{directory} dizininden yüklenen Extractor'lar: {[e.__name__ for e in extractors]}[/yellow]")
         return extractors
@@ -70,21 +74,25 @@ class ExtractorLoader:
             path = directory / f"{module_name}.py"
             spec = importlib.util.spec_from_file_location(module_name, path)
             if not spec or not spec.loader:
-                return None
+                return []
 
             # Modülü içe aktar
             module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(module)
 
-            # Yalnızca doğru modülden gelen ExtractorBase sınıflarını yükle
+            # Yalnızca doğru modülden gelen ExtractorBase sınıflarını yükle (TÜM CLASS'LAR)
+            extractors = []
             for attr in dir(module):
                 obj = getattr(module, attr)
-                if obj.__module__ == module_name and isinstance(obj, type) and issubclass(obj, ExtractorBase) and obj is not ExtractorBase:
+                # isinstance kontrolünü __module__ kontrolünden ÖNCE yap
+                if isinstance(obj, type) and issubclass(obj, ExtractorBase) and obj is not ExtractorBase and obj.__module__ == module_name:
                     # konsol.log(f"[green]Yüklenen sınıf\t\t: {module_name}.{obj.__name__} ({obj.__module__}.{obj.__name__})[/green]")
-                    return obj
+                    extractors.append(obj)
+            
+            return extractors
 
         except Exception as hata:
             konsol.log(f"[red][!] Extractor yüklenirken hata oluştu: {module_name}\nHata: {hata}")
             konsol.print(f"[dim]{traceback.format_exc()}[/dim]")
 
-        return None
+        return []

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Core/Extractor/ExtractorManager.py

@@ -63,7 +63,7 @@ class ExtractorManager:
         """
         # Lazy loading: İlk kullanımda extractorları initialize et
         self._ensure_initialized()
-        
+
         mapping = {}
         for link in links:
             # Cached instance'ları kullan

kekikstream-2.1.0/KekikStream/Core/Extractor/YTDLPCache.py

@@ -0,0 +1,35 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from Kekik.cli        import konsol
+from yt_dlp.extractor import gen_extractors
+
+# Global cache (module-level singleton)
+_YTDLP_EXTRACTORS_CACHE = None
+_CACHE_INITIALIZED      = False
+
+def get_ytdlp_extractors() -> list:
+    """
+    yt-dlp extractorlarını cache'le ve döndür
+
+    Returns:
+        list: yt-dlp extractor sınıfları
+    """
+    global _YTDLP_EXTRACTORS_CACHE, _CACHE_INITIALIZED
+
+    if _CACHE_INITIALIZED:
+        return _YTDLP_EXTRACTORS_CACHE
+
+    try:
+        extractors = list(gen_extractors())
+        extractors = [ie for ie in extractors if ie.ie_key() != 'Generic']
+
+        _YTDLP_EXTRACTORS_CACHE = extractors
+        _CACHE_INITIALIZED      = True
+
+        return extractors
+
+    except Exception as e:
+        konsol.log(f"[red][⚠] yt-dlp extractor cache hatası: {e}[/red]")
+        _YTDLP_EXTRACTORS_CACHE = []
+        _CACHE_INITIALIZED      = True
+        return []

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Core/Plugin/PluginBase.py

@@ -1,11 +1,13 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
+from ...CLI                       import konsol
 from abc                          import ABC, abstractmethod
 from cloudscraper                 import CloudScraper
 from httpx                        import AsyncClient
 from .PluginModels                import MainPageResult, SearchResult, MovieInfo
 from ..Media.MediaHandler         import MediaHandler
 from ..Extractor.ExtractorManager import ExtractorManager
+from ..Extractor.ExtractorModels  import ExtractResult
 from urllib.parse                 import urljoin
 import re
 
@@ -34,7 +36,10 @@ class PluginBase(ABC):
         )
         self.httpx.headers.update(self.cloudscraper.headers)
         self.httpx.cookies.update(self.cloudscraper.cookies)
-        self.httpx.headers.update({"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:135.0) Gecko/20100101 Firefox/135.0"})
+        self.httpx.headers.update({
+            "User-Agent" : "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:135.0) Gecko/20100101 Firefox/135.0",
+            "Accept"     : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        })
 
         self.media_handler = MediaHandler()
         self.ex_manager    = ExtractorManager()
@@ -92,6 +97,41 @@ class PluginBase(ABC):
 
         return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
 
+    async def extract(self, url: str, referer: str = None, prefix: str | None = None) -> dict | None:
+        """
+        Extractor ile video URL'sini çıkarır.
+
+        Args:
+            url: Iframe veya video URL'si
+            referer: Referer header (varsayılan: plugin main_url)
+            prefix: İsmin başına eklenecek opsiyonel etiket (örn: "Türkçe Dublaj")
+
+        Returns:
+            dict: Extractor sonucu (name prefix ile birleştirilmiş) veya None
+            
+        Extractor bulunamadığında veya hata oluştuğunda uyarı verir.
+        """
+        if referer is None:
+            referer = f"{self.main_url}/"
+
+        extractor = self.ex_manager.find_extractor(url)
+        if not extractor:
+            konsol.log(f"[magenta][?] {self.name} » Extractor bulunamadı: {url}")
+            return None
+
+        try:
+            data = await extractor.extract(url, referer=referer)
+            result = data.dict()
+            
+            # prefix varsa name'e ekle
+            if prefix and result.get("name"):
+                result["name"] = f"{prefix} | {result['name']}"
+            
+            return result
+        except Exception as hata:
+            konsol.log(f"[red][!] {self.name} » Extractor hatası ({extractor.name}): {hata}")
+            return None
+
     @staticmethod
     def clean_title(title: str) -> str:
         suffixes = [
@@ -116,4 +156,16 @@ class PluginBase(ABC):
         for suffix in suffixes:
             cleaned_title = re.sub(f"{re.escape(suffix)}.*$", "", cleaned_title, flags=re.IGNORECASE).strip()
 
-        return cleaned_title
+        return cleaned_title
+
+    async def play(self, **kwargs):
+        """
+        Varsayılan oynatma metodu.
+        Tüm pluginlerde ortak kullanılır.
+        """
+        extract_result = ExtractResult(**kwargs)
+        self.media_handler.title = kwargs.get("name")
+        if self.name not in self.media_handler.title:
+            self.media_handler.title = f"{self.name} | {self.media_handler.title}"
+
+        self.media_handler.play_media(extract_result)

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Core/Plugin/PluginLoader.py

@@ -19,15 +19,19 @@ class PluginLoader:
     def load_all(self) -> dict[str, PluginBase]:
         plugins = {}
 
-        # Global eklentileri yükle
-        if self.global_plugins_dir.exists():
-            # konsol.log(f"[green][*] Global Eklenti dizininden yükleniyor: {self.global_plugins_dir}[/green]")
-            plugins |= self._load_from_directory(self.global_plugins_dir)
-
-        # Yerel eklentileri yükle
+        # Eğer yerel dizinde Plugin varsa, sadece onları yükle (eklenti geliştirme modu)
         if self.local_plugins_dir.exists():
             # konsol.log(f"[green][*] Yerel Eklenti dizininden yükleniyor: {self.local_plugins_dir}[/green]")
-            plugins |= self._load_from_directory(self.local_plugins_dir)
+            local_plugins = self._load_from_directory(self.local_plugins_dir)
+
+            if local_plugins:
+                # konsol.log("[cyan][*] Yerel Plugin bulundu, global Plugin'ler atlanıyor (eklenti geliştirme modu)[/cyan]")
+                plugins |= local_plugins
+
+        # Yerel dizinde Plugin yoksa, global'leri yükle
+        if not plugins and self.global_plugins_dir.exists():
+            # konsol.log(f"[green][*] Global Eklenti dizininden yükleniyor: {self.global_plugins_dir}[/green]")
+            plugins |= self._load_from_directory(self.global_plugins_dir)
 
         if not plugins:
             konsol.print("[yellow][!] Yüklenecek bir Eklenti bulunamadı![/yellow]")

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Core/__init__.py

@@ -13,6 +13,7 @@ from .Extractor.ExtractorManager import ExtractorManager
 from .Extractor.ExtractorBase    import ExtractorBase
 from .Extractor.ExtractorLoader  import ExtractorLoader
 from .Extractor.ExtractorModels  import ExtractResult, Subtitle
+from .Extractor.YTDLPCache       import get_ytdlp_extractors
 
 from .Media.MediaManager import MediaManager
 from .Media.MediaHandler import MediaHandler

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Extractors/CloseLoad.py

@@ -6,7 +6,7 @@ import re
 
 class CloseLoadExtractor(ExtractorBase):
     name     = "CloseLoad"
-    main_url = "https://closeload.filmmakinesi.sh"
+    main_url = "https://closeload.filmmakinesi.to"
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Extractors/ContentX.py

@@ -7,10 +7,26 @@ class ContentX(ExtractorBase):
     name     = "ContentX"
     main_url = "https://contentx.me"
 
+    # Birden fazla domain destekle
+    supported_domains = [
+        "contentx.me", "four.contentx.me",
+        "dplayer82.site", "sn.dplayer82.site", "four.dplayer82.site", "org.dplayer82.site",
+        "dplayer74.site", "sn.dplayer74.site",
+        "hotlinger.com", "sn.hotlinger.com",
+        "playru.net", "four.playru.net",
+        "pichive.online", "four.pichive.online", "pichive.me", "four.pichive.me"
+    ]
+
+    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})
 
+        # Dinamik base URL kullan
+        base_url = self.get_base_url(url)
+
         istek = await self.httpx.get(url)
         istek.raise_for_status()
         i_source = istek.text
@@ -39,7 +55,8 @@ class ContentX(ExtractorBase):
                 )
             )
 
-        vid_source_request = await self.httpx.get(f"{self.main_url}/source2.php?v={i_extract_value}", headers={"Referer": referer or self.main_url})
+        # 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
@@ -59,7 +76,7 @@ class ContentX(ExtractorBase):
 
         if i_dublaj := re.search(r',\"([^"]+)\",\"Türkçe"', i_source):
             dublaj_value          = i_dublaj[1]
-            dublaj_source_request = await self.httpx.get(f"{self.main_url}/source2.php?v={dublaj_value}", headers={"Referer": referer or self.main_url})
+            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

kekikstream-2.1.0/KekikStream/Extractors/DonilasPlay.py

@@ -0,0 +1,86 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from Kekik.Sifreleme   import AESManager
+import re, json
+
+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
+        be_player_match = re.search(r"bePlayer\('([^']+)',\s*'(\{[^}]+\})'\);", i_source)
+        if be_player_match:
+            be_player_pass = be_player_match.group(1)
+            be_player_data = be_player_match.group(2)
+
+            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 = re.search(r'file:"([^"]+)"', i_source)
+            if file_match:
+                m3u_link = file_match.group(1)
+
+            # tracks pattern for subtitles
+            tracks_match = re.search(r'tracks:\[([^\]]+)', i_source)
+            if tracks_match:
+                try:
+                    tracks_str = f"[{tracks_match.group(1)}]"
+                    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
+        )

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Extractors/Odnoklassniki.py

@@ -7,6 +7,12 @@ 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/")

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Extractors/PeaceMakerst.py

@@ -7,6 +7,12 @@ 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})

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Extractors/PlayerFilmIzle.py

@@ -1,12 +1,15 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
-import re, json
+import re
 
 class PlayerFilmIzle(ExtractorBase):
     name     = "PlayerFilmIzle"
     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:
         # Kotlin tarafında referer mainUrl olarak zorlanmış
         ext_ref = self.main_url
@@ -29,20 +32,20 @@ class PlayerFilmIzle(ExtractorBase):
         # Data yakalama: FirePlayer|DATA|...
         data_match = re.search(r'FirePlayer\|([^|]+)\|', video_req, re.IGNORECASE)
         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("\\", "")
 

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Extractors/RapidVid.py

@@ -8,6 +8,12 @@ class RapidVid(ExtractorBase):
     name     = "RapidVid"
     main_url = "https://rapidvid.net"
 
+    # Birden fazla domain destekle
+    supported_domains = ["rapidvid.net", "rapid.filmmakinesi.to"]
+
+    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})

{kekikstream-1.9.9 → kekikstream-2.1.0}/KekikStream/Extractors/SetPlay.py

@@ -1,11 +1,18 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult
+from urllib.parse import urlparse, parse_qs
 import re
 
 class SetPlay(ExtractorBase):
     name     = "SetPlay"
-    main_url = "https://setplay.cfd"
+    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 ""
@@ -13,6 +20,9 @@ class SetPlay(ExtractorBase):
         if referer:
             self.httpx.headers.update({"Referer": referer})
 
+        # Dinamik base URL kullan
+        base_url = self.get_base_url(url)
+
         istek = await self.httpx.get(url)
         istek.raise_for_status()
 
@@ -33,7 +43,6 @@ class SetPlay(ExtractorBase):
         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]
@@ -46,8 +55,8 @@ class SetPlay(ExtractorBase):
         else:
             name_suffix = title_base
 
-        # M3U8 link oluştur
-        m3u_link = f"{self.main_url}{video_url}?s={video_server}"
+        # M3U8 link oluştur - base_url kullan (main_url yerine)
+        m3u_link = f"{base_url}{video_url}?s={video_server}"
 
         return ExtractResult(
             name      = f"{self.name} - {name_suffix}",

kekikstream-2.1.0/KekikStream/Extractors/VCTPlay.py

@@ -0,0 +1,41 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from urllib.parse     import urlparse, parse_qs
+
+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})
+
+        # 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
+
+        return ExtractResult(
+            name      = display_name,
+            url       = master_url,
+            referer   = f"{self.main_url}/",
+            subtitles = []
+        )