KekikStream 2.0.2__py3-none-any.whl → 2.2.0__py3-none-any.whl

KekikStream/Plugins/SelcukFlix.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
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult
 from parsel           import Selector
 import re, base64, json, urllib.parse
 
@@ -9,7 +9,7 @@ class SelcukFlix(PluginBase):
     lang        = "tr"
     main_url    = "https://selcukflix.net"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Selcukflix'te her türden en yeni ve en popüler dizi ve filmleri izlemenin keyfini çıkarın. Aksiyondan romantiğe, bilim kurgudan dramaya, geniş kütüphanemizde herkes için bir şey var."
+    description = "Selcukflix'te her türden en yeni ve en popüler dizi ve filmleri izlemenin keyfini çıkarın. Aksiyondan romantiğe, bilim kurgudan dramaya, geniş kütüphanemizde herkes için bir şey var."
 
     main_page = {
         f"{main_url}/tum-bolumler" : "Yeni Eklenen Bölümler",
@@ -137,8 +137,13 @@ class SelcukFlix(PluginBase):
         search_url = f"{self.main_url}/api/bg/searchcontent?searchterm={query}"
 
         headers = {
+            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0",
             "Accept"           : "application/json, text/plain, */*",
+            "Accept-Language"  : "en-US,en;q=0.5",
             "X-Requested-With" : "XMLHttpRequest",
+            "Sec-Fetch-Site"   : "same-origin",
+            "Sec-Fetch-Mode"   : "cors",
+            "Sec-Fetch-Dest"   : "empty",
             "Referer"          : f"{self.main_url}/"
         }
 
@@ -151,15 +156,16 @@ class SelcukFlix(PluginBase):
             try:
                 decoded_str = raw_data.decode('utf-8')
             except UnicodeDecodeError:
-                decoded_str = raw_data.decode('iso-8859-1').encode('utf-8').decode('utf-8')
+                decoded_str = raw_data.decode('iso-8859-1')
 
             search_data = json.loads(decoded_str)
 
             results = []
             for item in search_data.get("result", []):
-                title  = item.get("title")
-                slug   = item.get("slug")
-                poster = item.get("poster")
+                # API field isimleri: object_name, used_slug, object_poster_url
+                title  = item.get("object_name") or item.get("title")
+                slug   = item.get("used_slug") or item.get("slug")
+                poster = item.get("object_poster_url") or item.get("poster")
 
                 if poster:
                     poster = self.clean_image_url(poster)
@@ -176,7 +182,7 @@ class SelcukFlix(PluginBase):
         except Exception:
             return []
 
-    async def load_item(self, url: str) -> SeriesInfo:
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         resp = await self.httpx.get(url)
         sel  = Selector(resp.text)
 
@@ -190,15 +196,17 @@ class SelcukFlix(PluginBase):
         try:
             decoded_str = raw_data.decode('utf-8')
         except UnicodeDecodeError:
-            decoded_str = raw_data.decode('iso-8859-1') # .encode('utf-8').decode('utf-8') implied
+            decoded_str = raw_data.decode('iso-8859-1')
 
         content_details = json.loads(decoded_str)
         item            = content_details.get("contentItem", {})
 
-        title           = item.get("original_title") or item.get("originalTitle")
+        title           = item.get("original_title") or item.get("originalTitle") or ""
         poster          = self.clean_image_url(item.get("poster_url") or item.get("posterUrl"))
         description     = item.get("description") or item.get("used_description")
         rating          = str(item.get("imdb_point") or item.get("imdbPoint", ""))
+        year            = item.get("release_year") or item.get("releaseYear")
+        duration        = item.get("total_minutes") or item.get("totalMinutes")
 
         series_data     = content_details.get("relatedData", {}).get("seriesData")
         if not series_data and "RelatedResults" in content_details:
@@ -206,17 +214,18 @@ class SelcukFlix(PluginBase):
              if series_data and isinstance(series_data, list):
                   pass
 
-        episodes = []
+        # Dizi mi film mi kontrol et (Kotlin referansı)
         if series_data:
-             seasons_list = []
-             if isinstance(series_data, dict):
-                 seasons_list = series_data.get("seasons", [])
-             elif isinstance(series_data, list):
-                 seasons_list = series_data
-
-             for season in seasons_list:
+            episodes = []
+            seasons_list = []
+            if isinstance(series_data, dict):
+                seasons_list = series_data.get("seasons", [])
+            elif isinstance(series_data, list):
+                seasons_list = series_data
+
+            for season in seasons_list:
                 if not isinstance(season, dict): continue
-                s_no = season.get("season_no") or season.get("seasonNo") # Try snake_case too
+                s_no = season.get("season_no") or season.get("seasonNo")
                 ep_list = season.get("episodes", [])
                 for ep in ep_list:
                     episodes.append(Episode(
@@ -225,75 +234,85 @@ class SelcukFlix(PluginBase):
                         title   = ep.get("ep_text") or ep.get("epText"),
                         url     = self.fix_url(ep.get("used_slug") or ep.get("usedSlug"))
                     ))
-        
-        return SeriesInfo(
-            title       = title,
-            url         = url,
-            poster      = poster,
-            description = description,
-            rating      = rating,
-            episodes    = episodes
-        )
-
-    async def load_links(self, url: str) -> list[dict]:
+            
+            return SeriesInfo(
+                title       = title,
+                url         = url,
+                poster      = poster,
+                description = description,
+                rating      = rating,
+                year        = year,
+                episodes    = episodes
+            )
+        else:
+            # Film ise MovieInfo döndür
+            return MovieInfo(
+                title       = title,
+                url         = url,
+                poster      = poster,
+                description = description,
+                rating      = rating,
+                year        = year,
+                duration    = duration
+            )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
         resp = await self.httpx.get(url)
         sel  = Selector(resp.text)
         
         next_data = sel.css("script#__NEXT_DATA__::text").get()
-        if not next_data: return []
+        if not next_data:
+            return []
 
         try:
-             data = json.loads(next_data)
-             secure_data = data["props"]["pageProps"]["secureData"]
-             raw_data = base64.b64decode(secure_data.replace('"', ''))
-             try:
-                 decoded_str = raw_data.decode('utf-8')
-             except UnicodeDecodeError:
-                 decoded_str = raw_data.decode('iso-8859-1')
+            data = json.loads(next_data)
+            secure_data = data["props"]["pageProps"]["secureData"]
+            raw_data = base64.b64decode(secure_data.replace('"', ''))
             
-             content_details = json.loads(decoded_str)
-             related_data = content_details.get("relatedData", {})
-             
-             source_content = None
-             
-             # Check if Series (episode) or Movie
-             if "/dizi/" in url:
-                 if related_data.get("episodeSources", {}).get("state"):
-                      res = related_data["episodeSources"].get("result", [])
-                      if res:
-                          source_content = res[0].get("sourceContent")
-             else:
-                 # Movie
-                 if related_data.get("movieParts", {}).get("state"):
-                      # Looking for first part source
-                      movie_parts = related_data["movieParts"].get("result", [])
-                      if movie_parts:
-                          first_part_id = movie_parts[0].get("id")
-                          # RelatedResults -> getMoviePartSourcesById_ID
-                          rr = content_details.get("RelatedResults", {})
-                          key = f"getMoviePartSourcesById_{first_part_id}"
-                          if key in rr:
-                              res = rr[key].get("result", [])
-                              if res:
-                                  source_content = res[0].get("source_content")
-
-             results = []
-             if source_content:
-                 iframe_sel = Selector(source_content)
-                 iframe_src = iframe_sel.css("iframe::attr(src)").get()
-                 if iframe_src:
-                     iframe_src = self.fix_url(iframe_src)
-                     # Domain replace
-                     if "sn.dplayer74.site" in iframe_src:
-                         iframe_src = iframe_src.replace("sn.dplayer74.site", "sn.hotlinger.com")
-                     
-                     extractor = self.ex_manager.find_extractor(iframe_src)
-                     results.append({
-                         "url": iframe_src,
-                         "name": extractor.name if extractor else "Iframe"
-                     })
-             
-             return results
+            try:
+                decoded_str = raw_data.decode('utf-8')
+            except UnicodeDecodeError:
+                decoded_str = raw_data.decode('iso-8859-1')
+            
+            content_details = json.loads(decoded_str)
+            related_results = content_details.get("RelatedResults", {})
+            
+            source_content = None
+            
+            # Dizi (bölüm) için
+            if "/dizi/" in url:
+                episode_sources = related_results.get("getEpisodeSources", {})
+                if episode_sources.get("state"):
+                    res = episode_sources.get("result", [])
+                    if res:
+                        source_content = res[0].get("source_content") or res[0].get("sourceContent")
+            else:
+                # Film için
+                movie_parts = related_results.get("getMoviePartsById", {})
+                if movie_parts.get("state"):
+                    parts = movie_parts.get("result", [])
+                    if parts:
+                        first_part_id = parts[0].get("id")
+                        key = f"getMoviePartSourcesById_{first_part_id}"
+                        if key in related_results:
+                            res = related_results[key].get("result", [])
+                            if res:
+                                source_content = res[0].get("source_content") or res[0].get("sourceContent")
+
+            if source_content:
+                iframe_sel = Selector(source_content)
+                iframe_src = iframe_sel.css("iframe::attr(src)").get()
+                if iframe_src:
+                    iframe_src = self.fix_url(iframe_src)
+                    # Hotlinger domain değişimi (Kotlin referansı)
+                    if "sn.dplayer74.site" in iframe_src:
+                        iframe_src = iframe_src.replace("sn.dplayer74.site", "sn.hotlinger.com")
+                    
+                    data = await self.extract(iframe_src)
+                    if data:
+                        return [data]
+            
+            return []
 
         except Exception:
             return []

KekikStream/Plugins/SetFilmIzle.py

@@ -0,0 +1,252 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult
+from parsel           import Selector
+import re, json
+
+class SetFilmIzle(PluginBase):
+    name        = "SetFilmIzle"
+    language    = "tr"
+    main_url    = "https://www.setfilmizle.uk"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Setfilmizle sitemizde, donma yaşamadan Türkçe dublaj ve altyazılı filmleri ile dizileri muhteşem 1080p full HD kalitesinde izleyebilirsiniz."
+
+    main_page   = {
+        f"{main_url}/tur/aile/"        : "Aile",
+        f"{main_url}/tur/aksiyon/"     : "Aksiyon",
+        f"{main_url}/tur/animasyon/"   : "Animasyon",
+        f"{main_url}/tur/belgesel/"    : "Belgesel",
+        f"{main_url}/tur/bilim-kurgu/" : "Bilim-Kurgu",
+        f"{main_url}/tur/biyografi/"   : "Biyografi",
+        f"{main_url}/tur/dini/"        : "Dini",
+        f"{main_url}/tur/dram/"        : "Dram",
+        f"{main_url}/tur/fantastik/"   : "Fantastik",
+        f"{main_url}/tur/genclik/"     : "Gençlik",
+        f"{main_url}/tur/gerilim/"     : "Gerilim",
+        f"{main_url}/tur/gizem/"       : "Gizem",
+        f"{main_url}/tur/komedi/"      : "Komedi",
+        f"{main_url}/tur/korku/"       : "Korku",
+        f"{main_url}/tur/macera/"      : "Macera",
+        f"{main_url}/tur/romantik/"    : "Romantik",
+        f"{main_url}/tur/savas/"       : "Savaş",
+        f"{main_url}/tur/suc/"         : "Suç",
+        f"{main_url}/tur/tarih/"       : "Tarih",
+        f"{main_url}/tur/western/"     : "Western"
+    }
+
+    def _get_nonce(self, nonce_type: str = "video_nonce", referer: str = None) -> str:
+        """Site cache'lenmiş nonce'ları expire olabiliyor, fresh nonce al"""
+        try:
+            resp = self.cloudscraper.post(
+                f"{self.main_url}/wp-admin/admin-ajax.php",
+                headers = {
+                    "Referer"      : referer or self.main_url,
+                    "Origin"       : self.main_url,
+                    "Content-Type" : "application/x-www-form-urlencoded",
+                },
+                data = "action=st_cache_refresh_nonces"
+            )
+            nonces = resp.json().get("data", {}).get("nonces", {})
+            return nonces.get(nonce_type, "")
+        except:
+            return ""
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = self.cloudscraper.get(url)
+        secici = Selector(istek.text)
+
+        results = []
+        for item in secici.css("div.items article"):
+            title  = item.css("h2::text").get()
+            href   = item.css("a::attr(href)").get()
+            poster = item.css("img::attr(data-src)").get()
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = title.strip(),
+                    url      = self.fix_url(href),
+                    poster   = self.fix_url(poster) if poster else None
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        nonce = self._get_nonce("search")
+
+        search_resp = self.cloudscraper.post(
+            f"{self.main_url}/wp-admin/admin-ajax.php",
+            headers = {
+                "X-Requested-With" : "XMLHttpRequest",
+                "Content-Type"     : "application/x-www-form-urlencoded",
+                "Referer"          : f"{self.main_url}/"
+            },
+            data    = {
+                "action"          : "ajax_search",
+                "search"          : query,
+                "original_search" : query,
+                "nonce"           : nonce
+            }
+        )
+
+        try:
+            data = search_resp.json()
+            html = data.get("html", "")
+        except:
+            return []
+
+        secici  = Selector(text=html)
+        results = []
+
+        for item in secici.css("div.items article"):
+            title  = item.css("h2::text").get()
+            href   = item.css("a::attr(href)").get()
+            poster = item.css("img::attr(data-src)").get()
+
+            if title and href:
+                results.append(SearchResult(
+                    title  = title.strip(),
+                    url    = self.fix_url(href),
+                    poster = self.fix_url(poster) if poster else None
+                ))
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        raw_title   = secici.css("h1::text").get() or ""
+        title       = re.sub(r"\s*izle.*$", "", raw_title, flags=re.IGNORECASE).strip()
+        poster      = secici.css("div.poster img::attr(src)").get()
+        description = secici.css("div.wp-content p::text").get()
+        year        = secici.css("div.extra span.C a::text").get()
+        if year:
+            year_match = re.search(r"\d{4}", year)
+            year = year_match.group() if year_match else None
+        tags     = [a.css("::text").get().strip() for a in secici.css("div.sgeneros a") if a.css("::text").get()]
+        duration = secici.css("span.runtime::text").get()
+        if duration:
+            dur_match = re.search(r"\d+", duration)
+            duration = int(dur_match.group()) if dur_match else None
+
+        actors = [span.css("::text").get().strip() for span in secici.css("span.valor a > span") if span.css("::text").get()]
+
+        trailer_match = re.search(r'embed/([^?]*)\?rel', istek.text)
+        trailer = f"https://www.youtube.com/embed/{trailer_match.group(1)}" if trailer_match else None
+
+        # Dizi mi film mi kontrol et
+        is_series = "/dizi/" in url
+
+        if is_series:
+            year_elem = secici.css("a[href*='/yil/']::text").get()
+            if year_elem:
+                year_match = re.search(r"\d{4}", year_elem)
+                year = year_match.group() if year_match else year
+
+            dur_elem = secici.css("div#info span:contains('Dakika')::text").get()
+            if dur_elem:
+                dur_match = re.search(r"\d+", dur_elem)
+                duration = int(dur_match.group()) if dur_match else duration
+
+            episodes = []
+            for ep_item in secici.css("div#episodes ul.episodios li"):
+                ep_href = ep_item.css("h4.episodiotitle a::attr(href)").get()
+                ep_name = ep_item.css("h4.episodiotitle a::text").get()
+
+                if not ep_href or not ep_name:
+                    continue
+
+                ep_detail = ep_name.strip()
+                season_match = re.search(r"(\d+)\.\s*Sezon", ep_detail)
+                episode_match = re.search(r"Sezon\s+(\d+)\.\s*Bölüm", ep_detail)
+
+                ep_season = int(season_match.group(1)) if season_match else 1
+                ep_episode = int(episode_match.group(1)) if episode_match else None
+
+                episodes.append(Episode(
+                    season  = ep_season,
+                    episode = ep_episode,
+                    title   = ep_name.strip(),
+                    url     = self.fix_url(ep_href)
+                ))
+
+            return SeriesInfo(
+                url         = url,
+                poster      = self.fix_url(poster) if poster else None,
+                title       = title,
+                description = description.strip() if description else None,
+                tags        = tags,
+                year        = year,
+                duration    = duration,
+                actors      = actors,
+                episodes    = episodes
+            )
+
+        return MovieInfo(
+            url         = url,
+            poster      = self.fix_url(poster) if poster else None,
+            title       = title,
+            description = description.strip() if description else None,
+            tags        = tags,
+            year        = year,
+            duration    = duration,
+            actors      = actors
+        )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        nonce = self._get_nonce("video_nonce", referer=url)
+
+        # partKey to dil label mapping
+        part_key_labels = {
+            "turkcedublaj"  : "Türkçe Dublaj",
+            "turkcealtyazi" : "Türkçe Altyazı",
+            "orijinal"      : "Orijinal"
+        }
+
+        links = []
+        for player in secici.css("nav.player a"):
+            source_id   = player.css("::attr(data-post-id)").get()
+            player_name = player.css("::attr(data-player-name)").get()
+            part_key    = player.css("::attr(data-part-key)").get()
+
+            if not source_id or "event" in source_id or source_id == "":
+                continue
+
+            try:
+                resp = self.cloudscraper.post(
+                    f"{self.main_url}/wp-admin/admin-ajax.php",
+                    headers = {"Referer": url},
+                    data    = {
+                        "action"      : "get_video_url",
+                        "nonce"       : nonce,
+                        "post_id"     : source_id,
+                        "player_name" : player_name or "",
+                        "part_key"    : part_key or ""
+                    }
+                )
+                data = resp.json()
+            except:
+                continue
+
+            iframe_url = data.get("data", {}).get("url")
+            if not iframe_url:
+                continue
+
+            # SetPlay URL'si için part_key ekleme
+            if "setplay" not in iframe_url and part_key:
+                iframe_url = f"{iframe_url}?partKey={part_key}"
+
+            # Dil etiketi oluştur
+            label = part_key_labels.get(part_key, "")
+            if not label and part_key:
+                label = part_key.replace("_", " ").title()
+
+            data = await self.extract(iframe_url, prefix=label if label else None)
+            if data:
+                links.append(data)
+
+        return links

KekikStream/Plugins/SezonlukDizi.py

@@ -1,7 +1,8 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult
 from parsel           import Selector
+import re
 
 class SezonlukDizi(PluginBase):
     name        = "SezonlukDizi"
@@ -19,6 +20,23 @@ class SezonlukDizi(PluginBase):
         f"{main_url}/diziler.asp?siralama_tipi=id&kat=4&s="    : "Animasyonlar",
         f"{main_url}/diziler.asp?siralama_tipi=id&kat=5&s="    : "Animeler",
         f"{main_url}/diziler.asp?siralama_tipi=id&kat=6&s="    : "Belgeseller",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=aile&s="       : "Aile",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=aksiyon&s="    : "Aksiyon",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=bilimkurgu&s=" : "Bilim Kurgu",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=biyografik&s=" : "Biyografi",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=dram&s="       : "Dram",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=fantastik&s="  : "Fantastik",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=gerilim&s="    : "Gerilim",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=gizem&s="      : "Gizem",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=korku&s="      : "Korku",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=komedi&s="     : "Komedi",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=macera&s="     : "Macera",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=muzikal&s="    : "Müzikal",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=suc&s="        : "Suç",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=romantik&s="   : "Romantik",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=savas&s="      : "Savaş",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=tarihi&s="     : "Tarihi",
+        f"{main_url}/diziler.asp?siralama_tipi=id&tur=western&s="    : "Western"
     }
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
@@ -99,7 +117,21 @@ class SezonlukDizi(PluginBase):
             actors      = actors
         )
 
-    async def load_links(self, url: str) -> list[dict]:
+    async def get_asp_data(self) -> tuple[str, str]:
+        """Fetch dynamic ASP version numbers from site.min.js"""
+        try:
+            js_content = await self.httpx.get(f"{self.main_url}/js/site.min.js")
+            alternatif_match = re.search(r'dataAlternatif(.*?)\.asp', js_content.text)
+            embed_match = re.search(r'dataEmbed(.*?)\.asp', js_content.text)
+            
+            alternatif_ver = alternatif_match.group(1) if alternatif_match else "22"
+            embed_ver = embed_match.group(1) if embed_match else "22"
+            
+            return (alternatif_ver, embed_ver)
+        except Exception:
+            return ("22", "22")  # Fallback to default versions
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
@@ -107,10 +139,13 @@ class SezonlukDizi(PluginBase):
         if not bid:
             return []
 
+        # Get dynamic ASP versions
+        alternatif_ver, embed_ver = await self.get_asp_data()
+
         results = []
         for dil, label in [("1", "Altyazı"), ("0", "Dublaj")]:
             dil_istek = await self.httpx.post(
-                url     = f"{self.main_url}/ajax/dataAlternatif22.asp",
+                url     = f"{self.main_url}/ajax/dataAlternatif{alternatif_ver}.asp",
                 headers = {"X-Requested-With": "XMLHttpRequest"},
                 data    = {"bid": bid, "dil": dil},
             )
@@ -123,7 +158,7 @@ class SezonlukDizi(PluginBase):
             if dil_json.get("status") == "success":
                 for idx, veri in enumerate(dil_json.get("data", [])):
                     veri_response = await self.httpx.post(
-                        url     = f"{self.main_url}/ajax/dataEmbed22.asp",
+                        url     = f"{self.main_url}/ajax/dataEmbed{embed_ver}.asp",
                         headers = {"X-Requested-With": "XMLHttpRequest"},
                         data    = {"id": veri.get("id")},
                     )
@@ -133,10 +168,9 @@ class SezonlukDizi(PluginBase):
                         if "link.asp" in iframe:
                             continue
                             
-                        extractor = self.ex_manager.find_extractor(self.fix_url(iframe))
-                        results.append({
-                            "url"  : self.fix_url(iframe),
-                            "name" : f"{extractor.name if extractor else f'{label} - Player {idx + 1}'}"
-                        })
+                        iframe_url = self.fix_url(iframe)
+                        data = await self.extract(iframe_url, prefix=label)
+                        if data:
+                            results.append(data)
 
         return results