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

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

KekikStream/Plugins/SezonlukDizi.py

@@ -1,7 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, HTMLHelper
-import asyncio
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, HTMLHelper
+import asyncio, contextlib
 
 class SezonlukDizi(PluginBase):
     name        = "SezonlukDizi"
@@ -40,10 +40,10 @@ class SezonlukDizi(PluginBase):
 
     async def _get_asp_data(self) -> dict:
         js_req = await self.httpx.get(f"{self.main_url}/js/site.min.js")
-        js = HTMLHelper(js_req.text)
-        alt = js.regex_first(r"dataAlternatif(.*?)\.asp")
-        emb = js.regex_first(r"dataEmbed(.*?)\.asp")
-        
+        js     = HTMLHelper(js_req.text)
+        alt    = js.regex_first(r"dataAlternatif(.*?)\.asp")
+        emb    = js.regex_first(r"dataEmbed(.*?)\.asp")
+
         return {
             "alternatif": alt or "",
             "embed":      emb or ""
@@ -116,7 +116,12 @@ class SezonlukDizi(PluginBase):
                 href = e_sel.select_attr("a", "href", tds[3])
                 if name and href:
                     s, e = e_sel.extract_season_episode(f"{tds[1].text(strip=True)} {tds[2].text(strip=True)}")
-                    episodes.append(Episode(season=s or 1, episode=e or 1, title=name, url=self.fix_url(href)))
+                    episodes.append(Episode(
+                        season  = s or 1,
+                        episode = e or 1,
+                        title   = name,
+                        url     = self.fix_url(href)
+                    ))
 
         return SeriesInfo(
             url         = url,
@@ -131,10 +136,10 @@ class SezonlukDizi(PluginBase):
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
-        istek  = await self.httpx.get(url)
-        secici = HTMLHelper(istek.text)
+        istek    = await self.httpx.get(url)
+        secici   = HTMLHelper(istek.text)
         asp_data = await self._get_asp_data()
-        
+
         bid = secici.select_attr("div#dilsec", "data-id")
         if not bid:
             return []
@@ -142,41 +147,64 @@ class SezonlukDizi(PluginBase):
         semaphore = asyncio.Semaphore(5)
         tasks = []
 
-        async def fetch_and_extract(veri, dil_etiketi):
+        async def fetch_and_extract(veri, dil_etiketi) -> list[ExtractResult]:
             async with semaphore:
                 try:
                     embed_resp = await self.httpx.post(
-                        f"{self.main_url}/ajax/dataEmbed{asp_data['embed']}.asp",
+                        url     = f"{self.main_url}/ajax/dataEmbed{asp_data['embed']}.asp",
                         headers = {"X-Requested-With": "XMLHttpRequest"},
                         data    = {"id": str(veri.get("id"))}
                     )
                     embed_secici = HTMLHelper(embed_resp.text)
-                    iframe_src = embed_secici.select_attr("iframe", "src")
-                    
-                    if iframe_src:
-                        if "link.asp" in iframe_src:
-                            return None
-                            
-                        iframe_url = self.fix_url(iframe_src)
-                        return await self.extract(iframe_url, referer=f"{self.main_url}/", prefix=f"{dil_etiketi} - {veri.get('baslik')}")
-                except:
-                    pass
-                return None
+                    iframe_src   = embed_secici.select_attr("iframe", "src") or embed_secici.regex_first(r'src="(.*?)"')
+
+                    if not iframe_src:
+                        return []
+
+                    iframe_url = self.fix_url(iframe_src)
+
+                    real_url = iframe_url
+                    if "url=" in iframe_url:
+                        real_url = HTMLHelper(iframe_url).regex_first(r"url=([^&]+)")
+                        if real_url:
+                            real_url = self.fix_url(real_url)
+
+                    source_name = veri.get('baslik') or "SezonlukDizi"
+                    full_name   = f"{dil_etiketi} - {source_name}"
+
+                    extracted = await self.extract(real_url, referer=f"{self.main_url}/")
+
+                    if not extracted:
+                         return []
+
+                    results = []
+                    items   = extracted if isinstance(extracted, list) else [extracted]
+                    for item in items:
+                        item.name = full_name
+                        results.append(item)
+                    return results
+
+                except Exception:
+                    return []
 
         for dil_kodu, dil_etiketi in [("1", "Altyazı"), ("0", "Dublaj")]:
-            altyazi_resp = await self.httpx.post(
-                f"{self.main_url}/ajax/dataAlternatif{asp_data['alternatif']}.asp",
-                headers = {"X-Requested-With": "XMLHttpRequest"},
-                data    = {"bid": bid, "dil": dil_kodu}
-            )
-            
-            try:
+            with contextlib.suppress(Exception):
+                altyazi_resp = await self.httpx.post(
+                    url     = f"{self.main_url}/ajax/dataAlternatif{asp_data['alternatif']}.asp",
+                    headers = {"X-Requested-With": "XMLHttpRequest"},
+                    data    = {"bid": bid, "dil": dil_kodu}
+                )
+
                 data_json = altyazi_resp.json()
                 if data_json.get("status") == "success" and data_json.get("data"):
                     for veri in data_json["data"]:
                         tasks.append(fetch_and_extract(veri, dil_etiketi))
-            except:
-                continue
 
-        results = await asyncio.gather(*tasks)
-        return [r for r in results if r]
+        results_groups = await asyncio.gather(*tasks)
+
+        final_results = []
+        for group in results_groups:
+             if group:
+                 final_results.extend(group)
+
+        return final_results

KekikStream/Plugins/Sinefy.py

@@ -1,7 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, MovieInfo, ExtractResult, HTMLHelper
-import json, urllib.parse
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, MovieInfo, ExtractResult, HTMLHelper
+import json, contextlib, asyncio
 
 class Sinefy(PluginBase):
     name        = "Sinefy"
@@ -42,14 +42,14 @@ class Sinefy(PluginBase):
         else:
             full_url = f"{url}&page={page}"
 
-        resp = await self.httpx.get(full_url)
-        sel  = HTMLHelper(resp.text)
+        istek  = await self.httpx.get(full_url)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for item in sel.select("div.poster-with-subject, div.dark-segment div.poster-md.poster"):
-            title  = sel.select_text("h2", item)
-            href   = sel.select_attr("a", "href", item)
-            poster = sel.select_attr("img", "data-srcset", item)
+        for item in secici.select("div.poster-with-subject, div.dark-segment div.poster-md.poster"):
+            title  = secici.select_text("h2", item)
+            href   = secici.select_attr("a", "href", item)
+            poster = secici.select_attr("img", "data-srcset", item)
 
             if poster:
                 poster = poster.split(",")[0].split(" ")[0]
@@ -69,89 +69,84 @@ class Sinefy(PluginBase):
         c_key   = "ca1d4a53d0f4761a949b85e51e18f096"
         c_value = "MTc0NzI2OTAwMDU3ZTEwYmZjMDViNWFmOWIwZDViODg0MjU4MjA1ZmYxOThmZTYwMDdjMWQzMzliNzY5NzFlZmViMzRhMGVmNjgwODU3MGIyZA=="
 
-        try:
-            resp = await self.httpx.get(self.main_url)
-            sel  = HTMLHelper(resp.text)
+        with contextlib.suppress(Exception):
+            istek = await self.httpx.get(self.main_url)
+            secici  = HTMLHelper(istek.text)
 
-            cke = sel.select_attr("input[name='cKey']", "value")
-            cval = sel.select_attr("input[name='cValue']", "value")
+            cke  = secici.select_attr("input[name='cKey']", "value")
+            cval = secici.select_attr("input[name='cValue']", "value")
 
             if cke and cval:
                 c_key   = cke
                 c_value = cval
 
-        except Exception:
-            pass
+        response = await self.httpx.post(
+            url     = f"{self.main_url}/bg/searchcontent",
+            headers = {
+                "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0",
+                "Accept"           : "application/json, text/javascript, */*; q=0.01",
+                "X-Requested-With" : "XMLHttpRequest",
+                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8"
+            },
+            data    = {
+                "cKey"       : c_key,
+                "cValue"     : c_value,
+                "searchTerm" : query
+            }
+        )
 
-        post_url = f"{self.main_url}/bg/searchcontent"
-        data = {
-            "cKey"       : c_key,
-            "cValue"     : c_value,
-            "searchTerm" : query
-        }
-        
-        headers = {
-            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0",
-            "Accept"           : "application/json, text/javascript, */*; q=0.01",
-            "X-Requested-With" : "XMLHttpRequest",
-            "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8"
-        }
-        
-        response = await self.httpx.post(post_url, data=data, headers=headers)
-        
-        try:
+        with contextlib.suppress(Exception):
             # Extract JSON data from response (might contain garbage chars at start)
             raw = response.text
             json_start = raw.find('{')
             if json_start != -1:
                 clean_json = raw[json_start:]
-                data = json.loads(clean_json)
-                
+                data       = json.loads(clean_json)
+
                 results = []
                 # Result array is in data['data']['result']
                 res_array = data.get("data", {}).get("result", [])
-                
+
                 if not res_array:
                     # Fallback manual parsing ?
                     pass
 
                 for item in res_array:
-                    name = item.get("object_name")
-                    slug = item.get("used_slug")
+                    name   = item.get("object_name")
+                    slug   = item.get("used_slug")
                     poster = item.get("object_poster_url")
-                    
+
                     if name and slug:
                         if "cdn.ampproject.org" in poster:
                             poster = "https://images.macellan.online/images/movie/poster/180/275/80/" + poster.split("/")[-1]
-                        
+
                         results.append(SearchResult(
-                            title=name,
-                            url=self.fix_url(slug),
-                            poster=self.fix_url(poster)
+                            title  = name,
+                            url    = self.fix_url(slug),
+                            poster = self.fix_url(poster)
                         ))
                 return results
 
-        except Exception:
-            pass
         return []
 
     async def load_item(self, url: str) -> SeriesInfo | MovieInfo:
-        resp = await self.httpx.get(url)
-        sel  = HTMLHelper(resp.text)
+        istek  = await self.httpx.get(url)
+        secici = HTMLHelper(istek.text)
         
-        title       = sel.select_direct_text("h1")
-        poster_attr = sel.select_attr("img.series-profile-thumb", "data-srcset") or sel.select_attr("img.series-profile-thumb", "srcset")
+        title       = secici.select_direct_text("h1")
+        poster_attr = secici.select_attr("img.series-profile-thumb", "data-srcset") or secici.select_attr("img.series-profile-thumb", "srcset")
         if poster_attr:
             # "url 1x, url 2x" -> en sondakini (en yüksek kalite) al
             poster = poster_attr.split(",")[-1].strip().split(" ")[0]
         else:
-            poster = sel.select_poster("img.series-profile-thumb")
-        description = sel.select_text("p#tv-series-desc")
-        tags        = sel.select_texts("div.item.categories a")
-        rating      = sel.select_text("span.color-imdb")
-        actors      = sel.select_texts("div.content h5")
-        year        = sel.extract_year("div.truncate")
-        duration    = sel.regex_first(r"(\d+)", sel.select_text(".media-meta td:last-child"))
+            poster = secici.select_poster("img.series-profile-thumb")
+
+        description = secici.select_text("p#tv-series-desc")
+        tags        = secici.select_texts("div.item.categories a")
+        rating      = secici.select_text("span.color-imdb")
+        actors      = secici.select_texts("div.content h5")
+        year        = secici.extract_year("div.truncate")
+        duration    = secici.regex_first(r"(\d+)", secici.select_text(".media-meta td:last-child"))
         if duration == year or int(duration) < 40:
             duration = None
 
@@ -168,40 +163,136 @@ class Sinefy(PluginBase):
         }
 
         episodes = []
-        for tab in sel.select("div.ui.tab"):
-            for link in sel.select("a[href*='bolum']", tab):
+        for tab in secici.select("div.ui.tab"):
+            for link in secici.select("a[href*='bolum']", tab):
                 href = link.attrs.get("href")
                 if href:
-                    s, e = sel.extract_season_episode(href)
-                    name = sel.select_text("div.content div.header", link) or link.text(strip=True)
+                    s, e = secici.extract_season_episode(href)
+                    name = secici.select_text("div.content div.header", link) or link.text(strip=True)
                     episodes.append(Episode(season=s or 1, episode=e or 1, title=name, url=self.fix_url(href)))
-        
+
         if episodes:
             return SeriesInfo(**common_info, episodes=episodes)
 
         return MovieInfo(**common_info)
 
-    async def load_links(self, url: str) -> list[ExtractResult]:
-        resp = await self.httpx.get(url)
-        sel  = HTMLHelper(resp.text)
-        
-        iframe = sel.select_attr("iframe", "src")
+    def _find_iframe(self, secici: HTMLHelper) -> str | None:
+        """Sayfa kaynağındaki video iframe adresini bulur."""
+        src = secici.select_attr("iframe", "src") or \
+              secici.select_attr("iframe", "data-src") or \
+              secici.regex_first(r'<iframe[^>]+src="([^"]+)"')
+        return self.fix_url(src) if src else None
 
-        if not iframe:
-            return []
-            
-        iframe_url = self.fix_url(iframe)
-        
-        # Try to extract actual video URL, fallback to raw iframe if fails
+    async def _process_source(self, source: dict, subtitles: list) -> list[ExtractResult]:
+        """Tekil bir kaynağı işleyip sonucu döndürür."""
+        target_url = source["url"]
+        name       = source["name"]
+
+        # Eğer direkt iframe değilse (Sayfa linki ise), önce iframe'i bul
+        if not source.get("is_main"):
+            try:
+                resp     = await self.httpx.get(target_url)
+                temp_sel = HTMLHelper(resp.text)
+
+                if not (iframe_url := self._find_iframe(temp_sel)):
+                    return []
+
+                target_url = iframe_url
+
+                # Tab (Dil Seçeneği) ise, gittiğimiz sayfadaki aktif player ismini ekle
+                if source.get("is_tab"):
+                    p_name = temp_sel.select_text("div.alternatives-for-this div.playeritems.active") or "PUB"
+                    name   = f"{name} | {p_name}"
+            except Exception:
+                return []
+
+        # Linki Extract Et
         try:
-            result = await self.extract(iframe_url)
-            if result:
-                return [result] if not isinstance(result, list) else result
+            extracted = await self.extract(target_url, referer=self.main_url)
+            if not extracted:
+                return []
+
+            items = extracted if isinstance(extracted, list) else [extracted]
+
+            # Sonuçları işle (İsim ver, altyazı ekle)
+            copy_subtitles = list(subtitles) # Her item için kopyasını kullan
+            for item in items:
+                item.name = name
+                if copy_subtitles:
+                    if not item.subtitles:
+                        item.subtitles = copy_subtitles
+                    else:
+                        item.subtitles.extend(copy_subtitles)
+
+            return items
         except Exception:
-            pass
-        
-        # Fallback: return raw iframe URL
-        return [ExtractResult(
-            url  = iframe_url,
-            name = "Sinefy Player"
-        )]
+            return []
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek  = await self.httpx.get(url)
+        secici = HTMLHelper(istek.text)
+
+        # 1. Altyazıları Topla
+        subtitles = []
+        for track in secici.select("track"):
+            if track.attrs.get("kind") in ("subtitles", "captions"):
+                if src := track.attrs.get("src"):
+                    lang = track.attrs.get("label") or track.attrs.get("srclang") or "Altyazı"
+                    subtitles.append(self.new_subtitle(src, lang))
+
+        sources = []
+
+        # Aktif Sayfa Bilgileri
+        active_tab_name = secici.select_text("div#series-tabs a.active") or "Sinefy"
+        active_player   = secici.select_text("div.alternatives-for-this div.playeritems.active") or "PUB"
+
+        # A) Ana Video (Main Iframe)
+        if main_iframe := self._find_iframe(secici):
+            sources.append({
+                "url"     : main_iframe,
+                "name"    : f"{active_tab_name} | {active_player}",
+                "is_main" : True,
+                "is_tab"  : False
+            })
+
+        # B) Alternatif Playerlar (Mevcut Sayfa Player Butonları)
+        for btn in secici.select("div.alternatives-for-this div.playeritems:not(.active) a"):
+            if href := btn.attrs.get("href"):
+                if "javascript" not in href:
+                    sources.append({
+                        "url"     : self.fix_url(href),
+                        "name"    : f"{active_tab_name} | {btn.text(strip=True)}",
+                        "is_main" : False,
+                        "is_tab"  : False
+                    })
+
+        # C) Diğer Dil Seçenekleri (Tabs - Sekmeler)
+        for tab in secici.select("div#series-tabs a:not(.active)"):
+            if href := tab.attrs.get("href"):
+                sources.append({
+                    "url"     : self.fix_url(href),
+                    "name"    : tab.text(strip=True),
+                    "is_main" : False,
+                    "is_tab"  : True
+                })
+
+        # 2. Kaynakları Paralel İşle
+        tasks = [self._process_source(src, subtitles) for src in sources]
+        results_groups = await asyncio.gather(*tasks)
+
+        # 3. Sonuçları Birleştir
+        final_results = []
+        for group in results_groups:
+             if group:
+                final_results.extend(group)
+
+        # 4. Duplicate Temizle (URL + İsim Kombinasyonu)
+        unique_results = []
+        seen = set()
+        for res in final_results:
+            key = (res.url, res.name) 
+            if res.url and key not in seen:
+                unique_results.append(res)
+                seen.add(key)
+
+        return unique_results