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

KekikStream/Core/Plugin/PluginBase.py

@@ -144,14 +144,20 @@ class PluginBase(ABC):
                     if name_override:
                         item.name = name_override
                     elif prefix and item.name:
-                        item.name = f"{prefix} | {item.name}"
+                        if item.name.lower() in prefix.lower():
+                            item.name = prefix
+                        else:
+                            item.name = f"{prefix} | {item.name}"
                 return data
 
             # Tekil öğe ise
             if name_override:
                 data.name = name_override
             elif prefix and data.name:
-                data.name = f"{prefix} | {data.name}"
+                if data.name.lower() in prefix.lower():
+                    data.name = prefix
+                else:
+                    data.name = f"{prefix} | {data.name}"
 
             return data
         except Exception as hata:

KekikStream/Extractors/Abstream.py

@@ -0,0 +1,27 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+
+class Abstream(ExtractorBase):
+    name     = "Abstream"
+    main_url = "https://abstream.to"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        istek  = await self.httpx.get(
+            url     = url,
+            headers = {
+                "Accept-Language" : "en-US,en;q=0.5",
+                "Referer"         : referer or self.main_url,
+            }
+        )
+        secici    = HTMLHelper(istek.text)
+        video_url = secici.regex_first(r'file:"([^"]*)"')
+
+        if not video_url:
+            raise ValueError(f"Abstream: Video URL bulunamadı. {url}")
+
+        return ExtractResult(
+            name    = self.name,
+            url     = video_url,
+            referer = referer or self.main_url
+        )

KekikStream/Extractors/Filemoon.py

@@ -13,7 +13,8 @@ class Filemoon(ExtractorBase):
         "filemoon.in",
         "filemoon.sx",
         "filemoon.nl",
-        "filemoon.com"
+        "filemoon.com",
+        "bysejikuar.com"
     ]
 
     def can_handle_url(self, url: str) -> bool:

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)

KekikStream/Plugins/SetFilmIzle.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, HTMLHelper
-import json, asyncio
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, HTMLHelper
+import asyncio, contextlib
 
 class SetFilmIzle(PluginBase):
     name        = "SetFilmIzle"
@@ -35,7 +35,7 @@ class SetFilmIzle(PluginBase):
 
     def _get_nonce(self, nonce_type: str = "video", referer: str = None) -> str:
         """Site cache'lenmiş nonce'ları expire olabiliyor, fresh nonce al veya sayfadan çek"""
-        try:
+        with contextlib.suppress(Exception):
             resp = self.cloudscraper.post(
                 f"{self.main_url}/wp-admin/admin-ajax.php",
                 headers = {
@@ -49,17 +49,15 @@ class SetFilmIzle(PluginBase):
             if data and data.get("success"):
                 nonces = data.get("data", {}).get("nonces", {})
                 return nonces.get(nonce_type if nonce_type != "search" else "dt_ajax_search", "")
-        except:
-            pass
 
         # AJAX başarısızsa sayfadan çekmeyi dene
-        try:
+        with contextlib.suppress(Exception):
             main_resp = self.cloudscraper.get(referer or self.main_url)
             # STMOVIE_AJAX = { ... nonces: { search: "...", ... } }
             nonce = HTMLHelper(main_resp.text).regex_first(rf'"{nonce_type}":\s*"([^"]+)"')
             return nonce or ""
-        except:
-            return ""
+
+        return ""
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = self.cloudscraper.get(url)
@@ -106,8 +104,8 @@ class SetFilmIzle(PluginBase):
             return []
 
         secici  = HTMLHelper(html)
-        results = []
 
+        results = []
         for item in secici.select("div.items article"):
             title  = secici.select_text("h2", item)
             href   = secici.select_attr("a", "href", item)
@@ -175,14 +173,14 @@ class SetFilmIzle(PluginBase):
         semaphore = asyncio.Semaphore(5)
         tasks = []
 
-        async def fetch_and_extract(player):
+        async def fetch_and_extract(player) -> list[ExtractResult]:
             async with semaphore:
                 source_id   = player.attrs.get("data-post-id")
-                player_name = player.attrs.get("data-player-name")
+                player_name = player.attrs.get("data-player-name") or secici.select_text("b", player)
                 part_key    = player.attrs.get("data-part-key")
 
                 if not source_id or "event" in source_id or source_id == "":
-                    return None
+                    return []
 
                 try:
                     resp = self.cloudscraper.post(
@@ -192,17 +190,17 @@ class SetFilmIzle(PluginBase):
                             "action"      : "get_video_url",
                             "nonce"       : nonce,
                             "post_id"     : source_id,
-                            "player_name" : player_name or "",
+                            "player_name" : player.attrs.get("data-player-name") or "",
                             "part_key"    : part_key or ""
                         }
                     )
                     data = resp.json()
                 except:
-                    return None
+                    return []
 
                 iframe_url = data.get("data", {}).get("url")
                 if not iframe_url:
-                    return None
+                    return []
 
                 if "setplay" not in iframe_url and part_key:
                     iframe_url = f"{iframe_url}?partKey={part_key}"
@@ -211,10 +209,40 @@ class SetFilmIzle(PluginBase):
                 if not label and part_key:
                     label = part_key.replace("_", " ").title()
 
-                return await self.extract(iframe_url, prefix=label if label else None)
+                # İsimlendirme Formatı: "FastPlay | Türkçe Dublaj"
+                final_name = player_name
+                if label:
+                    final_name = f"{final_name} | {label}" if final_name else label
 
-        for player in secici.select("nav.player a"):
+                # Extract et
+                extracted = await self.extract(iframe_url)
+                if not extracted:
+                    return []
+
+                results = []
+                items = extracted if isinstance(extracted, list) else [extracted]
+                for item in items:
+                    if final_name:
+                        item.name = final_name
+                    results.append(item)
+
+                return results
+
+        # Selector Güncellemesi: data-player-name içeren tüm a tagleri
+        players = secici.select("a[data-player-name]")
+        if not players:
+            # Fallback legacy selector
+            players = secici.select("nav.player a")
+
+        for player in players:
             tasks.append(fetch_and_extract(player))
 
-        results = await asyncio.gather(*tasks)
-        return [r for r in results if r]
+        results_groups = await asyncio.gather(*tasks)
+
+        # Flatten
+        final_results = []
+        for group in results_groups:
+             if group:
+                 final_results.extend(group)
+
+        return final_results