KekikStream 2.4.8__py3-none-any.whl → 2.5.0__py3-none-any.whl

KekikStream/Plugins/JetFilmizle.py

@@ -1,6 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, HTMLHelper
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, HTMLHelper
+import asyncio
 
 class JetFilmizle(PluginBase):
     name        = "JetFilmizle"
@@ -42,17 +43,15 @@ class JetFilmizle(PluginBase):
 
         results = []
         for veri in secici.select("article.movie"):
-            # h2-h6 içindeki a linki
             title_text = None
             for h_tag in ["h2", "h3", "h4", "h5", "h6"]:
                 title_text = secici.select_text(f"{h_tag} a", veri)
                 if title_text:
                     break
 
-            href = secici.select_attr("a", "href", veri)
-            poster = secici.select_poster("img", veri)
-
             title  = self.clean_title(title_text) if title_text else None
+            href   = secici.select_attr("a", "href", veri)
+            poster = secici.select_poster("img", veri)
 
             if title and href:
                 results.append(MainPageResult(
@@ -74,17 +73,15 @@ class JetFilmizle(PluginBase):
 
         results = []
         for article in secici.select("article.movie"):
-            # h2-h6 içindeki a linki
             title_text = None
             for h_tag in ["h2", "h3", "h4", "h5", "h6"]:
                 title_text = secici.select_text(f"{h_tag} a", article)
                 if title_text:
                     break
 
-            href = secici.select_attr("a", "href", article)
-            poster = secici.select_poster("img", article)
-
             title  = self.clean_title(title_text) if title_text else None
+            href   = secici.select_attr("a", "href", article)
+            poster = secici.select_poster("img", article)
 
             if title and href:
                 results.append(SearchResult(
@@ -126,53 +123,89 @@ class JetFilmizle(PluginBase):
             rating      = rating,
             year        = year,
             actors      = actors,
-            duration    = int(total_minutes) if duration else None
+            duration    = total_minutes if total_minutes else None
         )
 
-    async def load_links(self, url: str) -> list[ExtractResult]:
-        istek  = await self.httpx.get(url)
-        secici = HTMLHelper(istek.text)
-
+    async def _process_source(self, url: str, name: str, html: str | None) -> list[ExtractResult]:
         results = []
-
-        # 1) Ana iframe'leri kontrol et
-        for iframe in secici.select("iframe"):
-            src = (iframe.attrs.get("src") or 
-                   iframe.attrs.get("data-src") or
-                   iframe.attrs.get("data-lazy-src"))
-            
-            if src and src != "about:blank":
-                iframe_url = self.fix_url(src)
-                data = await self.extract(iframe_url)
-                if data:
-                    results.append(data)
-
-        # 2) Sayfa numaralarından linkleri topla (Fragman hariç)
-        page_links = []
-        for link in secici.select("a.post-page-numbers"):
-            isim = secici.select_text("span", link) or ""
-            if isim != "Fragman":
-                href = link.attrs.get("href")
-                if href:
-                    page_links.append((self.fix_url(href), isim))
-
-        # 3) Her sayfa linkindeki iframe'leri bul
-        for page_url, isim in page_links:
-            try:
-                page_resp = await self.httpx.get(page_url)
-                page_sel = HTMLHelper(page_resp.text)
-                
-                for iframe in page_sel.select("div#movie iframe"):
+        try:
+            if html:
+                secici = HTMLHelper(html)
+            else:
+                resp   = await self.httpx.get(url)
+                secici = HTMLHelper(resp.text)
+
+            # Iframe'leri bul
+            container = secici.select_first("div#movie") or secici.select_first("div.film-content")
+
+            if container:
+                for iframe in secici.select("iframe", container):
                     src = (iframe.attrs.get("src") or 
                            iframe.attrs.get("data-src") or
                            iframe.attrs.get("data-lazy-src"))
-                    
+
                     if src and src != "about:blank":
                         iframe_url = self.fix_url(src)
-                        data = await self.extract(iframe_url, prefix=isim)
+                        # name_override KULLANMA, extractor kendi ismini versin
+                        # Sonra biz düzenleriz
+                        data = await self.extract(iframe_url)
+
                         if data:
-                            results.append(data)
-            except Exception:
-                continue
+                            items = data if isinstance(data, list) else [data]
+
+                            for item in items:
+                                # Sadece kalite bilgisi içeriyorsa ekle, yoksa sadece buton adını kullan
+                                # Özellikle Zeus için kalite önemli (1080p, 720p)
+                                # Diğerlerinde plugin adı (Apollo, JetPlay vb.) önemsiz
+
+                                # Kalite kontrolü (basitçe)
+                                quality_indicators = ["1080p", "720p", "480p", "360p", "240p", "144p", "4k", "2k"]
+                                has_quality = any(q in item.name.lower() for q in quality_indicators)
+
+                                if has_quality:
+                                    # Buton Adı | Extractor Adı (Kalite içerdiği için)
+                                    # Örn: Zeus | 1080p
+                                    # Eğer Extractor adı zaten Buton adını içeriyorsa (Zeus | 1080p -> Zeus) tekrar ekleme
+                                    if name.lower() not in item.name.lower():
+                                         item.name = f"{name} | {item.name}"
+                                else:
+                                    # Kalite yoksa sadece Buton adını kullan
+                                    # Örn: Apollo | JetTv -> JetTv
+                                    item.name = name
+
+                                results.append(item)
+            return results
+        except Exception:
+            return []
 
-        return results
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek  = await self.httpx.get(url)
+        secici = HTMLHelper(istek.text)
+
+        sources = []
+        if film_part := secici.select_first("div.film_part"):
+            # Tüm spanları gez
+            for span in secici.select("span", film_part):
+                # Eğer bu span bir <a> etiketi içinde değilse, aktif kaynaktır
+                if span.parent.tag != "a":
+                    name = span.text(strip=True)
+                    if name:
+                        sources.append((url, name, istek.text)) # html content var
+                        break
+
+            # Diğer kaynak linkleri
+            for link in secici.select("a.post-page-numbers", film_part):
+                name = secici.select_text("span", link) or link.text(strip=True)
+                href = link.attrs.get("href")
+                if name != "Fragman" and href:
+                    sources.append((self.fix_url(href), name, None)) # html yok, çekilecek
+
+        # Eğer film_part yoksa, sadece mevcut sayfayı tara (Tek part olabilir)
+        if not sources:
+            sources.append((url, "JetFilmizle", istek.text))
+
+        tasks = []
+        for page_url, source_name, html_content in sources:
+            tasks.append(self._process_source(page_url, source_name, html_content))
+
+        return [item for sublist in await asyncio.gather(*tasks) for item in sublist]

KekikStream/Plugins/KultFilmler.py

@@ -1,7 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, Subtitle, HTMLHelper
-import base64
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, Subtitle, HTMLHelper
+import base64, asyncio, contextlib
 
 class KultFilmler(PluginBase):
     name        = "KultFilmler"
@@ -99,91 +99,159 @@ class KultFilmler(PluginBase):
                     episodes.append(Episode(season=s or 1, episode=e or 1, title=name, url=self.fix_url(href)))
 
             return SeriesInfo(
-                url=url, poster=poster, title=title, description=description,
-                tags=tags, year=year, actors=actors, rating=rating, episodes=episodes
+                url         = url,
+                poster      = poster,
+                title       = title,
+                description = description,
+                tags        = tags,
+                year        = year,
+                actors      = actors,
+                rating      = rating,
+                episodes    = episodes
             )
 
         return MovieInfo(
-            url=url, poster=poster, title=title, description=description,
-            tags=tags, year=year, rating=rating, actors=actors, duration=duration
+            url         = url,
+            poster      = poster,
+            title       = title,
+            description = description,
+            tags        = tags,
+            year        = year,
+            rating      = rating,
+            actors      = actors,
+            duration    = duration
         )
 
-    def _get_iframe(self, source_code: str) -> str:
-        """Base64 kodlu iframe'i çözümle"""
-        atob = HTMLHelper(source_code).regex_first(r"PHA\+[0-9a-zA-Z+/=]*")
-        if not atob:
-            return ""
+    def _decode_iframe(self, content: str) -> str | None:
+        """Base64 kodlanmış iframe verisini çözer"""
+        match = HTMLHelper(content).regex_first(r"PHA\+[0-9a-zA-Z+/=]*")
+        if not match:
+            return None
 
-        # Padding düzelt
-        padding = 4 - len(atob) % 4
-        if padding < 4:
-            atob = atob + "=" * padding
+        # Base64 Padding Fix
+        pad = len(match) % 4
+        if pad:
+            match += "=" * (4 - pad)
 
         try:
-            decoded = base64.b64decode(atob).decode("utf-8")
-            secici  = HTMLHelper(decoded)
-            iframe_src = secici.select_attr("iframe", "src")
-            return self.fix_url(iframe_src) if iframe_src else ""
+            decoded = base64.b64decode(match).decode("utf-8")
+            src = HTMLHelper(decoded).select_attr("iframe", "src")
+            return self.fix_url(src) if src else None
         except Exception:
-            return ""
+            return None
 
-    def _extract_subtitle_url(self, source_code: str) -> str | None:
-        """Altyazı URL'sini çıkar"""
-        return HTMLHelper(source_code).regex_first(r"(https?://[^\s\"]+\.srt)")
+    async def _resolve_alt_page(self, url: str, title: str) -> tuple[str | None, str]:
+        """Alternatif sayfa kaynak kodunu indirip iframe'i bulur"""
+        try:
+            res = await self.httpx.get(url)
+            return self._decode_iframe(res.text), title
+        except Exception:
+            return None, title
+
+    async def _extract_stream(self, iframe_url: str, title: str, subtitles: list[Subtitle]) -> list[ExtractResult]:
+        """Iframe üzerinden stream linklerini ayıklar"""
+        results = []
+
+        # 1. VidMoly Özel Çözümleme(M3U)
+        if "vidmoly" in iframe_url:
+            with contextlib.suppress(Exception):
+                res = await self.httpx.get(
+                    url     = iframe_url,
+                    headers = {
+                        "User-Agent"     : "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36",
+                        "Sec-Fetch-Dest" : "iframe"
+                    }
+                )
+                m3u = HTMLHelper(res.text).regex_first(r'file:"([^"]+)"')
+
+                if m3u:
+                    results.append(ExtractResult(
+                        name      = title or "VidMoly",
+                        url       = m3u,
+                        referer   = self.main_url,
+                        subtitles = subtitles
+                    ))
+
+            return results
+
+        # 2. Genel Extractor Kullanımı
+        with contextlib.suppress(Exception):
+            extracted = await self.extract(iframe_url)
+            if not extracted:
+                return []
+
+            items = extracted if isinstance(extracted, list) else [extracted]
+            for item in items:
+                # İsim ve altyazı bilgilerini güncelle
+                # Orijinal extractor ismini ezmek için title kullan
+                if title:
+                    item.name = title
+
+                # Varsa altyazıları ekle
+                if subtitles:
+                     # Copy update daha güvenli (Pydantic model)
+                    if hasattr(item, "model_copy"):
+                        item = item.model_copy(update={"subtitles": subtitles})
+                    else:
+                        item.subtitles = subtitles
+
+                results.append(item)
+
+        return results
 
     async def load_links(self, url: str) -> list[ExtractResult]:
-        istek  = await self.httpx.get(url)
-        secici = HTMLHelper(istek.text)
+        response = await self.httpx.get(url)
+        source   = response.text
+        helper   = HTMLHelper(source)
 
-        iframes = set()
+        # Altyazı Bul
+        sub_url   = helper.regex_first(r"(https?://[^\s\"]+\.srt)")
+        subtitles = [Subtitle(name="Türkçe", url=sub_url)] if sub_url else []
 
-        # Ana iframe
-        main_frame = self._get_iframe(istek.text)
-        if main_frame:
-            iframes.add(main_frame)
+        # İşlenecek kaynakları topla: (Iframe_URL, Başlık)
+        sources = []
 
-        # Alternatif player'lar
-        for player in secici.select("div.container#player"):
-            iframe_src = secici.select_attr("iframe", "src", player)
-            alt_iframe = self.fix_url(iframe_src) if iframe_src else None
-            if alt_iframe:
-                alt_istek = await self.httpx.get(alt_iframe)
-                alt_frame = self._get_iframe(alt_istek.text)
-                if alt_frame:
-                    iframes.add(alt_frame)
+        # A) Ana Player
+        main_iframe = self._decode_iframe(source)
+        if main_iframe:
+            p_name = helper.select_text("div.parts-middle div.part.active div.part-name") or None
+            p_lang = helper.select_attr("div.parts-middle div.part.active div.part-lang span", "title")
+            full_title = f"{p_name} | {p_lang}" if p_lang else p_name
+            sources.append((main_iframe, full_title))
 
-        results = []
+        # B) Alternatif Playerlar (Link Çözümleme Gerektirir)
+        alt_tasks = []
+        for link in helper.select("div.parts-middle a.post-page-numbers"):
+            href = link.attrs.get("href")
+            if not href:
+                continue
 
-        for iframe in iframes:
-            subtitles = []
+            a_name     = helper.select_text("div.part-name", link) or "Alternatif"
+            a_lang     = helper.select_attr("div.part-lang span", "title", link)
+            full_title = f"{a_name} | {a_lang}" if a_lang else a_name
 
-            # VidMoly özel işleme
-            if "vidmoly" in iframe:
-                headers = {
-                    "User-Agent"     : "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36",
-                    "Sec-Fetch-Dest" : "iframe"
-                }
-                iframe_istek = await self.httpx.get(iframe, headers=headers)
-                m3u_match    = HTMLHelper(iframe_istek.text).regex_first(r'file:"([^"]+)"')
+            alt_tasks.append(self._resolve_alt_page(self.fix_url(href), full_title))
 
-                if m3u_match:
-                    results.append(ExtractResult(
-                        name      = "VidMoly",
-                        url       = m3u_match,
-                        referer   = self.main_url,
-                        subtitles = []
-                    ))
-                    continue
+        if alt_tasks:
+            resolved_alts = await asyncio.gather(*alt_tasks)
+            for iframe, title in resolved_alts:
+                if iframe:
+                    sources.append((iframe, title))
 
-            # Altyazı çıkar
-            subtitle_url = self._extract_subtitle_url(url)
-            if subtitle_url:
-                subtitles.append(Subtitle(name="Türkçe", url=subtitle_url))
+        # 3. Tüm kaynakları paralel işle (Extract)
+        if not sources:
+            return []
 
-            data = await self.extract(iframe)
-            if data:
-                # ExtractResult objesi immutable, yeni bir kopya oluştur
-                updated_data = data.model_copy(update={"subtitles": subtitles}) if subtitles else data
-                results.append(updated_data)
+        extract_tasks = [
+            self._extract_stream(iframe, title, subtitles) 
+                for iframe, title in sources
+        ]
 
-        return results
+        results_groups = await asyncio.gather(*extract_tasks)
+
+        # Sonuçları düzleştir
+        final_results = []
+        for group in results_groups:
+            final_results.extend(group)
+
+        return final_results

KekikStream/Plugins/RecTV.py

@@ -2,7 +2,7 @@
 
 from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, Episode, SeriesInfo, ExtractResult, HTMLHelper
 from json             import dumps, loads
-import re
+import re, contextlib
 
 class RecTV(PluginBase):
     name        = "RecTV"
@@ -73,11 +73,10 @@ class RecTV(PluginBase):
         duration_raw = veri.get("duration")
         duration = None
         if duration_raw:
-            try:
+            with contextlib.suppress(Exception):
                 h = int(HTMLHelper(duration_raw).regex_first(r"(\d+)h") or 0)
                 m = int(HTMLHelper(duration_raw).regex_first(r"(\d+)min") or 0)
                 duration = h * 60 + m
-            except: pass
 
         common_info = {
             "url"         : url,
@@ -110,10 +109,15 @@ class RecTV(PluginBase):
                             tag = " (Altyazı)"; clean_s = re.sub(r"\s*altyaz[ıi]\s*", "", s_title, flags=re.I).strip()
 
                         ep_data = {"url": self.fix_url(source.get("url")), "title": f"{veri.get('title')} | {s_title} {e_title} - {source.get('title')}", "is_episode": True}
-                        episodes.append(Episode(season=s or 1, episode=e or 1, title=f"{clean_s} {e_title}{tag} - {source.get('title')}", url=dumps(ep_data)))
+                        episodes.append(Episode(
+                            season  = s or 1,
+                            episode = e or 1,
+                            title   = f"{clean_s} {e_title}{tag} - {source.get('title')}",
+                            url     = dumps(ep_data)
+                        ))
 
             return SeriesInfo(**common_info, episodes=episodes, actors=[])
-        
+
         return MovieInfo(**common_info, actors=[])
 
     async def load_links(self, url: str) -> list[ExtractResult]:

KekikStream/Plugins/RoketDizi.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, MovieInfo, HTMLHelper
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, MovieInfo, HTMLHelper
 import base64, json
 
 class RoketDizi(PluginBase):
@@ -26,8 +26,6 @@ class RoketDizi(PluginBase):
         secici = HTMLHelper(istek.text)
 
         results = []
-
-        # Use div.new-added-list to find the container, then get items
         for item in secici.select("div.new-added-list > span"):
             title  = secici.select_text("span.line-clamp-1", item)
             href   = secici.select_attr("a", "href", item)
@@ -52,7 +50,7 @@ class RoketDizi(PluginBase):
                 "Referer"          : f"{self.main_url}/",
             }
         )
-        
+
         try:
             veri    = istek.json()
             encoded = veri.get("response", "")
@@ -87,39 +85,33 @@ class RoketDizi(PluginBase):
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         resp = await self.httpx.get(url)
         sel  = HTMLHelper(resp.text)
-        
+
         next_data_text = sel.select_text("script#__NEXT_DATA__")
         if not next_data_text:
             return SeriesInfo(url=url, title=sel.select_text("h1") or "Bilinmeyen")
 
         try:
-            next_data = json.loads(next_data_text)
+            next_data       = json.loads(next_data_text)
             secure_data_raw = next_data["props"]["pageProps"]["secureData"]
-            secure_data = json.loads(base64.b64decode(secure_data_raw).decode('utf-8'))
-            
+            secure_data     = json.loads(base64.b64decode(secure_data_raw).decode('utf-8'))
+
             content_item = secure_data.get("contentItem", {})
             content      = secure_data.get("content", {}).get("result", {})
-            
+
             title       = content_item.get("original_title") or content_item.get("culture_title")
             poster      = content_item.get("poster_url") or content_item.get("face_url")
             description = content_item.get("description")
             rating      = str(content_item.get("imdb_point") or "")
             year        = str(content_item.get("release_year") or "")
             tags        = content_item.get("categories", "").split(",")
-            
-            # Actors extraction from getSerieCastsById or getMovieCastsById
+
             actors = []
             casts_data = content.get("getSerieCastsById") or content.get("getMovieCastsById")
             if casts_data and casts_data.get("result"):
                 actors = [cast.get("name") for cast in casts_data["result"] if cast.get("name")]
 
-            # Episodes extraction
             episodes = []
             if "Series" in str(content.get("FindedType")):
-                # Check for episodes in SecureData -> RelatedResults -> getEpisodeSources (this might be for the current episode)
-                # Usually full episode list isn't in secureData, but we can get it from HTML or another API
-                # However, many times Next.js pages have them in props
-                # Let's fallback to the previous regex method for episodes if not in JSON
                 all_urls = HTMLHelper(resp.text).regex_all(r'"url":"([^"]*)"')
                 episodes_dict = {}
                 for u in all_urls:
@@ -169,17 +161,16 @@ class RoketDizi(PluginBase):
     async def load_links(self, url: str) -> list[ExtractResult]:
         resp = await self.httpx.get(url)
         sel  = HTMLHelper(resp.text)
-        
+
         next_data = sel.select_text("script#__NEXT_DATA__")
         if not next_data:
             return []
 
         try:
-            data = json.loads(next_data)
-            secure_data = data["props"]["pageProps"]["secureData"]
+            data         = json.loads(next_data)
+            secure_data  = data["props"]["pageProps"]["secureData"]
             decoded_json = json.loads(base64.b64decode(secure_data).decode('utf-8'))
 
-            # secureData içindeki RelatedResults -> getEpisodeSources -> result dizisini al
             sources = decoded_json.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
 
             seen_urls = set()
@@ -200,8 +191,8 @@ class RoketDizi(PluginBase):
                         iframe_url = "https://" + iframe_url
 
                 iframe_url = self.fix_url(iframe_url)
-                
-                # Deduplicate  
+
+                # Deduplicate
                 if iframe_url in seen_urls:
                     continue
                 seen_urls.add(iframe_url)