KekikStream 2.3.7__py3-none-any.whl → 2.3.8__py3-none-any.whl

KekikStream/Extractors/MolyStream.py

@@ -9,6 +9,7 @@ class MolyStream(ExtractorBase):
 
     # Birden fazla domain destekle
     supported_domains = [
+        "dbx.molystream.org",
         "ydx.molystream.org",
         "yd.sheila.stream",
         "ydf.popcornvakti.net",
@@ -18,13 +19,54 @@ class MolyStream(ExtractorBase):
         return any(domain in url for domain in self.supported_domains)
 
     async def extract(self, url, referer=None) -> ExtractResult:
-        if "doctype html" in url:
-            secici   = HTMLHelper(url)
-            video    = secici.select_attr("video#sheplayer source", "src")
+        if "doctype html" in url.lower():
+            text = url
         else:
-            video = url
+            # Sheila-style referer fix
+            if "/embed/sheila/" in url:
+                referer = url.replace("/embed/sheila/", "/embed/")
 
-        resp_sec = HTMLHelper(url)
+            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 = [
@@ -34,8 +76,8 @@ class MolyStream(ExtractorBase):
 
         return ExtractResult(
             name       = self.name,
-            url        = video,
-            referer    = video.replace("/sheila", "") if video else None,
-            user_agent = "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0",
+            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/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/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/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/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/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/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/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/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/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/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/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/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]:

KekikStream/Plugins/RoketDizi.py

@@ -84,89 +84,87 @@ class RoketDizi(PluginBase):
         except Exception:
             return []
 
-    async def load_item(self, url: str) -> SeriesInfo:
-        # Note: Handling both Movie and Series logic in one, returning SeriesInfo generally or MovieInfo
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         resp = await self.httpx.get(url)
         sel  = HTMLHelper(resp.text)
-        html_text = resp.text
-
-        title    = sel.select_text("h1.text-white")
-
-        poster    = sel.select_attr("div.w-full.page-top img", "src")
-
-        description = sel.select_text("div.mt-2.text-sm")
-
-        # Tags - genre bilgileri (Detaylar bölümünde)
-        tags = []
-        genre_text = sel.select_text("h3.text-white.opacity-90")
-        if genre_text:
-            tags = [t.strip() for t in genre_text.split(",")]
-
-        # Rating
-        rating    = sel.select_text("span.text-white.text-sm.font-bold")
-
-        # Year ve Actors - Detaylar (Details) bölümünden
-        year = None
-        actors = []
+        
+        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")
 
-        # Detaylar bölümündeki tüm flex-col div'leri al
-        detail_items = sel.select("div.flex.flex-col")
-        for item in detail_items:
-            label = sel.select_text("span.text-base", item)
-            value = sel.select_text("span.text-sm.opacity-90", item)
+        try:
+            next_data = json.loads(next_data_text)
+            secure_data_raw = next_data["props"]["pageProps"]["secureData"]
+            secure_data = json.loads(base64.b64decode(secure_data_raw).decode('utf-8'))
             
-            label = label if label else None
-            value = value if value else None
+            content_item = secure_data.get("contentItem", {})
+            content      = secure_data.get("content", {}).get("result", {})
             
-            if label and value:
-                # Yayın tarihi (yıl)
-                if label == "Yayın tarihi":
-                    # "16 Ekim 2018" formatından yılı çıkar
-                    year = HTMLHelper(value).regex_first(r'\d{4}')
-                # Yaratıcılar veya Oyuncular
-                elif label in ["Yaratıcılar", "Oyuncular"]:
-                    if value:
-                        actors.append(value)
-
-        # Check urls for episodes
-        all_urls = HTMLHelper(html_text).regex_all(r'"url":"([^"]*)"')
-        is_series = any("bolum-" in u for u in all_urls)
-
-        episodes = []
-        if is_series:
-            # Dict kullanarak duplicate'leri önle ama sıralı tut
-            episodes_dict = {}
-            for u in all_urls:
-                if "bolum" in u and u not in episodes_dict:
-                    season = HTMLHelper(u).regex_first(r'/sezon-(\d+)')
-                    ep_num = HTMLHelper(u).regex_first(r'/bolum-(\d+)')
-
-                    season = int(season) if season else 1
-                    episode_num = int(ep_num) if ep_num else 1
-
-                    # Key olarak (season, episode) tuple kullan
-                    key = (season, episode_num)
-                    episodes_dict[key] = Episode(
-                        season  = season,
-                        episode = episode_num,
-                        title   = f"{season}. Sezon {episode_num}. Bölüm",
-                        url     = self.fix_url(u)
-                    )
-
-            # Sıralı liste oluştur
-            episodes = [episodes_dict[key] for key in sorted(episodes_dict.keys())]
-
-        return SeriesInfo(
-            title       = title,
-            url         = url,
-            poster      = self.fix_url(poster) if poster else None,
-            description = description,
-            tags        = tags,
-            rating      = rating,
-            actors      = actors,
-            episodes    = episodes,
-            year        = year
-        )
+            title       = content_item.get("original_title") or content_item.get("culture_title")
+            poster      = content_item.get("poster_url") or content_item.get("face_url")
+            description = content_item.get("description")
+            rating      = str(content_item.get("imdb_point") or "")
+            year        = str(content_item.get("release_year") or "")
+            tags        = content_item.get("categories", "").split(",")
+            
+            # Actors extraction from getSerieCastsById or getMovieCastsById
+            actors = []
+            casts_data = content.get("getSerieCastsById") or content.get("getMovieCastsById")
+            if casts_data and casts_data.get("result"):
+                actors = [cast.get("name") for cast in casts_data["result"] if cast.get("name")]
+
+            # Episodes extraction
+            episodes = []
+            if "Series" in str(content.get("FindedType")):
+                # Check for episodes in SecureData -> RelatedResults -> getEpisodeSources (this might be for the current episode)
+                # Usually full episode list isn't in secureData, but we can get it from HTML or another API
+                # However, many times Next.js pages have them in props
+                # Let's fallback to the previous regex method for episodes if not in JSON
+                all_urls = HTMLHelper(resp.text).regex_all(r'"url":"([^"]*)"')
+                episodes_dict = {}
+                for u in all_urls:
+                    if "bolum" in u and u not in episodes_dict:
+                        s_match = HTMLHelper(u).regex_first(r'/sezon-(\d+)')
+                        e_match = HTMLHelper(u).regex_first(r'/bolum-(\d+)')
+                        s_val = int(s_match) if s_match else 1
+                        e_val = int(e_match) if e_match else 1
+                        episodes_dict[(s_val, e_val)] = Episode(
+                            season  = s_val,
+                            episode = e_val,
+                            title   = f"{s_val}. Sezon {e_val}. Bölüm",
+                            url     = self.fix_url(u)
+                        )
+                episodes = [episodes_dict[key] for key in sorted(episodes_dict.keys())]
+
+                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
+                )
+
+        except Exception:
+            # Fallback to simple extraction if JSON parsing fails
+            return SeriesInfo(
+                url   = url,
+                title = self.clean_title(sel.select_text("h1")) or "Bilinmeyen"
+            )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         resp = await self.httpx.get(url)

KekikStream/Plugins/SelcukFlix.py

@@ -184,76 +184,99 @@ class SelcukFlix(PluginBase):
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         resp = await self.httpx.get(url)
         sel  = HTMLHelper(resp.text)
+        
+        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")
 
-        next_data = sel.select_text("script#__NEXT_DATA__")
-        if not next_data:
-             return None
-
-        data         = json.loads(next_data)
-        secure_data  = data["props"]["pageProps"]["secureData"]
-        raw_data     = base64.b64decode(secure_data.replace('"', ''))
         try:
-            decoded_str = raw_data.decode('utf-8')
-        except UnicodeDecodeError:
-            decoded_str = raw_data.decode('iso-8859-1')
-
-        content_details = json.loads(decoded_str)
-        item            = content_details.get("contentItem", {})
-
-        title           = item.get("original_title") or item.get("originalTitle") or ""
-        poster          = self.clean_image_url(item.get("poster_url") or item.get("posterUrl"))
-        description     = item.get("description") or item.get("used_description")
-        rating          = str(item.get("imdb_point") or item.get("imdbPoint", ""))
-        year            = item.get("release_year") or item.get("releaseYear")
-        duration        = item.get("total_minutes") or item.get("totalMinutes")
-
-        series_data     = content_details.get("relatedData", {}).get("seriesData")
-        if not series_data and "RelatedResults" in content_details:
-             series_data = content_details["RelatedResults"].get("getSerieSeasonAndEpisodes", {}).get("result")
-             if series_data and isinstance(series_data, list):
-                  pass
-
-        # Dizi mi film mi kontrol et (Kotlin referansı)
-        if series_data:
-            episodes = []
-            seasons_list = []
-            if isinstance(series_data, dict):
-                seasons_list = series_data.get("seasons", [])
-            elif isinstance(series_data, list):
-                seasons_list = series_data
-
-            for season in seasons_list:
-                if not isinstance(season, dict): continue
-                s_no = season.get("season_no") or season.get("seasonNo")
-                ep_list = season.get("episodes", [])
-                for ep in ep_list:
-                    episodes.append(Episode(
-                        season  = s_no,
-                        episode = ep.get("episode_no") or ep.get("episodeNo"),
-                        title   = ep.get("ep_text") or ep.get("epText"),
-                        url     = self.fix_url(ep.get("used_slug") or ep.get("usedSlug"))
-                    ))
+            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(
-                title       = title,
-                url         = url,
-                poster      = poster,
-                description = description,
-                rating      = rating,
-                year        = year,
-                episodes    = episodes
-            )
-        else:
-            # Film ise MovieInfo döndür
-            return MovieInfo(
-                title       = title,
-                url         = url,
-                poster      = poster,
-                description = description,
-                rating      = rating,
-                year        = year,
-                duration    = duration
-            )
+            # 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)
+
+            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")
+
+            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(",")]
+            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")]
+
+            series_data = related_results.get("getSerieSeasonAndEpisodes")
+            if series_data and isinstance(series_data, dict) and series_data.get("result"):
+                episodes = []
+                for season in series_data["result"]:
+                    s_no = season.get("season_no") or season.get("seasonNo") or 1
+                    for ep in season.get("episodes", []):
+                        ep_slug = ep.get("used_slug") or ep.get("usedSlug")
+                        if ep_slug:
+                            episodes.append(Episode(
+                                season  = s_no,
+                                episode = ep.get("episode_no") or ep.get("episodeNo") or 1,
+                                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
+                )
+
+        except Exception:
+            return SeriesInfo(url=url, title=self.clean_title(sel.select_text("h1")) or "Bilinmeyen")
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         resp = await self.httpx.get(url)

KekikStream/Plugins/SetFilmIzle.py

@@ -33,8 +33,8 @@ class SetFilmIzle(PluginBase):
         f"{main_url}/tur/western/"     : "Western"
     }
 
-    def _get_nonce(self, nonce_type: str = "video_nonce", referer: str = None) -> str:
-        """Site cache'lenmiş nonce'ları expire olabiliyor, fresh nonce al"""
+    def _get_nonce(self, nonce_type: str = "video", referer: str = None) -> str:
+        """Site cache'lenmiş nonce'ları expire olabiliyor, fresh nonce al veya sayfadan çek"""
         try:
             resp = self.cloudscraper.post(
                 f"{self.main_url}/wp-admin/admin-ajax.php",
@@ -45,8 +45,19 @@ class SetFilmIzle(PluginBase):
                 },
                 data = "action=st_cache_refresh_nonces"
             )
-            nonces = resp.json().get("data", {}).get("nonces", {})
-            return nonces.get(nonce_type, "")
+            data = resp.json()
+            if data and data.get("success"):
+                nonces = data.get("data", {}).get("nonces", {})
+                return nonces.get(nonce_type if nonce_type != "search" else "dt_ajax_search", "")
+        except:
+            pass
+
+        # AJAX başarısızsa sayfadan çekmeyi dene
+        try:
+            main_resp = self.cloudscraper.get(referer or self.main_url)
+            # STMOVIE_AJAX = { ... nonces: { search: "...", ... } }
+            nonce = HTMLHelper(main_resp.text).regex_first(rf'"{nonce_type}":\s*"([^"]+)"')
+            return nonce or ""
         except:
             return ""
 
@@ -112,7 +123,7 @@ class SetFilmIzle(PluginBase):
         return results
 
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
-        istek  = await self.httpx.get(url)
+        istek  = self.cloudscraper.get(url)
         secici = HTMLHelper(istek.text)
         html_text = istek.text
 
@@ -123,15 +134,21 @@ class SetFilmIzle(PluginBase):
 
         description = secici.select_text("div.wp-content p")
 
-        year_text = secici.select_text("div.extra span.C a")
-        year = secici.regex_first(r"\d{4}", year_text) if year_text else None
+        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 = [span.text(strip=True) for span in secici.select("span.valor a > span") if span.text(strip=True)]
+        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):
@@ -179,6 +196,7 @@ class SetFilmIzle(PluginBase):
                 title       = title,
                 description = description,
                 tags        = tags,
+                rating      = rating,
                 year        = year,
                 duration    = duration,
                 actors      = actors,
@@ -191,6 +209,7 @@ class SetFilmIzle(PluginBase):
             title       = title,
             description = description,
             tags        = tags,
+            rating      = rating,
             year        = year,
             duration    = duration,
             actors      = actors

KekikStream/Plugins/YabanciDizi.py

@@ -90,14 +90,17 @@ class YabanciDizi(PluginBase):
         poster   = sel.select_attr("meta[property='og:image']", "content")
         description = sel.select_text("p#tv-series-desc")
         
-        year = sel.select_text("td div.truncate")
-        if year:
-            year = year.strip()
+        # Try to extract year from table first
+        year_cell = sel.select_text("td div.truncate")
+        year = None
+        if year_cell:
+            year_match = sel.regex_first(r"(\d{4})", year_cell)
+            if year_match:
+                year = year_match
             
         tags = []
         rating = None
         duration = None
-        year = None
         actors = []
         for item in sel.select("div.item"):
             text = item.text(strip=True)
@@ -174,13 +177,14 @@ class YabanciDizi(PluginBase):
             )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
-        resp = await self.httpx.get(url, headers={"Referer": f"{self.main_url}/"})
+        # Use cloudscraper to bypass Cloudflare
+        resp = self.cloudscraper.get(url, headers={"Referer": f"{self.main_url}/"})
         sel  = HTMLHelper(resp.text)
         
         results = []
         
-        # Method 1: alternatives-for-this
-        for alt in sel.select("div.alternatives-for-this div.item:not(.active)"):
+        # Method 1: alternatives-for-this (include active too)
+        for alt in sel.select("div.alternatives-for-this div.item"):
             data_hash = alt.attrs.get("data-hash")
             data_link = alt.attrs.get("data-link")
             q_type    = alt.attrs.get("data-querytype")
@@ -188,7 +192,7 @@ class YabanciDizi(PluginBase):
             if not data_hash or not data_link: continue
             
             try:
-                post_resp = await self.httpx.post(
+                post_resp = self.cloudscraper.post(
                     f"{self.main_url}/ajax/service",
                     data = {
                         "link"      : data_link,
@@ -219,7 +223,7 @@ class YabanciDizi(PluginBase):
             data_eid = id_el.attrs.get("data-eid")
             
             try:
-                post_resp = await self.httpx.post(
+                post_resp = self.cloudscraper.post(
                     f"{self.main_url}/ajax/service",
                     data = {
                         "e_id"   : data_eid,
@@ -244,9 +248,10 @@ class YabanciDizi(PluginBase):
 
         return results
 
-    async def _fetch_and_extract(self, iframe_url, prefix=""):
+    def _fetch_and_extract_sync(self, iframe_url, prefix=""):
+        """Synchronous helper for _fetch_and_extract using cloudscraper."""
         # Initial fetch
-        resp = await self.httpx.get(
+        resp = self.cloudscraper.get(
             iframe_url,
             headers = {"Referer": f"{self.main_url}/"},
             cookies = {"udys": "1760709729873", "level": "1"}
@@ -254,11 +259,12 @@ class YabanciDizi(PluginBase):
         
         # Handle "Lütfen bekleyiniz" check from Kotlin
         if "Lütfen bekleyiniz" in resp.text:
-            await asyncio.sleep(1)
-            timestamp = int(time.time())
+            import time as time_module
+            time_module.sleep(1)
+            timestamp = int(time_module.time())
             # Retry with t=timestamp as in Kotlin
             sep = "&" if "?" in iframe_url else "?"
-            resp = await self.httpx.get(
+            resp = self.cloudscraper.get(
                 f"{iframe_url}{sep}t={timestamp}",
                 headers = {"Referer": f"{self.main_url}/"},
                 cookies = resp.cookies # Use cookies from first response
@@ -267,6 +273,11 @@ class YabanciDizi(PluginBase):
         sel = HTMLHelper(resp.text)
         final_iframe = sel.select_attr("iframe", "src")
         
+        return final_iframe
+
+    async def _fetch_and_extract(self, iframe_url, prefix=""):
+        final_iframe = self._fetch_and_extract_sync(iframe_url, prefix)
+        
         if final_iframe:
             final_url = self.fix_url(final_iframe)
             return await self.extract(final_url, referer=f"{self.main_url}/", prefix=prefix)

{kekikstream-2.3.7.dist-info → kekikstream-2.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KekikStream
-Version: 2.3.7
+Version: 2.3.8
 Summary: terminal üzerinden medya içeriği aramanızı ve VLC/MPV gibi popüler medya oynatıcılar aracılığıyla doğrudan izlemenizi sağlayan modüler ve genişletilebilir bir bıdı bıdı
 Home-page: https://github.com/keyiflerolsun/KekikStream
 Author: keyiflerolsun

{kekikstream-2.3.7.dist-info → kekikstream-2.3.8.dist-info}/RECORD

@@ -29,7 +29,7 @@ KekikStream/Extractors/JetTv.py,sha256=2X1vYDQ0hxBTcpnE_XTcbw9tMS1aXFURcobnPdN8Z
 KekikStream/Extractors/MailRu.py,sha256=xQVCWwYqNoG5T43VAW1_m0v4e80FbO-1pNPKkwhTccU,1218
 KekikStream/Extractors/MixPlayHD.py,sha256=u5fUePHfjOI3n7KlNsWhXIv7HA_NMj5bPw1ug-eiXLU,1557
 KekikStream/Extractors/MixTiger.py,sha256=4VbOYgE4s5H-BGVvJI0AI57M-WBWqnek_LGfCFHAucw,2116
-KekikStream/Extractors/MolyStream.py,sha256=SGKr4HdfxDmRk6nPgQUjSbdqFCKWzl7xWxRJtjjFMng,1420
+KekikStream/Extractors/MolyStream.py,sha256=sEyJE8L_49GOVOhkA_FvZjwXhzLhyue0gw3gQT-dW8A,3125
 KekikStream/Extractors/Odnoklassniki.py,sha256=hajKPhWKiIuu_i441TXrWVORpLo2CdTcoJiyU3WQAuI,4038
 KekikStream/Extractors/PeaceMakerst.py,sha256=BJ5Cv5X2GEaMTwn_XFpAVVmts1h5xGno3l5rL7Ugob4,2335
 KekikStream/Extractors/PixelDrain.py,sha256=xPud8W_hqLUXJSU5O-MiCOblcmzrlDJpnEtuxr4ZdI4,1011
@@ -45,30 +45,30 @@ KekikStream/Extractors/TurboImgz.py,sha256=zLGMUwoThZ_LoW0bThyV8TSCcIYHsUme1RTqq
 KekikStream/Extractors/TurkeyPlayer.py,sha256=zdX0IOO3M-kgAYWex2WwJJu9aGf8WhOY-ZIrRmZRiC0,1246
 KekikStream/Extractors/VCTPlay.py,sha256=1BCl2_vVIrwvG56LCzl2KE5g2CUaMAhzImOZMdZpZCQ,1377
 KekikStream/Extractors/VidHide.py,sha256=38ly2Gi44rxIyjeM-6H_HjmwXbKEpSqK4ba16ToQUYs,2707
-KekikStream/Extractors/VidMoly.py,sha256=XYgqlyCUdDNN7Naxa_rjX0WoB5zt17Dda_TdNEDpKOE,4974
+KekikStream/Extractors/VidMoly.py,sha256=4k5z68MrUASUuDMEWZ_Ynvp1Z7njjRcXPBZAnpbtGB4,5500
 KekikStream/Extractors/VidMoxy.py,sha256=dM7yBfrXSESvYyqc2uP_gLSgV61gpIAY940NAQ58Mts,1843
 KekikStream/Extractors/VidPapi.py,sha256=9y8TN-o4C3JvRyr2V8Ox908tFE1I2BItQLHZlqs8AuI,3175
 KekikStream/Extractors/VideoSeyred.py,sha256=KJxbJkuupmn4wWBj_ejnoDvmjUXwEXkzStYha3EsSpA,1995
 KekikStream/Extractors/YTDLP.py,sha256=Hy8loCSFSquu2zaL3INord-Jm6T8CM6K2-VcDA2K79g,7390
 KekikStream/Extractors/YildizKisaFilm.py,sha256=R_JlrOVeMiDlXYcuTdItnKvidyx8_u3B14fSrxew2aE,1316
 KekikStream/Plugins/BelgeselX.py,sha256=smoLjEJTdptjb7h4m6LhG7ZUmJQtIhYyi0CUFBsk970,8696
-KekikStream/Plugins/DiziBox.py,sha256=KZGWhs6p2-hUTsd-fjz2fsmGEkanL4At2PI8qHAoDm4,10541
-KekikStream/Plugins/DiziPal.py,sha256=CTCGlknBUQIzubhvjexQoqiT3sHni34lpxiTLTemCGo,10299
-KekikStream/Plugins/DiziWatch.py,sha256=Y5-tBK316WdJhc-OZsYiwjSdfjcdz-A78o_bDP4qu08,8847
-KekikStream/Plugins/DiziYou.py,sha256=ZV80_XHv1nN0wRGgJEtnoJcgFX7S_iVSKFGiFlAqcGQ,11277
-KekikStream/Plugins/Dizilla.py,sha256=apDLGe3Fd-13nNyhcV_TFQxqX4bOZZZxEEGLonKQzS4,13803
-KekikStream/Plugins/FilmBip.py,sha256=pzvleSRZCDHh2tx8Q0JwTFiH9TexNCRnFpr3MCiMb0E,6087
-KekikStream/Plugins/FilmMakinesi.py,sha256=WaCQD7tsZdPbeU35SEnBVRZt2SzUiAQOBRBZR6drvQ4,7797
+KekikStream/Plugins/DiziBox.py,sha256=CKfbMAtyE6J7QgD19iryzhD5VJlc0Tz2s4nSYW7XSrg,11354
+KekikStream/Plugins/DiziPal.py,sha256=tHUqAN8UvvzBAkJaGS4hFvdLo-eRO4EdQ_C9HYkj_0U,10576
+KekikStream/Plugins/DiziWatch.py,sha256=NK9xccX4-HwWq67FFVfqDDzKwCDc_HvDJDW2QIvqjig,8900
+KekikStream/Plugins/DiziYou.py,sha256=4KOvxHg-84mUHuHWsXoYlIG2SX4DCV2dm6GblHQ5wGo,11162
+KekikStream/Plugins/Dizilla.py,sha256=PLN0pOkWB4IaGC7Toe-8f5rksmaNm_WfdSFMTAtt--0,13624
+KekikStream/Plugins/FilmBip.py,sha256=40eSECwMHSKTWoUmF90UXxTJkbx6f71J_98Ht4Hnoj8,6352
+KekikStream/Plugins/FilmMakinesi.py,sha256=0bVN28aCEfrxrvXrGyL6XtgipzUKUD9vN2QkHie2gY0,7859
 KekikStream/Plugins/FilmModu.py,sha256=ou1BrFNR4RQaJdxVqPB5FI8vnQ0UmD-siVdwLnpp7x0,7147
 KekikStream/Plugins/FullHDFilm.py,sha256=08NF5qEydmxT0rGYDWpTOSIYSad8Uv1H1V8yCKG_568,10525
-KekikStream/Plugins/FullHDFilmizlesene.py,sha256=QD1mQwwPFkNoWgBdLaSPFq22S1N1RSKspyyTqz-1Wjk,7145
+KekikStream/Plugins/FullHDFilmizlesene.py,sha256=OpdndVQ7LjZ-sJdILGEqhYX-0D18yRqTS7Kpu-HrXmY,6870
 KekikStream/Plugins/HDFilmCehennemi.py,sha256=jntMKgE81k_jl3pFzJI3akqvi3g8U961dVx7bj5Pf2w,13140
-KekikStream/Plugins/JetFilmizle.py,sha256=I76CCdH8AJAfjPr5jejtndidcGTBMrVfTFNjnZwp9yo,7801
-KekikStream/Plugins/KultFilmler.py,sha256=e5kXjGJYiI15PQhSADIGznqX7MlA0lK5HYnfFwx_cpM,9383
-KekikStream/Plugins/RecTV.py,sha256=E5ZyWU_lqibwcRm9amb_fqdXpc8qdMkekbHVxY3UmuU,7268
-KekikStream/Plugins/RoketDizi.py,sha256=92c3_UFIhM1SkB0Ybnp53A06VtGw2GmXtr-xmiKeJi0,8444
-KekikStream/Plugins/SelcukFlix.py,sha256=iHLO52_726gzmKAsqgW5ki2_V16fdGAZVjvaqqnQozY,13601
-KekikStream/Plugins/SetFilmIzle.py,sha256=pM4DgR2La9jUacQPRr4dilbfnljcC9l_o1OUipJh3Eg,10418
+KekikStream/Plugins/JetFilmizle.py,sha256=9sH9Z3y4SP8vta9v-gJOQOxFWAQnbZomFea1_G5EbmM,8100
+KekikStream/Plugins/KultFilmler.py,sha256=rvIkd2OXRxuAXHMjiHCRmKrS5m09gy2JoMBgJh7ZIOk,9478
+KekikStream/Plugins/RecTV.py,sha256=p-RELvvD1-gyUgitwosYryH9gRWQTjmn1O9tw-0YInk,8295
+KekikStream/Plugins/RoketDizi.py,sha256=KiX7Xf5IyPPJ-CVcJLM9qc0M6Fi2dhg7zU3EgWkICXA,9318
+KekikStream/Plugins/SelcukFlix.py,sha256=nJ7I5e5vBkn9AbLC_2bSu9bSSgMQeDhCQZBZovK00bc,15299
+KekikStream/Plugins/SetFilmIzle.py,sha256=Z8A_Ivbe65i13RocGZXwmpwrVxNOwdj7Gh3CS2-Fslg,11437
 KekikStream/Plugins/SezonlukDizi.py,sha256=h8mIglL2ORUklnAvEwH_5z6tT3WYxiNnbkeIvxtGUTE,9751
 KekikStream/Plugins/SineWix.py,sha256=z0r90lggAugEWE1g9vg8gZsInBObUZPnVFQwq7GYmJs,7052
 KekikStream/Plugins/Sinefy.py,sha256=ShX13Q-_5KFBobxZufI5V_4zwWvEWfNYuP-g5CkBuww,11099
@@ -76,10 +76,10 @@ KekikStream/Plugins/SinemaCX.py,sha256=11kzAZWgjkitIonDHHiFHMgnViBj-GjyvTXg7k28M
 KekikStream/Plugins/Sinezy.py,sha256=fUj-3WaJMEsKZRnDpHFPxl5Eq2RPLroY80DcftLqvjM,5743
 KekikStream/Plugins/SuperFilmGeldi.py,sha256=StW0ue4qDj8p7CiWy19Lfr2aWtfYvslPExZJuR-3xiY,6348
 KekikStream/Plugins/UgurFilm.py,sha256=H6AA2iTaM0fn6uN8_Dfvr-OqUtM9gDdkg0BKIcZEj7U,4930
-KekikStream/Plugins/YabanciDizi.py,sha256=r3jusGf1Ufr0O1O04qQLxcxk3raCI3EFs4Z2Jwva2-s,11444
-kekikstream-2.3.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-kekikstream-2.3.7.dist-info/METADATA,sha256=725PgUwp-rl5ONFCRfex-qsmSzYu85DOFTqCvvzkz5U,10761
-kekikstream-2.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kekikstream-2.3.7.dist-info/entry_points.txt,sha256=dFwdiTx8djyehI0Gsz-rZwjAfZzUzoBSrmzRu9ubjJc,50
-kekikstream-2.3.7.dist-info/top_level.txt,sha256=DNmGJDXl27Drdfobrak8KYLmocW_uznVYFJOzcjUgmY,12
-kekikstream-2.3.7.dist-info/RECORD,,
+KekikStream/Plugins/YabanciDizi.py,sha256=QXzifSl2JMcVOwkwn2vafYIw1jqB5vBTrf-usvsyMBc,11947
+kekikstream-2.3.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+kekikstream-2.3.8.dist-info/METADATA,sha256=9xG4vCFR9UYkg6ZuhfdW9WEIMlLDVVYZoRp5mJqdqSs,10761
+kekikstream-2.3.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kekikstream-2.3.8.dist-info/entry_points.txt,sha256=dFwdiTx8djyehI0Gsz-rZwjAfZzUzoBSrmzRu9ubjJc,50
+kekikstream-2.3.8.dist-info/top_level.txt,sha256=DNmGJDXl27Drdfobrak8KYLmocW_uznVYFJOzcjUgmY,12
+kekikstream-2.3.8.dist-info/RECORD,,