KekikStream 1.0.5__tar.gz → 2.4.6__tar.gz

{kekikstream-1.0.5 → kekikstream-2.4.6}/KekikStream/CLI/pypi_kontrol.py

@@ -1,16 +1,16 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from .             import konsol
-from rich.panel    import Panel
-from pkg_resources import get_distribution
-from requests      import get
-from subprocess    import check_call
+from .          import konsol
+from rich.panel import Panel
+from importlib  import metadata
+from requests   import get
+from subprocess import check_call
 import sys
 
 def pypi_kontrol_guncelle(paket_adi: str):
     try:
         konsol.print(f"[bold cyan] {paket_adi} Güncellemesi kontrol ediliyor...[/bold cyan]")
-        mevcut_surum = get_distribution(paket_adi).version
+        mevcut_surum = metadata.version(paket_adi)
         konsol.print(Panel(f"[cyan]Yüklü sürüm:[/cyan] [bold yellow]{mevcut_surum}[/bold yellow]"))
 
         istek = get(f"https://pypi.org/pypi/{paket_adi}/json")

kekikstream-2.4.6/KekikStream/Core/Extractor/ExtractorBase.py

@@ -0,0 +1,55 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from abc              import ABC, abstractmethod
+from cloudscraper     import CloudScraper
+from httpx            import AsyncClient
+from typing           import Optional
+from .ExtractorModels import ExtractResult
+from urllib.parse     import urljoin, urlparse
+
+class ExtractorBase(ABC):
+    # Çıkarıcının temel özellikleri
+    name     = "Extractor"
+    main_url = ""
+
+    def __init__(self):
+        # cloudscraper - for bypassing Cloudflare
+        self.cloudscraper = CloudScraper()
+
+        # 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):
+        """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
+        if not url:
+            return ""
+
+        if url.startswith("http") or url.startswith("{\""):
+            return url.replace("\\", "")
+
+        url = f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        return url.replace("\\", "")

{kekikstream-1.0.5 → kekikstream-2.4.6}/KekikStream/Core/Extractor/ExtractorLoader.py

@@ -3,7 +3,7 @@
 from ...CLI         import konsol, cikis_yap
 from .ExtractorBase import ExtractorBase
 from pathlib        import Path
-import os, importlib.util
+import os, importlib.util, traceback
 
 class ExtractorLoader:
     def __init__(self, extractors_dir: str):
@@ -13,25 +13,28 @@ class ExtractorLoader:
 
         # Dizin kontrolü
         if not self.local_extractors_dir.exists() and not self.global_extractors_dir.exists():
-            konsol.log(f"[red][!] Extractor dizini bulunamadı: {self.global_extractors_dir}[/red]")
+            # konsol.log(f"[red][!] Extractor dizini bulunamadı: {self.global_extractors_dir}[/red]")
             cikis_yap(False)
 
     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]")
+            # 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)
+            # konsol.log(f"[green]Yerel Extractor'lar: {[e.__name__ for e in local_extractors]}[/green]")
+
+            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 = []
@@ -42,7 +45,7 @@ class ExtractorLoader:
                 unique_extractors.append(ext)
                 seen_names.add(identifier)
 
-        konsol.log(f"[blue]Sonuç Extractor'lar: {[e.__name__ for e in unique_extractors]}[/blue]")
+        # konsol.log(f"[blue]Sonuç Extractor'lar: {[e.__name__ for e in unique_extractors]}[/blue]")
 
         if not unique_extractors:
             konsol.log("[yellow][!] Yüklenecek bir Extractor bulunamadı![/yellow]")
@@ -56,12 +59,13 @@ class ExtractorLoader:
         for file in os.listdir(directory):
             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)
+                # konsol.log(f"[cyan]Okunan Dosya\t\t: {module_name}[/cyan]")
+                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]")
+        # konsol.log(f"[yellow]{directory} dizininden yüklenen Extractor'lar: {[e.__name__ for e in extractors]}[/yellow]")
         return extractors
 
     def _load_extractor(self, directory: Path, module_name: str):
@@ -70,20 +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:
-                    konsol.log(f"[green]Yüklenen sınıf\t\t: {module_name}.{obj.__name__} ({obj.__module__}.{obj.__name__})[/green]")
-                    return obj
+                # 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]")
+                    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-2.4.6/KekikStream/Core/Extractor/ExtractorManager.py

@@ -0,0 +1,75 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from .ExtractorLoader import ExtractorLoader
+from .ExtractorBase   import ExtractorBase
+
+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()  # Sadece class'lar
+
+        # 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:
+            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
+        """
+        # Lazy loading: İlk kullanımda extractorları initialize et
+        self._ensure_initialized()
+
+        mapping = {}
+        for link in links:
+            # 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  # İlk eşleşmede dur
+
+        return mapping

{kekikstream-1.0.5 → kekikstream-2.4.6}/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
-    subtitles : List[Subtitle] = []
-    headers   : Optional[dict] = {}
+    name       : str
+    url        : str
+    referer    : str | None     = None
+    user_agent : str | None     = None
+    subtitles  : list[Subtitle] = []

kekikstream-2.4.6/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-2.4.6/KekikStream/Core/HTMLHelper.py

@@ -0,0 +1,205 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from __future__ import annotations
+
+import re
+from selectolax.parser import HTMLParser, Node
+
+
+class HTMLHelper:
+    """
+    Selectolax ile HTML parsing işlemlerini temiz, kısa ve okunabilir hale getiren yardımcı sınıf.
+    """
+
+    def __init__(self, html: str):
+        self.html   = html
+        self.parser = HTMLParser(html)
+
+    # ========================
+    # SELECTOR (CSS) İŞLEMLERİ
+    # ========================
+
+    def _root(self, element: Node | None) -> Node | HTMLParser:
+        """İşlem yapılacak temel elementi döndürür."""
+        return element if element is not None else self.parser
+
+    def select(self, selector: str, element: Node | None = None) -> list[Node]:
+        """CSS selector ile tüm eşleşen elementleri döndür."""
+        return self._root(element).css(selector)
+
+    def select_first(self, selector: str | None, element: Node | None = None) -> Node | None:
+        """CSS selector ile ilk eşleşen elementi döndür."""
+        if not selector:
+            return element
+        return self._root(element).css_first(selector)
+
+    def select_text(self, selector: str | None = None, element: Node | None = None) -> str | None:
+        """CSS selector ile element bul ve text içeriğini döndür."""
+        el = self.select_first(selector, element)
+        if not el:
+            return None
+        val = el.text(strip=True)
+        return val or None
+
+    def select_texts(self, selector: str, element: Node | None = None) -> list[str]:
+        """CSS selector ile tüm eşleşen elementlerin text içeriklerini döndür."""
+        out: list[str] = []
+        for el in self.select(selector, element):
+            txt = el.text(strip=True)
+            if txt:
+                out.append(txt)
+        return out
+
+    def select_attr(self, selector: str | None, attr: str, element: Node | None = None) -> str | None:
+        """CSS selector ile element bul ve attribute değerini döndür."""
+        el = self.select_first(selector, element)
+        return el.attrs.get(attr) if el else None
+
+    def select_attrs(self, selector: str, attr: str, element: Node | None = None) -> list[str]:
+        """CSS selector ile tüm eşleşen elementlerin attribute değerlerini döndür."""
+        out: list[str] = []
+        for el in self.select(selector, element):
+            val = el.attrs.get(attr)
+            if val:
+                out.append(val)
+        return out
+
+    def select_poster(self, selector: str = "img", element: Node | None = None) -> str | None:
+        """Poster URL'sini çıkar. Önce data-src, sonra src dener."""
+        el = self.select_first(selector, element)
+        if not el:
+            return None
+        return el.attrs.get("data-src") or el.attrs.get("src")
+
+    def select_direct_text(self, selector: str, element: Node | None = None) -> str | None:
+        """
+        Elementin yalnızca "kendi" düz metnini döndürür (child elementlerin text'ini katmadan).
+        """
+        el = self.select_first(selector, element)
+        if not el:
+            return None
+
+        # type: ignore[call-arg]
+        val = el.text(strip=True, deep=False)
+        return val or None
+
+    # ========================
+    # META (LABEL -> VALUE) İŞLEMLERİ
+    # ========================
+
+    def meta_value(self, label: str, container_selector: str | None = None) -> str | None:
+        """
+        Herhangi bir container içinde: LABEL metnini içeren bir elementten SONRA gelen metni döndürür.
+        label örn: "Oyuncular", "Yapım Yılı", "IMDB"
+        """
+        needle = label.casefold()
+
+        # Belirli bir container varsa içinde ara, yoksa tüm dökümanda
+        targets = self.select(container_selector) if container_selector else [self.parser.body]
+
+        for root in targets:
+            if not root: continue
+
+            # Kalın/vurgulu elementlerde (span, strong, b, label, dt) label'ı ara
+            for label_el in self.select("span, strong, b, label, dt", root):
+                txt = (label_el.text(strip=True) or "").casefold()
+                if needle not in txt:
+                    continue
+
+                # 1) Elementin kendi içindeki text'te LABEL: VALUE formatı olabilir
+                # "Oyuncular: Brad Pitt" gibi. LABEL: sonrasını al.
+                full_txt = label_el.text(strip=True)
+                if ":" in full_txt and needle in full_txt.split(":")[0].casefold():
+                    val = full_txt.split(":", 1)[1].strip()
+                    if val: return val
+
+                # 2) Label sonrası gelen ilk text node'u veya element'i al
+                curr = label_el.next
+                while curr:
+                    if curr.tag == "-text":
+                        val = curr.text(strip=True).strip(" :")
+                        if val: return val
+                    elif curr.tag != "br":
+                        val = curr.text(strip=True).strip(" :")
+                        if val: return val
+                    else: # <br> gördüysek satır bitmiştir
+                        break
+                    curr = curr.next
+
+        return None
+
+    def meta_list(self, label: str, container_selector: str | None = None, sep: str = ",") -> list[str]:
+        """meta_value(...) çıktısını veya label'ın ebeveynindeki linkleri listeye döndürür."""
+        needle = label.casefold()
+        targets = self.select(container_selector) if container_selector else [self.parser.body]
+
+        for root in targets:
+            if not root: continue
+            for label_el in self.select("span, strong, b, label, dt", root):
+                if needle in (label_el.text(strip=True) or "").casefold():
+                    # Eğer elementin ebeveyninde linkler varsa (Kutucuklu yapı), onları al
+                    links = self.select_texts("a", label_el.parent)
+                    if links: return links
+
+                    # Yoksa düz metin olarak meta_value mantığıyla al
+                    raw = self.meta_value(label, container_selector=container_selector)
+                    if not raw: return []
+                    return [x.strip() for x in raw.split(sep) if x.strip()]
+
+        return []
+
+    # ========================
+    # REGEX İŞLEMLERİ
+    # ========================
+
+    def _regex_source(self, target: str | int | None) -> str:
+        """Regex için kaynak metni döndürür."""
+        return target if isinstance(target, str) else self.html
+
+    def regex_first(self, pattern: str, target: str | int | None = None, group: int | None = 1) -> str | tuple | None:
+        """Regex ile arama yap, istenen grubu döndür (group=None ise tüm grupları tuple olarak döndür)."""
+        match = re.search(pattern, self._regex_source(target))
+        if not match:
+            return None
+            
+        if group is None:
+            return match.groups()
+            
+        last_idx = match.lastindex or 0
+        return match.group(group) if last_idx >= group else match.group(0)
+
+    def regex_all(self, pattern: str, target: str | int | None = None) -> list[str] | list[tuple]:
+        """Regex ile tüm eşleşmeleri döndür."""
+        return re.findall(pattern, self._regex_source(target))
+
+    def regex_replace(self, pattern: str, repl: str, target: str | int | None = None) -> str:
+        """Regex ile replace yap."""
+        return re.sub(pattern, repl, self._regex_source(target))
+
+    # ========================
+    # ÖZEL AYIKLAYICILAR
+    # ========================
+
+    @staticmethod
+    def extract_season_episode(text: str) -> tuple[int | None, int | None]:
+        """Metin içinden sezon ve bölüm numarasını çıkar."""
+        if m := re.search(r"[Ss](\d+)[Ee](\d+)", text):
+            return int(m.group(1)), int(m.group(2))
+
+        s = re.search(r"(\d+)\.\s*[Ss]ezon|[Ss]ezon[- ]?(\d+)|-(\d+)-sezon|S(\d+)|(\d+)\.[Ss]", text, re.I)
+        e = re.search(r"(\d+)\.\s*[Bb][öo]l[üu]m|[Bb][öo]l[üu]m[- ]?(\d+)|-(\d+)-bolum|[Ee](\d+)", text, re.I)
+
+        s_val = next((int(g) for g in s.groups() if g), None) if s else None
+        e_val = next((int(g) for g in e.groups() if g), None) if e else None
+
+        return s_val, e_val
+
+    def extract_year(self, *selectors: str, pattern: str = r"(\d{4})") -> int | None:
+        """Birden fazla selector veya regex ile yıl bilgisini çıkar."""
+        for selector in selectors:
+            if text := self.select_text(selector):
+                if m := re.search(r"(\d{4})", text):
+                    return int(m.group(1))
+
+        val = self.regex_first(pattern)
+        return int(val) if val and val.isdigit() else None