KekikStream 2.0.3__py3-none-any.whl → 2.0.9__py3-none-any.whl

KekikStream/Plugins/BelgeselX.py

@@ -0,0 +1,204 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
+from parsel           import Selector
+import re
+
+class BelgeselX(PluginBase):
+    name        = "BelgeselX"
+    language    = "tr"
+    main_url    = "https://belgeselx.com"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "2022 yılında son çıkan belgeselleri belgeselx.com'da izle. En yeni belgeseller, türkçe altyazılı yada dublaj olarak 1080p kalitesinde hd belgesel izle."
+
+    main_page   = {
+        f"{main_url}/konu/turk-tarihi-belgeselleri&page=" : "Türk Tarihi",
+        f"{main_url}/konu/tarih-belgeselleri&page="       : "Tarih",
+        f"{main_url}/konu/seyehat-belgeselleri&page="     : "Seyahat",
+        f"{main_url}/konu/seri-belgeseller&page="         : "Seri",
+        f"{main_url}/konu/savas-belgeselleri&page="       : "Savaş",
+        f"{main_url}/konu/sanat-belgeselleri&page="       : "Sanat",
+        f"{main_url}/konu/psikoloji-belgeselleri&page="   : "Psikoloji",
+        f"{main_url}/konu/polisiye-belgeselleri&page="    : "Polisiye",
+        f"{main_url}/konu/otomobil-belgeselleri&page="    : "Otomobil",
+        f"{main_url}/konu/nazi-belgeselleri&page="        : "Nazi",
+        f"{main_url}/konu/muhendislik-belgeselleri&page=" : "Mühendislik",
+        f"{main_url}/konu/kultur-din-belgeselleri&page="  : "Kültür Din",
+        f"{main_url}/konu/kozmik-belgeseller&page="       : "Kozmik",
+        f"{main_url}/konu/hayvan-belgeselleri&page="      : "Hayvan",
+        f"{main_url}/konu/eski-tarih-belgeselleri&page="  : "Eski Tarih",
+        f"{main_url}/konu/egitim-belgeselleri&page="      : "Eğitim",
+        f"{main_url}/konu/dunya-belgeselleri&page="       : "Dünya",
+        f"{main_url}/konu/doga-belgeselleri&page="        : "Doğa",
+        f"{main_url}/konu/bilim-belgeselleri&page="       : "Bilim"
+    }
+
+    @staticmethod
+    def _to_title_case(text: str) -> str:
+        """Türkçe için title case dönüşümü."""
+        return " ".join(
+            word.lower().replace("i", "İ").capitalize() if word.lower().startswith("i") else word.capitalize()
+            for word in text.split()
+        )
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = self.cloudscraper.get(f"{url}{page}")
+        secici = Selector(istek.text)
+
+        results = []
+        for item in secici.css("div.gen-movie-contain > div.gen-info-contain > div.gen-movie-info"):
+            title  = item.css("div.gen-movie-info > h3 a::text").get()
+            href   = item.css("div.gen-movie-info > h3 a::attr(href)").get()
+            parent = item.xpath("../../..")
+            poster = parent.css("div.gen-movie-img > img::attr(src)").get()
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = self._to_title_case(title.strip()),
+                    url      = self.fix_url(href),
+                    poster   = self.fix_url(poster) if poster else None
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        # Google Custom Search API kullanıyor
+        cx = "016376594590146270301:iwmy65ijgrm"
+
+        token_resp = self.cloudscraper.get(f"https://cse.google.com/cse.js?cx={cx}")
+        token_text = token_resp.text
+
+        cse_lib_match = re.search(r'cselibVersion": "(.*)"', token_text)
+        cse_tok_match = re.search(r'cse_token": "(.*)"', token_text)
+
+        if not cse_lib_match or not cse_tok_match:
+            return []
+
+        cse_lib = cse_lib_match.group(1)
+        cse_tok = cse_tok_match.group(1)
+
+        search_url = (
+            f"https://cse.google.com/cse/element/v1?"
+            f"rsz=filtered_cse&num=100&hl=tr&source=gcsc&cselibv={cse_lib}&cx={cx}"
+            f"&q={query}&safe=off&cse_tok={cse_tok}&sort=&exp=cc%2Capo&oq={query}"
+            f"&callback=google.search.cse.api9969&rurl=https%3A%2F%2Fbelgeselx.com%2F"
+        )
+
+        resp = self.cloudscraper.get(search_url)
+        resp_text = resp.text
+
+        titles = re.findall(r'"titleNoFormatting": "(.*?)"', resp_text)
+        urls   = re.findall(r'"url": "(.*?)"', resp_text)
+        images = re.findall(r'"ogImage": "(.*?)"', resp_text)
+
+        results = []
+        for i, title in enumerate(titles):
+            url_val = urls[i] if i < len(urls) else None
+            poster  = images[i] if i < len(images) else None
+
+            if not url_val or "diziresimleri" not in url_val:
+                # URL'den belgesel linkini oluştur
+                if poster and "diziresimleri" in poster:
+                    file_name = poster.rsplit("/", 1)[-1]
+                    file_name = re.sub(r"\.(jpe?g|png|webp)$", "", file_name)
+                    url_val = f"{self.main_url}/belgeseldizi/{file_name}"
+                else:
+                    continue
+
+            clean_title = title.split("İzle")[0].strip()
+            results.append(SearchResult(
+                title  = self._to_title_case(clean_title),
+                url    = url_val,
+                poster = poster
+            ))
+
+        return results
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("h2.gen-title::text").get()
+        poster      = secici.css("div.gen-tv-show-top img::attr(src)").get()
+        description = secici.css("div.gen-single-tv-show-info p::text").get()
+
+        tags = []
+        for tag_link in secici.css("div.gen-socail-share a[href*='belgeselkanali']"):
+            tag_href = tag_link.css("::attr(href)").get()
+            if tag_href:
+                tag_name = tag_href.rsplit("/", 1)[-1].replace("-", " ")
+                tags.append(self._to_title_case(tag_name))
+
+        episodes = []
+        counter  = 0
+        for ep_item in secici.css("div.gen-movie-contain"):
+            ep_name = ep_item.css("div.gen-movie-info h3 a::text").get()
+            ep_href = ep_item.css("div.gen-movie-info h3 a::attr(href)").get()
+
+            if not ep_name or not ep_href:
+                continue
+
+            season_text   = ep_item.css("div.gen-single-meta-holder ul li::text").get() or ""
+            episode_match = re.search(r"Bölüm (\d+)", season_text)
+            season_match  = re.search(r"Sezon (\d+)", season_text)
+
+            ep_episode = int(episode_match.group(1)) if episode_match else counter
+            ep_season  = int(season_match.group(1)) if season_match else 1
+
+            counter += 1
+
+            episodes.append(Episode(
+                season  = ep_season,
+                episode = ep_episode,
+                title   = ep_name.strip(),
+                url     = self.fix_url(ep_href)
+            ))
+
+        return SeriesInfo(
+            url         = url,
+            poster      = self.fix_url(poster) if poster else None,
+            title       = self._to_title_case(title.strip()) if title else None,
+            description = description.strip() if description else None,
+            tags        = tags,
+            episodes    = episodes
+        )
+
+    async def load_links(self, url: str) -> list[dict]:
+        istek = await self.httpx.get(url)
+        text  = istek.text
+
+        # fnc_addWatch div'inden data-episode ID'sini al
+        ep_match = re.search(r'<div[^>]*class=["\'][^"\']*fnc_addWatch[^"\']*["\'][^>]*data-episode=["\'](\d+)["\']', text)
+        if not ep_match:
+            return []
+
+        episode_id  = ep_match.group(1)
+        iframe_url  = f"{self.main_url}/video/data/new4.php?id={episode_id}"
+
+        iframe_resp = await self.httpx.get(iframe_url, headers={"Referer": url})
+        iframe_text = iframe_resp.text
+
+        links = []
+        for match in re.finditer(r'file:"([^"]+)", label: "([^"]+)"', iframe_text):
+            video_url = match.group(1)
+            quality   = match.group(2)
+
+            source_name = "Google" if quality == "FULL" else self.name
+            quality_str = "1080p" if quality == "FULL" else quality
+
+            links.append({
+                "url"     : video_url,
+                "name"    : f"{source_name} | {quality_str}",
+                "referer" : url
+            })
+
+        return links
+
+    async def play(self, **kwargs):
+        extract_result = ExtractResult(**kwargs)
+        self.media_handler.title = kwargs.get("name")
+        if self.name not in self.media_handler.title:
+            self.media_handler.title = f"{self.name} | {self.media_handler.title}"
+
+        self.media_handler.play_media(extract_result)

KekikStream/Plugins/Dizilla.py

@@ -179,17 +179,25 @@ class Dizilla(PluginBase):
         decrypted   = await self.decrypt_response(secure_data)
         results     = decrypted.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
 
-        links = []
-        for result in results:
-            iframe_src = Selector(result.get("source_content")).css("iframe::attr(src)").get()
-            iframe_url = self.fix_url(iframe_src)
-            if not iframe_url:
-                continue
-
-            extractor = self.ex_manager.find_extractor(iframe_url)
-            links.append({
-                "url"  : iframe_url,
-                "name" : f"{extractor.name if extractor else 'Main Player'} | {result.get('language_name')}",
-            })
-
-        return links
+        if not results:
+            return []
+
+        # Get first source (matching Kotlin)
+        first_result = results[0]
+        source_content = first_result.get("source_content", "")
+        
+        # Clean the source_content string (matching Kotlin: .replace("\"", "").replace("\\", ""))
+        cleaned_source = source_content.replace('"', '').replace('\\', '')
+        
+        # Parse cleaned HTML
+        iframe_src = Selector(cleaned_source).css("iframe::attr(src)").get()
+        iframe_url = self.fix_url(iframe_src)
+        
+        if not iframe_url:
+            return []
+
+        extractor = self.ex_manager.find_extractor(iframe_url)
+        return [{
+            "url"  : iframe_url,
+            "name" : f"{extractor.name if extractor else 'Main Player'} | {first_result.get('language_name', 'Unknown')}",
+        }]

KekikStream/Plugins/FilmMakinesi.py

@@ -8,7 +8,7 @@ class FilmMakinesi(PluginBase):
     language    = "tr"
     main_url    = "https://filmmakinesi.to"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Film Makinesi, en yeni ve en güncel filmleri sitemizde full HD kalite farkı ile izleyebilirsiniz. HD film izle denildiğinde akla gelen en kaliteli film izleme sitesi."
+    description = "Film Makinesi ile en yeni ve güncel filmleri Full HD kalite farkı ile izleyebilirsiniz. Film izle denildiğinde akla gelen en kaliteli film sitesi."
 
     main_page   = {
         f"{main_url}/filmler-1/"                : "Son Filmler",

KekikStream/Plugins/FilmModu.py

@@ -9,7 +9,7 @@ class FilmModu(PluginBase):
     language    = "tr"
     main_url    = "https://www.filmmodu.ws"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "HD Film izle, Türkçe Dublaj ve Altyazılı filmler."
+    description = "Film modun geldiyse yüksek kalitede yeni filmleri izle, 1080p izleyebileceğiniz reklamsız tek film sitesi."
 
     main_page   = {
         f"{main_url}/hd-film-kategori/4k-film-izle?page=SAYFA"          : "4K",
@@ -91,9 +91,13 @@ class FilmModu(PluginBase):
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
+        alternates = secici.css("div.alternates a")
+        if not alternates:
+            return []  # No alternates available
+
         results = []
 
-        for alternatif in secici.css("div.alternates a"):
+        for alternatif in alternates:
             alt_link = self.fix_url(alternatif.css("::attr(href)").get())
             alt_name = alternatif.css("::text").get()
 

KekikStream/Plugins/FullHDFilmizlesene.py

@@ -10,7 +10,7 @@ class FullHDFilmizlesene(PluginBase):
     language    = "tr"
     main_url    = "https://www.fullhdfilmizlesene.tv"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Sinema zevkini evinize kadar getirdik. Türkiye'nin lider Film sitesinde, en yeni filmleri Full HD izleyin."
+    description = "Türkiye'nin ilk ve lider HD film izleme platformu, kaliteli ve sorunsuz hizmetiyle sinema keyfini zirveye taşır."
 
     main_page   = {
         f"{main_url}/en-cok-izlenen-hd-filmler/"            : "En Çok izlenen Filmler",

KekikStream/Plugins/HDFilmCehennemi.py

@@ -3,14 +3,14 @@
 from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, Subtitle
 from parsel           import Selector
 from Kekik.Sifreleme  import Packer, StreamDecoder
-import random, string, re
+import random, string, re, base64
 
 class HDFilmCehennemi(PluginBase):
     name        = "HDFilmCehennemi"
     language    = "tr"
     main_url    = "https://www.hdfilmcehennemi.ws"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Türkiye'nin en hızlı hd film izleme sitesi"
+    description = "Türkiye'nin en hızlı hd film izleme sitesi. Tek ve gerçek hdfilmcehennemi sitesi."
     
 
 
@@ -146,17 +146,85 @@ class HDFilmCehennemi(PluginBase):
 
         return results
 
+    def hdch_decode(self, value_parts: list[str]) -> str:
+        """
+        HDFilmCehennemi için özel decoder.
+        JavaScript sırası: join -> reverse -> atob -> atob -> shift_back
+        """
+        try:
+            # 1. Parçaları birleştir
+            joined = ''.join(value_parts)
+            
+            # 2. Ters çevir (REV)
+            result = StreamDecoder._reverse(joined)
+            
+            # 3. İlk base64 decode (B64D)
+            result = StreamDecoder._base64_decode(result)
+            if result is None:
+                return ""
+            
+            # 4. İkinci base64 decode (B64D) - JavaScript'te iki kez atob yapılıyor!
+            result = StreamDecoder._base64_decode(result)
+            if result is None:
+                return ""
+            
+            # 5. Shift back (SHF)
+            result = StreamDecoder._shift_back(result)
+            
+            return result
+        except Exception:
+            return ""
+
+    def extract_hdch_url(self, unpacked: str) -> str:
+        """HDFilmCehennemi unpacked script'ten video URL'sini çıkar"""
+        # 1) Decode fonksiyonunun adını bul: function <NAME>(value_parts)
+        match_fn = re.search(r'function\s+(\w+)\s*\(\s*value_parts\s*\)', unpacked)
+        if not match_fn:
+            return ""
+        
+        fn_name = match_fn.group(1)
+        
+        # 2) Bu fonksiyonun array ile çağrıldığı yeri bul: <NAME>([ ... ])
+        array_call_regex = re.compile(rf'{re.escape(fn_name)}\(\s*\[(.*?)\]\s*\)', re.DOTALL)
+        match_call = array_call_regex.search(unpacked)
+        if not match_call:
+            return ""
+        
+        array_body = match_call.group(1)
+        
+        # 3) Array içindeki string parçalarını topla
+        parts = re.findall(r'["\']([^"\']+)["\']', array_body)
+        if not parts:
+            return ""
+        
+        # 4) Özel decoder ile çöz
+        return self.hdch_decode(parts)
+
     async def invoke_local_source(self, iframe: str, source: str, url: str):
-        self.httpx.headers.update({"Referer": f"{self.main_url}/"})
+        self.httpx.headers.update({
+            "Referer": f"{self.main_url}/",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0"
+        })
         istek = await self.httpx.get(iframe)
 
+        if not istek.text:
+            return await self.cehennempass(iframe.split("/")[-1])
+
+        # eval(function...) içeren packed script bul
+        eval_match = re.search(r'(eval\(function[\s\S]+)', istek.text)
+        if not eval_match:
+            return await self.cehennempass(iframe.split("/")[-1])
+
         try:
-            eval_func = re.compile(r'\s*(eval\(function[\s\S].*)\s*').findall(istek.text)[0]
+            unpacked = Packer.unpack(eval_match.group(1))
         except Exception:
             return await self.cehennempass(iframe.split("/")[-1])
 
-        unpacked  = Packer.unpack(eval_func)
-        video_url = StreamDecoder.extract_stream_url(unpacked)
+        # HDFilmCehennemi özel decoder ile video URL'sini çıkar
+        video_url = self.extract_hdch_url(unpacked)
+        
+        if not video_url:
+            return await self.cehennempass(iframe.split("/")[-1])
 
         subtitles = []
         try:
@@ -200,8 +268,15 @@ class HDFilmCehennemi(PluginBase):
                 match  = re.search(r'data-src=\\\"([^"]+)', api_get.text)
                 iframe = match[1].replace("\\", "") if match else None
 
-                if iframe and "?rapidrame_id=" in iframe:
-                    iframe = f"{self.main_url}/playerr/{iframe.split('?rapidrame_id=')[1]}"
+                if not iframe:
+                    continue
+
+                # mobi URL'si varsa direkt kullan (query string'i kaldır)
+                if "mobi" in iframe:
+                    iframe = iframe.split("?")[0]  # rapidrame_id query param'ı kaldır
+                # mobi değilse ve rapidrame varsa rplayer kullan
+                elif "rapidrame" in iframe and "?rapidrame_id=" in iframe:
+                    iframe = f"{self.main_url}/rplayer/{iframe.split('?rapidrame_id=')[1]}"
 
                 video_data_list = await self.invoke_local_source(iframe, source, url)
                 if not video_data_list:

KekikStream/Plugins/JetFilmizle.py

@@ -8,7 +8,7 @@ class JetFilmizle(PluginBase):
     language    = "tr"
     main_url    = "https://jetfilmizle.website"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Binlerce Film İzleme Seçeneğiyle En İyi Film İzleme Sitesi"
+    description = "Film izle, Yerli, Yabancı film izle, Türkçe dublaj, alt yazılı seçenekleriyle ödül almış filmleri Full HD kalitesiyle ve jetfilmizle hızıyla donmadan ücretsizce izleyebilirsiniz."
 
     main_page   = {
         f"{main_url}/page/"                                     : "Son Filmler",

KekikStream/Plugins/KultFilmler.py

@@ -9,7 +9,7 @@ class KultFilmler(PluginBase):
     language    = "tr"
     main_url    = "https://kultfilmler.net"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Kült film ve dizi izleme sitesi."
+    description = "Kült Filmler özenle en iyi filmleri derler ve iyi bir altyazılı film izleme deneyimi sunmayı amaçlar. Reklamsız 1080P Altyazılı Film izle..."
 
     main_page   = {
         f"{main_url}/category/aile-filmleri-izle"       : "Aile",

KekikStream/Plugins/RoketDizi.py

@@ -185,6 +185,7 @@ class RoketDizi(PluginBase):
             # secureData içindeki RelatedResults -> getEpisodeSources -> result dizisini al
             sources = decoded_json.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
 
+            seen_urls = set()
             results = []
             for source in sources:
                 source_content = source.get("source_content", "")
@@ -195,35 +196,27 @@ class RoketDizi(PluginBase):
                     continue
 
                 iframe_url = iframe_match.group(1)
-                if "http" not in iframe_url:
-                     if iframe_url.startswith("//"):
-                         iframe_url = "https:" + iframe_url
-                     else:
-                         iframe_url = "https://" + iframe_url
+                
+                # Fix URL protocol
+                if not iframe_url.startswith("http"):
+                    if iframe_url.startswith("//"):
+                        iframe_url = "https:" + iframe_url
+                    else:
+                        iframe_url = "https://" + iframe_url
+
+                iframe_url = self.fix_url(iframe_url)
+                
+                # Deduplicate  
+                if iframe_url in seen_urls:
+                    continue
+                seen_urls.add(iframe_url)
 
                 # Check extractor
                 extractor = self.ex_manager.find_extractor(iframe_url)
-                ext_name  = extractor.name if extractor else ""
-
-                # Metadata'dan bilgileri al
-                source_name   = source.get("source_name", "")
-                language_name = source.get("language_name", "")
-                quality_name  = source.get("quality_name", "")
-
-                # İsmi oluştur
-                name_parts = []
-                if source_name:
-                    name_parts.append(source_name)
-                if ext_name:
-                    name_parts.append(ext_name)
-                if language_name:
-                    name_parts.append(language_name)
-                if quality_name:
-                    name_parts.append(quality_name)
-
+                
                 results.append({
                     "url"  : iframe_url,
-                    "name" : " | ".join(name_parts)
+                    "name" : extractor.name if extractor else "Player"
                 })
 
             return results

KekikStream/Plugins/SelcukFlix.py

@@ -9,7 +9,7 @@ class SelcukFlix(PluginBase):
     lang        = "tr"
     main_url    = "https://selcukflix.net"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Selcukflix'te her türden en yeni ve en popüler dizi ve filmleri izlemenin keyfini çıkarın. Aksiyondan romantiğe, bilim kurgudan dramaya, geniş kütüphanemizde herkes için bir şey var."
+    description = "Selcukflix'te her türden en yeni ve en popüler dizi ve filmleri izlemenin keyfini çıkarın. Aksiyondan romantiğe, bilim kurgudan dramaya, geniş kütüphanemizde herkes için bir şey var."
 
     main_page = {
         f"{main_url}/tum-bolumler" : "Yeni Eklenen Bölümler",
@@ -240,60 +240,59 @@ class SelcukFlix(PluginBase):
         sel  = Selector(resp.text)
         
         next_data = sel.css("script#__NEXT_DATA__::text").get()
-        if not next_data: return []
+        if not next_data:
+            return []
 
         try:
-             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')
+            data = json.loads(next_data)
+            secure_data = data["props"]["pageProps"]["secureData"]
+            raw_data = base64.b64decode(secure_data.replace('"', ''))
+            
+            # Try UTF-8 first, fallback to ISO-8859-1 (matching Kotlin)
+            try:
+                decoded_str = raw_data.decode('utf-8')
+            except UnicodeDecodeError:
+                decoded_str = raw_data.decode('iso-8859-1')
             
-             content_details = json.loads(decoded_str)
-             related_data = content_details.get("relatedData", {})
-             
-             source_content = None
-             
-             # Check if Series (episode) or Movie
-             if "/dizi/" in url:
-                 if related_data.get("episodeSources", {}).get("state"):
-                      res = related_data["episodeSources"].get("result", [])
-                      if res:
-                          source_content = res[0].get("sourceContent")
-             else:
-                 # Movie
-                 if related_data.get("movieParts", {}).get("state"):
-                      # Looking for first part source
-                      movie_parts = related_data["movieParts"].get("result", [])
-                      if movie_parts:
-                          first_part_id = movie_parts[0].get("id")
-                          # RelatedResults -> getMoviePartSourcesById_ID
-                          rr = content_details.get("RelatedResults", {})
-                          key = f"getMoviePartSourcesById_{first_part_id}"
-                          if key in rr:
-                              res = rr[key].get("result", [])
-                              if res:
-                                  source_content = res[0].get("source_content")
-
-             results = []
-             if source_content:
-                 iframe_sel = Selector(source_content)
-                 iframe_src = iframe_sel.css("iframe::attr(src)").get()
-                 if iframe_src:
-                     iframe_src = self.fix_url(iframe_src)
-                     # Domain replace
-                     if "sn.dplayer74.site" in iframe_src:
-                         iframe_src = iframe_src.replace("sn.dplayer74.site", "sn.hotlinger.com")
-                     
-                     extractor = self.ex_manager.find_extractor(iframe_src)
-                     results.append({
-                         "url": iframe_src,
-                         "name": extractor.name if extractor else "Iframe"
-                     })
-             
-             return results
+            content_details = json.loads(decoded_str)
+            related_data = content_details.get("relatedData", {})
+            
+            source_content = None
+            
+            # Check if Series (episode) or Movie
+            if "/dizi/" in url:
+                if related_data.get("episodeSources", {}).get("state"):
+                    res = related_data["episodeSources"].get("result", [])
+                    if res:
+                        source_content = res[0].get("sourceContent")
+            else:
+                # Movie
+                if related_data.get("movieParts", {}).get("state"):
+                    movie_parts = related_data["movieParts"].get("result", [])
+                    if movie_parts:
+                        first_part_id = movie_parts[0].get("id")
+                        # RelatedResults -> getMoviePartSourcesById_ID
+                        rr = content_details.get("RelatedResults", {})
+                        key = f"getMoviePartSourcesById_{first_part_id}"
+                        if key in rr:
+                            res = rr[key].get("result", [])
+                            if res:
+                                source_content = res[0].get("source_content")
+
+            if source_content:
+                iframe_sel = Selector(source_content)
+                iframe_src = iframe_sel.css("iframe::attr(src)").get()
+                if iframe_src:
+                    iframe_src = self.fix_url(iframe_src)
+                    extractor  = self.ex_manager.find_extractor(iframe_src)
+
+                    if extractor:  # Only return if extractor found
+                        return [{
+                            "url"  : iframe_src,
+                            "name" : extractor.name
+                        }]
+            
+            return []
 
         except Exception:
             return []