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

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)

KekikStream/Plugins/SinemaCX.py

@@ -83,36 +83,30 @@ class SinemaCX(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        duration_match = secici.regex_first(r"Süre:.*?(\d+)\s*Dakika")
-
+        title       = secici.select_text("div.f-bilgi h1")
+        poster      = secici.select_poster("div.resim img")
         description = secici.select_text("div.ackl div.scroll-liste")
-
-        poster = secici.select_attr("link[rel='image_src']", "href")
-
-        title = secici.select_text("div.f-bilgi h1")
-
-        tags = secici.select_all_text("div.f-bilgi div.tur a")
-
-        year = secici.select_text("div.f-bilgi ul.detay a[href*='yapim']")
-
-        actors = secici.select_all_text("li.oync li.oyuncu-k span.isim")
+        rating      = secici.select_text("b.puandegistir")
+        tags        = secici.select_texts("div.f-bilgi div.tur a")
+        year        = secici.extract_year("ul.detay a[href*='yapim']")
+        actors      = secici.select_texts("li.oync li.oyuncu-k span.isim")
 
         return MovieInfo(
             url         = url,
             poster      = self.fix_url(poster) if poster else None,
-            title       = title,
+            title       = title or "Bilinmiyor",
             description = description,
+            rating      = rating,
             tags        = tags,
-            year        = year,
-            actors      = actors,
-            duration    = int(duration_match) if duration_match else None,
+            year        = str(year) if year else None,
+            actors      = actors
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        iframe_list = secici.select_all_attr("iframe", "data-vsrc")
+        iframe_list = secici.select_attrs("iframe", "data-vsrc")
 
         # Sadece fragman varsa /2/ sayfasından dene
         has_only_trailer = all(
@@ -125,7 +119,7 @@ class SinemaCX(PluginBase):
             alt_istek = await self.httpx.get(alt_url)
             alt_istek = await self.httpx.get(alt_url)
             alt_sec   = HTMLHelper(alt_istek.text)
-            iframe_list = alt_sec.select_all_attr("iframe", "data-vsrc")
+            iframe_list = alt_sec.select_attrs("iframe", "data-vsrc")
 
         if not iframe_list:
             return []

KekikStream/Plugins/Sinezy.py

@@ -6,7 +6,7 @@ import base64
 class Sinezy(PluginBase):
     name        = "Sinezy"
     language    = "tr"
-    main_url    = "https://sinezy.fit"
+    main_url    = "https://sinezy.ink"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "Yerli ve yabancı film izle! Türkçe Dublaj ve Alt Yazılı Seçenekleriyle full hd film izlemek için En çok tercih edilen adres!"
 
@@ -83,29 +83,28 @@ class Sinezy(PluginBase):
         return results
 
     async def load_item(self, url: str) -> MovieInfo:
-        resp = await self.httpx.get(url)
+        resp   = await self.httpx.get(url)
         secici = HTMLHelper(resp.text)
 
-        title = secici.select_attr("div.detail", "title")
-        poster = secici.select_attr("div.move_k img", "data-src")
+        title       = secici.select_attr("div.detail", "title")
+        poster      = secici.select_poster("div.move_k img")
         description = secici.select_text("div.desc.yeniscroll p")
-        rating = secici.select_text("span.info span.imdb")
-
-        tags = secici.select_all_text("div.detail span a")
-        actors = secici.select_all_text("span.oyn p")
+        rating      = secici.select_text("span.info span.imdb")
+        tags        = secici.select_texts("div.detail span a")
+        actors      = secici.select_texts("span.oyn p")
+        year        = secici.extract_year()
+        duration    = secici.regex_first(r"(\d+) Dakika", secici.select_text("div.detail p"))
 
-        year = secici.regex_first(r"\b(19\d{2}|20\d{2})\b")
-        if not year:
-            year = secici.regex_first(r"\b(19\d{2}|20\d{2})\b", secici.html)
         return MovieInfo(
-            title       = title,
             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,
-            year        = year
+            duration    = duration
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:

KekikStream/Plugins/SuperFilmGeldi.py

@@ -79,26 +79,21 @@ class SuperFilmGeldi(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        title = secici.select_text("div.title h1") or ""
-        title = self.clean_title(title.split(" izle")[0]) if title else ""
-
-        poster = secici.select_attr("div.poster img", "src")
-
-        year = secici.extract_year("div.release a")
-
+        title       = self.clean_title(secici.select_text("div.title h1").split(" izle")[0]) if secici.select_text("div.title h1") else ""
+        poster      = secici.select_poster("div.poster img")
+        year        = secici.extract_year("div.release a")
         description = secici.select_text("div.excerpt p")
-
-        tags = secici.select_all_text("div.categories a")
-        actors = secici.select_all_text("div.actor a")
+        tags        = secici.select_texts("div.categories a")
+        actors      = secici.select_texts("div.actor a")
 
         return MovieInfo(
             url         = url,
             poster      = self.fix_url(poster) if poster else None,
-            title       = title,
+            title       = title or "Bilinmiyor",
             description = description,
             tags        = tags,
-            year        = year,
-            actors      = actors,
+            year        = str(year) if year else None,
+            actors      = actors
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]: