KekikStream 1.7.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

KekikStream/Plugins/FullHDFilm.py

@@ -0,0 +1,220 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, Subtitle
+from parsel import Selector
+import re, base64
+
+class FullHDFilm(PluginBase):
+    name        = "FullHDFilm"
+    language    = "tr"
+    main_url    = "https://hdfilm.us"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Full HD Film izle, Türkçe Dublaj ve Altyazılı filmler."
+
+    main_page   = {
+        f"{main_url}/tur/turkce-altyazili-film-izle"     : "Altyazılı Filmler",
+        f"{main_url}/tur/netflix-filmleri-izle"          : "Netflix",
+        f"{main_url}/tur/yerli-film-izle"                : "Yerli Film",
+        f"{main_url}/category/aile-filmleri-izle"        : "Aile",
+        f"{main_url}/category/aksiyon-filmleri-izle"     : "Aksiyon",
+        f"{main_url}/category/animasyon-filmleri-izle"   : "Animasyon",
+        f"{main_url}/category/belgesel-filmleri-izle"    : "Belgesel",
+        f"{main_url}/category/bilim-kurgu-filmleri-izle" : "Bilim Kurgu",
+        f"{main_url}/category/biyografi-filmleri-izle"   : "Biyografi",
+        f"{main_url}/category/dram-filmleri-izle"        : "Dram",
+        f"{main_url}/category/fantastik-filmler-izle"    : "Fantastik",
+        f"{main_url}/category/gerilim-filmleri-izle"     : "Gerilim",
+        f"{main_url}/category/gizem-filmleri-izle"       : "Gizem",
+        f"{main_url}/category/kisa"                      : "Kısa",
+        f"{main_url}/category/komedi-filmleri-izle"      : "Komedi",
+        f"{main_url}/category/korku-filmleri-izle"       : "Korku",
+        f"{main_url}/category/macera-filmleri-izle"      : "Macera",
+        f"{main_url}/category/muzik"                     : "Müzik",
+        f"{main_url}/category/muzikal-filmleri-izle"     : "Müzikal",
+        f"{main_url}/category/romantik-filmler-izle"     : "Romantik",
+        f"{main_url}/category/savas-filmleri-izle"       : "Savaş",
+        f"{main_url}/category/spor-filmleri-izle"        : "Spor",
+        f"{main_url}/category/suc-filmleri-izle"         : "Suç",
+        f"{main_url}/category/tarih-filmleri-izle"       : "Tarih",
+        f"{main_url}/category/western-filmleri-izle"     : "Western",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        page_url = url if page == 1 else f"{url}/page/{page}"
+
+        self.httpx.headers.update({
+            "User-Agent" : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "Referer"    : f"{self.main_url}/"
+        })
+
+        istek  = await self.httpx.get(page_url)
+        secici = Selector(istek.text)
+
+        return [
+            MainPageResult(
+                category = category,
+                title    = veri.css("img::attr(alt)").get(),
+                url      = self.fix_url(veri.css("a::attr(href)").get()),
+                poster   = self.fix_url(veri.css("img::attr(src)").get()),
+            )
+                for veri in secici.css("div.movie-poster")
+                    if veri.css("img::attr(alt)").get()
+        ]
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek  = await self.httpx.get(f"{self.main_url}/?s={query}")
+        secici = Selector(istek.text)
+
+        return [
+            SearchResult(
+                title  = veri.css("img::attr(alt)").get(),
+                url    = self.fix_url(veri.css("a::attr(href)").get()),
+                poster = self.fix_url(veri.css("img::attr(src)").get()),
+            )
+                for veri in secici.css("div.movie-poster")
+                    if veri.css("img::attr(alt)").get()
+        ]
+
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("h1::text").get() or ""
+        title       = title.strip() if title else ""
+        poster      = self.fix_url(secici.css("div.poster img::attr(src)").get() or "")
+        
+        actors_text = secici.css("div.oyuncular.info::text").get()
+        if actors_text:
+            actors_text = actors_text.replace("Oyuncular:", "").strip()
+            actors = [a.strip() for a in actors_text.split(",")]
+        else:
+            actors = []
+
+        year   = secici.css("div.yayin-tarihi.info::text").re_first(r"(\d{4})")
+        tags   = secici.css("div.tur.info a::text").getall()
+        rating = secici.css("div.imdb::text").re_first(r"IMDb\s*([\d\.]+)")
+        
+        # Description
+        description = secici.xpath("//div[contains(@class, 'others')]/preceding-sibling::div[1]//text()").getall()
+        description = "".join(description).strip() if description else None
+
+        # Kotlin referansı: URL'de -dizi kontrolü veya tags içinde "dizi" kontrolü
+        is_series = "-dizi" in url.lower() or any("dizi" in tag.lower() for tag in tags)
+
+        if is_series:
+            episodes = []
+            part_elements = secici.css("li.psec")
+            part_names    = secici.css("li.psec a::text").getall()
+            
+            # pdata değerlerini çıkar
+            pdata_matches = re.findall(r"pdata\['([^']+)'\]\s*=\s*'([^']+)'", istek.text)
+            
+            for idx, (part_id, part_name) in enumerate(zip([el.css("::attr(id)").get() for el in part_elements], part_names)):
+                if not part_name:
+                    continue
+                    
+                part_name = part_name.strip()
+                
+                # Fragman'ları atla
+                if "fragman" in part_name.lower() or (part_id and "fragman" in part_id.lower()):
+                    continue
+                
+                # Sezon ve bölüm numarası çıkar
+                sz_match = re.search(r'(\d+)\s*sezon', part_id.lower() if part_id else "")
+                ep_match = re.search(r'^(\d+)\.', part_name)
+                
+                sz_num = int(sz_match.group(1)) if sz_match else 1
+                ep_num = int(ep_match.group(1)) if ep_match else idx + 1
+                
+                # pdata'dan video URL'si çık (varsa)
+                video_url = url  # Varsayılan olarak ana URL kullan
+                if idx < len(pdata_matches):
+                    video_url = pdata_matches[idx][1] if pdata_matches[idx][1] else url
+                
+                episodes.append(Episode(
+                    season  = sz_num,
+                    episode = ep_num,
+                    title   = f"{sz_num}. Sezon {ep_num}. Bölüm",
+                    url     = url  # Bölüm URL'leri load_links'te işlenecek
+                ))
+
+            return SeriesInfo(
+                url         = url,
+                poster      = poster,
+                title       = self.clean_title(title) if title else "",
+                description = description,
+                tags        = tags,
+                year        = year,
+                actors      = actors,
+                rating      = rating.strip() if rating else None,
+                episodes    = episodes
+            )
+        else:
+            return MovieInfo(
+                url         = url,
+                poster      = poster,
+                title       = self.clean_title(title) if title else "",
+                description = description,
+                tags        = tags,
+                year        = year,
+                actors      = actors,
+                rating      = rating.strip() if rating else None,
+            )
+
+    def _get_iframe(self, source_code: str) -> str:
+        """Base64 kodlu iframe'i çözümle"""
+        match = re.search(r'<script[^>]*>(PCEtLWJhc2xpazp[^<]*)</script>', source_code)
+        if not match:
+            return ""
+
+        try:
+            decoded_html = base64.b64decode(match[1]).decode("utf-8")
+            iframe_match = re.search(r'<iframe[^>]+src=["\']([^"\']+)["\']', decoded_html)
+            return self.fix_url(iframe_match[1]) if iframe_match else ""
+        except Exception:
+            return ""
+
+    def _extract_subtitle_url(self, source_code: str) -> str | None:
+        """playerjsSubtitle değişkeninden .srt URL çıkar"""
+        patterns = [
+            r'var playerjsSubtitle = "\[Türkçe\](https?://[^\s"]+?\.srt)";',
+            r'var playerjsSubtitle = "(https?://[^\s"]+?\.srt)";',
+            r'subtitle:\s*"(https?://[^\s"]+?\.srt)"',
+        ]
+
+        for pattern in patterns:
+            if match := re.search(pattern, source_code):
+                return match[1]
+
+        return None
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        self.httpx.headers.update({
+            "User-Agent" : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "Referer"    : self.main_url
+        })
+
+        istek       = await self.httpx.get(url)
+        source_code = istek.text
+
+        # Ana sayfadan altyazı URL'sini çek
+        subtitle_url = self._extract_subtitle_url(source_code)
+
+        # Iframe'den altyazı URL'sini çek
+        iframe_src = self._get_iframe(source_code)
+
+        if not subtitle_url and iframe_src:
+            iframe_istek = await self.httpx.get(iframe_src)
+            subtitle_url = self._extract_subtitle_url(iframe_istek.text)
+
+        results = []
+
+        if iframe_src:
+            data = await self.extract(iframe_src)
+            if data:
+                # ExtractResult objesi immutable, yeni bir kopya oluştur
+                subtitles = [Subtitle(name="Türkçe", url=subtitle_url)] if subtitle_url else []
+                updated_data = data.model_copy(update={"subtitles": subtitles}) if subtitles else data
+                results.append(updated_data)
+
+        return results

KekikStream/Plugins/FullHDFilmizlesene.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import kekik_cache, PluginBase, MainPageResult, SearchResult, MovieInfo
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult
 from parsel           import Selector
 from Kekik.Sifreleme  import StringCodec
 import json, re
@@ -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",
@@ -40,7 +40,6 @@ class FullHDFilmizlesene(PluginBase):
         f"{main_url}/filmizle/yerli-filmler-hd-izle/"       : "Yerli Filmler"
     }
 
-    #@kekik_cache(ttl=60*60)
     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)
@@ -55,9 +54,8 @@ class FullHDFilmizlesene(PluginBase):
                 for veri in secici.css("li.film")
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
-        istek  = await self.cffi.get(f"{self.main_url}/arama/{query}")
+        istek  = await self.httpx.get(f"{self.main_url}/arama/{query}")
         secici = Selector(istek.text)
 
         results = []
@@ -77,9 +75,8 @@ class FullHDFilmizlesene(PluginBase):
 
         return results
 
-    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> MovieInfo:
-        istek  = await self.cffi.get(url)
+        istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
         title       = secici.xpath("normalize-space(//div[@class='izle-titles'])").get().strip()
@@ -103,9 +100,8 @@ class FullHDFilmizlesene(PluginBase):
             duration    = duration
         )
 
-    #@kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[dict]:
-        istek  = await self.cffi.get(url)
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
         script   = secici.xpath("(//script)[1]").get()
@@ -123,10 +119,8 @@ class FullHDFilmizlesene(PluginBase):
         response = []
         for link in link_list:
             link = f"https:{link}" if link.startswith("//") else link
-            extractor = self.ex_manager.find_extractor(link)
-            response.append({
-                "url"  : link,
-                "name" : extractor.name if extractor else "Direct Link"
-            })
+            data = await self.extract(link)
+            if data:
+                response.append(data)
 
         return response

KekikStream/Plugins/HDFilmCehennemi.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import kekik_cache, PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, Subtitle
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, Subtitle, ExtractResult
 from parsel           import Selector
 from Kekik.Sifreleme  import Packer, StreamDecoder
 import random, string, re
@@ -10,7 +10,7 @@ class HDFilmCehennemi(PluginBase):
     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."
 
     main_page   = {
         f"{main_url}"                                      : "Yeni Eklenen Filmler",
@@ -29,9 +29,8 @@ class HDFilmCehennemi(PluginBase):
         f"{main_url}/tur/romantik-filmleri-izle-1"         : "Romantik Filmleri"
     }
 
-    #@kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
-        istek  = await self.cffi.get(f"{url}", allow_redirects=True)
+        istek  = await self.httpx.get(f"{url}", follow_redirects=True)
         secici = Selector(istek.text)
 
         return [
@@ -44,9 +43,8 @@ class HDFilmCehennemi(PluginBase):
                 for veri in secici.css("div.section-content a.poster")
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
-        istek = await self.cffi.get(
+        istek = await self.httpx.get(
             url     = f"{self.main_url}/search/?q={query}",
             headers = {
                 "Referer"          : f"{self.main_url}/",
@@ -73,46 +71,84 @@ class HDFilmCehennemi(PluginBase):
             
         return results
 
-    #@kekik_cache(ttl=60*60)
-    async def load_item(self, url: str) -> MovieInfo:
-        istek  = await self.cffi.get(url, headers = {"Referer": f"{self.main_url}/"})
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        istek  = await self.httpx.get(url, headers = {"Referer": f"{self.main_url}/"})
         secici = Selector(istek.text)
 
-        title       = secici.css("h1.section-title::text").get().strip()
-        poster      = secici.css("aside.post-info-poster img.lazyload::attr(data-src)").get().strip()
-        description = secici.css("article.post-info-content > p::text").get().strip()
+        title       = secici.css("h1.section-title::text").get()
+        title       = title.strip() if title else ""
+        poster      = secici.css("aside.post-info-poster img.lazyload::attr(data-src)").get() or ""
+        poster      = poster.strip() if poster else ""
+        description = secici.css("article.post-info-content > p::text").get() or ""
+        description = description.strip() if description else ""
         tags        = secici.css("div.post-info-genres a::text").getall()
-        rating      = secici.css("div.post-info-imdb-rating span::text").get().strip()
-        year        = secici.css("div.post-info-year-country a::text").get().strip()
+        rating      = secici.css("div.post-info-imdb-rating span::text").get() or ""
+        rating      = rating.strip() if rating else ""
+        year        = secici.css("div.post-info-year-country a::text").get() or ""
+        year        = year.strip() if year else ""
         actors      = secici.css("div.post-info-cast a > strong::text").getall()
-        duration    = secici.css("div.post-info-duration::text").get().replace("dakika", "").strip()
+        duration    = secici.css("div.post-info-duration::text").get() or "0"
+        duration    = duration.replace("dakika", "").strip()
 
-        
         try:
-            duration_minutes = int(duration[2:-1])
+            duration_minutes = int(re.search(r'\d+', duration).group()) if re.search(r'\d+', duration) else 0
         except Exception:
             duration_minutes = 0
 
-        return MovieInfo(
-            url         = url,
-            poster      = self.fix_url(poster),
-            title       = self.clean_title(title),
-            description = description,
-            tags        = tags,
-            rating      = rating,
-            year        = year,
-            actors      = actors,
-            duration    = duration_minutes
-        )
+        # Dizi mi film mi kontrol et (Kotlin referansı: div.seasons kontrolü)
+        is_series = len(secici.css("div.seasons").getall()) > 0
+
+        if is_series:
+            episodes = []
+            for ep in secici.css("div.seasons-tab-content a"):
+                ep_name = ep.css("h4::text").get()
+                ep_href = ep.css("::attr(href)").get()
+                if ep_name and ep_href:
+                    ep_name = ep_name.strip()
+                    # Regex ile sezon ve bölüm numarası çıkar
+                    ep_match = re.search(r'(\d+)\.\s*Bölüm', ep_name)
+                    sz_match = re.search(r'(\d+)\.\s*Sezon', ep_name)
+                    ep_num = int(ep_match.group(1)) if ep_match else 1
+                    sz_num = int(sz_match.group(1)) if sz_match else 1
+                    
+                    episodes.append(Episode(
+                        season  = sz_num,
+                        episode = ep_num,
+                        title   = ep_name,
+                        url     = self.fix_url(ep_href)
+                    ))
+
+            return SeriesInfo(
+                url         = url,
+                poster      = self.fix_url(poster),
+                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),
+                title       = self.clean_title(title),
+                description = description,
+                tags        = tags,
+                rating      = rating,
+                year        = year,
+                actors      = actors,
+                duration    = duration_minutes
+            )
 
     def generate_random_cookie(self):
         return "".join(random.choices(string.ascii_letters + string.digits, k=16))
 
-    #@kekik_cache(ttl=15*60)
-    async def cehennempass(self, video_id: str) -> list[dict]:
+    async def cehennempass(self, video_id: str) -> list:
         results = []
         
-        istek = await self.cffi.post(
+        istek = await self.httpx.post(
             url     = "https://cehennempass.pw/process_quality_selection.php",
             headers = {
                 "Referer"          : f"https://cehennempass.pw/download/{video_id}", 
@@ -123,13 +159,13 @@ class HDFilmCehennemi(PluginBase):
             data    = {"video_id": video_id, "selected_quality": "low"},
         )
         if video_url := istek.json().get("download_link"):
-            results.append({
-                "url"     : self.fix_url(video_url),
-                "name"    : "Düşük Kalite",
-                "referer" : f"https://cehennempass.pw/download/{video_id}"
-            })
+            results.append(ExtractResult(
+                url     = self.fix_url(video_url),
+                name    = "Düşük Kalite",
+                referer = f"https://cehennempass.pw/download/{video_id}"
+            ))
 
-        istek = await self.cffi.post(
+        istek = await self.httpx.post(
             url     = "https://cehennempass.pw/process_quality_selection.php",
             headers = {
                 "Referer"          : f"https://cehennempass.pw/download/{video_id}", 
@@ -140,26 +176,64 @@ class HDFilmCehennemi(PluginBase):
             data    = {"video_id": video_id, "selected_quality": "high"},
         )
         if video_url := istek.json().get("download_link"):
-            results.append({
-                "url"     : self.fix_url(video_url),
-                "name"    : "Yüksek Kalite",
-                "referer" : f"https://cehennempass.pw/download/{video_id}"
-            })
+            results.append(ExtractResult(
+                url     = self.fix_url(video_url),
+                name    = "Yüksek Kalite",
+                referer = f"https://cehennempass.pw/download/{video_id}"
+            ))
 
         return results
 
-    #@kekik_cache(ttl=15*60)
+    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 StreamDecoder._brute_force(parts)
+
     async def invoke_local_source(self, iframe: str, source: str, url: str):
-        self.cffi.headers.update({"Referer": f"{self.main_url}/"})
-        istek = await self.cffi.get(iframe)
+        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:
@@ -172,16 +246,15 @@ class HDFilmCehennemi(PluginBase):
         except Exception:
             pass
 
-        return [{
-            "url"       : video_url,
-            "name"      : source,
-            "referer"   : url,
-            "subtitles" : subtitles
-        }]
+        return [ExtractResult(
+            url       = video_url,
+            name      = source,
+            referer   = url,
+            subtitles = subtitles
+        )]
 
-    #@kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[dict]:
-        istek  = await self.cffi.get(url)
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
         results = []
@@ -192,7 +265,7 @@ class HDFilmCehennemi(PluginBase):
                 source   = f"{link.css('::text').get().replace('(HDrip Xbet)', '').strip()} {lang_code}"
                 video_id = link.css("::attr(data-video)").get()
 
-                api_get = await self.cffi.get(
+                api_get = await self.httpx.get(
                     url     = f"{self.main_url}/video/{video_id}/",
                     headers = {
                         "Content-Type"     : "application/json",
@@ -204,8 +277,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:
@@ -214,12 +294,4 @@ class HDFilmCehennemi(PluginBase):
                 for video_data in video_data_list:
                     results.append(video_data)
 
-        return results
-
-    async def play(self, name: str, url: str, referer: str, subtitles: list[Subtitle]):
-        extract_result = ExtractResult(name=name, url=url, referer=referer, subtitles=subtitles)
-        self.media_handler.title = 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)
+        return results