KekikStream 2.3.9__py3-none-any.whl → 2.5.3__py3-none-any.whl

KekikStream/Plugins/DiziYou.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, Subtitle, ExtractResult, HTMLHelper
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, Subtitle, ExtractResult, HTMLHelper
 
 class DiziYou(PluginBase):
     name        = "DiziYou"
@@ -42,7 +42,7 @@ class DiziYou(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
@@ -61,7 +61,7 @@ class DiziYou(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
@@ -69,87 +69,29 @@ class DiziYou(PluginBase):
     async def load_item(self, url: str) -> SeriesInfo:
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
-        html_text = istek.text
 
-        # Title - div.title h1 içinde
-        title = (secici.select_text("div.title h1") or "").strip()
-
-        # Fallback: Eğer title boşsa URL'den çıkar (telif kısıtlaması olan sayfalar için)
-        if not title:
-            # URL'den slug'ı al: https://www.diziyou.one/jasmine/ -> jasmine -> Jasmine
-            slug = url.rstrip('/').split('/')[-1]
-            title = slug.replace('-', ' ').title()
-
-        # Poster
-        poster_src = secici.select_attr("div.category_image img", "src") or secici.select_attr("meta[property='og:image']", "content")
-        poster = self.fix_url(poster_src) if poster_src else ""
-
-        # Year - regex ile çıkarma (xpath yerine)
-        year = secici.regex_first(r"(?is)Yapım Yılı.*?(\d{4})", secici.html)
-
-        description_el = secici.select("div.diziyou_desc") or secici.select("div#icerikcat")
-        description = ""
-        if description_el:
-             # Scriptleri temizle
-             for script in secici.select("script", description_el[0]):
-                  script.decompose()
-             description = secici.select_text(None, description_el[0])
-
-        tags = [secici.select_text(None, a) for a in secici.select("div.genres a") if secici.select_text(None, a)]
-
-        # Rating - daha spesifik regex ile
-        rating = secici.regex_first(r"(?is)IMDB\s*:\s*</span>([0-9.]+)", secici.html)
-
-        # Actors - regex ile
-        actors_raw = secici.regex_first(r"(?is)Oyuncular.*?</span>([^<]+)", secici.html)
-        actors = [actor.strip() for actor in actors_raw.split(",") if actor.strip()] if actors_raw else []
+        poster      = secici.select_poster("div.category_image img")
+        title       = secici.select_text("h1.title-border")
+        description = secici.select_direct_text("div#icerikcatright")
+        tags        = secici.select_texts("div.genres a")
+        rating      = secici.regex_first(r"(?is)IMDB\s*:\s*</span>([0-9.]+)", secici.html)
+        year        = secici.extract_year("div#icerikcat2")
+        raw_actors  = secici.meta_value("Oyuncular", container_selector="div#icerikcat2")
+        actors      = [x.strip() for x in raw_actors.split(",")] if raw_actors else None
 
         episodes = []
-        # Episodes - div#scrollbar-container a (kısıtlı alan)
         for link in secici.select("div#scrollbar-container a"):
-            ep_href = secici.select_attr(None, "href", link)
-            if not ep_href:
-                continue
-
-            # Link metni veya alt başlık al
-            ep_name = (secici.select_text(None, link) or "").strip()
-            title_child = secici.select_text("div.baslik", link) or secici.select_text("div.bolumismi", link)
-            if title_child:
-                ep_name = title_child
-
-            # Önce metin üzerinden sezon/bölüm çıkart
-            s_val, e_val = HTMLHelper.extract_season_episode(ep_name)
-
-            # URL bazlı kalıplar: -1-sezon-2-bolum gibi
-            if not (s_val or e_val):
-                    pairs = HTMLHelper(ep_href).regex_all(r"-(\d+)-sezon-(\d+)-bolum")
-                    if pairs:
-                        s_val, e_val = int(pairs[0][0]), int(pairs[0][1])
-                    else:
-                        pairs = HTMLHelper(ep_href).regex_all(r"(\d+)-sezon-(\d+)-bolum")
-                        if pairs:
-                            s_val, e_val = int(pairs[0][0]), int(pairs[0][1])
-                        else:
-                            e_val_str = HTMLHelper(ep_href).regex_first(r"(\d+)-bolum")
-                            if e_val_str:
-                                e_val = int(e_val_str)
-            # Metin üzerinden son bir deneme
-            if not e_val:
-                e_str = HTMLHelper(ep_name).regex_first(r"(\d+)\s*\.\s*[Bb]ölüm")
-                if e_str:
-                    e_val = int(e_str)
-            if not s_val:
-                s_str = HTMLHelper(ep_name).regex_first(r"(\d+)\s*\.\s*[Ss]ezon")
-                if s_str:
-                    s_val = int(s_str)
-
-            if e_val or HTMLHelper(ep_href).regex_first(r"-\d+-sezon-\d+-bolum"):
-                episodes.append(Episode(
-                    season  = s_val,
-                    episode = e_val,
-                    title   = ep_name if ep_name else None,
-                    url     = self.fix_url(ep_href),
-                ))
+            href = secici.select_attr(None, "href", link)
+            if href:
+                name = secici.select_text("div.bolumismi", link).strip("()")
+                s, e = secici.extract_season_episode(f"{name} {href}")
+                if e:
+                    episodes.append(Episode(
+                        season  = s or 1,
+                        episode = e,
+                        title   = name,
+                        url     = self.fix_url(href)
+                    ))
 
         return SeriesInfo(
             url         = url,
@@ -167,77 +109,39 @@ class DiziYou(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        # Title ve episode name - None kontrolü ekle
-        item_title = secici.select_text("div.title h1")
-        ep_name = secici.select_text("div#bolum-ismi")
-        
-        # Player src'den item_id çıkar
-        # Player src'den item_id çıkar - önce özel player seçicisini dene
-        player_src = None
-        # Yaygın locatorlar
-        for sel in ["iframe#diziyouPlayer", "div.player iframe", "iframe[src*='/player/']", "iframe[src*='/episodes/']", "iframe"]:
-            p = secici.select_attr(sel, "src")
-            if p and any(x in p.lower() for x in ["/player/", "/episodes/", "diziyou"]):
-                player_src = p
-                break
-
-        # Eğer hâlâ bulunamadıysa, varsa bir bölüm sayfasına git ve oradan player'ı çek
-        if not player_src:
-            for a in secici.select("a"):
-                href = secici.select_attr("a", "href", a)
-                if not href:
-                    continue
-                if HTMLHelper(href).regex_first(r"(-\d+-sezon-\d+-bolum|/bolum|/episode|/episodes|/play)"):
-                        break
-
-        if not player_src:
-            return []  # Player bulunamadıysa boş liste döndür
-
-        item_id = player_src.split("/")[-1].replace(".html", "")
-
-        subtitles   = []
-        stream_urls = []
-
-        for secenek in secici.select("span.diziyouOption"):
-            opt_id  = secici.select_attr("span.diziyouOption", "id", secenek)
-            op_name = secici.select_text("span.diziyouOption", secenek)
-
-            match opt_id:
-                case "turkceAltyazili":
-                    subtitles.append(Subtitle(
-                        name = op_name,
-                        url  = self.fix_url(f"{self.main_url.replace('www', 'storage')}/subtitles/{item_id}/tr.vtt"),
-                    ))
-                    veri = {
-                        "dil": "Orjinal Dil (TR Altyazı)",
-                        "url": f"{self.main_url.replace('www', 'storage')}/episodes/{item_id}/play.m3u8"
-                    }
-                    if veri not in stream_urls:
-                        stream_urls.append(veri)
-                case "ingilizceAltyazili":
-                    subtitles.append(Subtitle(
-                        name = op_name,
-                        url  = self.fix_url(f"{self.main_url.replace('www', 'storage')}/subtitles/{item_id}/en.vtt"),
-                    ))
-                    veri = {
-                        "dil": "Orjinal Dil (EN Altyazı)",
-                        "url": f"{self.main_url.replace('www', 'storage')}/episodes/{item_id}/play.m3u8"
-                    }
-                    if veri not in stream_urls:
-                        stream_urls.append(veri)
-                case "turkceDublaj":
-                    stream_urls.append({
-                        "dil": "Türkçe Dublaj",
-                        "url": f"{self.main_url.replace('www', 'storage')}/episodes/{item_id}_tr/play.m3u8"
-                    })
+        # Player iframe'inden ID'yi yakala
+        iframe_src = secici.select_attr("iframe#diziyouPlayer", "src") or secici.select_attr("iframe[src*='/player/']", "src")
+        if not iframe_src:
+            return []
+
+        item_id      = iframe_src.split("/")[-1].replace(".html", "")
+        base_storage = self.main_url.replace("www", "storage")
+
+        subtitles = []
+        for sub in [("turkceAltyazili", "tr", "Türkçe"), ("ingilizceAltyazili", "en", "İngilizce")]:
+            if secici.select_first(f"span#{sub[0]}"):
+                subtitles.append(Subtitle(
+                    name = f"{sub[2]} Altyazı",
+                    url  = f"{base_storage}/subtitles/{item_id}/{sub[1]}.vtt"
+                ))
 
         results = []
-        for stream in stream_urls:
+        # Altyazılı Seçenek (Eğer varsa)
+        if secici.select_first("span#turkceAltyazili") or secici.select_first("span#ingilizceAltyazili"):
+            results.append(ExtractResult(
+                name      = "Altyazılı",
+                url       = f"{base_storage}/episodes/{item_id}/play.m3u8",
+                referer   = url,
+                subtitles = subtitles
+            ))
+
+        # Dublaj Seçeneği (Eğer varsa)
+        if secici.select_first("span#turkceDublaj"):
             results.append(ExtractResult(
-                url       = stream.get("url"),
-                name      = f"{stream.get('dil')}",
+                name      = "Türkçe Dublaj",
+                url       = f"{base_storage}/episodes/{item_id}_tr/play.m3u8",
                 referer   = url,
                 subtitles = subtitles
             ))
 
-        return results
+        return results

KekikStream/Plugins/Dizilla.py

@@ -1,10 +1,10 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, HTMLHelper
-from json              import loads
-from urllib.parse      import urlparse, urlunparse
-from Crypto.Cipher     import AES
-from base64            import b64decode
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, HTMLHelper
+from json             import loads
+from urllib.parse     import urlparse, urlunparse
+from Crypto.Cipher    import AES
+from base64           import b64decode
 
 class Dizilla(PluginBase):
     name        = "Dizilla"
@@ -44,7 +44,7 @@ class Dizilla(PluginBase):
                     category = category,
                     title    = veri.get("original_title"),
                     url      = self.fix_url(f"{self.main_url}/{veri.get('used_slug')}"),
-                    poster   = self.fix_poster_url(self.fix_url(veri.get("object_poster_url"))),
+                    poster   = self.fix_poster_url(self.fix_url(veri.get("poster_url"))),
                 )
                     for veri in veriler
             ])
@@ -54,21 +54,21 @@ class Dizilla(PluginBase):
 
             # Genel olarak dizi sayfalarına giden linkleri al
             for veri in secici.select('a[href*="/dizi/"]'):
-                href = secici.select_attr('a', 'href', veri)
+                href  = secici.select_attr('a', 'href', veri)
                 title = secici.select_text(None, veri)
                 if not href or not title:
                     continue
 
                 # Detay sayfasından poster vb. bilgileri al
-                ep_req = await self.httpx.get(self.fix_url(href))
+                ep_req    = await self.httpx.get(self.fix_url(href))
                 ep_secici = HTMLHelper(ep_req.text)
-                poster = ep_secici.select_attr('img.imgt', 'src') or ep_secici.select_attr('img', 'src')
+                poster    = ep_secici.select_poster('img.imgt') or ep_secici.select_poster('img')
 
                 ana_sayfa.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 ana_sayfa
@@ -155,43 +155,25 @@ class Dizilla(PluginBase):
         description = content.get("description") or content.get("used_description")
         rating      = content.get("imdb_point") or content.get("local_vote_avg")
         year        = content.get("release_year")
-        
-        # Poster and Backdrop - prefer backdrop if available for SeriesInfo
-        poster = self.fix_poster_url(self.fix_url(content.get("back_url") or content.get("poster_url")))
-
-        # Tags
-        tags = []
-        categories = decrypted.get("RelatedResults", {}).get("getSerieCategoriesById", {}).get("result", [])
-        for cat in categories:
-            tags.append(cat.get("name"))
-
-        # Actors
-        actors = []
-        casts = decrypted.get("RelatedResults", {}).get("getSerieCastsById", {}).get("result", [])
-        for cast in casts:
-            actors.append(cast.get("name"))
-
-        # Episodes
-        episodes = []
-        seasons_data = decrypted.get("RelatedResults", {}).get("getSerieSeasonAndEpisodes", {}).get("result", [])
-        for season_item in seasons_data:
-            season_num = season_item.get("season_no")
-            for ep_item in season_item.get("episodes", []):
-                ep_num = ep_item.get("episode_no")
-                ep_slug = ep_item.get("used_slug")
-                ep_name = ep_item.get("episode_text") or ""
-                
-                # Filter out duplicate language entries if any (we just need one link per episode)
-                # Usually they share the same slug for the episode page
-                if any(e.season == season_num and e.episode == ep_num for e in episodes):
-                    continue
+        poster      = self.fix_poster_url(self.fix_url(content.get("back_url") or content.get("poster_url")))
 
-                episodes.append(Episode(
-                    season  = season_num,
-                    episode = ep_num,
-                    title   = ep_name,
-                    url     = self.fix_url(f"{self.main_url}/{ep_slug}")
-                ))
+        tags   = [cat.get("name") for cat in decrypted.get("RelatedResults", {}).get("getSerieCategoriesById", {}).get("result", [])]
+        actors = [cast.get("name") for cast in decrypted.get("RelatedResults", {}).get("getSerieCastsById", {}).get("result", [])]
+
+        episodes = []
+        for season in decrypted.get("RelatedResults", {}).get("getSerieSeasonAndEpisodes", {}).get("result", []):
+            s_no = season.get("season_no")
+            for ep in season.get("episodes", []):
+                e_no = ep.get("episode_no")
+                slug = ep.get("used_slug")
+                name = ep.get("episode_text") or ""
+                if not any(e.season == s_no and e.episode == e_no for e in episodes):
+                    episodes.append(Episode(
+                        season  = s_no,
+                        episode = e_no,
+                        title   = name,
+                        url     = self.fix_url(f"{self.main_url}/{slug}")
+                    ))
 
         return SeriesInfo(
             url         = url,
@@ -199,21 +181,21 @@ class Dizilla(PluginBase):
             title       = title,
             description = description,
             tags        = tags,
-            rating      = str(rating) if rating else None,
-            year        = str(year) if year else None,
+            rating      = rating,
+            year        = year,
             episodes    = episodes,
             actors      = actors
         )
 
     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)
 
         next_data_text = secici.select_text("script#__NEXT_DATA__")
         if not next_data_text:
             return []
 
-        next_data = loads(next_data_text)
+        next_data   = loads(next_data_text)
         secure_data = next_data.get("props", {}).get("pageProps", {}).get("secureData", {})
         decrypted   = await self.decrypt_response(secure_data)
         results     = decrypted.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
@@ -221,24 +203,21 @@ class Dizilla(PluginBase):
         if not results:
             return []
 
-        # Get first source (matching Kotlin)
-        first_result = results[0]
+        first_result   = results[0]
         source_content = str(first_result.get("source_content", ""))
-        
-        # Clean the source_content string (matching Kotlin: .replace("\"", "").replace("\\", ""))
+
         cleaned_source = source_content.replace('"', '').replace('\\', '')
-        
-        # Parse cleaned HTML
+
         iframe_secici = HTMLHelper(cleaned_source)
-        iframe_src = iframe_secici.select_attr("iframe", "src")
-        
-        # Referer check (matching Kotlin: loadExtractor(iframe, "${mainUrl}/", ...))
+        iframe_src    = iframe_secici.select_attr("iframe", "src")
+
         iframe_url = self.fix_url(iframe_src) if iframe_src else None
-        
+
         if not iframe_url:
             return []
 
         data = await self.extract(iframe_url, referer=f"{self.main_url}/", prefix=first_result.get('language_name', 'Unknown'))
         if not data:
             return []
+
         return data if isinstance(data, list) else [data]

KekikStream/Plugins/FilmBip.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
+from contextlib       import suppress
 
 class FilmBip(PluginBase):
     name        = "FilmBip"
@@ -39,8 +40,8 @@ class FilmBip(PluginBase):
 
         results = []
         for veri in secici.select("div.poster-long"):
-            title = secici.select_attr("a.block img.lazy", "alt", veri)
-            href = secici.select_attr("a.block", "href", veri)
+            title  = secici.select_attr("a.block img.lazy", "alt", veri)
+            href   = secici.select_attr("a.block", "href", veri)
             poster = secici.select_poster("a.block img.lazy", veri)
 
             if title and href:
@@ -48,7 +49,7 @@ class FilmBip(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
@@ -87,7 +88,7 @@ class FilmBip(PluginBase):
                 results.append(SearchResult(
                     title  = title.strip(),
                     url    = self.fix_url(href),
-                    poster = self.fix_url(poster) if poster else None,
+                    poster = self.fix_url(poster),
                 ))
 
         return results
@@ -95,40 +96,26 @@ class FilmBip(PluginBase):
     async def load_item(self, url: str) -> MovieInfo:
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
-        html_text = istek.text
-
-        title = secici.select_text("div.page-title h1") or ""
-
-        poster = secici.select_attr("meta[property='og:image']", "content")
-
-        trailer = secici.select_attr("div.series-profile-trailer", "data-yt")
 
+        title       = self.clean_title(secici.select_direct_text("div.page-title h1"))
+        poster      = secici.select_poster("div.series-profile-image a img")
         description = secici.select_text("div.series-profile-infos-in.article p") or secici.select_text("div.series-profile-summary p")
-        
-        tags = secici.select_all_text("div.series-profile-type.tv-show-profile-type a")
-
-        # XPath yerine regex kullanarak yıl, süre vs. çıkarma
-        year = secici.regex_first(r"(?is)Yap\u0131m y\u0131l\u0131.*?<p[^>]*>(.*?)<\/p>")
-        if not year:
-            # Fallback: Başlığın sonundaki parantezli yılı yakala
-            year = secici.regex_first(r"\((\d{4})\)", title)
-
-        duration_raw = secici.regex_first(r"(?is)S\u00fcre.*?<p[^>]*>(.*?)<\/p>")
-        duration = secici.regex_first(r"(\d+)", duration_raw) if duration_raw else None
-
-        rating = secici.regex_first(r"(?is)IMDB Puan\u0131.*?<span[^>]*>(.*?)<\/span>")
-
-        actors = [img.attrs.get("alt") for img in secici.select("div.series-profile-cast ul li a img") if img.attrs.get("alt")]
+        tags        = secici.select_texts("div.series-profile-type.tv-show-profile-type a")
+        year        = secici.extract_year("div.series-profile-infos-in") or secici.regex_first(r"\((\d{4})\)", title)
+        duration    = secici.regex_first(r"(\d+)", secici.meta_value("Süre", container_selector="div.series-profile-infos"))
+        rating      = secici.meta_value("IMDB Puanı", container_selector="div.series-profile-infos")
+        rating      = rating.split("(")[0] if rating else None
+        actors      = secici.select_attrs("div.series-profile-cast ul li a img", "alt")
 
         return MovieInfo(
             url         = url,
-            poster      = self.fix_url(poster) if poster else None,
-            title       = HTMLHelper(title).regex_replace(r"\(\d{4}\)", "").strip() if title else "",
+            poster      = self.fix_url(poster),
+            title       = title,
             description = description,
             tags        = tags,
             year        = year,
             rating      = rating,
-            duration    = int(duration) if duration else None,
+            duration    = duration,
             actors      = actors,
         )
 
@@ -137,14 +124,78 @@ class FilmBip(PluginBase):
         secici = HTMLHelper(istek.text)
 
         results = []
-
-        for player in secici.select("div#tv-spoox2"):
-            iframe    = secici.select_attr("iframe", "src", player)
-
-            if iframe:
-                iframe = self.fix_url(iframe)
-                data = await self.extract(iframe)
-                if data:
-                    results.append(data)
+        for tab in secici.select("ul.tab.alternative-group li[data-number]"):
+            tab_id   = tab.attrs.get("data-number")
+            tab_name = secici.select_text(None, tab)
+            tab_hash = tab.attrs.get("data-group-hash")
+
+            if not tab_id:
+                continue
+
+            button_data = [] # (player_name, iframe_url)
+
+            # İlgili content divini bul
+            content_div = secici.select_first(f"div#{tab_id}")
+
+            # Eğer div var ve içi doluysa oradan al
+            if content_div and secici.select("ul li button", content_div):
+                buttons = secici.select("ul li button", content_div)
+                for btn in buttons:
+                    button_data.append((btn.text(strip=True), btn.attrs.get("data-hhs")))
+
+            elif tab_hash:
+                # Div yok veya boş, AJAX ile çek
+                with suppress(Exception):
+                    hash_resp = await self.httpx.post(
+                        url     = f"{self.main_url}/get/video/group",
+                        headers = {
+                            "X-Requested-With" : "XMLHttpRequest",
+                            "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+                            "Referer"          : url
+                        },
+                        data    = {"hash": tab_hash}
+                    )
+
+                    if hash_resp.status_code == 200:
+                        json_data = hash_resp.json()
+                        if json_data.get("success"):
+                            # 1. Videos listesi (API yanıtı)
+                            if videos := json_data.get("videos"):
+                                for vid in videos:
+                                    button_data.append((vid.get("name"), vid.get("link")))
+
+                            # 2. HTML content (Fallback)
+                            else:
+                                html_content = json_data.get("content") or json_data.get("html") or json_data.get("theme")
+                                if html_content:
+                                    sub_helper = HTMLHelper(html_content)
+                                    sub_btns = sub_helper.select("ul li button")
+                                    for btn in sub_btns:
+                                        button_data.append((btn.text(strip=True), btn.attrs.get("data-hhs")))
+
+            for player_name, iframe_url in button_data:
+                with suppress(Exception):
+                    if iframe_url:
+                        data = await self.extract(
+                            url           = self.fix_url(iframe_url),
+                            name_override = f"{tab_name} | {player_name}"
+                        )
+                        if data:
+                            if isinstance(data, list):
+                                results.extend(data)
+                            else:
+                                results.append(data)
+
+        # Eğer hiç sonuç bulunamazsa fallback
+        if not results:
+             for player in secici.select("div#tv-spoox2"):
+                if iframe := secici.select_attr("iframe", "src", player):
+                    iframe = self.fix_url(iframe)
+                    data = await self.extract(iframe)
+                    if data:
+                        if isinstance(data, list):
+                            results.extend(data)
+                        else:
+                            results.append(data)
 
         return results