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

KekikStream/Plugins/FullHDFilm.py

@@ -87,108 +87,38 @@ class FullHDFilm(PluginBase):
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
-        html_text = istek.text
-
-        title = secici.select_text("h1") or ""
-
-        poster = secici.select_attr("div.poster img", "src") or ""
-        poster = self.fix_url(poster)
-        
-        actors = []
-        actors_text = secici.select_text("div.oyuncular.info")
-        if actors_text:
-            actors_text = actors_text.replace("Oyuncular:", "").strip()
-            actors = [a.strip() for a in actors_text.split(",")]
-
-        # Year: önce div.yayin-tarihi.info dene
-        year = secici.extract_year("div.yayin-tarihi.info")
-
-        # Fallback: h1'in parent'ından (2019) formatında ara
-        if not year:
-            # Parent'ın tüm text içeriğinden yıl çıkar
-            title_text = secici.select_text("h1")
-            if title_text:
-                # h1 parent'ındaki (2019) gibi text'i bul
-                year = secici.regex_first(r"\((\d{4})\)")
-
-        tags = secici.select_all_text("div.tur.info a")
-
-        # Rating: regex
-        rating_text = secici.select_text("div.imdb") or ""
-        rating = HTMLHelper(rating_text).regex_first(r"IMDb\s*([\d\.]+)")
-        
-        # Description: önce div.film dene, yoksa og:description meta tag'ını kullan
-        description = secici.select_text("div.film")
-        
-        # Fallback: og:description meta tag'ı
-        if not description:
-            og_desc = secici.select_attr("meta[property='og:description']", "content")
-            if og_desc:
-                description = og_desc
-
-        # Kotlin referansı: URL'de -dizi kontrolü veya tags içinde "dizi" kontrolü
+
+        title       = self.clean_title(secici.select_text("h1"))
+        poster      = secici.select_poster("div.poster img")
+        description = secici.select_text("div.film") or secici.select_attr("meta[property='og:description']", "content")
+        year        = secici.extract_year("div.yayin-tarihi.info") or secici.regex_first(r"\((\d{4})\)")
+        tags        = secici.select_texts("div.tur.info a")
+        rating      = secici.regex_first(r"IMDb\s*([\d\.]+)", secici.select_text("div.imdb"))
+        actors      = secici.select_direct_text("div.oyuncular")
+
+        # Kotlin referansı: URL'de -dizi veya tags içinde dizi kontrolü
         is_series = "-dizi" in url.lower() or any("dizi" in tag.lower() for tag in tags)
 
         if is_series:
             episodes = []
-            part_elements = secici.select("li.psec")
-            
-            # pdata değerlerini çıkar
-            pdata_matches = HTMLHelper(html_text).regex_all(r"pdata\['([^']+)'\]\s*=\s*'([^']+)'")
-            
-            for idx, el in enumerate(part_elements):
-                part_id = el.attrs.get("id")
-                part_name = secici.select_text("a", el)
-
-                if not part_name:
-                    continue
-                
-                # Fragman'ları atla
-                if "fragman" in part_name.lower() or (part_id and "fragman" in part_id.lower()):
-                    continue
+            for idx, el in enumerate(secici.select("li.psec")):
+                part_id   = el.attrs.get("id")
+                part_name = secici.select_text("a", el) or ""
+                if not part_name or "fragman" in part_name.lower(): continue
                 
-                # Sezon ve bölüm numarası çıkar
-                sz_val = HTMLHelper(part_id.lower() if part_id else "").regex_first(r'(\d+)\s*sezon')
-                ep_val = HTMLHelper(part_name).regex_first(r'^(\d+)\.')
-
-                sz_num = int(sz_val) if sz_val and sz_val.isdigit() else 1
-                ep_num = int(ep_val) if ep_val and ep_val.isdigit() else idx + 1
-                
-                # pdata'dan video URL'si çık (varsa)
-                video_url = url  # Varsayılan olarak ana URL kullan
-                if idx < len(pdata_matches):
-                    video_url = pdata_matches[idx][1] if pdata_matches[idx][1] else url
-                
-                episodes.append(Episode(
-                    season  = sz_num,
-                    episode = ep_num,
-                    title   = f"{sz_num}. Sezon {ep_num}. Bölüm",
-                    url     = url  # Bölüm URL'leri load_links'te işlenecek
-                ))
+                s, e = secici.extract_season_episode(f"{part_id} {part_name}")
+                episodes.append(Episode(season=s or 1, episode=e or (idx+1), title=f"{s or 1}. Sezon {e or idx+1}. Bölüm", url=url))
 
             return SeriesInfo(
-                url         = url,
-                poster      = poster,
-                title       = self.clean_title(title) if title else "",
-                description = description,
-                tags        = tags,
-                year        = year,
-                actors      = actors,
-                rating      = rating,
-                episodes    = episodes
-            )
-        else:
-            return MovieInfo(
-                url         = url,
-                poster      = poster,
-                title       = self.clean_title(title) if title else "",
-                description = description,
-                tags        = tags,
-                year        = year,
-                actors      = actors,
-                rating      = rating,
+                url=url, poster=self.fix_url(poster) if poster else None, title=title or "", description=description,
+                tags=tags, year=str(year) if year else None, actors=actors, rating=rating, episodes=episodes
             )
 
+        return MovieInfo(
+            url=url, poster=self.fix_url(poster) if poster else None, title=title or "", description=description,
+            tags=tags, year=str(year) if year else None, actors=actors, rating=rating
+        )
+
     def _get_iframe(self, source_code: str) -> str:
         """Base64 kodlu iframe'i çözümle"""
         script_val = HTMLHelper(source_code).regex_first(r'<script[^>]*>(PCEtLWJhc2xpazp[^<]*)</script>')

KekikStream/Plugins/FullHDFilmizlesene.py

@@ -81,43 +81,24 @@ class FullHDFilmizlesene(PluginBase):
     async def load_item(self, url: str) -> MovieInfo:
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
-        html_text = istek.text
-
-        # Title: normalize-space yerine doğrudan class ile
-        title = secici.select_text("div.izle-titles") or ""
-
-        poster = secici.select_attr("div img[data-src]", "data-src") or ""
-        poster = poster.strip()
-
-        description = secici.select_text("div.ozet-ic p") or ""
-
-        tags = secici.select_all_text("a[rel='category tag']")
-
-        # Rating: regex ile sayısal değeri yakala
-        rating_text = secici.select_text("div.puanx-puan") or ""
-        rating = secici.regex_first(r"(\d+\.\d+|\d+)", rating_text)
-
-        # Year: ilk yıl formatında değer
-        year_text = secici.select_text("div.dd a.category") or ""
-        year = secici.regex_first(r"(\d{4})", year_text)
-
-        # Actors: nth-child yerine tüm li'leri alıp 2. index
-        lis = secici.select("div.film-info ul li")
-        actors = []
-        if len(lis) >= 2:
-            actors = secici.select_all_text("a > span", lis[1])
 
-        # Duration: regex ile yakala (örn: 201 dk)
-        duration = secici.regex_first(r"(\d+)\s*(?:dk|dakika)", html_text)
+        title       = self.clean_title(secici.select_text("div.izle-titles"))
+        poster      = secici.select_poster("div img[data-src]")
+        description = secici.select_text("div.ozet-ic p")
+        tags        = secici.select_texts("a[rel='category tag']")
+        rating      = secici.regex_first(r"(\d+\.\d+|\d+)", secici.select_text("div.puanx-puan"))
+        year        = secici.extract_year("div.dd a.category")
+        actors      = secici.select_texts("a > span", secici.select_first("div.film-info ul li:nth-child(2)"))
+        duration    = int(secici.regex_first(r"(\d+)", secici.select_text("div.film-info ul li:nth-child(4)")) or 0)
 
         return MovieInfo(
             url         = url,
             poster      = self.fix_url(poster) if poster else None,
-            title       = title,
+            title       = title or "Bilinmiyor",
             description = description,
             tags        = tags,
             rating      = rating,
-            year        = year,
+            year        = str(year) if year else None,
             actors      = actors,
             duration    = duration
         )

KekikStream/Plugins/HDFilmCehennemi.py

@@ -78,77 +78,38 @@ class HDFilmCehennemi(PluginBase):
         istek  = await self.httpx.get(url, headers = {"Referer": f"{self.main_url}/"})
         secici = HTMLHelper(istek.text)
 
-        title = secici.select_text("h1.section-title") or ""
-
-        poster = secici.select_attr("aside.post-info-poster img.lazyload", "data-src") or ""
-        poster = poster.strip()
-
-        description = secici.select_text("article.post-info-content > p") or ""
-
-        tags = secici.select_all_text("div.post-info-genres a")
-
-        rating = secici.select_text("div.post-info-imdb-rating span") or ""
-
-        year = secici.select_text("div.post-info-year-country a") or ""
-
-        actors = secici.select_all_text("div.post-info-cast a > strong")
-
-        duration_str = secici.select_text("div.post-info-duration") or "0"
-        duration_str = duration_str.replace("dakika", "").strip()
-
-        try:
-            duration_val = HTMLHelper(duration_str).regex_first(r'\d+')
-            duration_minutes = int(duration_val) if duration_val else 0
-        except Exception:
-            duration_minutes = 0
-
-        # Dizi mi film mi kontrol et (Kotlin referansı: div.seasons kontrolü)
-        is_series = len(secici.select("div.seasons")) > 0
-
-        if is_series:
+        title       = self.clean_title(secici.select_text("h1.section-title"))
+        poster      = secici.select_poster("aside.post-info-poster img.lazyload")
+        description = secici.select_text("article.post-info-content > p")
+        tags        = secici.select_texts("div.post-info-genres a")
+        rating      = secici.select_text("div.post-info-imdb-rating span")
+        rating      = rating.split("(")[0] if rating else None
+        year        = secici.select_text("div.post-info-year-country a")
+        actors      = secici.select_texts("div.post-info-cast a > strong")
+        duration    = int(secici.regex_first(r"(\d+)", secici.select_text("div.post-info-duration")) or 0)
+
+        # Dizi mi film mi kontrol et
+        ep_links = secici.select("div.seasons-tab-content a")
+
+        if ep_links:
             episodes = []
-            for ep in secici.select("div.seasons-tab-content a"):
-                ep_name = secici.select_text("h4", ep)
-                ep_href = ep.attrs.get("href")
-
-                if ep_name and ep_href:
-                    # Regex ile sezon ve bölüm numarası çıkar
-                    ep_val = HTMLHelper(ep_name).regex_first(r'(\d+)\.\s*Bölüm')
-                    sz_val = HTMLHelper(ep_name).regex_first(r'(\d+)\.\s*Sezon')
-                    ep_num = int(ep_val) if ep_val and ep_val.isdigit() else 1
-                    sz_num = int(sz_val) if sz_val and sz_val.isdigit() else 1
-                    
-                    episodes.append(Episode(
-                        season  = sz_num,
-                        episode = ep_num,
-                        title   = ep_name,
-                        url     = self.fix_url(ep_href)
-                    ))
+            for ep in ep_links:
+                name = secici.select_text("h4", ep)
+                href = ep.attrs.get("href")
+                if name and href:
+                    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(
-                url         = url,
-                poster      = self.fix_url(poster) if poster else None,
-                title       = self.clean_title(title),
-                description = description,
-                tags        = tags,
-                rating      = rating,
-                year        = year,
-                actors      = actors,
-                episodes    = episodes
-            )
-        else:
-            return MovieInfo(
-                url         = url,
-                poster      = self.fix_url(poster) if poster else None,
-                title       = self.clean_title(title),
-                description = description,
-                tags        = tags,
-                rating      = rating,
-                year        = year,
-                actors      = actors,
-                duration    = duration_minutes
+                url=url, poster=self.fix_url(poster) if poster else None, title=title or "Bilinmiyor",
+                description=description, tags=tags, rating=rating, year=year, actors=actors, episodes=episodes
             )
 
+        return MovieInfo(
+            url=url, poster=self.fix_url(poster) if poster else None, title=title or "Bilinmiyor",
+            description=description, tags=tags, rating=rating, year=year, actors=actors, duration=duration
+        )
+
     def generate_random_cookie(self):
         return "".join(random.choices(string.ascii_letters + string.digits, k=16))
 

KekikStream/Plugins/JetFilmizle.py

@@ -99,35 +99,34 @@ class JetFilmizle(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        title    = self.clean_title(secici.select_text("div.movie-exp-title")) if secici.select_text("div.movie-exp-title") else None
-
-        poster = secici.select_poster("section.movie-exp img")
-        poster = poster.strip() if poster else None
-        
+        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_all_text("section.movie-exp div.catss a")
-        
-        rating = secici.select_text("section.movie-exp div.imdb_puan span")
-        
-        year = secici.extract_year("div.yap")
-        
-        actors = secici.select_all_text("div[itemprop='actor'] a span")
-        if not actors: # Fallback to img alt
-            actors = [img.attrs.get("alt") for img in secici.select("div.oyuncular div.oyuncu img") if img.attrs.get("alt")]
-
-        duration = secici.regex_first(r"(\d+)\s*dk", istek.text)
+        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,
-            title       = title,
+            title       = title or "Bilinmiyor",
             description = description,
             tags        = tags,
             rating      = rating,
-            year        = year,
+            year        = str(year) if year else None,
             actors      = actors,
-            duration    = int(duration) if duration else None
+            duration    = int(total_minutes) if duration else None
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:

KekikStream/Plugins/KultFilmler.py

@@ -78,68 +78,34 @@ class KultFilmler(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        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")) if secici.select_attr("[property='og:image']", "content") 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")
 
-        tags = [a.text(strip=True) for a in secici.select("ul.post-categories a") if a.text(strip=True)]
-
-        # HTML analizine göre güncellenen alanlar
-        year    = secici.select_text("li.release span a")
-
-        time_text = secici.select_text("li.time span")
-        duration = secici.regex_first(r"(\d+)", time_text) if time_text else None
-
-        rating_text = secici.select_text("div.imdb-count")
-        rating = secici.regex_first(r"(\d+\.\d+|\d+)", rating_text) if rating_text else None
-
-        actors = [a.text(strip=True) for a in secici.select("div.actors a") if a.text(strip=True)]
-
-        # Dizi mi kontrol et
         if "/dizi/" in url:
             episodes = []
             for bolum in secici.select("div.episode-box"):
-                ep_href   = secici.select_attr("div.name a", "href", bolum)
-
+                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 ""
-
-                ep_name = f"{ssn_detail} - {ep_detail}"
-
-                if ep_href:
-                    ep_season  = secici.regex_first(r"(\d+)\.", ssn_detail)
-                    ep_episode = secici.regex_first(r"(\d+)\.", ep_detail)
-
-                    episodes.append(Episode(
-                        season  = int(ep_season) if ep_season else 1,
-                        episode = int(ep_episode) if ep_episode else 1,
-                        title   = ep_name.strip(" -"),
-                        url     = self.fix_url(ep_href),
-                    ))
+                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 "",
-                description = description,
-                tags        = tags,
-                year        = year,
-                actors      = actors,
-                rating      = rating,
-                episodes    = episodes,
+                url=url, poster=poster, title=title or "Bilinmiyor", description=description,
+                tags=tags, year=str(year) if year else None, actors=actors, rating=rating, episodes=episodes
             )
 
         return MovieInfo(
-            url         = url,
-            poster      = poster,
-            title       = self.clean_title(title) if title else "",
-            description = description,
-            tags        = tags,
-            year        = year,
-            rating      = rating,
-            actors      = actors,
-            duration    = int(duration) if duration else None,
+            url=url, poster=poster, title=title or "Bilinmiyor", description=description,
+            tags=tags, year=str(year) if year else None, rating=rating, actors=actors, duration=duration
         )
 
     def _get_iframe(self, source_code: str) -> str:

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: