KekikStream 2.3.7__tar.gz → 2.3.8__tar.gz

kekikstream-2.3.8/KekikStream/Extractors/MolyStream.py

@@ -0,0 +1,83 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+import re
+
+class MolyStream(ExtractorBase):
+    name     = "MolyStream"
+    main_url = "https://dbx.molystream.org"
+
+    # Birden fazla domain destekle
+    supported_domains = [
+        "dbx.molystream.org",
+        "ydx.molystream.org",
+        "yd.sheila.stream",
+        "ydf.popcornvakti.net",
+    ]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if "doctype html" in url.lower():
+            text = url
+        else:
+            # Sheila-style referer fix
+            if "/embed/sheila/" in url:
+                referer = url.replace("/embed/sheila/", "/embed/")
+
+            self.httpx.headers.update({
+                "User-Agent" : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                "Referer"    : referer or self.main_url
+            })
+            istek = await self.httpx.get(url, follow_redirects=True)
+            text  = istek.text
+
+        # 1. Sheila-style links often have the m3u8 directly as the first http line or in script
+        m3u8 = None
+        if "#EXTM3U" in text:
+            for line in text.splitlines():
+                line = line.strip().replace('"', '').replace("'", "")
+                if line.startswith("http"):
+                    m3u8 = line
+                    break
+
+        if not m3u8:
+            for line in text.splitlines():
+                line = line.strip().replace('"', '').replace("'", "")
+                if line.startswith("http") and ".m3u8" in line:
+                    m3u8 = line
+                    break
+
+        if not m3u8:
+            secici = HTMLHelper(text)
+            # 2. Try video tag
+            m3u8 = secici.select_attr("video#sheplayer source", "src") or secici.select_attr("video source", "src")
+            
+        if not m3u8:
+            # 3. Try regex
+            m3u8 = HTMLHelper(text).regex_first(r'["\'](https?://[^"\']+\.m3u8[^"\']*)["\']')
+
+        if not m3u8:
+            # Fallback to any http link in a script if it looks like a video link
+            m3u8 = HTMLHelper(text).regex_first(r'["\'](https?://[^"\']+/q/\d+)["\']')
+
+        if not m3u8:
+            m3u8 = url # Final fallback
+
+        # Subtitles (Sheila style addSrtFile)
+        resp_sec = HTMLHelper(text)
+        matches = resp_sec.regex_all(r"addSrtFile\(['\"]([^'\"]+\.srt)['\"]\s*,\s*['\"][a-z]{2}['\"]\s*,\s*['\"]([^'\"]+)['\"]")
+
+        subtitles = [
+            Subtitle(name = name, url = self.fix_url(url))
+                for url, name in matches
+        ]
+
+        return ExtractResult(
+            name       = self.name,
+            url        = m3u8,
+            referer    = url,
+            user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            subtitles  = subtitles
+        )

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Extractors/VidMoly.py

@@ -24,6 +24,8 @@ class VidMoly(ExtractorBase):
 
         if ".me" in url:
             url = url.replace(".me", ".net")
+        if ".to" in url:
+            url = url.replace(".to", ".net")
 
         # VidMoly bazen redirect ediyor, takip et
         response = await self.httpx.get(url, follow_redirects=True)
@@ -70,6 +72,17 @@ class VidMoly(ExtractorBase):
                             if sub.get("kind") == "captions"
                 ]
 
+        if "#EXTM3U" in response.text:
+            for line in response.text.splitlines():
+                line = line.strip().replace('"', '').replace("'", "")
+                if line.startswith("http"):
+                    return ExtractResult(
+                        name      = self.name,
+                        url       = line,
+                        referer   = self.main_url,
+                        subtitles = subtitles
+                    )
+
         if script_str := resp_sec.regex_first(r"sources:\s*\[(.*?)\],", flags= re.DOTALL):
             script_content = script_str
             # Video kaynaklarını ayrıştır

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/DiziBox.py

@@ -167,34 +167,44 @@ class DiziBox(PluginBase):
 
                 crypt_data = iframe_secici.regex_first(r"CryptoJS\.AES\.decrypt\(\"(.*)\",\"", iframe_istek.text)
                 crypt_pass = iframe_secici.regex_first(r"\",\"(.*)\"\);", iframe_istek.text)
-                decode     = CryptoJS.decrypt(crypt_pass, crypt_data)
-
-                if video_match := iframe_secici.regex_first(r"file: '(.*)',", decode):
-                    results.append(video_match)
-                else:
-                    results.append(decode)
+                if crypt_data and crypt_pass:
+                    decode = CryptoJS.decrypt(crypt_pass, crypt_data)
+                    if video_match := iframe_secici.regex_first(r"file: '(.*)',", decode):
+                        results.append(video_match)
+                    else:
+                        results.append(decode)
 
         elif "/player/moly/moly.php" in iframe_link:
             iframe_link = iframe_link.replace("moly.php?h=", "moly.php?wmode=opaque&h=")
-            while True:
+            for _ in range(3): # Max 3 attempts
                 await asyncio.sleep(.3)
                 with contextlib.suppress(Exception):
                     moly_istek  = await self.httpx.get(iframe_link)
                     moly_secici = HTMLHelper(moly_istek.text)
 
-                    if atob_data := moly_secici.regex_first(r"unescape\(\"(.*)\"\)", moly_istek.text):
+                    if atob_data := moly_secici.regex_first(r"unescape\(\"(.*)\"\)"):
                         decoded_atob = urllib.parse.unquote(atob_data)
                         str_atob     = base64.b64decode(decoded_atob).decode("utf-8")
 
-                    iframe_src = HTMLHelper(str_atob).select_attr("div#Player iframe", "src")
-                    if iframe_src:
-                        results.append(iframe_src)
-
-                    break
+                        iframe_src = HTMLHelper(str_atob).select_attr("div#Player iframe", "src")
+                        if iframe_src:
+                            # ! Sheila replacement (Kotlin referansı)
+                            if "/embed/" in iframe_src:
+                                iframe_src = iframe_src.replace("/embed/", "/embed/sheila/").replace("vidmoly.me", "vidmoly.net")
+                            
+                            results.append(iframe_src)
+                            break
+                    elif embed_matches := moly_secici.regex_all(r'iframe.*?src="(.*?)"'):
+                        for src in embed_matches:
+                            if "/embed/" in src:
+                                src = src.replace("/embed/", "/embed/sheila/").replace("vidmoly.me", "vidmoly.net")
+                            results.append(src)
+                        break
 
         elif "/player/haydi.php" in iframe_link:
-            okru_url = base64.b64decode(iframe_link.split("?v=")[-1]).decode("utf-8")
-            results.append(okru_url)
+            with contextlib.suppress(Exception):
+                okru_url = base64.b64decode(iframe_link.split("?v=")[-1]).decode("utf-8")
+                results.append(okru_url)
 
         return results
 

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/DiziPal.py

@@ -127,18 +127,27 @@ class DiziPal(PluginBase):
 
         poster   = self.fix_url(secici.select_attr("meta[property='og:image']", "content")) if secici.select_attr("meta[property='og:image']", "content") else None
 
-        # XPath yerine regex ile HTML'den çıkarma
-        year = secici.regex_first(r'(?is)Yapım Yılı.*?<div[^>]*>(\d{4})</div>', secici.html)
-
-        description = secici.select_text("div.summary p")
+        # Sidebar bilgilerini topla
+        info = {}
+        for li in secici.select("li"):
+             key = secici.select_text("div.key", li)
+             val = secici.select_text("div.value", li)
+             if key and val:
+                 info[key.strip(":")] = val.strip()
+
+        year   = info.get("Yapım Yılı")
+        rating = info.get("IMDB Puanı")
+        
+        tags_raw = info.get("Türler", "")
+        tags = [t.strip() for t in tags_raw.split() if t.strip()] if tags_raw else None
 
-        rating = secici.regex_first(r'(?is)IMDB Puanı.*?<div[^>]*>([0-9.]+)</div>', secici.html)
+        actors_raw = info.get("Oyuncular")
+        actors = [a.strip() for a in actors_raw.split(",") if a.strip()] if actors_raw else None
 
-        tags_raw = secici.regex_first(r'(?is)Türler.*?<div[^>]*>([^<]+)</div>', secici.html)
-        tags = [t.strip() for t in tags_raw.split() if t.strip()] if tags_raw else None
+        description = secici.select_text("div.summary p")
 
-        duration_raw = secici.regex_first(r'(?is)Ortalama Süre.*?<div[^>]*>(\d+)', secici.html)
-        duration = int(duration_raw) if duration_raw else None
+        duration_raw = info.get("Ortalama Süre")
+        duration = int(secici.regex_first(r"(\d+)", duration_raw)) if duration_raw else None
 
         if "/dizi/" in url:
             title    = secici.select_text("div.cover h5")
@@ -177,6 +186,7 @@ class DiziPal(PluginBase):
                 year        = year,
                 duration    = duration,
                 episodes    = episodes if episodes else None,
+                actors      = actors,
             )
         else:
             # Film için title - g-title div'lerinin 2. olanı
@@ -192,6 +202,7 @@ class DiziPal(PluginBase):
                 rating      = rating,
                 year        = year,
                 duration    = duration,
+                actors      = actors,
             )
 
     async def load_links(self, url: str) -> list[ExtractResult]:

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/DiziWatch.py

@@ -27,10 +27,10 @@ class DiziWatch(PluginBase):
         "1"   : "Suç",
     }
 
+    c_key     = ""
+    c_value   = ""
+
     async def _init_session(self):
-        if getattr(self, "c_key", None) and getattr(self, "c_value", None):
-            return
-        
         # Fetch anime-arsivi to get CSRF tokens
         resp = await self.httpx.get(f"{self.main_url}/anime-arsivi")
         sel  = HTMLHelper(resp.text)
@@ -137,9 +137,9 @@ class DiziWatch(PluginBase):
         resp = await self.httpx.get(url)
         sel  = HTMLHelper(resp.text)
 
-        title    = sel.select_text("h2")
-        poster   = sel.select_attr("img.rounded-md", "src")
-        description = sel.select_text("div.text-sm")
+        title    = sel.select_text("h2") or sel.select_text("h1")
+        poster   = sel.select_attr("img.rounded-md", "src") or sel.select_attr("meta[property='og:image']", "content")
+        description = sel.select_text("div.text-sm") or sel.select_text("div.summary")
         
         year = sel.regex_first(r"Yap\u0131m Y\u0131l\u0131\s*:\s*(\d+)", resp.text)
         

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/DiziYou.py

@@ -72,7 +72,7 @@ class DiziYou(PluginBase):
         html_text = istek.text
 
         # Title - div.title h1 içinde
-        title = secici.select_text("div.title h1")
+        title = (secici.select_text("div.title h1") or "").strip()
 
         # Fallback: Eğer title boşsa URL'den çıkar (telif kısıtlaması olan sayfalar için)
         if not title:
@@ -81,23 +81,19 @@ class DiziYou(PluginBase):
             title = slug.replace('-', ' ').title()
 
         # Poster
-        poster_src = secici.select_attr("div.category_image img", "src")
+        poster_src = secici.select_attr("div.category_image img", "src") or secici.select_attr("meta[property='og:image']", "content")
         poster = self.fix_url(poster_src) if poster_src else ""
 
         # Year - regex ile çıkarma (xpath yerine)
         year = secici.regex_first(r"(?is)Yapım Yılı.*?(\d{4})", secici.html)
 
-        description = None
-        # Extract inner HTML via regex and clean
-        desc_html = secici.regex_first(r'(?s)<div class="diziyou_desc">(.*?)</div>', secici.html)
-        if desc_html:
-            # Script taglarını kaldır
-            desc_html = HTMLHelper(desc_html).regex_replace(r"(?s)<script.*?</script>", "")
-            # div#icerikcat2 ve sonrasını kaldır (meta bilgileri içeriyor)
-            desc_html = HTMLHelper(desc_html).regex_replace(r"(?s)<div id=\"icerikcat2\".*", "")
-            # Kalan HTML'den text çıkar
-            clean_sel = HTMLHelper(desc_html)
-            description = clean_sel.select_text()
+        description_el = secici.select("div.diziyou_desc") or secici.select("div#icerikcat")
+        description = ""
+        if description_el:
+             # Scriptleri temizle
+             for script in secici.select("script", description_el[0]):
+                  script.decompose()
+             description = secici.select_text(None, description_el[0])
 
         tags = [secici.select_text(None, a) for a in secici.select("div.genres a") if secici.select_text(None, a)]
 
@@ -109,9 +105,9 @@ class DiziYou(PluginBase):
         actors = [actor.strip() for actor in actors_raw.split(",") if actor.strip()] if actors_raw else []
 
         episodes = []
-        # Episodes - daha fazla DOM/URL kalıbını destekle
-        for link in secici.select("a"):
-            ep_href = secici.select_attr("a", "href", link)
+        # Episodes - div#scrollbar-container a (kısıtlı alan)
+        for link in secici.select("div#scrollbar-container a"):
+            ep_href = secici.select_attr(None, "href", link)
             if not ep_href:
                 continue
 
@@ -179,9 +175,9 @@ class DiziYou(PluginBase):
         # Player src'den item_id çıkar - önce özel player seçicisini dene
         player_src = None
         # Yaygın locatorlar
-        for sel in ["iframe#diziyouPlayer", "div.player iframe", "iframe[src*='/episodes/']", "iframe"]:
+        for sel in ["iframe#diziyouPlayer", "div.player iframe", "iframe[src*='/player/']", "iframe[src*='/episodes/']", "iframe"]:
             p = secici.select_attr(sel, "src")
-            if p and "youtube.com" not in p.lower():
+            if p and any(x in p.lower() for x in ["/player/", "/episodes/", "diziyou"]):
                 player_src = p
                 break
 

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/Dizilla.py

@@ -137,70 +137,60 @@ class Dizilla(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        title = secici.select_text("div.poster.poster h2")
-        if not title:
+        next_data_text = secici.select_text("script#__NEXT_DATA__")
+        if not next_data_text:
             return None
 
-        poster = secici.select_attr("div.w-full.page-top.relative img", "src")
-        poster = self.fix_url(poster) if poster else None
-
-        # Year extraction (Kotlin: [1] index for w-fit min-w-fit)
-        info_boxes = secici.select("div.w-fit.min-w-fit")
-        year = None
-        if len(info_boxes) > 1:
-            year_text = secici.select_text("span.text-sm.opacity-60", info_boxes[1])
-            if year_text:
-                year = year_text.split(" ")[-1] if " " in year_text else year_text
-
-        description = secici.select_text("div.mt-2.text-sm")
-
-        tags_text = secici.select_text("div.poster.poster h3")
-        tags = [t.strip() for t in tags_text.split(",")] if tags_text else []
-
-        actors = secici.select_all_text("div.global-box h5")
-
-        episodeses = []
-        # Seasons links iteration
-        season_links = secici.select("div.flex.items-center.flex-wrap.gap-2.mb-4 a")
-        for sezon in season_links:
-            sezon_href = secici.select_attr("a", "href", sezon)
-            sezon_href = self.fix_url(sezon_href)
-            sezon_req = await self.httpx.get(sezon_href)
-            
-            season_num = None
-            try:
-                # URL'den sezon numarasını çek: ...-N-sezon formatı
-                season_match = secici.regex_first(r"-(\d+)-sezon", sezon_href)
-                if season_match:
-                    season_num = int(season_match)
-            except:
-                pass
-
-            sezon_secici = HTMLHelper(sezon_req.text)
-            for bolum in sezon_secici.select("div.episodes div.cursor-pointer"):
-                # Kotlin: bolum.select("a").last()
-                links = sezon_secici.select("a", bolum)
-                if not links:
-                    continue
-                
-                ep_link = links[-1]
-                ep_name = sezon_secici.select_text("a", ep_link)
-                ep_href = sezon_secici.select_attr("a", "href", ep_link)
-                ep_href = self.fix_url(ep_href)
+        next_data   = loads(next_data_text)
+        secure_data = next_data.get("props", {}).get("pageProps", {}).get("secureData")
+        if not secure_data:
+            return None
+
+        decrypted = await self.decrypt_response(secure_data)
+        content   = decrypted.get("contentItem", {})
+        if not content:
+            return None
+
+        title       = content.get("original_title") or content.get("used_title")
+        description = content.get("description") or content.get("used_description")
+        rating      = content.get("imdb_point") or content.get("local_vote_avg")
+        year        = content.get("release_year")
+        
+        # Poster and Backdrop - prefer backdrop if available for SeriesInfo
+        poster = self.fix_poster_url(self.fix_url(content.get("back_url") or content.get("poster_url")))
+
+        # Tags
+        tags = []
+        categories = decrypted.get("RelatedResults", {}).get("getSerieCategoriesById", {}).get("result", [])
+        for cat in categories:
+            tags.append(cat.get("name"))
+
+        # Actors
+        actors = []
+        casts = decrypted.get("RelatedResults", {}).get("getSerieCastsById", {}).get("result", [])
+        for cast in casts:
+            actors.append(cast.get("name"))
+
+        # Episodes
+        episodes = []
+        seasons_data = decrypted.get("RelatedResults", {}).get("getSerieSeasonAndEpisodes", {}).get("result", [])
+        for season_item in seasons_data:
+            season_num = season_item.get("season_no")
+            for ep_item in season_item.get("episodes", []):
+                ep_num = ep_item.get("episode_no")
+                ep_slug = ep_item.get("used_slug")
+                ep_name = ep_item.get("episode_text") or ""
                 
-                # Episode number (first link's text usually)
-                ep_num = None
-                try:
-                    ep_num_text = sezon_secici.select_text("a", links[0])
-                    ep_num = int(ep_num_text) if ep_num_text else None
-                except:
-                    pass
-
-                episodeses.append(Episode(
+                # Filter out duplicate language entries if any (we just need one link per episode)
+                # Usually they share the same slug for the episode page
+                if any(e.season == season_num and e.episode == ep_num for e in episodes):
+                    continue
+
+                episodes.append(Episode(
                     season  = season_num,
                     episode = ep_num,
                     title   = ep_name,
-                    url     = ep_href
+                    url     = self.fix_url(f"{self.main_url}/{ep_slug}")
                 ))
 
         return SeriesInfo(
@@ -209,8 +199,9 @@ class Dizilla(PluginBase):
             title       = title,
             description = description,
             tags        = tags,
+            rating      = str(rating) if rating else None,
             year        = str(year) if year else None,
-            episodes    = episodeses,
+            episodes    = episodes,
             actors      = actors
         )
 

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/FilmBip.py

@@ -108,18 +108,22 @@ class FilmBip(PluginBase):
         tags = secici.select_all_text("div.series-profile-type.tv-show-profile-type a")
 
         # XPath yerine regex kullanarak yıl, süre vs. çıkarma
-        year = secici.regex_first(r'(?i)Yapım yılı.*?<p[^>]*>(\d{4})</p>', secici.html)
+        year = secici.regex_first(r"(?is)Yap\u0131m y\u0131l\u0131.*?<p[^>]*>(.*?)<\/p>")
+        if not year:
+            # Fallback: Başlığın sonundaki parantezli yılı yakala
+            year = secici.regex_first(r"\((\d{4})\)", title)
 
-        duration = secici.regex_first(r'(?i)Süre.*?<p[^>]*>(\d+)', secici.html)
+        duration_raw = secici.regex_first(r"(?is)S\u00fcre.*?<p[^>]*>(.*?)<\/p>")
+        duration = secici.regex_first(r"(\d+)", duration_raw) if duration_raw else None
 
-        rating = secici.regex_first(r'(?i)IMDB Puanı.*?<span[^>]*>([0-9.]+)</span>', secici.html)
+        rating = secici.regex_first(r"(?is)IMDB Puan\u0131.*?<span[^>]*>(.*?)<\/span>")
 
         actors = [img.attrs.get("alt") for img in secici.select("div.series-profile-cast ul li a img") if img.attrs.get("alt")]
 
         return MovieInfo(
             url         = url,
             poster      = self.fix_url(poster) if poster else None,
-            title       = self.clean_title(title) if title else "",
+            title       = HTMLHelper(title).regex_replace(r"\(\d{4}\)", "").strip() if title else "",
             description = description,
             tags        = tags,
             year        = year,

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/FilmMakinesi.py

@@ -91,7 +91,7 @@ class FilmMakinesi(PluginBase):
         year = secici.select_text("span.date a") or ""
 
         actors = secici.select_all_text("div.cast-name")
-        tags = secici.select_all_text("div.genre a")
+        tags = [a.text(strip=True) for a in secici.select("div.type a") if "/tur/" in (a.attrs.get("href") or "")]
 
         duration = None
         duration_text = secici.select_text("div.time") or None

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/FullHDFilmizlesene.py

@@ -93,19 +93,13 @@ class FullHDFilmizlesene(PluginBase):
 
         tags = secici.select_all_text("a[rel='category tag']")
 
-        # Rating: normalize-space yerine doğrudan class ile ve son kelimeyi al
-        rating_text = secici.select_text("div.puanx-puan") or None
-        rating = None
-        if rating_text:
-            parts = rating_text.split()
-            rating = parts[-1] if parts else None
+        # 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 None
-        year = None
-        if year_text:
-            parts = year_text.split()
-            year = parts[0] if parts else None
+        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")
@@ -113,11 +107,8 @@ class FullHDFilmizlesene(PluginBase):
         if len(lis) >= 2:
             actors = secici.select_all_text("a > span", lis[1])
 
-        duration = "0"
-        duration_text = secici.select_text("span.sure") or None
-        if duration_text:
-            duration_parts = duration_text.split()
-            duration = duration_parts[0] if duration_parts else "0"
+        # Duration: regex ile yakala (örn: 201 dk)
+        duration = secici.regex_first(r"(\d+)\s*(?:dk|dakika)", html_text)
 
         return MovieInfo(
             url         = url,

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/JetFilmizle.py

@@ -113,6 +113,10 @@ class JetFilmizle(PluginBase):
         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)
 
         return MovieInfo(
             url         = url,
@@ -122,7 +126,8 @@ class JetFilmizle(PluginBase):
             tags        = tags,
             rating      = rating,
             year        = year,
-            actors      = actors
+            actors      = actors,
+            duration    = int(duration) if duration else None
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/KultFilmler.py

@@ -91,7 +91,8 @@ class KultFilmler(PluginBase):
         time_text = secici.select_text("li.time span")
         duration = secici.regex_first(r"(\d+)", time_text) if time_text else None
 
-        rating    = secici.select_text("div.imdb-count")
+        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)]
 

{kekikstream-2.3.7 → kekikstream-2.3.8}/KekikStream/Plugins/RecTV.py

@@ -96,27 +96,49 @@ class RecTV(PluginBase):
 
                         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      = veri.get("imdb") or veri.get("rating"),
-                    year        = veri.get("year"),
+                    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      = veri.get("imdb") or veri.get("rating"),
-                    year        = veri.get("year"),
-                    actors      = []
+                    rating      = str(veri.get("imdb") or veri.get("rating") or ""),
+                    year        = str(veri.get("year") or ""),
+                    actors      = [],
+                    duration    = duration
                 )
 
     async def load_links(self, url: str) -> list[ExtractResult]: