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

KekikStream/Plugins/Full4kizle.py

@@ -98,151 +98,51 @@ class Full4kizle(PluginBase):
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         istek = await self.httpx.get(url)
         helper = HTMLHelper(istek.text)
-        
-        title_raw = helper.select_text("h1") or "Bilinmiyor"
-        title = re.sub(r"(?i)izle", "", title_raw).strip()
-        
-        poster_el = helper.select_first(".poster img")
-        poster = self.fix_url(poster_el.attrs.get("src")) if poster_el else None
-        
-        description = helper.select_text(".excerpt p")
-        
-        # Robust metadata extraction using Regex
-        
-        # Initialize year first
-        year = None
-        
-        # Try .release first (legacy) or directly regex
-        rel_text = helper.select_text(".release")
-        if rel_text:
-             m_y = re.search(r"(\d{4})", rel_text)
-             if m_y: year = m_y.group(1)
-             
-        # Year fallbacks
-        if not year:
-            # Try finding year in text like "Yapım: 2024" or just isolated year in release date
-            m_year = helper.regex_first(r"Yapım:\s*(\d{4})") or helper.regex_first(r"Yıl:\s*(\d{4})")
-            if m_year:
-                year = m_year
-
-        # Rating
-        rating_text = helper.select_text(".imdb-rating")
-        if rating_text:
-            rating = rating_text.replace("IMDB Puanı", "").strip()
-        else:
-            rating = helper.regex_first(r"IMDB\s*:\s*([\d\.]+)")
-
-        # Duration
-        duration = None
-        duration_val = helper.regex_first(r"Süre:\s*(\d+)")
-        if duration_val:
-            duration = int(duration_val)
 
-        # Actors - Extract from actor links
-        actors = None
-        actors_list = []
-        
-        # Site uses: <a href=".../oyuncular/...">Actor Name</a>
-        actor_els = helper.select("a[href*='/oyuncular/']")
-        if actor_els:
-            actors_list = [el.text(strip=True) for el in actor_els if el.text(strip=True)]
-        
-        # Fallback: Try .cast-list selector
-        if not actors_list:
-            actor_els = helper.select(".cast-list .actor-name, .cast-list a")
-            if actor_els:
-                actors_list = [el.text(strip=True) for el in actor_els if el.text(strip=True)]
-        
-        if actors_list:
-            actors = ", ".join(actors_list)
-
-
-        # Tags (Genres) - Extract from genre links
-        tags = None
-        tags_list = []
-        
-        # Site uses: <a href=".../tur/...">Genre Name</a> or <a href=".../Kategori/tur/...">
-        tag_els = helper.select("a[href*='/tur/'], a[href*='/Kategori/tur/']")
-        if tag_els:
-            tags_list = [el.text(strip=True) for el in tag_els if el.text(strip=True)]
-        
-        # Fallback: Try .genres selector
-        if not tags_list:
-            tag_els = helper.select(".genres a, .genre a")
-            if tag_els:
-                tags_list = [el.text(strip=True) for el in tag_els if el.text(strip=True)]
-        
-        # Remove duplicates while preserving order
-        if tags_list:
-            seen = set()
-            unique_tags = []
-            for tag in tags_list:
-                if tag not in seen:
-                    seen.add(tag)
-                    unique_tags.append(tag)
-            tags = unique_tags if unique_tags else None
+        title       = self.clean_title(helper.select_text("h1"))
+        poster      = helper.select_poster(".poster img")
+        description = helper.select_text(".excerpt p")
+        year        = helper.extract_year(".release", ".movie-info")
+        rating      = helper.regex_first(r"([\d\.]+)", helper.select_text(".imdb-rating"))
+        duration    = int(helper.regex_first(r"(\d+)", helper.select_text(".movie-info")) or 0)
+        tags        = helper.select_texts("a[href*='/tur/'], a[href*='/Kategori/tur/']")
+        actors      = helper.select_texts("a[href*='/oyuncular/']") or helper.select_texts(".cast-list .actor-name, .cast-list a")
 
-            
-        # Check for Episodes to decide if Series or Movie
+        # Bölüm linklerini kontrol et
         ep_elements = helper.select(".parts-middle a, .parts-middle .part.active")
-        
+
         if not ep_elements:
-            # Movie
             return MovieInfo(
                 url         = url,
-                title       = title,
+                title       = title or "Bilinmiyor",
                 description = description,
-                poster      = poster,
-                year        = year,
+                poster      = self.fix_url(poster) if poster else None,
+                year        = str(year) if year else None,
                 rating      = rating,
                 duration    = duration,
                 tags        = tags,
                 actors      = actors
             )
-        else:
-            # Series
-            episodes = []
-            for i, el in enumerate(ep_elements):
-                ep_name = helper.select_text(".part-name", el) or f"Bölüm {i+1}"
-                ep_href = el.attrs.get("href")
-                if not ep_href:
-                    ep_href = url # Current page if href is empty/active?
-                ep_href = self.fix_url(ep_href)
-                
-                # Parse season/episode from name if possible
-                # Kotlin: find digit for season, substringAfter("Sezon") digit for episode
-                season = 1
-                episode = i + 1
-                
-                # Simple heuristic similar to Kotlin
-                # "1. Sezon 5. Bölüm"
-                s_match = re.search(r"(\d+)\.\s*Sezon", ep_name)
-                e_match = re.search(r"(\d+)\.\s*Bölüm", ep_name)
-                
-                if s_match:
-                    season = int(s_match.group(1))
-                if e_match:
-                    episode = int(e_match.group(1))
-                    
-                episodes.append(Episode(
-                    season  = season,
-                    episode = episode,
-                    title   = ep_name,
-                    url     = ep_href
-                ))
-                
-            return SeriesInfo(
-                url         = url,
-                title       = title,
-                description = description,
-                poster      = poster,
-                year        = year,
-                rating      = rating,
-                duration    = duration,
-                tags        = tags,
-                actors      = actors,
-                episodes    = episodes
-            )
+        
+        episodes = []
+        for i, el in enumerate(ep_elements):
+            name = helper.select_text(".part-name", el) or f"Bölüm {i+1}"
+            href = el.attrs.get("href") or url
+            s, e = helper.extract_season_episode(name)
+            episodes.append(Episode(season=s or 1, episode=e or (i + 1), title=name, url=self.fix_url(href)))
+
+        return SeriesInfo(
+            url         = url,
+            title       = title or "Bilinmiyor",
+            description = description,
+            poster      = self.fix_url(poster) if poster else None,
+            year        = str(year) if year else None,
+            rating      = rating,
+            duration    = duration,
+            tags        = tags,
+            actors      = actors,
+            episodes    = episodes
+        )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek = await self.httpx.get(url)

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: