KekikStream 1.4.4__py3-none-any.whl → 2.0.2__py3-none-any.whl

KekikStream/Extractors/YTDLP.py

@@ -0,0 +1,177 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, get_ytdlp_extractors
+from urllib.parse     import urlparse
+import yt_dlp, re, sys, os
+
+class YTDLP(ExtractorBase):
+    name     = "yt-dlp"
+    main_url = ""  # Universal - tüm siteleri destekler
+
+    _FAST_DOMAIN_RE = None  # compiled mega-regex (host üstünden)
+
+    @classmethod
+    def _init_fast_domain_regex(cls):
+        """
+        Fast domain regex'i initialize et
+        """
+        if cls._FAST_DOMAIN_RE is not None:
+            return
+
+        domains = set()
+
+        # Merkezi cache'den extractorları al
+        extractors = get_ytdlp_extractors()
+
+        # yt-dlp extractor'larının _VALID_URL regex'lerinden domain yakala
+        # Regex metinlerinde domainler genelde "\." şeklinde geçer.
+        domain_pat = re.compile(r"(?:[a-z0-9-]+\\\.)+[a-z]{2,}", re.IGNORECASE)
+
+        for ie in extractors:
+            valid = getattr(ie, "_VALID_URL", None)
+            if not valid or not isinstance(valid, str):
+                continue
+
+            for m in domain_pat.findall(valid):
+                d = m.replace(r"\.", ".").lower()
+
+                # Çok agresif/şüpheli şeyleri elemek istersen burada filtre koyabilirsin
+                # (genelde gerek kalmıyor)
+                domains.add(d)
+
+        # Hiç domain çıkmazsa (çok uç durum) fallback: boş regex
+        if not domains:
+            cls._FAST_DOMAIN_RE = re.compile(r"$^")  # hiçbir şeye match etmez
+            return
+
+        # Host eşleştirmesi: subdomain destekli (m.youtube.com, player.vimeo.com vs.)
+        # (?:^|.*\.) (domain1|domain2|...) $
+        joined = "|".join(sorted(re.escape(d) for d in domains))
+        pattern = rf"(?:^|.*\.)(?:{joined})$"
+        cls._FAST_DOMAIN_RE = re.compile(pattern, re.IGNORECASE)
+
+    def __init__(self):
+        self.__class__._init_fast_domain_regex()
+
+    def can_handle_url(self, url: str) -> bool:
+        """
+        Fast-path: URL host'unu tek mega-regex ile kontrol et (loop yok)
+        Slow-path: gerekirse mevcut extract_info tabanlı kontrolün
+        """
+        # URL parse + host al
+        try:
+            parsed = urlparse(url)
+            host = (parsed.hostname or "").lower()
+        except Exception:
+            host = ""
+
+        # Şemasız URL desteği: "youtube.com/..." gibi
+        if not host and "://" not in url:
+            try:
+                parsed = urlparse("https://" + url)
+                host = (parsed.hostname or "").lower()
+            except Exception:
+                host = ""
+
+        # Fast-path
+        if host and self.__class__._FAST_DOMAIN_RE.search(host):
+            return True
+
+        # SLOW PATH: Diğer siteler için yt-dlp'nin native kontrolü
+        try:
+            # stderr'ı geçici olarak kapat (hata mesajlarını gizle)
+            old_stderr = sys.stderr
+            sys.stderr = open(os.devnull, "w")
+
+            try:
+                ydl_opts = {
+                    "simulate"              : True,  # Download yok, sadece tespit
+                    "quiet"                 : True,  # Log kirliliği yok
+                    "no_warnings"           : True,  # Uyarı mesajları yok
+                    "extract_flat"          : True,  # Minimal işlem
+                    "no_check_certificates" : True,
+                    "ignoreerrors"          : True,  # Hataları yoksay
+                    "socket_timeout"        : 3,
+                    "retries"               : 1
+                }
+
+                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                    # URL'yi işleyebiliyor mu kontrol et
+                    info = ydl.extract_info(url, download=False, process=False)
+
+                    # Generic extractor ise atla
+                    if info and info.get("extractor_key") != "Generic":
+                        return True
+
+                    return False
+            finally:
+                # stderr'ı geri yükle
+                sys.stderr.close()
+                sys.stderr = old_stderr
+
+        except Exception:
+            # yt-dlp işleyemezse False döndür
+            return False
+
+    async def extract(self, url: str, referer: str | None = None) -> ExtractResult:
+        ydl_opts = {
+            "quiet"                 : True,
+            "no_warnings"           : True,
+            "extract_flat"          : False,   # Tam bilgi al
+            "format"                : "best",  # En iyi kalite
+            "no_check_certificates" : True,
+            "socket_timeout"        : 3,
+            "retries"               : 1
+        }
+
+        # Referer varsa header olarak ekle
+        if referer:
+            ydl_opts["http_headers"] = {"Referer": referer}
+
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=False)
+
+            if not info:
+                raise ValueError("yt-dlp video bilgisi döndürmedi")
+
+            # Video URL'sini al
+            video_url = info.get("url")
+            if not video_url:
+                # Bazen formatlar listesinde olabilir
+                formats = info.get("formats", [])
+                if formats:
+                    video_url = formats[-1].get("url")  # Son format (genellikle en iyi)
+
+            if not video_url:
+                raise ValueError("Video URL bulunamadı")
+
+            # Altyazıları çıkar
+            subtitles = []
+            if subtitle_data := info.get("subtitles"):
+                for lang, subs in subtitle_data.items():
+                    for sub in subs:
+                        if sub_url := sub.get("url"):
+                            subtitles.append(
+                                Subtitle(
+                                    name=f"{lang} ({sub.get('ext', 'unknown')})",
+                                    url=sub_url
+                                )
+                            )
+
+            # User-Agent al
+            user_agent = None
+            http_headers = info.get("http_headers", {})
+            if http_headers:
+                user_agent = http_headers.get("User-Agent")
+
+            return ExtractResult(
+                name       = self.name,
+                url        = video_url,
+                referer    = referer or info.get("webpage_url"),
+                user_agent = user_agent,
+                subtitles  = subtitles
+            )
+
+    async def close(self):
+        """yt-dlp için cleanup gerekmez"""
+        pass

KekikStream/Extractors/YildizKisaFilm.py

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

KekikStream/Plugins/DiziBox.py

@@ -1,9 +1,9 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import kekik_cache, PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
 from Kekik.Sifreleme  import CryptoJS
 from parsel           import Selector
-import re, urllib.parse, base64, contextlib, asyncio
+import re, urllib.parse, base64, contextlib, asyncio, time
 
 class DiziBox(PluginBase):
     name        = "DiziBox"
@@ -40,8 +40,11 @@ class DiziBox(PluginBase):
         f"{main_url}/dizi-arsivi/page/SAYFA/?tur[0]=yarisma&yil&imdb"    : "Yarışma"
     }
 
-    @kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        self.httpx.cookies.update({
+            "isTrustedUser" : "true",
+            "dbxu"          : str(time.time() * 1000).split(".")[0]
+        })
         istek = await self.httpx.get(
             url              = f"{url.replace('SAYFA', str(page))}",
             follow_redirects = True
@@ -58,12 +61,10 @@ class DiziBox(PluginBase):
                 for veri in secici.css("article.detailed-article")
         ]
 
-    @kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
         self.httpx.cookies.update({
-            "LockUser"      : "true",
             "isTrustedUser" : "true",
-            "dbxu"          : "1722403730363"
+            "dbxu"          : str(time.time() * 1000).split(".")[0]
         })
         istek  = await self.httpx.get(f"{self.main_url}/?s={query}")
         secici = Selector(istek.text)
@@ -77,7 +78,6 @@ class DiziBox(PluginBase):
                 for item in secici.css("article.detailed-article")
         ]
 
-    @kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> SeriesInfo:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
@@ -124,13 +124,17 @@ class DiziBox(PluginBase):
             actors      = actors,
         )
 
-    @kekik_cache(ttl=60*60)
     async def _iframe_decode(self, name:str, iframe_link:str, referer:str) -> list[str]:
         results = []
 
+        self.httpx.headers.update({"Referer": referer})
+        self.httpx.cookies.update({
+            "isTrustedUser" : "true",
+            "dbxu"          : str(time.time() * 1000).split(".")[0]
+        })
+
         if "/player/king/king.php" in iframe_link:
             iframe_link = iframe_link.replace("king.php?v=", "king.php?wmode=opaque&v=")
-            self.httpx.headers.update({"Referer": referer})
 
             istek  = await self.httpx.get(iframe_link)
             secici = Selector(istek.text)
@@ -150,7 +154,6 @@ class DiziBox(PluginBase):
 
         elif "/player/moly/moly.php" in iframe_link:
             iframe_link = iframe_link.replace("moly.php?h=", "moly.php?wmode=opaque&h=")
-            self.httpx.headers.update({"Referer": referer})
             while True:
                 await asyncio.sleep(.3)
                 with contextlib.suppress(Exception):
@@ -171,15 +174,19 @@ class DiziBox(PluginBase):
 
         return results
 
-    @kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[str]:
+    async def load_links(self, url: str) -> list[dict]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
-        iframes = []
+        results = []
         if main_iframe := secici.css("div#video-area iframe::attr(src)").get():
             if decoded := await self._iframe_decode(self.name, main_iframe, url):
-                iframes.extend(decoded)
+                for iframe in decoded:
+                    extractor = self.ex_manager.find_extractor(iframe)
+                    results.append({
+                        "url"  : iframe,
+                        "name" : f"{extractor.name if extractor else 'Main Player'}"
+                    })
 
         for alternatif in secici.css("div.video-toolbar option[value]"):
             alt_name = alternatif.css("::text").get()
@@ -195,6 +202,11 @@ class DiziBox(PluginBase):
             alt_secici = Selector(alt_istek.text)
             if alt_iframe := alt_secici.css("div#video-area iframe::attr(src)").get():
                 if decoded := await self._iframe_decode(alt_name, alt_iframe, url):
-                    iframes.extend(decoded)
+                    for iframe in decoded:
+                        extractor = self.ex_manager.find_extractor(iframe)
+                        results.append({
+                            "url"  : iframe,
+                            "name" : f"{extractor.name if extractor else alt_name}"
+                        })
 
-        return iframes
+        return results

KekikStream/Plugins/DiziPal.py

@@ -0,0 +1,246 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, Subtitle
+from parsel import Selector
+import re
+
+class DiziPal(PluginBase):
+    name        = "DiziPal"
+    language    = "tr"
+    main_url    = "https://dizipal1223.com"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "dizipal güncel, dizipal yeni ve gerçek adresi. dizipal en yeni dizi ve filmleri güvenli ve hızlı şekilde sunar."
+
+    main_page   = {
+        f"{main_url}/diziler/son-bolumler"              : "Son Bölümler",
+        f"{main_url}/diziler"                           : "Yeni Diziler",
+        f"{main_url}/filmler"                           : "Yeni Filmler",
+        f"{main_url}/koleksiyon/netflix"                : "Netflix",
+        f"{main_url}/koleksiyon/exxen"                  : "Exxen",
+        f"{main_url}/koleksiyon/blutv"                  : "BluTV",
+        f"{main_url}/koleksiyon/disney"                 : "Disney+",
+        f"{main_url}/koleksiyon/amazon-prime"           : "Amazon Prime",
+        f"{main_url}/koleksiyon/tod-bein"               : "TOD (beIN)",
+        f"{main_url}/koleksiyon/gain"                   : "Gain",
+        f"{main_url}/tur/mubi"                          : "Mubi",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        results = []
+
+        if "/son-bolumler" in url:
+            for veri in secici.css("div.episode-item"):
+                name     = veri.css("div.name::text").get()
+                episode  = veri.css("div.episode::text").get()
+                href     = veri.css("a::attr(href)").get()
+                poster   = veri.css("img::attr(src)").get()
+
+                if name and href:
+                    ep_text = episode.strip().replace(". Sezon ", "x").replace(". Bölüm", "") if episode else ""
+                    title   = f"{name} {ep_text}"
+                    # Son bölümler linkini dizi sayfasına çevir
+                    dizi_url = href.split("/sezon")[0] if "/sezon" in href else href
+
+                    results.append(MainPageResult(
+                        category = category,
+                        title    = title,
+                        url      = self.fix_url(dizi_url),
+                        poster   = self.fix_url(poster) if poster else None,
+                    ))
+        else:
+            for veri in secici.css("article.type2 ul li"):
+                title  = veri.css("span.title::text").get()
+                href   = veri.css("a::attr(href)").get()
+                poster = veri.css("img::attr(src)").get()
+
+                if title and href:
+                    results.append(MainPageResult(
+                        category = category,
+                        title    = title,
+                        url      = self.fix_url(href),
+                        poster   = self.fix_url(poster) if poster else None,
+                    ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        self.httpx.headers.update({
+            "Accept"           : "application/json, text/javascript, */*; q=0.01",
+            "X-Requested-With" : "XMLHttpRequest"
+        })
+
+        istek = await self.httpx.post(
+            url  = f"{self.main_url}/api/search-autocomplete",
+            data = {"query": query}
+        )
+
+        try:
+            data = istek.json()
+        except Exception:
+            return []
+
+        results = []
+
+        # API bazen dict, bazen list döner
+        items = data.values() if isinstance(data, dict) else data
+
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+
+            title  = item.get("title")
+            url    = item.get("url")
+            poster = item.get("poster")
+
+            if title and url:
+                results.append(SearchResult(
+                    title  = title,
+                    url    = f"{self.main_url}{url}",
+                    poster = self.fix_url(poster) if poster else None,
+                ))
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        # Reset headers to get HTML response
+        self.httpx.headers.update({
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        })
+        self.httpx.headers.pop("X-Requested-With", None)
+
+        istek  = await self.httpx.get(url)
+        secici = Selector(text=istek.text, type="html")
+
+        poster      = self.fix_url(secici.css("meta[property='og:image']::attr(content)").get())
+        year        = secici.xpath("//div[text()='Yapım Yılı']//following-sibling::div/text()").get()
+        description = secici.css("div.summary p::text").get()
+        rating      = secici.xpath("//div[text()='IMDB Puanı']//following-sibling::div/text()").get()
+        tags_raw    = secici.xpath("//div[text()='Türler']//following-sibling::div/text()").get()
+        tags        = [t.strip() for t in tags_raw.split() if t.strip()] if tags_raw else None
+
+        dur_text    = secici.xpath("//div[text()='Ortalama Süre']//following-sibling::div/text()").get()
+        dur_match   = re.search(r"(\d+)", dur_text or "")
+        duration    = int(dur_match[1]) if dur_match else None
+
+        if "/dizi/" in url:
+            title = secici.css("div.cover h5::text").get()
+
+            episodes = []
+            for ep in secici.css("div.episode-item"):
+                ep_name    = ep.css("div.name::text").get()
+                ep_href    = ep.css("a::attr(href)").get()
+                ep_text    = ep.css("div.episode::text").get() or ""
+                ep_parts   = ep_text.strip().split(" ")
+
+                ep_season  = None
+                ep_episode = None
+                if len(ep_parts) >= 4:
+                    try:
+                        ep_season  = int(ep_parts[0].replace(".", ""))
+                        ep_episode = int(ep_parts[2].replace(".", ""))
+                    except ValueError:
+                        pass
+
+                if ep_name and ep_href:
+                    episodes.append(Episode(
+                        season  = ep_season,
+                        episode = ep_episode,
+                        title   = ep_name.strip(),
+                        url     = self.fix_url(ep_href),
+                    ))
+
+            return SeriesInfo(
+                url         = url,
+                poster      = poster,
+                title       = title,
+                description = description.strip() if description else None,
+                tags        = tags,
+                rating      = rating.strip() if rating else None,
+                year        = year.strip() if year else None,
+                duration    = duration,
+                episodes    = episodes if episodes else None,
+            )
+        else:
+            title = secici.xpath("//div[@class='g-title'][2]/div/text()").get()
+
+            return MovieInfo(
+                url         = url,
+                poster      = poster,
+                title       = title.strip() if title else None,
+                description = description.strip() if description else None,
+                tags        = tags,
+                rating      = rating.strip() if rating else None,
+                year        = year.strip() if year else None,
+                duration    = duration,
+            )
+
+    async def load_links(self, url: str) -> list[dict]:
+        # Reset headers to get HTML response
+        self.httpx.headers.update({
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        })
+        self.httpx.headers.pop("X-Requested-With", None)
+
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        iframe = secici.css(".series-player-container iframe::attr(src)").get()
+        if not iframe:
+            iframe = secici.css("div#vast_new iframe::attr(src)").get()
+
+        if not iframe:
+            return []
+
+        results = []
+
+        self.httpx.headers.update({"Referer": f"{self.main_url}/"})
+        i_istek = await self.httpx.get(iframe)
+        i_text  = i_istek.text
+
+        # m3u link çıkar
+        m3u_match = re.search(r'file:"([^"]+)"', i_text)
+        if m3u_match:
+            m3u_link = m3u_match[1]
+
+            # Altyazıları çıkar
+            subtitles = []
+            sub_match = re.search(r'"subtitle":"([^"]+)"', i_text)
+            if sub_match:
+                sub_text = sub_match[1]
+                if "," in sub_text:
+                    for sub in sub_text.split(","):
+                        lang = sub.split("[")[1].split("]")[0] if "[" in sub else "Türkçe"
+                        sub_url = sub.replace(f"[{lang}]", "")
+                        subtitles.append(Subtitle(name=lang, url=self.fix_url(sub_url)))
+                else:
+                    lang = sub_text.split("[")[1].split("]")[0] if "[" in sub_text else "Türkçe"
+                    sub_url = sub_text.replace(f"[{lang}]", "")
+                    subtitles.append(Subtitle(name=lang, url=self.fix_url(sub_url)))
+
+            results.append({
+                "name"      : self.name,
+                "url"       : m3u_link,
+                "referer"   : f"{self.main_url}/",
+                "subtitles" : subtitles
+            })
+        else:
+            # Extractor'a yönlendir
+            extractor = self.ex_manager.find_extractor(iframe)
+            results.append({
+                "name"    : f"{extractor.name if extractor else self.name}",
+                "url"     : iframe,
+                "referer" : f"{self.main_url}/",
+            })
+
+        return results
+
+    async def play(self, **kwargs):
+        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)