KekikStream 1.7.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

KekikStream/Core/Extractor/ExtractorBase.py

@@ -1,11 +1,11 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from abc              import ABC, abstractmethod
-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
+from urllib.parse     import urljoin, urlparse
 
 class ExtractorBase(ABC):
     # Çıkarıcının temel özellikleri
@@ -13,24 +13,35 @@ class ExtractorBase(ABC):
     main_url = ""
 
     def __init__(self):
-        # HTTP istekleri için oturum oluştur
-        self.cffi         = AsyncSession(impersonate="firefox135")
+        # cloudscraper - for bypassing Cloudflare
         self.cloudscraper = CloudScraper()
-        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"})
+
+        # httpx - lightweight and safe for most HTTP requests
+        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",
+            "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
         pass
 
     async def close(self):
-        # HTTP oturumunu güvenli bir şekilde kapat
-        await self.cffi.close()
+        """Close HTTP client."""
+        await self.httpx.aclose()
 
     def fix_url(self, url: str) -> str:
         # Eksik URL'leri düzelt ve tam URL formatına çevir
@@ -40,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/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

@@ -7,25 +7,69 @@ class ExtractorManager:
     def __init__(self, extractor_dir="Extractors"):
         # Çıkarıcı yükleyiciyi başlat ve tüm çıkarıcıları yükle
         self.extractor_loader = ExtractorLoader(extractor_dir)
-        self.extractors       = self.extractor_loader.load_all()
+        self.extractors       = self.extractor_loader.load_all()  # Sadece class'lar
 
-    def find_extractor(self, link) -> ExtractorBase:
-        # Verilen bağlantıyı işleyebilecek çıkarıcıyı bul
+        # Lazy loading: Instance'lar ilk kullanımda oluşturulacak
+        self._extractor_instances = None  # None = henüz oluşturulmadı
+        self._ytdlp_extractor     = None
+        self._initialized         = False
+
+    def _ensure_initialized(self):
+        """
+        Lazy initialization: İlk kullanımda TÜM extractorları initialize et
+
+        Startup'ta sadece class'ları yükledik (hızlı).
+        Şimdi instance'ları oluştur ve cache'le (bir kere).
+        """
+        if self._initialized:
+            return
+
+        # Instance listesi oluştur
+        self._extractor_instances = []
+
+        # TÜM extractorları instance'la
         for extractor_cls in self.extractors:
-            extractor:ExtractorBase = extractor_cls()
+            instance = extractor_cls()
+
+            # YTDLP'yi ayrı tut
+            if instance.name == "yt-dlp":
+                self._ytdlp_extractor = instance
+            else:
+                self._extractor_instances.append(instance)
+
+        # YTDLP'yi EN BAŞA ekle
+        if self._ytdlp_extractor:
+            self._extractor_instances.insert(0, self._ytdlp_extractor)
+
+        self._initialized = True
+
+    def find_extractor(self, link) -> ExtractorBase:
+        """
+        Verilen bağlantıyı işleyebilecek çıkarıcıyı bul
+        """
+        # Lazy loading: İlk kullanımda extractorları initialize et
+        self._ensure_initialized()
+
+        # Cached instance'ları kullan
+        for extractor in self._extractor_instances:
             if extractor.can_handle_url(link):
                 return extractor
 
         return None
 
     def map_links_to_extractors(self, links) -> dict:
-        # Bağlantıları uygun çıkarıcılarla eşleştir
+        """
+        Bağlantıları uygun çıkarıcılarla eşleştir
+        """
+        # Lazy loading: İlk kullanımda extractorları initialize et
+        self._ensure_initialized()
+
         mapping = {}
         for link in links:
-            for extractor_cls in self.extractors:
-                extractor:ExtractorBase = extractor_cls()
+            # Cached instance'ları kullan
+            for extractor in self._extractor_instances:
                 if extractor.can_handle_url(link):
                     mapping[link] = f"{extractor.name:<30} » {link.replace(extractor.main_url, '')}"
-                    break
+                    break  # İlk eşleşmede dur
 
-        return mapping
+        return mapping

KekikStream/Core/Extractor/ExtractorModels.py

@@ -1,8 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from pydantic import BaseModel
-from typing   import List, Optional
-
 
 class Subtitle(BaseModel):
     """Altyazı modeli."""
@@ -12,8 +10,8 @@ class Subtitle(BaseModel):
 
 class ExtractResult(BaseModel):
     """Extractor'ın döndürmesi gereken sonuç modeli."""
-    name      : str
-    url       : str
-    referer   : str
-    headers   : Optional[dict] = {}
-    subtitles : List[Subtitle] = []
+    name       : str
+    url        : str
+    referer    : str | None     = None
+    user_agent : str | None     = None
+    subtitles  : list[Subtitle] = []

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/Media/MediaHandler.py

@@ -5,36 +5,47 @@ from ..Extractor.ExtractorModels import ExtractResult
 import subprocess, os
 
 class MediaHandler:
-    def __init__(self, title: str = "KekikStream", headers: dict = None):
-        # Varsayılan HTTP başlıklarını ayarla
-        if headers is None:
-            headers = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5)"}
-
-        self.headers = headers
+    def __init__(self, title: str = "KekikStream"):
         self.title   = title
+        self.headers = {}
 
     def play_media(self, extract_data: ExtractResult):
-        # Referer varsa headers'a ekle
-        if extract_data.referer:
-            self.headers.update({"Referer": extract_data.referer})
+        # user-agent ekle (varsayılan veya extract_data'dan)
+        user_agent = extract_data.user_agent or "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5)"
+        self.headers["user-agent"] = user_agent
 
-        # ExtractResult'tan gelen headers'ları ekle
-        if extract_data.headers:
-            self.headers.update(extract_data.headers)
+        # referer ekle
+        if extract_data.referer:
+            self.headers["referer"] = extract_data.referer
 
-        # Google Drive gibi özel durumlar için yt-dlp kullan
-        if self.headers.get("User-Agent") in ["googleusercontent", "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0"]:
+        # Özel Durumlar (RecTV vs. Googleusercontent)
+        if user_agent in ["googleusercontent", "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0"]:
             return self.play_with_ytdlp(extract_data)
 
-        # İşletim sistemine göre oynatıcı seç
+        # İşletim sistemine göre oynatıcı seç (Android durumu)
         if subprocess.check_output(['uname', '-o']).strip() == b'Android':
             return self.play_with_android_mxplayer(extract_data)
 
-        # Cookie veya alt yazılar varsa mpv kullan
-        if "Cookie" in self.headers or extract_data.subtitles:
-            return self.play_with_mpv(extract_data)
+        # Oynatıcı öncelik sırası (fallback zincirleme)
+        players = [
+            ("MPV", self.play_with_mpv),
+            ("VLC", self.play_with_vlc),
+            ("yt-dlp", self.play_with_ytdlp)
+        ]
 
-        return self.play_with_vlc(extract_data) or self.play_with_mpv(extract_data)
+        # Fallback zincirleme
+        for player_name, player_func in players:
+            try:
+                result = player_func(extract_data)
+                if result or result is None:  # None = MPV (exception yok)
+                    konsol.log(f"[green][✓] {player_name} ile başarılı[/green]")
+                    return True
+            except Exception as e:
+                konsol.log(f"[yellow][⚠] {player_name} hatası: {e}[/yellow]")
+                continue
+
+        konsol.print("[red][✗] Hiçbir oynatıcı çalışmadı![/red]")
+        return False
 
     def play_with_vlc(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] VLC ile Oynatılıyor : {extract_data.url}")
@@ -48,11 +59,11 @@ class MediaHandler:
                     f"--input-title-format={self.title}"
                 ])
 
-            if "User-Agent" in self.headers:
-                vlc_command.append(f"--http-user-agent={self.headers.get('User-Agent')}")
+            if "user-agent" in self.headers:
+                vlc_command.append(f"--http-user-agent={self.headers.get('user-agent')}")
 
-            if "Referer" in self.headers:
-                vlc_command.append(f"--http-referrer={self.headers.get('Referer')}")
+            if "referer" in self.headers:
+                vlc_command.append(f"--http-referrer={self.headers.get('referer')}")
 
             vlc_command.extend(
                 f"--sub-file={subtitle.url}" for subtitle in extract_data.subtitles
@@ -92,12 +103,15 @@ class MediaHandler:
             with open(os.devnull, "w") as devnull:
                 subprocess.run(mpv_command, stdout=devnull, stderr=devnull, check=True)
 
+            return True
         except subprocess.CalledProcessError as hata:
             konsol.print(f"[red]mpv oynatma hatası: {hata}[/red]")
             konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
         except FileNotFoundError:
             konsol.print("[red]mpv bulunamadı! mpv kurulu olduğundan emin olun.[/red]")
             konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
 
     def play_with_ytdlp(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] yt-dlp ile Oynatılıyor : {extract_data.url}")
@@ -125,12 +139,15 @@ class MediaHandler:
             with subprocess.Popen(ytdlp_command, stdout=subprocess.PIPE) as ytdlp_proc:
                 subprocess.run(mpv_command, stdin=ytdlp_proc.stdout, check=True)
 
+            return True
         except subprocess.CalledProcessError as hata:
             konsol.print(f"[red]Oynatma hatası: {hata}[/red]")
             konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
         except FileNotFoundError:
             konsol.print("[red]yt-dlp veya mpv bulunamadı! Kurulumlarından emin olun.[/red]")
             konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
 
     def play_with_android_mxplayer(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] MxPlayer ile Oynatılıyor : {extract_data.url}")
@@ -155,11 +172,12 @@ class MediaHandler:
                 with open(os.devnull, "w") as devnull:
                     subprocess.run(android_command, stdout=devnull, stderr=devnull, check=True)
 
-                return
-
+                return True
             except subprocess.CalledProcessError as hata:
                 konsol.print(f"[red]{paket} oynatma hatası: {hata}[/red]")
                 konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+                return False
             except FileNotFoundError:
                 konsol.print(f"Paket: {paket}, Hata: MX Player kurulu değil")
-                konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+                konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+                return False

KekikStream/Core/Media/MediaManager.py

@@ -12,8 +12,5 @@ class MediaManager:
     def get_title(self):
         return self.media_handler.title
 
-    def set_headers(self, headers):
-        self.media_handler.headers.update(headers)
-
     def play_media(self, extract_data):
         self.media_handler.play_media(extract_data)

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 curl_cffi                    import AsyncSession
 from cloudscraper                 import CloudScraper
-from .PluginModels                import MainPageResult, SearchResult, MovieInfo
+from httpx                        import AsyncClient
+from .PluginModels                import MainPageResult, SearchResult, MovieInfo, SeriesInfo
 from ..Media.MediaHandler         import MediaHandler
 from ..Extractor.ExtractorManager import ExtractorManager
+from ..Extractor.ExtractorModels  import ExtractResult
 from urllib.parse                 import urljoin
 import re
 
@@ -24,17 +26,28 @@ class PluginBase(ABC):
         self.main_url  = new_url
 
     def __init__(self):
-        self.cffi         = AsyncSession(impersonate="firefox135")
+        # cloudscraper - for bypassing Cloudflare
         self.cloudscraper = CloudScraper()
-        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"})
+
+        # httpx - lightweight and safe for most HTTP requests
+        self.httpx = AsyncClient(
+            timeout          = 3,
+            follow_redirects = True
+        )
+        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",
+            "Accept"     : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        })
+
         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 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]:
@@ -42,37 +55,38 @@ class PluginBase(ABC):
         pass
 
     @abstractmethod
-    async def load_item(self, url: str) -> MovieInfo:
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         """Bir medya öğesi hakkında detaylı bilgi döndürür."""
         pass
 
     @abstractmethod
-    async def load_links(self, url: str) -> list[dict]:
+    async def load_links(self, url: str) -> list[ExtractResult]:
         """
         Bir medya öğesi için oynatma bağlantılarını döndürür.
-        
+
         Args:
             url: Medya URL'si
-            
+
         Returns:
-            Dictionary listesi, her biri şu alanları içerir:
+            ExtractResult listesi, her biri şu alanları içerir:
             - url (str, zorunlu): Video URL'si
             - name (str, zorunlu): Gösterim adı (tüm bilgileri içerir)
             - referer (str, opsiyonel): Referer header
-            - subtitles (list, opsiyonel): Altyazı listesi
-        
+            - subtitles (list[Subtitle], opsiyonel): Altyazı listesi
+
         Example:
             [
-                {
-                    "url": "https://example.com/video.m3u8",
-                    "name": "HDFilmCehennemi | 1080p TR Dublaj"
-                }
+                ExtractResult(
+                    url="https://example.com/video.m3u8",
+                    name="HDFilmCehennemi | 1080p TR Dublaj"
+                )
             ]
         """
         pass
 
     async def close(self):
-        await self.cffi.close()
+        """Close HTTP client."""
+        await self.httpx.aclose()
 
     def fix_url(self, url: str) -> str:
         if not url:
@@ -83,6 +97,40 @@ 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) -> ExtractResult | 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:
+            ExtractResult: 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)
+
+            # prefix varsa name'e ekle
+            if prefix and data.name:
+                data.name = f"{prefix} | {data.name}"
+
+            return data
+        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 = [
@@ -107,4 +155,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/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]")