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

KekikStream/Plugins/RecTV.py

@@ -65,94 +65,56 @@ class RecTV(PluginBase):
                 for veri in tum_veri
         ]
 
-    async def load_item(self, url: str) -> MovieInfo:
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         self.httpx.headers.update({"user-agent": "okhttp/4.12.0"})
         veri = loads(url)
 
-        match veri.get("type"):
-            case "serie":
-                dizi_istek = await self.httpx.get(f"{self.main_url}/api/season/by/serie/{veri.get('id')}/{self.sw_key}/")
-                dizi_veri  = dizi_istek.json()
-
-                episodes = []
-                for season in dizi_veri:
-                    season_title = season.get("title", "").strip()
-                    for episode in season.get("episodes"):
-                        ep_label = episode.get("title", "").strip()
-                        for source in episode.get("sources"):
-                            # Bölüm için gerekli bilgileri JSON olarak sakla
-                            ep_data = {
-                                "url"        : self.fix_url(source.get("url")),
-                                "title"      : f"{veri.get('title')} | {season_title} {ep_label} - {source.get('title')}",
-                                "is_episode" : True
-                            }
-
-                            # Extract season/episode numbers using helper
-                            s1, _ = HTMLHelper.extract_season_episode(season_title or "")
-                            _, e2 = HTMLHelper.extract_season_episode(ep_label or "")
-
-                            tag = ""
-                            clean_season = season_title
-                            if "dublaj" in season_title.lower():
-                                tag = " (Dublaj)"
-                                clean_season = re.sub(r"\s*dublaj\s*", "", season_title, flags=re.I).strip()
-                            elif any(x in season_title.lower() for x in ["altyazı", "altyazi"]):
-                                tag = " (Altyazı)"
-                                clean_season = re.sub(r"\s*altyaz[ıi]\s*", "", season_title, flags=re.I).strip()
-
-                            ep_model = Episode(
-                                season  = s1 or 1,
-                                episode = e2 or 1,
-                                title   = f"{clean_season} {ep_label}{tag} - {source.get('title')}",
-                                url     = dumps(ep_data),
-                            )
-
-                            episodes.append(ep_model)
-
-                # Süreyi dakikaya çevir (Örn: "1h 59min")
-                duration_raw = veri.get("duration")
-                duration = None
-                if duration_raw:
-                    try:
-                        h = int(HTMLHelper(duration_raw).regex_first(r"(\d+)h") or 0)
-                        m = int(HTMLHelper(duration_raw).regex_first(r"(\d+)min") or 0)
-                        duration = h * 60 + m
-                    except: pass
-
-                return SeriesInfo(
-                    url         = url,
-                    poster      = self.fix_url(veri.get("image")),
-                    title       = veri.get("title"),
-                    description = veri.get("description"),
-                    tags        = [genre.get("title") for genre in veri.get("genres")] if veri.get("genres") else [],
-                    rating      = str(veri.get("imdb") or veri.get("rating") or ""),
-                    year        = str(veri.get("year") or ""),
-                    actors      = [],
-                    duration    = duration,
-                    episodes    = episodes
-                )
-            case _:
-                # Süreyi dakikaya çevir
-                duration_raw = veri.get("duration")
-                duration = None
-                if duration_raw:
-                    try:
-                        h = int(HTMLHelper(duration_raw).regex_first(r"(\d+)h") or 0)
-                        m = int(HTMLHelper(duration_raw).regex_first(r"(\d+)min") or 0)
-                        duration = h * 60 + m
-                    except: pass
-
-                return MovieInfo(
-                    url         = url,
-                    poster      = self.fix_url(veri.get("image")),
-                    title       = veri.get("title"),
-                    description = veri.get("description"),
-                    tags        = [genre.get("title") for genre in veri.get("genres")] if veri.get("genres") else [],
-                    rating      = str(veri.get("imdb") or veri.get("rating") or ""),
-                    year        = str(veri.get("year") or ""),
-                    actors      = [],
-                    duration    = duration
-                )
+        # Süreyi dakikaya çevir (Örn: "1h 59min")
+        duration_raw = veri.get("duration")
+        duration = None
+        if duration_raw:
+            try:
+                h = int(HTMLHelper(duration_raw).regex_first(r"(\d+)h") or 0)
+                m = int(HTMLHelper(duration_raw).regex_first(r"(\d+)min") or 0)
+                duration = h * 60 + m
+            except: pass
+
+        common_info = {
+            "url"         : url,
+            "poster"      : self.fix_url(veri.get("image")),
+            "title"       : veri.get("title"),
+            "description" : veri.get("description"),
+            "tags"        : [genre.get("title") for genre in veri.get("genres")] if veri.get("genres") else [],
+            "rating"      : str(veri.get("imdb") or veri.get("rating") or ""),
+            "year"        : str(veri.get("year") or ""),
+            "duration"    : duration
+        }
+
+        if veri.get("type") == "serie":
+            dizi_istek = await self.httpx.get(f"{self.main_url}/api/season/by/serie/{veri.get('id')}/{self.sw_key}/")
+            dizi_veri  = dizi_istek.json()
+
+            episodes = []
+            for season in dizi_veri:
+                s_title = season.get("title", "").strip()
+                s, _    = HTMLHelper.extract_season_episode(s_title)
+                for ep in season.get("episodes"):
+                    e_title = ep.get("title", "").strip()
+                    _, e    = HTMLHelper.extract_season_episode(e_title)
+                    for source in ep.get("sources"):
+                        tag = ""
+                        clean_s = s_title
+                        if "dublaj" in s_title.lower():
+                            tag = " (Dublaj)"; clean_s = re.sub(r"\s*dublaj\s*", "", s_title, flags=re.I).strip()
+                        elif "altyaz" in s_title.lower():
+                            tag = " (Altyazı)"; clean_s = re.sub(r"\s*altyaz[ıi]\s*", "", s_title, flags=re.I).strip()
+
+                        ep_data = {"url": self.fix_url(source.get("url")), "title": f"{veri.get('title')} | {s_title} {e_title} - {source.get('title')}", "is_episode": True}
+                        episodes.append(Episode(season=s or 1, episode=e or 1, title=f"{clean_s} {e_title}{tag} - {source.get('title')}", url=dumps(ep_data)))
+
+            return SeriesInfo(**common_info, episodes=episodes, actors=[])
+        
+        return MovieInfo(**common_info, actors=[])
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         try:

KekikStream/Plugins/SelcukFlix.py

@@ -187,54 +187,55 @@ class SelcukFlix(PluginBase):
         
         next_data_text = sel.select_text("script#__NEXT_DATA__")
         if not next_data_text:
-            return SeriesInfo(url=url, title=sel.select_text("h1") or "Bilinmeyen")
+            return SeriesInfo(url=url, title=self.clean_title(sel.select_text("h1")) or "Bilinmeyen")
 
         try:
             next_data = json.loads(next_data_text)
             secure_data_raw = next_data["props"]["pageProps"].get("secureData")
             if not secure_data_raw:
-                 return SeriesInfo(url=url, title=sel.select_text("h1") or "Bilinmeyen")
+                  return SeriesInfo(url=url, title=self.clean_title(sel.select_text("h1")) or "Bilinmeyen")
             
             # Clean possible quotes from string before decoding
             if isinstance(secure_data_raw, str):
                 secure_data_raw = secure_data_raw.strip('"')
 
-            decoded_str = base64.b64decode(secure_data_raw).decode('utf-8')
-            content_details = json.loads(decoded_str)
-            
-            # Sometimes content_details might be a string (double encoded)
-            if isinstance(content_details, str):
-                content_details = json.loads(content_details)
+            content_details = json.loads(base64.b64decode(secure_data_raw).decode('utf-8'))
+            if isinstance(content_details, str): content_details = json.loads(content_details)
 
-            print(f"DEBUG: type(content_details)={type(content_details)}")
             item            = content_details.get("contentItem", {})
-            print(f"DEBUG: type(item)={type(item)}")
             related_results = content_details.get("RelatedResults", {})
 
-            title           = item.get("original_title") or item.get("culture_title") or item.get("originalTitle") or ""
-            poster          = self.clean_image_url(item.get("poster_url") or item.get("posterUrl") or item.get("face_url"))
-            description     = item.get("description") or item.get("used_description")
-            rating          = str(item.get("imdb_point") or item.get("imdbPoint") or "")
-            year            = str(item.get("release_year") or item.get("releaseYear") or "")
-            duration        = item.get("total_minutes") or item.get("totalMinutes")
+            title       = self.clean_title(item.get("original_title") or item.get("culture_title") or item.get("originalTitle") or "")
+            poster      = self.clean_image_url(item.get("poster_url") or item.get("posterUrl") or item.get("face_url"))
+            description = item.get("description") or item.get("used_description")
+            rating      = str(item.get("imdb_point") or item.get("imdbPoint") or "")
+            year        = str(item.get("release_year") or item.get("releaseYear") or "")
+            duration    = item.get("total_minutes") or item.get("totalMinutes")
 
             tags = []
             tags_raw = item.get("category_names") or item.get("categoryNames") or item.get("categories")
             if isinstance(tags_raw, str):
-                tags = [t.strip() for t in tags_raw.split(",")]
+                tags = [t.strip() for t in tags_raw.split(",") if t.strip()]
             elif isinstance(tags_raw, list):
                 tags = [c.get("title") if isinstance(c, dict) else str(c) for c in tags_raw]
 
             actors = []
-            actors_raw = item.get("actor_names") or item.get("actorNames")
-            if isinstance(actors_raw, str):
-                actors = [a.strip() for a in actors_raw.split(",")]
-            
-            # Casts from RelatedResults
             casts_data = related_results.get("getSerieCastsById") or related_results.get("getMovieCastsById")
             if casts_data and isinstance(casts_data, dict) and casts_data.get("result"):
                 actors = [cast.get("name") for cast in casts_data["result"] if cast.get("name")]
 
+            common_info = {
+                "url"         : url,
+                "poster"      : poster,
+                "title"       : title or "Bilinmiyor",
+                "description" : description,
+                "tags"        : tags,
+                "rating"      : rating,
+                "year"        : year,
+                "actors"      : actors,
+                "duration"    : duration
+            }
+
             series_data = related_results.get("getSerieSeasonAndEpisodes")
             if series_data and isinstance(series_data, dict) and series_data.get("result"):
                 episodes = []
@@ -249,31 +250,12 @@ class SelcukFlix(PluginBase):
                                 title   = ep.get("ep_text") or ep.get("epText") or "",
                                 url     = self.fix_url(ep_slug)
                             ))
-                
-                return SeriesInfo(
-                    url         = url,
-                    poster      = poster,
-                    title       = self.clean_title(title),
-                    description = description,
-                    tags        = tags,
-                    rating      = rating,
-                    year        = year,
-                    actors      = actors,
-                    duration    = duration,
-                    episodes    = episodes
-                )
-            else:
-                return MovieInfo(
-                    url         = url,
-                    poster      = poster,
-                    title       = self.clean_title(title),
-                    description = description,
-                    tags        = tags,
-                    rating      = rating,
-                    year        = year,
-                    actors      = actors,
-                    duration    = duration
-                )
+                return SeriesInfo(**common_info, episodes=episodes)
+
+            return MovieInfo(**common_info)
+
+        except Exception:
+            return SeriesInfo(url=url, title=self.clean_title(sel.select_text("h1")) or "Bilinmeyen")
 
         except Exception:
             return SeriesInfo(url=url, title=self.clean_title(sel.select_text("h1")) or "Bilinmeyen")

KekikStream/Plugins/SetFilmIzle.py

@@ -125,95 +125,39 @@ class SetFilmIzle(PluginBase):
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         istek  = self.cloudscraper.get(url)
         secici = HTMLHelper(istek.text)
-        html_text = istek.text
-
-        raw_title = secici.select_text("h1") or secici.select_text(".titles h1") or secici.select_attr("meta[property='og:title']", "content") or ""
-        title = HTMLHelper(raw_title).regex_replace(r"(?i)\s*izle.*$", "", flags=0).strip()
-
-        poster = secici.select_attr("div.poster img", "src")
 
+        title       = self.clean_title(secici.select_text("h1") or secici.select_text(".titles h1") or secici.select_attr("meta[property='og:title']", "content"))
+        poster      = secici.select_poster("div.poster img")
         description = secici.select_text("div.wp-content p")
+        rating      = secici.select_text("b#repimdb strong") or secici.regex_first(r"([\d.]+)", secici.select_text("div.imdb"))
+        year        = secici.extract_year("div.extra span.valor")
+        tags        = secici.select_texts("div.sgeneros a")
+        duration    = int(secici.regex_first(r"(\d+)", secici.select_text("span.runtime")) or 0)
+        actors      = secici.select_texts("span.valor a[href*='/oyuncu/']")
+
+        common_info = {
+            "url"         : url,
+            "poster"      : self.fix_url(poster) if poster else None,
+            "title"       : title or "Bilinmiyor",
+            "description" : description,
+            "tags"        : tags,
+            "rating"      : rating,
+            "year"        : str(year) if year else None,
+            "duration"    : duration,
+            "actors"      : actors
+        }
 
-        rating = secici.select_text("b#repimdb strong") or secici.regex_first(r'repimdb"><strong>\s*([^<]+)</strong>', html_text)
-        
-        # Yıl için info bölümünden veya regex ile yakala
-        year = secici.regex_first(r'(\d{4})', secici.select_text("div.extra span.valor") or secici.select_text("span.valor") or "")
-        if not year:
-            year = secici.regex_first(r'<span>(\d{4})</span>', html_text) or secici.regex_first(r'(\d{4})', html_text)
-
-        tags = [a.text(strip=True) for a in secici.select("div.sgeneros a") if a.text(strip=True)]
-
-        duration_text = secici.select_text("span.runtime")
-        duration = int(secici.regex_first(r"\d+", duration_text)) if duration_text and secici.regex_first(r"\d+", duration_text) else None
-
-        actors = [a.text(strip=True) for a in secici.select("span.valor a") if "/oyuncu/" in (a.attrs.get("href") or "")]
-        if not actors:
-             actors = secici.regex_all(r'href="[^"]*/oyuncu/[^"]*">([^<]+)</a>')
-
-        trailer = None
-        if trailer_id := secici.regex_first(r'embed/([^?]*)\?rel', html_text):
-            trailer = f"https://www.youtube.com/embed/{trailer_id}"
-
-        # Dizi mi film mi kontrol et
-        is_series = "/dizi/" in url
-
-        if is_series:
-            year_elem = secici.select_text("a[href*='/yil/']")
-            if year_elem:
-                year = secici.regex_first(r"\d{4}", year_elem) or year
-
-            # Duration from info section
-            for span in secici.select("div#info span"):
-                span_text = span.text(strip=True) if span.text() else ""
-                if "Dakika" in span_text:
-                    duration = secici.regex_first(r"\d+", span_text) and int(secici.regex_first(r"\d+", span_text))
-                    break
-
+        if "/dizi/" in url:
             episodes = []
             for ep_item in secici.select("div#episodes ul.episodios li"):
-                ep_href = secici.select_attr("h4.episodiotitle a", "href", ep_item)
-                ep_name = secici.select_text("h4.episodiotitle a", ep_item)
-
-                if not ep_href or not ep_name:
-                    continue
-
-                ep_detail = ep_name
-                ep_season = secici.regex_first(r"(\d+)\.\s*Sezon", ep_detail) or 1
-                ep_episode = secici.regex_first(r"Sezon\s+(\d+)\.\s*Bölüm", ep_detail)
-
-                ep_season = int(ep_season) if isinstance(ep_season, str) and ep_season.isdigit() else 1
-                ep_episode = int(ep_episode) if isinstance(ep_episode, str) and ep_episode.isdigit() else None
-
-                episodes.append(Episode(
-                    season  = ep_season,
-                    episode = ep_episode,
-                    title   = ep_name,
-                    url     = self.fix_url(ep_href)
-                ))
-            return SeriesInfo(
-                url         = url,
-                poster      = self.fix_url(poster) if poster else None,
-                title       = title,
-                description = description,
-                tags        = tags,
-                rating      = rating,
-                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,
-            tags        = tags,
-            rating      = rating,
-            year        = year,
-            duration    = duration,
-            actors      = actors
-        )
+                href = secici.select_attr("h4.episodiotitle a", "href", ep_item)
+                name = secici.select_direct_text("h4.episodiotitle a", ep_item)
+                if href and name:
+                    s, e = secici.extract_season_episode(name)
+                    episodes.append(Episode(season=s or 1, episode=e or 1, title=name, url=self.fix_url(href)))
+            return SeriesInfo(**common_info, episodes=episodes)
+
+        return MovieInfo(**common_info)
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek  = await self.httpx.get(url)

KekikStream/Plugins/SezonlukDizi.py

@@ -70,7 +70,7 @@ class SezonlukDizi(PluginBase):
         return results
 
     async def search(self, query: str) -> list[SearchResult]:
-        istek  = await self.httpx.get(f"{self.main_url}/diziler.asp?adi={query}")
+        istek  = await self.httpx.get(f"{self.main_url}/diziler.asp?q={query}")
         secici = HTMLHelper(istek.text)
 
         results = []
@@ -92,63 +92,31 @@ class SezonlukDizi(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        title    = secici.select_text("div.header") or ""
-
-        poster    = secici.select_attr("div.image img", "data-src") or ""
-
-        # year: re_first yerine re.search
-        year_text = secici.select_text("div.extra span") or ""
-        year = secici.regex_first(r"(\d{4})", year_text)
-
-        # xpath normalized-space yerine doğrudan ID ile element bulup text al
-        description = secici.select_text("span#tartismayorum-konu") or ""
-
-        tags = [a.text(strip=True) for a in secici.select("div.labels a[href*='tur']") if a.text(strip=True)]
-
-        # rating: regex ile çıkar
-        rating_text = secici.select_text("div.dizipuani a div") or ""
-        rating = secici.regex_first(r"[\d.,]+", rating_text)
-
-        actors = []
-
-        actors_istek  = await self.httpx.get(f"{self.main_url}/oyuncular/{url.split('/')[-1]}")
-        actors_secici = HTMLHelper(actors_istek.text)
-        for actor in actors_secici.select("div.doubling div.ui"):
-            header_text = actors_secici.select_text("div.header", actor)
-            if header_text:
-                actors.append(header_text)
-
-        episodes_istek  = await self.httpx.get(f"{self.main_url}/bolumler/{url.split('/')[-1]}")
-        episodes_secici = HTMLHelper(episodes_istek.text)
-        episodes        = []
-
-        for sezon in episodes_secici.select("table.unstackable"):
-            for bolum in episodes_secici.select("tbody tr", sezon):
-                # td:nth-of-type selectolax'ta desteklenmiyor, alternatif yol: tüm td'leri alıp indexle
-                tds = episodes_secici.select("td", bolum)
-                if len(tds) < 4:
-                    continue
-
-                # 4. td'den isim ve href
-                ep_name    = episodes_secici.select_text("a", tds[3])
-                ep_href    = episodes_secici.select_attr("a", "href", tds[3])
-
-                # 3. td'den episode (re_first yerine regex)
-                ep_episode_text = episodes_secici.select_text("a", tds[2]) or ""
-                ep_episode = episodes_secici.regex_first(r"(\d+)", ep_episode_text)
-
-                # 2. td'den season (re_first yerine regex)
-                ep_season_text = tds[1].text(strip=True) if tds[1] else ""
-                ep_season = secici.regex_first(r"(\d+)", ep_season_text)
-
-                if ep_name and ep_href:
-                    episode = Episode(
-                        season  = ep_season,
-                        episode = ep_episode,
-                        title   = ep_name,
-                        url     = self.fix_url(ep_href),
-                    )
-                    episodes.append(episode)
+        title       = secici.select_text("div.header") or ""
+        poster      = secici.select_poster("div.image img")
+        year        = secici.extract_year("div.extra span")
+        description = secici.select_text("span#tartismayorum-konu")
+        tags        = secici.select_texts("div.labels a[href*='tur']")
+        rating      = secici.regex_first(r"[\d.,]+", secici.select_text("div.dizipuani a div"))
+
+        # Actors extraction
+        id_slug = url.split('/')[-1]
+        a_resp  = await self.httpx.get(f"{self.main_url}/oyuncular/{id_slug}")
+        a_sel   = HTMLHelper(a_resp.text)
+        actors  = a_sel.select_texts("div.doubling div.ui div.header")
+
+        # Episodes extraction
+        e_resp   = await self.httpx.get(f"{self.main_url}/bolumler/{id_slug}")
+        e_sel    = HTMLHelper(e_resp.text)
+        episodes = []
+        for row in e_sel.select("table.unstackable tbody tr"):
+            tds = e_sel.select("td", row)
+            if len(tds) >= 4:
+                name = e_sel.select_text("a", tds[3])
+                href = e_sel.select_attr("a", "href", tds[3])
+                if name and href:
+                    s, e = e_sel.extract_season_episode(f"{tds[1].text(strip=True)} {tds[2].text(strip=True)}")
+                    episodes.append(Episode(season=s or 1, episode=e or 1, title=name, url=self.fix_url(href)))
 
         return SeriesInfo(
             url         = url,
@@ -157,7 +125,7 @@ class SezonlukDizi(PluginBase):
             description = description,
             tags        = tags,
             rating      = rating,
-            year        = year,
+            year        = str(year) if year else None,
             episodes    = episodes,
             actors      = actors
         )

KekikStream/Plugins/Sinefy.py

@@ -135,114 +135,51 @@ class Sinefy(PluginBase):
             pass
         return []
 
-    async def load_item(self, url: str) -> SeriesInfo:
+    async def load_item(self, url: str) -> SeriesInfo | MovieInfo:
         resp = await self.httpx.get(url)
         sel  = HTMLHelper(resp.text)
         
-        title    = sel.select_text("h1")
-
-        poster_info = sel.select_attr("div.ui.items img", "data-srcset")
-        poster = None
-        if poster_info:
-            parts = str(poster_info).split(",")
-            for p in parts:
-                if "1x" in p:
-                    poster = p.strip().split(" ")[0]
-                    break
-
+        title       = sel.select_direct_text("h1")
+        poster_attr = sel.select_attr("img.series-profile-thumb", "data-srcset") or sel.select_attr("img.series-profile-thumb", "srcset")
+        if poster_attr:
+            # "url 1x, url 2x" -> en sondakini (en yüksek kalite) al
+            poster = poster_attr.split(",")[-1].strip().split(" ")[0]
+        else:
+            poster = sel.select_poster("img.series-profile-thumb")
         description = sel.select_text("p#tv-series-desc")
+        tags        = sel.select_texts("div.item.categories a")
+        rating      = sel.select_text("span.color-imdb")
+        actors      = sel.select_texts("div.content h5")
+        year        = sel.extract_year("div.truncate")
+        duration    = sel.regex_first(r"(\d+)", sel.select_text(".media-meta td:last-child"))
+        if duration == year or int(duration) < 40:
+            duration = None
+
+        common_info = {
+            "url"         : url,
+            "poster"      : self.fix_url(poster) if poster else None,
+            "title"       : title or "Bilinmiyor",
+            "description" : description,
+            "tags"        : tags,
+            "rating"      : rating,
+            "year"        : str(year) if year else None,
+            "actors"      : actors,
+            "duration"    : duration
+        }
 
-        tags    = [a.text(strip=True) for a in sel.select("div.item.categories a") if a.text(strip=True)]
-
-        rating    = sel.select_text("span.color-imdb")
-
-        actors = [h5.text(strip=True) for h5 in sel.select("div.content h5") if h5.text(strip=True)]
-
-        year    = sel.select_text("span.item.year")
-        if not year and title:
-            # Try to extract year from title like "Movie Name(2024)"
-            year_match = sel.regex_first(r"\((\d{4})\)", title)
-            if year_match:
-                year = year_match
-        
         episodes = []
-        episodes_box_list = sel.select("section.episodes-box")
-        
-        if episodes_box_list:
-            episodes_box = episodes_box_list[0]
-            # Sezon menüsünden sezon linklerini al
-            season_menu = sel.select("div.ui.vertical.fluid.tabular.menu a.item", episodes_box)
-            
-            # Sezon tab içeriklerini al
-            season_tabs = sel.select("div.ui.tab", episodes_box)
-            
-            # Eğer birden fazla sezon varsa, her sezon tab'ından bölümleri çek
-            if season_tabs:
-                for idx, season_tab in enumerate(season_tabs):
-                    # Sezon numarasını belirle
-                    current_season_no = idx + 1
-                    
-                    # Menüden sezon numarasını almaya çalış
-                    if idx < len(season_menu):
-                        menu_href = season_menu[idx].attrs.get("href", "")
-                        match = sel.regex_first(r"sezon-(\d+)", menu_href)
-                        if match:
-                            current_season_no = int(match)
-                    
-                    # Bu sezon tab'ından bölüm linklerini çek
-                    ep_links = sel.select("a[href*='bolum']", season_tab)
-                    
-                    seen_urls = set()
-                    for ep_link in ep_links:
-                        href = ep_link.attrs.get("href")
-                        if not href or href in seen_urls:
-                            continue
-                        seen_urls.add(href)
-                        
-                        # Bölüm numarasını URL'den çıkar
-                        ep_no = 0
-                        match_ep = sel.regex_first(r"bolum-(\d+)", href)
-                        if match_ep:
-                            ep_no = int(match_ep)
-                        
-                        # Bölüm başlığını çıkar (önce title attribute, sonra text)
-                        name = ep_link.attrs.get("title", "")
-                        if not name:
-                            name = sel.select_text("div.content div.header", ep_link)
-                            if not name:
-                                name = ep_link.text(strip=True)
-                        
-                        if href and ep_no > 0:
-                            episodes.append(Episode(
-                                season  = current_season_no,
-                                episode = ep_no,
-                                title   = name.strip() if name else f"{ep_no}. Bölüm",
-                                url     = self.fix_url(href)
-                            ))
+        for tab in sel.select("div.ui.tab"):
+            for link in sel.select("a[href*='bolum']", tab):
+                href = link.attrs.get("href")
+                if href:
+                    s, e = sel.extract_season_episode(href)
+                    name = sel.select_text("div.content div.header", link) or link.text(strip=True)
+                    episodes.append(Episode(season=s or 1, episode=e or 1, title=name, url=self.fix_url(href)))
         
         if episodes:
-            return SeriesInfo(
-                title    = title,
-                url      = url,
-                poster   = self.fix_url(poster) if poster else None,
-                description = description,
-                rating   = rating,
-                tags     = tags,
-                actors   = actors,
-                year     = year,
-                episodes = episodes
-            )
-        else:
-            return MovieInfo(
-                title       = title,
-                url         = url,
-                poster      = self.fix_url(poster) if poster else None,
-                description = description,
-                rating      = rating,
-                tags        = tags,
-                actors      = actors,
-                year        = year
-            )
+            return SeriesInfo(**common_info, episodes=episodes)
+
+        return MovieInfo(**common_info)
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         resp = await self.httpx.get(url)