KekikStream 2.3.9__py3-none-any.whl → 2.5.4__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,24 +43,22 @@ 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(
                     category = category,
                     title    = title,
                     url      = self.fix_url(href),
-                    poster   = self.fix_url(poster) if poster else None,
+                    poster   = self.fix_url(poster),
                 ))
 
         return results
@@ -74,23 +73,21 @@ 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(
                     title  = title,
                     url    = self.fix_url(href),
-                    poster = self.fix_url(poster) if poster else None,
+                    poster = self.fix_url(poster),
                 ))
 
         return results
@@ -99,81 +96,116 @@ class JetFilmizle(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        title    = self.clean_title(secici.select_text("div.movie-exp-title")) if secici.select_text("div.movie-exp-title") else None
-
-        poster = secici.select_poster("section.movie-exp img")
-        poster = poster.strip() if poster else None
-        
+        title       = self.clean_title(secici.select_text("div.movie-exp-title"))
+        poster      = secici.select_poster("section.movie-exp img")
         description = secici.select_text("section.movie-exp p.aciklama")
-        
-        tags = secici.select_all_text("section.movie-exp div.catss a")
-        
-        rating = secici.select_text("section.movie-exp div.imdb_puan span")
-        
-        year = secici.extract_year("div.yap")
-        
-        actors = secici.select_all_text("div[itemprop='actor'] a span")
-        if not actors: # Fallback to img alt
-            actors = [img.attrs.get("alt") for img in secici.select("div.oyuncular div.oyuncu img") if img.attrs.get("alt")]
-
-        duration = secici.regex_first(r"(\d+)\s*dk", istek.text)
+        tags        = secici.select_texts("section.movie-exp div.catss a")
+        rating      = secici.select_text("section.movie-exp div.imdb_puan span")
+        year        = secici.meta_value("Yayın Yılı")
+        actors      = secici.select_texts("div[itemprop='actor'] a span") or [img.attrs.get("alt") for img in secici.select("div.oyuncular div.oyuncu img") if img.attrs.get("alt")]
+        duration    = secici.meta_value("Süre")
+        duration    = duration.split() if duration else None
+
+        total_minutes = 0
+        if duration:
+            for i, p in enumerate(duration):
+                if p == "saat":
+                    total_minutes += int(duration[i-1]) * 60
+                elif p == "dakika":
+                    total_minutes += int(duration[i-1])
 
         return MovieInfo(
             url         = url,
-            poster      = self.fix_url(poster) if poster else None,
+            poster      = self.fix_url(poster),
             title       = title,
             description = description,
             tags        = tags,
             rating      = rating,
             year        = year,
             actors      = actors,
-            duration    = int(duration) 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"
@@ -50,7 +50,7 @@ class KultFilmler(PluginBase):
                     category = category,
                     title    = title,
                     url      = self.fix_url(href),
-                    poster   = self.fix_url(poster) if poster else None,
+                    poster   = self.fix_url(poster),
                 ))
 
         return results
@@ -69,7 +69,7 @@ class KultFilmler(PluginBase):
                 results.append(SearchResult(
                     title  = title,
                     url    = self.fix_url(href),
-                    poster = self.fix_url(poster) if poster else None,
+                    poster = self.fix_url(poster),
                 ))
 
         return results
@@ -78,146 +78,180 @@ class KultFilmler(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        title       = secici.select_attr("div.film-bilgileri img", "alt") or secici.select_attr("[property='og:title']", "content")
-        poster      = self.fix_url(secici.select_attr("[property='og:image']", "content")) if secici.select_attr("[property='og:image']", "content") else None
-
+        title       = self.clean_title(secici.select_attr("div.film-bilgileri img", "alt") or secici.select_attr("[property='og:title']", "content"))
+        poster      = self.fix_url(secici.select_attr("[property='og:image']", "content"))
         description = secici.select_text("div.description")
+        tags        = secici.select_texts("ul.post-categories a")
+        year        = secici.extract_year("li.release span a")
+        duration    = int(secici.regex_first(r"(\d+)", secici.select_text("li.time span")) or 0)
+        rating      = secici.regex_first(r"(\d+\.\d+|\d+)", secici.select_text("div.imdb-count"))
+        actors      = secici.select_texts("div.actors a")
 
-        tags = [a.text(strip=True) for a in secici.select("ul.post-categories a") if a.text(strip=True)]
-
-        # HTML analizine göre güncellenen alanlar
-        year    = secici.select_text("li.release span a")
-
-        time_text = secici.select_text("li.time span")
-        duration = secici.regex_first(r"(\d+)", time_text) if time_text else None
-
-        rating_text = secici.select_text("div.imdb-count")
-        rating = secici.regex_first(r"(\d+\.\d+|\d+)", rating_text) if rating_text else None
-
-        actors = [a.text(strip=True) for a in secici.select("div.actors a") if a.text(strip=True)]
-
-        # Dizi mi kontrol et
         if "/dizi/" in url:
             episodes = []
             for bolum in secici.select("div.episode-box"):
-                ep_href   = secici.select_attr("div.name a", "href", bolum)
-
+                href       = secici.select_attr("div.name a", "href", bolum)
                 ssn_detail = secici.select_text("span.episodetitle", bolum) or ""
                 ep_detail  = secici.select_text("span.episodetitle b", bolum) or ""
-
-                ep_name = f"{ssn_detail} - {ep_detail}"
-
-                if ep_href:
-                    ep_season  = secici.regex_first(r"(\d+)\.", ssn_detail)
-                    ep_episode = secici.regex_first(r"(\d+)\.", ep_detail)
-
-                    episodes.append(Episode(
-                        season  = int(ep_season) if ep_season else 1,
-                        episode = int(ep_episode) if ep_episode else 1,
-                        title   = ep_name.strip(" -"),
-                        url     = self.fix_url(ep_href),
-                    ))
+                if href:
+                    s, e = secici.extract_season_episode(f"{ssn_detail} {ep_detail}")
+                    name = f"{ssn_detail} - {ep_detail}".strip(" -")
+                    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       = self.clean_title(title) if title else "",
+                title       = title,
                 description = description,
                 tags        = tags,
                 year        = year,
                 actors      = actors,
                 rating      = rating,
-                episodes    = episodes,
+                episodes    = episodes
             )
 
         return MovieInfo(
             url         = url,
             poster      = poster,
-            title       = self.clean_title(title) if title else "",
+            title       = title,
             description = description,
             tags        = tags,
             year        = year,
             rating      = rating,
             actors      = actors,
-            duration    = int(duration) if duration else None,
+            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 load_links(self, url: str) -> list[ExtractResult]:
-        istek  = await self.httpx.get(url)
-        secici = HTMLHelper(istek.text)
-
-        iframes = set()
-
-        # Ana iframe
-        main_frame = self._get_iframe(istek.text)
-        if main_frame:
-            iframes.add(main_frame)
-
-        # 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)
+    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 = []
 
-        for iframe in iframes:
-            subtitles = []
-
-            # 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:"([^"]+)"')
-
-                if m3u_match:
+        # 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      = "VidMoly",
-                        url       = m3u_match,
+                        name      = title or "VidMoly",
+                        url       = m3u,
                         referer   = self.main_url,
-                        subtitles = []
+                        subtitles = subtitles
                     ))
-                    continue
 
-            # Altyazı çıkar
-            subtitle_url = self._extract_subtitle_url(url)
-            if subtitle_url:
-                subtitles.append(Subtitle(name="Türkçe", url=subtitle_url))
+            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
 
-            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)
+                # 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]:
+        response = await self.httpx.get(url)
+        source   = response.text
+        helper   = HTMLHelper(source)
+
+        # Altyazı Bul
+        sub_url   = helper.regex_first(r"(https?://[^\s\"]+\.srt)")
+        subtitles = [Subtitle(name="Türkçe", url=sub_url)] if sub_url else []
+
+        # İşlenecek kaynakları topla: (Iframe_URL, Başlık)
+        sources = []
+
+        # 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))
+
+        # 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
+
+            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
+
+            alt_tasks.append(self._resolve_alt_page(self.fix_url(href), full_title))
+
+        if alt_tasks:
+            resolved_alts = await asyncio.gather(*alt_tasks)
+            for iframe, title in resolved_alts:
+                if iframe:
+                    sources.append((iframe, title))
+
+        # 3. Tüm kaynakları paralel işle (Extract)
+        if not sources:
+            return []
+
+        extract_tasks = [
+            self._extract_stream(iframe, title, subtitles) 
+                for iframe, title in sources
+        ]
+
+        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