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

KekikStream/Plugins/JetFilmizle.py

@@ -1,8 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult
-from selectolax.parser import HTMLParser
-import re
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, HTMLHelper
+import asyncio
 
 class JetFilmizle(PluginBase):
     name        = "JetFilmizle"
@@ -40,30 +39,26 @@ class JetFilmizle(PluginBase):
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(f"{url}{page}", follow_redirects=True)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("article.movie"):
-            # h2-h6 içindeki a linki
-            title_link = None
+        for veri in secici.select("article.movie"):
+            title_text = None
             for h_tag in ["h2", "h3", "h4", "h5", "h6"]:
-                title_link = veri.css_first(f"{h_tag} a")
-                if title_link:
+                title_text = secici.select_text(f"{h_tag} a", veri)
+                if title_text:
                     break
 
-            link_el = veri.css_first("a")
-            img_el  = veri.css_first("img")
-
-            title  = self.clean_title(title_link.text(strip=True)) if title_link else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = (img_el.attrs.get("data-src") or img_el.attrs.get("src")) if img_el else None
+            title  = self.clean_title(title_text) if title_text else None
+            href   = secici.select_attr("a", "href", veri)
+            poster = secici.select_poster("img", veri)
 
             if title and href:
                 results.append(MainPageResult(
                     category = category,
                     title    = title,
                     url      = self.fix_url(href),
-                    poster   = self.fix_url(poster) if poster else None,
+                    poster   = self.fix_url(poster),
                 ))
 
         return results
@@ -74,119 +69,143 @@ class JetFilmizle(PluginBase):
             data    = {"s": query},
             headers = {"Referer": f"{self.main_url}/"}
         )
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for article in secici.css("article.movie"):
-            # h2-h6 içindeki a linki
-            title_link = None
+        for article in secici.select("article.movie"):
+            title_text = None
             for h_tag in ["h2", "h3", "h4", "h5", "h6"]:
-                title_link = article.css_first(f"{h_tag} a")
-                if title_link:
+                title_text = secici.select_text(f"{h_tag} a", article)
+                if title_text:
                     break
 
-            link_el = article.css_first("a")
-            img_el  = article.css_first("img")
-
-            title  = self.clean_title(title_link.text(strip=True)) if title_link else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = (img_el.attrs.get("data-src") or img_el.attrs.get("src")) if img_el else None
+            title  = self.clean_title(title_text) if title_text else None
+            href   = secici.select_attr("a", "href", article)
+            poster = secici.select_poster("img", article)
 
             if title and href:
                 results.append(SearchResult(
                     title  = title,
                     url    = self.fix_url(href),
-                    poster = self.fix_url(poster) if poster else None,
+                    poster = self.fix_url(poster),
                 ))
 
         return results
 
     async def load_item(self, url: str) -> MovieInfo:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
-        html_text = istek.text
-
-        title_el = secici.css_first("div.movie-exp-title")
-        title    = self.clean_title(title_el.text(strip=True)) if title_el else None
-
-        img_el     = secici.css_first("section.movie-exp img")
-        poster_raw = (img_el.attrs.get("data-src") or img_el.attrs.get("src")) if img_el else None
-        poster     = poster_raw.strip() if poster_raw else None
-        
-        desc_el = secici.css_first("section.movie-exp p.aciklama")
-        description = desc_el.text(strip=True) if desc_el else None
-        
-        tags = [a.text(strip=True) for a in secici.css("section.movie-exp div.catss a") if a.text(strip=True)]
-        
-        rating_el = secici.css_first("section.movie-exp div.imdb_puan span")
-        rating    = rating_el.text(strip=True) if rating_el else None
-        
-        # Year - div.yap içinde 4 haneli sayı ara (xpath yerine regex)
-        year = None
-        yap_match = re.search(r'<div class="yap"[^>]*>([^<]*(?:Vizyon|Yapım)[^<]*)</div>', html_text, re.IGNORECASE)
-        if yap_match:
-            year_match = re.search(r'(\d{4})', yap_match.group(1))
-            if year_match:
-                year = year_match.group(1)
-        
-        actors = [a.text(strip=True) for a in secici.css("div[itemprop='actor'] a span") if a.text(strip=True)]
+        secici = HTMLHelper(istek.text)
+
+        title       = self.clean_title(secici.select_text("div.movie-exp-title"))
+        poster      = secici.select_poster("section.movie-exp img")
+        description = secici.select_text("section.movie-exp p.aciklama")
+        tags        = secici.select_texts("section.movie-exp div.catss a")
+        rating      = secici.select_text("section.movie-exp div.imdb_puan span")
+        year        = secici.meta_value("Yayın Yılı")
+        actors      = secici.select_texts("div[itemprop='actor'] a span") or [img.attrs.get("alt") for img in secici.select("div.oyuncular div.oyuncu img") if img.attrs.get("alt")]
+        duration    = secici.meta_value("Süre")
+        duration    = duration.split() if duration else None
+
+        total_minutes = 0
+        if duration:
+            for i, p in enumerate(duration):
+                if p == "saat":
+                    total_minutes += int(duration[i-1]) * 60
+                elif p == "dakika":
+                    total_minutes += int(duration[i-1])
 
         return MovieInfo(
             url         = url,
-            poster      = self.fix_url(poster) if poster else None,
+            poster      = self.fix_url(poster),
             title       = title,
             description = description,
             tags        = tags,
             rating      = rating,
             year        = year,
-            actors      = actors
+            actors      = actors,
+            duration    = total_minutes if total_minutes else None
         )
 
-    async def load_links(self, url: str) -> list[ExtractResult]:
-        istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
-
+    async def _process_source(self, url: str, name: str, html: str | None) -> list[ExtractResult]:
         results = []
-
-        # 1) Ana iframe'leri kontrol et
-        for iframe in secici.css("iframe"):
-            src = (iframe.attrs.get("src") or 
-                   iframe.attrs.get("data-src") or
-                   iframe.attrs.get("data-lazy-src"))
-            
-            if src and src != "about:blank":
-                iframe_url = self.fix_url(src)
-                data = await self.extract(iframe_url)
-                if data:
-                    results.append(data)
-
-        # 2) Sayfa numaralarından linkleri topla (Fragman hariç)
-        page_links = []
-        for link in secici.css("a.post-page-numbers"):
-            span_el = link.css_first("span")
-            isim = span_el.text(strip=True) if span_el else ""
-            if isim != "Fragman":
-                href = link.attrs.get("href")
-                if href:
-                    page_links.append((self.fix_url(href), isim))
-
-        # 3) Her sayfa linkindeki iframe'leri bul
-        for page_url, isim in page_links:
-            try:
-                page_resp = await self.httpx.get(page_url)
-                page_sel = HTMLParser(page_resp.text)
-                
-                for iframe in page_sel.css("div#movie iframe"):
+        try:
+            if html:
+                secici = HTMLHelper(html)
+            else:
+                resp   = await self.httpx.get(url)
+                secici = HTMLHelper(resp.text)
+
+            # Iframe'leri bul
+            container = secici.select_first("div#movie") or secici.select_first("div.film-content")
+
+            if container:
+                for iframe in secici.select("iframe", container):
                     src = (iframe.attrs.get("src") or 
                            iframe.attrs.get("data-src") or
                            iframe.attrs.get("data-lazy-src"))
-                    
+
                     if src and src != "about:blank":
                         iframe_url = self.fix_url(src)
-                        data = await self.extract(iframe_url, prefix=isim)
+                        # name_override KULLANMA, extractor kendi ismini versin
+                        # Sonra biz düzenleriz
+                        data = await self.extract(iframe_url)
+
                         if data:
-                            results.append(data)
-            except Exception:
-                continue
+                            items = data if isinstance(data, list) else [data]
+
+                            for item in items:
+                                # Sadece kalite bilgisi içeriyorsa ekle, yoksa sadece buton adını kullan
+                                # Özellikle Zeus için kalite önemli (1080p, 720p)
+                                # Diğerlerinde plugin adı (Apollo, JetPlay vb.) önemsiz
+
+                                # Kalite kontrolü (basitçe)
+                                quality_indicators = ["1080p", "720p", "480p", "360p", "240p", "144p", "4k", "2k"]
+                                has_quality = any(q in item.name.lower() for q in quality_indicators)
+
+                                if has_quality:
+                                    # Buton Adı | Extractor Adı (Kalite içerdiği için)
+                                    # Örn: Zeus | 1080p
+                                    # Eğer Extractor adı zaten Buton adını içeriyorsa (Zeus | 1080p -> Zeus) tekrar ekleme
+                                    if name.lower() not in item.name.lower():
+                                         item.name = f"{name} | {item.name}"
+                                else:
+                                    # Kalite yoksa sadece Buton adını kullan
+                                    # Örn: Apollo | JetTv -> JetTv
+                                    item.name = name
+
+                                results.append(item)
+            return results
+        except Exception:
+            return []
 
-        return results
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek  = await self.httpx.get(url)
+        secici = HTMLHelper(istek.text)
+
+        sources = []
+        if film_part := secici.select_first("div.film_part"):
+            # Tüm spanları gez
+            for span in secici.select("span", film_part):
+                # Eğer bu span bir <a> etiketi içinde değilse, aktif kaynaktır
+                if span.parent.tag != "a":
+                    name = span.text(strip=True)
+                    if name:
+                        sources.append((url, name, istek.text)) # html content var
+                        break
+
+            # Diğer kaynak linkleri
+            for link in secici.select("a.post-page-numbers", film_part):
+                name = secici.select_text("span", link) or link.text(strip=True)
+                href = link.attrs.get("href")
+                if name != "Fragman" and href:
+                    sources.append((self.fix_url(href), name, None)) # html yok, çekilecek
+
+        # Eğer film_part yoksa, sadece mevcut sayfayı tara (Tek part olabilir)
+        if not sources:
+            sources.append((url, "JetFilmizle", istek.text))
+
+        tasks = []
+        for page_url, source_name, html_content in sources:
+            tasks.append(self._process_source(page_url, source_name, html_content))
+
+        return [item for sublist in await asyncio.gather(*tasks) for item in sublist]

KekikStream/Plugins/KultFilmler.py

@@ -1,8 +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
-from selectolax.parser import HTMLParser
-import re, base64
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, Subtitle, HTMLHelper
+import base64, asyncio, contextlib
 
 class KultFilmler(PluginBase):
     name        = "KultFilmler"
@@ -38,210 +37,221 @@ class KultFilmler(PluginBase):
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("div.col-md-12 div.movie-box"):
-            img_el  = veri.css_first("div.img img")
-            link_el = veri.css_first("a")
-
-            title  = img_el.attrs.get("alt") if img_el else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = img_el.attrs.get("src") if img_el else None
+        for veri in secici.select("div.col-md-12 div.movie-box"):
+            title  = secici.select_attr("div.img img", "alt", veri)
+            href   = secici.select_attr("a", "href", veri)
+            poster = secici.select_attr("div.img img", "src", veri)
 
             if title and href:
                 results.append(MainPageResult(
                     category = category,
                     title    = title,
                     url      = self.fix_url(href),
-                    poster   = self.fix_url(poster) if poster else None,
+                    poster   = self.fix_url(poster),
                 ))
 
         return results
 
     async def search(self, query: str) -> list[SearchResult]:
         istek  = await self.httpx.get(f"{self.main_url}?s={query}")
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("div.movie-box"):
-            img_el  = veri.css_first("div.img img")
-            link_el = veri.css_first("a")
-
-            title  = img_el.attrs.get("alt") if img_el else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = img_el.attrs.get("src") if img_el else None
+        for veri in secici.select("div.movie-box"):
+            title  = secici.select_attr("div.img img", "alt", veri)
+            href   = secici.select_attr("a", "href", veri)
+            poster = secici.select_attr("div.img img", "src", veri)
 
             if title and href:
                 results.append(SearchResult(
                     title  = title,
                     url    = self.fix_url(href),
-                    poster = self.fix_url(poster) if poster else None,
+                    poster = self.fix_url(poster),
                 ))
 
         return results
 
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
-
-        film_img = secici.css_first("div.film-bilgileri img")
-        og_title = secici.css_first("[property='og:title']")
-        og_image = secici.css_first("[property='og:image']")
-
-        title       = (film_img.attrs.get("alt") if film_img else None) or (og_title.attrs.get("content") if og_title else None)
-        poster      = self.fix_url(og_image.attrs.get("content")) if og_image else None
-
-        desc_el     = secici.css_first("div.description")
-        description = desc_el.text(strip=True) if desc_el else None
-
-        tags = [a.text(strip=True) for a in secici.css("ul.post-categories a") if a.text(strip=True)]
-
-        # HTML analizine göre güncellenen alanlar
-        year_el = secici.css_first("li.release span a")
-        year    = year_el.text(strip=True) if year_el else None
-
-        time_el = secici.css_first("li.time span")
-        duration = None
-        if time_el:
-            time_text = time_el.text(strip=True)
-            dur_match = re.search(r"(\d+)", time_text)
-            duration  = dur_match.group(1) if dur_match else None
+        secici = HTMLHelper(istek.text)
 
-        rating_el = secici.css_first("div.imdb-count")
-        rating    = rating_el.text(strip=True) if rating_el else None
+        title       = self.clean_title(secici.select_attr("div.film-bilgileri img", "alt") or secici.select_attr("[property='og:title']", "content"))
+        poster      = self.fix_url(secici.select_attr("[property='og:image']", "content"))
+        description = secici.select_text("div.description")
+        tags        = secici.select_texts("ul.post-categories a")
+        year        = secici.extract_year("li.release span a")
+        duration    = int(secici.regex_first(r"(\d+)", secici.select_text("li.time span")) or 0)
+        rating      = secici.regex_first(r"(\d+\.\d+|\d+)", secici.select_text("div.imdb-count"))
+        actors      = secici.select_texts("div.actors a")
 
-        actors = [a.text(strip=True) for a in secici.css("div.actors a") if a.text(strip=True)]
-
-        # Dizi mi kontrol et
         if "/dizi/" in url:
             episodes = []
-            for bolum in secici.css("div.episode-box"):
-                name_link = bolum.css_first("div.name a")
-                ep_href   = name_link.attrs.get("href") if name_link else None
-
-                ssn_el = bolum.css_first("span.episodetitle")
-                ssn_detail = ssn_el.text(strip=True) if ssn_el else ""
-
-                ep_b_el = bolum.css_first("span.episodetitle b")
-                ep_detail = ep_b_el.text(strip=True) if ep_b_el else ""
-
-                ep_name = f"{ssn_detail} - {ep_detail}"
-
-                if ep_href:
-                    ep_season  = re.search(r"(\d+)\.", ssn_detail)
-                    ep_episode = re.search(r"(\d+)\.", ep_detail)
-
-                    episodes.append(Episode(
-                        season  = int(ep_season[1]) if ep_season else 1,
-                        episode = int(ep_episode[1]) if ep_episode else 1,
-                        title   = ep_name.strip(" -"),
-                        url     = self.fix_url(ep_href),
-                    ))
+            for bolum in secici.select("div.episode-box"):
+                href       = secici.select_attr("div.name a", "href", bolum)
+                ssn_detail = secici.select_text("span.episodetitle", bolum) or ""
+                ep_detail  = secici.select_text("span.episodetitle b", bolum) or ""
+                if href:
+                    s, e = secici.extract_season_episode(f"{ssn_detail} {ep_detail}")
+                    name = f"{ssn_detail} - {ep_detail}".strip(" -")
+                    episodes.append(Episode(season=s or 1, episode=e or 1, title=name, url=self.fix_url(href)))
 
             return SeriesInfo(
                 url         = url,
                 poster      = poster,
-                title       = self.clean_title(title) if title else "",
+                title       = title,
                 description = description,
                 tags        = tags,
                 year        = year,
                 actors      = actors,
                 rating      = rating,
-                episodes    = episodes,
+                episodes    = episodes
             )
 
         return MovieInfo(
             url         = url,
             poster      = poster,
-            title       = self.clean_title(title) if title else "",
+            title       = title,
             description = description,
             tags        = tags,
             year        = year,
             rating      = rating,
             actors      = actors,
-            duration    = int(duration) if duration else None,
+            duration    = duration
         )
 
-    def _get_iframe(self, source_code: str) -> str:
-        """Base64 kodlu iframe'i çözümle"""
-        atob_match = re.search(r"PHA\+[0-9a-zA-Z+/=]*", source_code)
-        if not atob_match:
-            return ""
-
-        atob = atob_match.group()
+    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  = HTMLParser(decoded)
-            iframe_el = secici.css_first("iframe")
-            return self.fix_url(iframe_el.attrs.get("src")) if iframe_el 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"""
-        match = re.search(r"(https?://[^\s\"]+\.srt)", source_code)
-        return match[1] if match else None
-
-    async def load_links(self, url: str) -> list[ExtractResult]:
-        istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
-
-        iframes = set()
-
-        # Ana iframe
-        main_frame = self._get_iframe(istek.text)
-        if main_frame:
-            iframes.add(main_frame)
-
-        # Alternatif player'lar
-        for player in secici.css("div.container#player"):
-            iframe_el = player.css_first("iframe")
-            alt_iframe = self.fix_url(iframe_el.attrs.get("src")) if iframe_el else None
-            if alt_iframe:
-                alt_istek = await self.httpx.get(alt_iframe)
-                alt_frame = self._get_iframe(alt_istek.text)
-                if alt_frame:
-                    iframes.add(alt_frame)
+    async def _resolve_alt_page(self, url: str, title: str) -> tuple[str | None, str]:
+        """Alternatif sayfa kaynak kodunu indirip iframe'i bulur"""
+        try:
+            res = await self.httpx.get(url)
+            return self._decode_iframe(res.text), title
+        except Exception:
+            return None, title
 
+    async def _extract_stream(self, iframe_url: str, title: str, subtitles: list[Subtitle]) -> list[ExtractResult]:
+        """Iframe üzerinden stream linklerini ayıklar"""
         results = []
 
-        for iframe in iframes:
-            subtitles = []
-
-            # VidMoly özel işleme
-            if "vidmoly" in iframe:
-                headers = {
-                    "User-Agent"     : "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36",
-                    "Sec-Fetch-Dest" : "iframe"
-                }
-                iframe_istek = await self.httpx.get(iframe, headers=headers)
-                m3u_match    = re.search(r'file:"([^"]+)"', iframe_istek.text)
-
-                if m3u_match:
+        # 1. VidMoly Özel Çözümleme(M3U)
+        if "vidmoly" in iframe_url:
+            with contextlib.suppress(Exception):
+                res = await self.httpx.get(
+                    url     = iframe_url,
+                    headers = {
+                        "User-Agent"     : "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36",
+                        "Sec-Fetch-Dest" : "iframe"
+                    }
+                )
+                m3u = HTMLHelper(res.text).regex_first(r'file:"([^"]+)"')
+
+                if m3u:
                     results.append(ExtractResult(
-                        name      = "VidMoly",
-                        url       = m3u_match[1],
+                        name      = title or "VidMoly",
+                        url       = m3u,
                         referer   = self.main_url,
-                        subtitles = []
+                        subtitles = subtitles
                     ))
-                    continue
 
-            # Altyazı çıkar
-            subtitle_url = self._extract_subtitle_url(url)
-            if subtitle_url:
-                subtitles.append(Subtitle(name="Türkçe", url=subtitle_url))
+            return results
+
+        # 2. Genel Extractor Kullanımı
+        with contextlib.suppress(Exception):
+            extracted = await self.extract(iframe_url)
+            if not extracted:
+                return []
+
+            items = extracted if isinstance(extracted, list) else [extracted]
+            for item in items:
+                # İsim ve altyazı bilgilerini güncelle
+                # Orijinal extractor ismini ezmek için title kullan
+                if title:
+                    item.name = title
 
-            data = await self.extract(iframe)
-            if data:
-                # ExtractResult objesi immutable, yeni bir kopya oluştur
-                updated_data = data.model_copy(update={"subtitles": subtitles}) if subtitles else data
-                results.append(updated_data)
+                # Varsa altyazıları ekle
+                if subtitles:
+                     # Copy update daha güvenli (Pydantic model)
+                    if hasattr(item, "model_copy"):
+                        item = item.model_copy(update={"subtitles": subtitles})
+                    else:
+                        item.subtitles = subtitles
+
+                results.append(item)
 
         return results
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        response = await self.httpx.get(url)
+        source   = response.text
+        helper   = HTMLHelper(source)
+
+        # Altyazı Bul
+        sub_url   = helper.regex_first(r"(https?://[^\s\"]+\.srt)")
+        subtitles = [Subtitle(name="Türkçe", url=sub_url)] if sub_url else []
+
+        # İşlenecek kaynakları topla: (Iframe_URL, Başlık)
+        sources = []
+
+        # A) Ana Player
+        main_iframe = self._decode_iframe(source)
+        if main_iframe:
+            p_name = helper.select_text("div.parts-middle div.part.active div.part-name") or None
+            p_lang = helper.select_attr("div.parts-middle div.part.active div.part-lang span", "title")
+            full_title = f"{p_name} | {p_lang}" if p_lang else p_name
+            sources.append((main_iframe, full_title))
+
+        # B) Alternatif Playerlar (Link Çözümleme Gerektirir)
+        alt_tasks = []
+        for link in helper.select("div.parts-middle a.post-page-numbers"):
+            href = link.attrs.get("href")
+            if not href:
+                continue
+
+            a_name     = helper.select_text("div.part-name", link) or "Alternatif"
+            a_lang     = helper.select_attr("div.part-lang span", "title", link)
+            full_title = f"{a_name} | {a_lang}" if a_lang else a_name
+
+            alt_tasks.append(self._resolve_alt_page(self.fix_url(href), full_title))
+
+        if alt_tasks:
+            resolved_alts = await asyncio.gather(*alt_tasks)
+            for iframe, title in resolved_alts:
+                if iframe:
+                    sources.append((iframe, title))
+
+        # 3. Tüm kaynakları paralel işle (Extract)
+        if not sources:
+            return []
+
+        extract_tasks = [
+            self._extract_stream(iframe, title, subtitles) 
+                for iframe, title in sources
+        ]
+
+        results_groups = await asyncio.gather(*extract_tasks)
+
+        # Sonuçları düzleştir
+        final_results = []
+        for group in results_groups:
+            final_results.extend(group)
+
+        return final_results