KekikStream 2.4.2__py3-none-any.whl → 2.4.3__py3-none-any.whl

KekikStream/Plugins/DiziBox.py

@@ -93,44 +93,24 @@ class DiziBox(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        title = secici.select_text("div.tv-overview h1 a")
-
-        poster = secici.select_attr("div.tv-overview figure img", "src")
-
+        title       = secici.select_text("div.tv-overview h1 a")
+        poster      = secici.select_poster("div.tv-overview figure img")
         description = secici.select_text("div.tv-story p")
-
-        # year
-        year_text = secici.select_text("a[href*='/yil/']")
-        year = secici.regex_first(r"(\d{4})", year_text)
-
-        tags = secici.select_all_text("a[href*='/tur/']")
-
-        # rating
-        rating_text = secici.select_text("span.label-imdb b")
-        rating = secici.regex_first(r"[\d.,]+", rating_text)
-
-        actors = secici.select_all_text("a[href*='/oyuncu/']")
+        year        = secici.extract_year("a[href*='/yil/']")
+        tags        = secici.select_texts("a[href*='/tur/']")
+        rating      = secici.regex_first(r"[\d.,]+", secici.select_text("span.label-imdb b"))
+        actors      = secici.select_texts("a[href*='/oyuncu/']")
 
         episodes = []
-        for sezon_link in secici.select_all_attr("div#seasons-list a", "href"):
-            sezon_url    = self.fix_url(sezon_link)
-            sezon_istek  = await self.httpx.get(sezon_url)
-            sezon_secici = HTMLHelper(sezon_istek.text)
-
-            for bolum in sezon_secici.select("article.grid-box"):
-                ep_title = sezon_secici.select_text("div.post-title a", bolum)
-                ep_href  = sezon_secici.select_attr("div.post-title a", "href", bolum)
-
-                ep_season  = sezon_secici.regex_first(r"(\d+)\. ?Sezon", ep_title)
-                ep_episode = sezon_secici.regex_first(r"(\d+)\. ?Bölüm", ep_title)
-
-                if ep_title and ep_href:
-                    episodes.append(Episode(
-                        season  = ep_season,
-                        episode = ep_episode,
-                        title   = ep_title,
-                        url     = self.fix_url(ep_href),
-                    ))
+        for link in secici.select_attrs("div#seasons-list a", "href"):
+            r = await self.httpx.get(self.fix_url(link))
+            s_secici = HTMLHelper(r.text)
+            for bolum in s_secici.select("article.grid-box"):
+                name = s_secici.select_text("div.post-title a", bolum)
+                href = s_secici.select_attr("div.post-title a", "href", bolum)
+                if name and href:
+                    s, e = s_secici.extract_season_episode(name)
+                    episodes.append(Episode(season=s, episode=e, title=name, url=self.fix_url(href)))
 
         return SeriesInfo(
             url         = url,
@@ -139,7 +119,7 @@ class DiziBox(PluginBase):
             description = description,
             tags        = tags,
             rating      = rating,
-            year        = year,
+            year        = str(year) if year else None,
             episodes    = episodes,
             actors      = actors,
         )

KekikStream/Plugins/DiziMom.py

@@ -19,34 +19,28 @@ class DiziMom(PluginBase):
     }
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
-        istek   = await self.httpx.get(f"{url}/{page}/")
-        helper  = HTMLHelper(istek.text)
+        full_url = f"{url}/{page}/"
+        istek    = await self.httpx.get(full_url)
+        helper   = HTMLHelper(istek.text)
 
+        results = []
+        # Eğer "tum-bolumler" ise Episode kutularını, değilse Dizi kutularını tara
         if "/tum-bolumler/" in url:
-            items = helper.select("div.episode-box")
-            results = []
-            for item in items:
-                name_el = helper.select_first("div.episode-name a", item)
-                if not name_el: continue
-                name = name_el.text(strip=True).split(" izle")[0]
-                title = name.replace(".Sezon ", "x").replace(".Bölüm", "")
-                
-                ep_href = self.fix_url(name_el.attrs.get("href"))
-                pass 
-            
-            # Revert to standard categories if "tum-bolumler" is complex
-            return [] 
+            for item in helper.select("div.episode-box"):
+                title = helper.select_text("div.episode-name a", item)
+                href  = helper.select_attr("div.episode-name a", "href", item)
+                img   = helper.select_poster("div.cat-img img", item)
+                if title and href:
+                    results.append(MainPageResult(category=category, title=title.split(" izle")[0], url=self.fix_url(href), poster=self.fix_url(img)))
         else:
-            items = helper.select("div.single-item")
-            return [
-                MainPageResult(
-                    category = category,
-                    title    = helper.select_text("div.categorytitle a", item).split(" izle")[0],
-                    url      = self.fix_url(helper.select_attr("div.categorytitle a", "href", item)),
-                    poster   = self.fix_url(helper.select_attr("div.cat-img img", "src", item))
-                )
-                for item in items
-            ]
+            for item in helper.select("div.single-item"):
+                title = helper.select_text("div.categorytitle a", item)
+                href  = helper.select_attr("div.categorytitle a", "href", item)
+                img   = helper.select_poster("div.cat-img img", item)
+                if title and href:
+                    results.append(MainPageResult(category=category, title=title.split(" izle")[0], url=self.fix_url(href), poster=self.fix_url(img)))
+
+        return results
 
     async def search(self, query: str) -> list[SearchResult]:
         url = f"{self.main_url}/?s={query}"
@@ -67,117 +61,31 @@ class DiziMom(PluginBase):
         istek  = await self.httpx.get(url)
         helper = HTMLHelper(istek.text)
 
-        title_raw = helper.select_text("div.title h1")
-        title = title_raw.split(" izle")[0] if title_raw else "Bilinmiyor"
-        
-        poster = self.fix_url(helper.select_attr("div.category_image img", "src"))
-        
-        # Custom extraction for fields that were using xpath_text
-        year = None
-        rating = None
-        actors = None
-        
-        # Regex approach based on debug output (multiline support)
-        # Context: <span class="dizimeta"><i class="fas fa-globe"></i> Yapım Yılı : </span>\n 2022
-        year_val_all = helper.regex_all(r"Yapım Yılı\s*:\s*(?:</span>)?\s*(\d{4})", flags=re.DOTALL)
-        if year_val_all:
-             year = int(year_val_all[0])
-            
-        # Context: <span class="dizimeta"><i class="fas fa-star"></i> IMDB : </span>\n 4.5
-        rating_val_all = helper.regex_all(r"IMDB\s*:\s*(?:</span>)?\s*([\d\.]+)", flags=re.DOTALL)
-        if rating_val_all:
-            rating = rating_val_all[0]
-            
-        actors_val = helper.regex_first(r"Oyuncular\s*:\s*(.+?)(?:</div>|<br|$)")
-        if not actors_val:
-             # Try selecting the div text directly if regex fails due to HTML tags
-             # Find div containing "Oyuncular :"
-             all_divs = helper.select("div")
-             for div in all_divs:
-                 txt = div.text()
-                 if "Oyuncular :" in txt:
-                     actors_val = txt.split("Oyuncular :")[1].strip()
-                     break
-        
-        if actors_val:
-             # Remove footer / junk from actors
-             if "IMDB :" in actors_val:
-                 actors_val = actors_val.split("IMDB :")[0].strip()
-                 
-             if "IMDB :" in actors_val:
-                 actors_val = actors_val.split("IMDB :")[0].strip()
-                 
-             # Remove '×' and other junk if present at end
-             if "×" in actors_val:
-                 actors_val = actors_val.split("×")[0].strip()
-
-             # Remove simple tags if any remaining
-             clean_actors = [a.strip() for a in actors_val.split(",")]
-             # Filter empty
-             clean_actors = [a for a in clean_actors if a]
-             
-             actors = ", ".join(clean_actors)
-             
-        description_raw = helper.select_text("div.category_desc")
-        description = None
-        if description_raw:
-             # Clean header "The Librarians izle..." etc. if present, usually it is fine.
-             # Clean "IMDB :" if attached
-             if "IMDB :" in description_raw:
-                 description_raw = description_raw.split("IMDB :")[0].strip()
-             
-             # Clean footer text start
-             # The footer block usually starts with "Dizimom, dizi ve film..."
-             if "Dizimom," in description_raw:
-                 description = description_raw.split("Dizimom,")[0].strip()
-             elif "dizi izle film izle" in description_raw:
-                 description = description_raw.split("dizi izle film izle")[0].strip()
-             else:
-                  description = description_raw
-
-             # Fallback cleanup for JSON
-             if description and "{" in description:
-                  description = description.split("{")[0].strip()
-
-        tags = helper.select_all_text("div.genres a")
-        
-        # Improved year regex
-        if not year:
-             # Look for "Yapım Yılı : 2014" pattern in ANY text
-             # Get all text from category_text which usually contains it
-             meta_text = helper.select_text("div.category_text")
-             if meta_text:
-                 match = re.search(r"Yapım Yılı\s*:\s*(\d{4})", meta_text)
-                 if match:
-                     year = int(match.group(1))
+        title       = self.clean_title(helper.select_text("div.title h1"))
+        poster      = helper.select_poster("div.category_image img")
+        description = helper.select_direct_text("div.category_desc")
+        tags        = helper.select_texts("div.genres a")
+        rating      = helper.regex_first(r"IMDB\s*:\s*(?:</span>)?\s*([\d\.]+)", helper.html, flags=re.DOTALL)
+        year        = helper.extract_year("div.category_text")
+        actors      = helper.meta_list("Oyuncular", container_selector="div#icerikcat2")
 
         episodes = []
-        ep_items = helper.select("div.bolumust")
-        for item in ep_items:
-            ep_name_raw = helper.select_text("div.baslik", item)
-            ep_href = self.fix_url(helper.select_attr("a", "href", item))
-            
-            if ep_name_raw:
-                # 1.Sezon 1.Bölüm
-                s_m = re.search(r"(\d+)\.Sezon", ep_name_raw)
-                e_m = re.search(r"(\d+)\.Bölüm", ep_name_raw)
-                
-                season = int(s_m.group(1)) if s_m else 1
-                episode = int(e_m.group(1)) if e_m else 1
-                
-                name = ep_name_raw.split(" izle")[0].replace(title, "").strip()
-                
+        for item in helper.select("div.bolumust"):
+            name = helper.select_text("div.baslik", item)
+            href = helper.select_attr("a", "href", item)
+            if name and href:
+                s, e = helper.extract_season_episode(name)
                 episodes.append(Episode(
-                    season  = season,
-                    episode = episode,
-                    title   = name,
-                    url     = ep_href
+                    season  = s or 1,
+                    episode = e or 1,
+                    title   = self.clean_title(name.replace(title or "", "").strip()),
+                    url     = self.fix_url(href)
                 ))
 
         return SeriesInfo(
             url         = url,
-            poster      = poster,
-            title       = title,
+            poster      = self.fix_url(poster) if poster else None,
+            title       = title or "Bilinmiyor",
             description = description,
             tags        = tags,
             rating      = rating,

KekikStream/Plugins/DiziPal.py

@@ -5,7 +5,7 @@ from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInf
 class DiziPal(PluginBase):
     name        = "DiziPal"
     language    = "tr"
-    main_url    = "https://dizipal1226.com"
+    main_url    = "https://dizipal.cc"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "dizipal güncel, dizipal yeni ve gerçek adresi. dizipal en yeni dizi ve filmleri güvenli ve hızlı şekilde sunar."
 
@@ -116,94 +116,45 @@ class DiziPal(PluginBase):
 
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         # Reset headers to get HTML response
-        self.httpx.headers.update({
-            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
-        })
+        self.httpx.headers.update({"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"})
         self.httpx.headers.pop("X-Requested-With", None)
 
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
-        html_text = istek.text
-
-        poster   = self.fix_url(secici.select_attr("meta[property='og:image']", "content")) if secici.select_attr("meta[property='og:image']", "content") else None
-
-        # Sidebar bilgilerini topla
-        info = {}
-        for li in secici.select("li"):
-             key = secici.select_text("div.key", li)
-             val = secici.select_text("div.value", li)
-             if key and val:
-                 info[key.strip(":")] = val.strip()
-
-        year   = info.get("Yapım Yılı")
-        rating = info.get("IMDB Puanı")
-        
-        tags_raw = info.get("Türler", "")
-        tags = [t.strip() for t in tags_raw.split() if t.strip()] if tags_raw else None
-
-        actors_raw = info.get("Oyuncular")
-        actors = [a.strip() for a in actors_raw.split(",") if a.strip()] if actors_raw else None
 
+        poster      = self.fix_url(secici.select_attr("meta[property='og:image']", "content"))
         description = secici.select_text("div.summary p")
-
-        duration_raw = info.get("Ortalama Süre")
-        duration = int(secici.regex_first(r"(\d+)", duration_raw)) if duration_raw else None
+        year        = secici.meta_value("Yapım Yılı", container_selector="div.sidebar")
+        rating      = secici.meta_value("IMDB Puanı", container_selector="div.sidebar")
+        duration    = secici.meta_value("Ortalama Süre", container_selector="div.sidebar")
+        duration    = int(secici.regex_first(r"(\d+)", duration)) if duration else None
+        tags        = secici.meta_list("Türler", sep=" ", container_selector="div.sidebar")
+        actors      = secici.meta_list("Oyuncular", container_selector="div.sidebar")
 
         if "/dizi/" in url:
             title    = secici.select_text("div.cover h5")
-
             episodes = []
             for ep in secici.select("div.episode-item"):
-                ep_name = secici.select_text("div.name", ep)
-                ep_href = secici.select_attr("a", "href", ep)
-                ep_text = secici.select_text("div.episode", ep)
-                ep_parts = ep_text.split(" ")
-
-                ep_season  = None
-                ep_episode = None
-                if len(ep_parts) >= 4:
-                    try:
-                        ep_season  = int(ep_parts[0].replace(".", ""))
-                        ep_episode = int(ep_parts[2].replace(".", ""))
-                    except ValueError:
-                        pass
-
-                if ep_name and ep_href:
-                    episodes.append(Episode(
-                        season  = ep_season,
-                        episode = ep_episode,
-                        title   = ep_name,
-                        url     = self.fix_url(ep_href),
-                    ))
+                name = secici.select_text("div.name", ep)
+                href = secici.select_attr("a", "href", ep)
+                text = secici.select_text("div.episode", ep)
+                if name and href:
+                    s, e = secici.extract_season_episode(text or "")
+                    episodes.append(Episode(season=s, episode=e, title=name, url=self.fix_url(href)))
 
             return SeriesInfo(
-                url         = url,
-                poster      = poster,
-                title       = title,
-                description = description,
-                tags        = tags,
-                rating      = rating,
-                year        = year,
-                duration    = duration,
-                episodes    = episodes if episodes else None,
-                actors      = actors,
-            )
-        else:
-            # Film için title - g-title div'lerinin 2. olanı
-            g_titles = secici.select("div.g-title div")
-            title = secici.select_text(element=g_titles[1]) if len(g_titles) >= 2 else None
-
-            return MovieInfo(
-                url         = url,
-                poster      = poster,
-                title       = title,
-                description = description,
-                tags        = tags,
-                rating      = rating,
-                year        = year,
-                duration    = duration,
-                actors      = actors,
+                url=url, poster=poster, title=title, description=description, tags=tags,
+                rating=rating, year=year, duration=duration, episodes=episodes or None, actors=actors
             )
+        
+        # Film için title - g-title div'lerinin 2. olanı
+        g_titles = secici.select("div.g-title div")
+        title = secici.select_text(element=g_titles[1]) if len(g_titles) >= 2 else None
+
+        return MovieInfo(
+            url=url, poster=poster, title=title, description=description, tags=tags,
+            rating=rating, year=year, duration=duration, actors=actors
+        )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         # Reset headers to get HTML response

KekikStream/Plugins/DiziYou.py

@@ -69,173 +69,65 @@ 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")
+        actors      = secici.meta_value("Oyuncular", container_selector="div#icerikcat2")
+        actors      = [a.strip() for a in actors.split(",")] if actors else []
 
         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,
-            poster      = poster,
-            title       = title,
-            description = description,
-            tags        = tags,
-            rating      = rating,
-            year        = year,
-            episodes    = episodes,
-            actors      = actors
+            url=url, poster=poster, title=title or "Bilinmiyor", description=description,
+            tags=tags, rating=rating, year=str(year) if year else None, episodes=episodes, actors=actors
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         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
             ))