KekikStream 1.9.9__py3-none-any.whl → 2.0.8__py3-none-any.whl

KekikStream/Core/Extractor/ExtractorBase.py

@@ -17,13 +17,13 @@ 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

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/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/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/Core/Plugin/PluginBase.py

@@ -34,7 +34,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()

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/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/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/Extractors/ContentX.py

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

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/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/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/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/Extractors/SetPlay.py

@@ -5,7 +5,13 @@ 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 ""

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 = []
+        )

KekikStream/Extractors/VidMoly.py

@@ -9,6 +9,12 @@ class VidMoly(ExtractorBase):
     name     = "VidMoly"
     main_url = "https://vidmoly.to"
 
+    # Birden fazla domain destekle
+    supported_domains = ["vidmoly.to", "vidmoly.me", "vidmoly.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: str, referer: str = None) -> ExtractResult:
         if referer:
             self.httpx.headers.update({"Referer": referer})
@@ -17,11 +23,11 @@ class VidMoly(ExtractorBase):
             "Sec-Fetch-Dest" : "iframe",
         })
 
-        if self.main_url.endswith(".me"):
-            self.main_url = self.main_url.replace(".me", ".net")
+        if ".me" in url:
             url = url.replace(".me", ".net")
 
-        response = await self.httpx.get(url)
+        # VidMoly bazen redirect ediyor, takip et
+        response = await self.httpx.get(url, follow_redirects=True)
         if "Select number" in response.text:
             secici = Selector(response.text)
             response = await self.httpx.post(
@@ -33,21 +39,10 @@ class VidMoly(ExtractorBase):
                     "ts"        : secici.css("input[name='ts']::attr(value)").get(),
                     "nonce"     : secici.css("input[name='nonce']::attr(value)").get(),
                     "ctok"      : secici.css("input[name='ctok']::attr(value)").get()
-                }
+                },
+                follow_redirects=True
             )
 
-        script_match   = re.search(r"sources:\s*\[(.*?)\],", response.text, re.DOTALL)
-        script_content = script_match[1] if script_match else None
-
-        if not script_content:
-            raise ValueError("Gerekli script bulunamadı.")
-
-        # Video kaynaklarını ayrıştır
-        video_data = self._add_marks(script_content, "file")
-        try:
-            video_sources = json.loads(f"[{video_data}]")
-        except json.JSONDecodeError as hata:
-            raise ValueError("Video kaynakları ayrıştırılamadı.") from hata
 
         # Altyazı kaynaklarını ayrıştır
         subtitles = []
@@ -66,22 +61,49 @@ class VidMoly(ExtractorBase):
                         for sub in subtitle_sources
                             if sub.get("kind") == "captions"
                 ]
-        # İlk video kaynağını al
-        video_url = None
-        for source in video_sources:
-            if file_url := source.get("file"):
-                video_url = file_url
-                break
 
-        if not video_url:
-            raise ValueError("Video URL bulunamadı.")
+        script_match = re.search(r"sources:\s*\[(.*?)\],", response.text, re.DOTALL)
+        if script_match:
+            script_content = script_match[1]
+            # Video kaynaklarını ayrıştır
+            video_data = self._add_marks(script_content, "file")
+            try:
+                video_sources = json.loads(f"[{video_data}]")
+                # İlk video kaynağını al
+                for source in video_sources:
+                    if file_url := source.get("file"):
+                        return ExtractResult(
+                            name      = self.name,
+                            url       = file_url,
+                            referer   = self.main_url,
+                            subtitles = subtitles
+                        )
+            except json.JSONDecodeError:
+                pass
+
+        # Fallback: Doğrudan file regex ile ara (Kotlin mantığı)
+        # file:"..." veya file: "..."
+        if file_match := re.search(r'file\s*:\s*["\']([^"\']+\.m3u8[^"\']*)["\']', response.text):
+            return ExtractResult(
+                name      = self.name,
+                url       = file_match.group(1),
+                referer   = self.main_url,
+                subtitles = subtitles
+            )
+            
+        # Fallback 2: Herhangi bir file (m3u8 olma şartı olmadan ama tercihen)
+        if file_match := re.search(r'file\s*:\s*["\']([^"\']+)["\']', response.text):
+            url_candidate = file_match.group(1)
+            # Resim dosyalarını hariç tut
+            if not url_candidate.endswith(('.jpg', '.png', '.jpeg')):
+                return ExtractResult(
+                    name      = self.name,
+                    url       = url_candidate,
+                    referer   = self.main_url,
+                    subtitles = subtitles
+                )
 
-        return ExtractResult(
-            name      = self.name,
-            url       = video_url,
-            referer   = self.main_url,
-            subtitles = subtitles
-        )
+        raise ValueError("Video URL bulunamadı.")
 
     def _add_marks(self, text: str, field: str) -> str:
         """