KekikStream 2.3.3__py3-none-any.whl → 2.3.5__py3-none-any.whl

KekikStream/Plugins/FullHDFilm.py

@@ -1,8 +1,7 @@
 # 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 selectolax.parser import HTMLParser
-import re, base64
+from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, Subtitle, HTMLHelper
+import base64
 
 class FullHDFilm(PluginBase):
     name        = "FullHDFilm"
@@ -48,16 +47,13 @@ class FullHDFilm(PluginBase):
         })
 
         istek  = await self.httpx.get(page_url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("div.movie-poster"):
-            img_el  = veri.css_first("img")
-            link_el = veri.css_first("a")
-
-            alt    = img_el.attrs.get("alt") if img_el else None
-            poster = img_el.attrs.get("src") if img_el else None
-            href   = link_el.attrs.get("href") if link_el else None
+        for veri in secici.select("div.movie-poster"):
+            alt = secici.select_attr("img", "alt", veri)
+            poster = secici.select_attr("img", "src", veri)
+            href = secici.select_attr("a", "href", veri)
 
             if alt and href:
                 results.append(MainPageResult(
@@ -71,16 +67,13 @@ class FullHDFilm(PluginBase):
 
     async def search(self, query: str) -> list[SearchResult]:
         istek  = await self.httpx.get(f"{self.main_url}/?s={query}")
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("div.movie-poster"):
-            img_el  = veri.css_first("img")
-            link_el = veri.css_first("a")
-
-            alt    = img_el.attrs.get("alt") if img_el else None
-            poster = img_el.attrs.get("src") if img_el else None
-            href   = link_el.attrs.get("href") if link_el else None
+        for veri in secici.select("div.movie-poster"):
+            alt = secici.select_attr("img", "alt", veri)
+            poster = secici.select_attr("img", "src", veri)
+            href = secici.select_attr("a", "href", veri)
 
             if alt and href:
                 results.append(SearchResult(
@@ -93,75 +86,59 @@ class FullHDFilm(PluginBase):
 
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
         html_text = istek.text
 
-        title_el = secici.css_first("h1")
-        title    = title_el.text(strip=True) if title_el else ""
+        title = secici.select_text("h1") or ""
 
-        poster_el = secici.css_first("div.poster img")
-        poster    = self.fix_url(poster_el.attrs.get("src")) if poster_el else ""
+        poster = secici.select_attr("div.poster img", "src") or ""
+        poster = self.fix_url(poster)
         
-        actors_el = secici.css_first("div.oyuncular.info")
         actors = []
-        if actors_el:
-            actors_text = actors_el.text(strip=True)
-            if actors_text:
-                actors_text = actors_text.replace("Oyuncular:", "").strip()
-                actors = [a.strip() for a in actors_text.split(",")]
+        actors_text = secici.select_text("div.oyuncular.info")
+        if actors_text:
+            actors_text = actors_text.replace("Oyuncular:", "").strip()
+            actors = [a.strip() for a in actors_text.split(",")]
 
         # Year: önce div.yayin-tarihi.info dene
-        year = None
-        year_el = secici.css_first("div.yayin-tarihi.info")
-        if year_el:
-            year_text = year_el.text(strip=True)
-            year_match = re.search(r"(\d{4})", year_text)
-            if year_match:
-                year = year_match.group(1)
-        
+        year = secici.extract_year("div.yayin-tarihi.info")
+
         # Fallback: h1'in parent'ından (2019) formatında ara
-        if not year and title_el:
-            parent = title_el.parent
-            if parent:
-                parent_text = parent.text(strip=True)
-                year_match = re.search(r"\((\d{4})\)", parent_text)
-                if year_match:
-                    year = year_match.group(1)
+        if not year:
+            # Parent'ın tüm text içeriğinden yıl çıkar
+            title_text = secici.select_text("h1")
+            if title_text:
+                # h1 parent'ındaki (2019) gibi text'i bul
+                year = secici.regex_first(r"\((\d{4})\)")
 
-        tags = [a.text(strip=True) for a in secici.css("div.tur.info a") if a.text(strip=True)]
+        tags = secici.select_all_text("div.tur.info a")
 
         # Rating: regex
-        rating_el = secici.css_first("div.imdb")
-        rating_text = rating_el.text(strip=True) if rating_el else ""
-        rating_match = re.search(r"IMDb\s*([\d\.]+)", rating_text)
-        rating = rating_match.group(1) if rating_match else None
+        rating_text = secici.select_text("div.imdb") or ""
+        rating = HTMLHelper(rating_text).regex_first(r"IMDb\s*([\d\.]+)")
         
         # Description: önce div.film dene, yoksa og:description meta tag'ını kullan
-        description = None
-        desc_el = secici.css_first("div.film")
-        if desc_el:
-            description = desc_el.text(strip=True)
+        description = secici.select_text("div.film")
         
         # Fallback: og:description meta tag'ı
         if not description:
-            og_desc = secici.css_first("meta[property='og:description']")
+            og_desc = secici.select_attr("meta[property='og:description']", "content")
             if og_desc:
-                description = og_desc.attrs.get("content", "")
+                description = og_desc
 
         # 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_elements = secici.select("li.psec")
             
             # pdata değerlerini çıkar
-            pdata_matches = re.findall(r"pdata\['([^']+)'\]\s*=\s*'([^']+)'", html_text)
+            pdata_matches = HTMLHelper(html_text).regex_all(r"pdata\['([^']+)'\]\s*=\s*'([^']+)'")
             
             for idx, el in enumerate(part_elements):
                 part_id = el.attrs.get("id")
-                link_el = el.css_first("a")
-                part_name = link_el.text(strip=True) if link_el else None
+                part_name = secici.select_text("a", el)
 
                 if not part_name:
                     continue
@@ -171,11 +148,11 @@ class FullHDFilm(PluginBase):
                     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
+                sz_val = HTMLHelper(part_id.lower() if part_id else "").regex_first(r'(\d+)\s*sezon')
+                ep_val = HTMLHelper(part_name).regex_first(r'^(\d+)\.')
+
+                sz_num = int(sz_val) if sz_val and sz_val.isdigit() else 1
+                ep_num = int(ep_val) if ep_val and ep_val.isdigit() else idx + 1
                 
                 # pdata'dan video URL'si çık (varsa)
                 video_url = url  # Varsayılan olarak ana URL kullan
@@ -214,14 +191,14 @@ class FullHDFilm(PluginBase):
 
     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:
+        script_val = HTMLHelper(source_code).regex_first(r'<script[^>]*>(PCEtLWJhc2xpazp[^<]*)</script>')
+        if not script_val:
             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 ""
+            decoded_html = base64.b64decode(script_val).decode("utf-8")
+            iframe_src = HTMLHelper(decoded_html).regex_first(r'<iframe[^>]+src=["\']([^"\']+)["\']')
+            return self.fix_url(iframe_src) if iframe_src else ""
         except Exception:
             return ""
 
@@ -234,8 +211,9 @@ class FullHDFilm(PluginBase):
         ]
 
         for pattern in patterns:
-            if match := re.search(pattern, source_code):
-                return match[1]
+            val = HTMLHelper(source_code).regex_first(pattern)
+            if val:
+                return val
 
         return None
 

KekikStream/Plugins/FullHDFilmizlesene.py

@@ -1,9 +1,8 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult
-from selectolax.parser import HTMLParser
+from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, HTMLHelper
 from Kekik.Sifreleme   import StringCodec
-import json, re
+import json
 
 class FullHDFilmizlesene(PluginBase):
     name        = "FullHDFilmizlesene"
@@ -42,17 +41,13 @@ class FullHDFilmizlesene(PluginBase):
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = self.cloudscraper.get(f"{url}{page}")
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("li.film"):
-            title_el = veri.css_first("span.film-title")
-            link_el  = veri.css_first("a")
-            img_el   = veri.css_first("img")
-
-            title  = title_el.text(strip=True) if title_el else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = img_el.attrs.get("data-src") if img_el else None
+        for veri in secici.select("li.film"):
+            title = secici.select_text("span.film-title", veri)
+            href = secici.select_attr("a", "href", veri)
+            poster = secici.select_attr("img", "data-src", veri)
 
             if title and href:
                 results.append(MainPageResult(
@@ -66,17 +61,13 @@ class FullHDFilmizlesene(PluginBase):
 
     async def search(self, query: str) -> list[SearchResult]:
         istek  = await self.httpx.get(f"{self.main_url}/arama/{query}")
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for film in secici.css("li.film"):
-            title_el = film.css_first("span.film-title")
-            link_el  = film.css_first("a")
-            img_el   = film.css_first("img")
-
-            title  = title_el.text(strip=True) if title_el else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = img_el.attrs.get("data-src") if img_el else None
+        for film in secici.select("li.film"):
+            title = secici.select_text("span.film-title", film)
+            href = secici.select_attr("a", "href", film)
+            poster = secici.select_attr("img", "data-src", film)
 
             if title and href:
                 results.append(SearchResult(
@@ -89,49 +80,42 @@ class FullHDFilmizlesene(PluginBase):
 
     async def load_item(self, url: str) -> MovieInfo:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
         html_text = istek.text
 
         # Title: normalize-space yerine doğrudan class ile
-        title_el = secici.css_first("div.izle-titles")
-        title    = title_el.text(strip=True) if title_el else ""
+        title = secici.select_text("div.izle-titles") or ""
 
-        img_el = secici.css_first("div img[data-src]")
-        poster = img_el.attrs.get("data-src", "").strip() if img_el else ""
+        poster = secici.select_attr("div img[data-src]", "data-src") or ""
+        poster = poster.strip()
 
-        desc_el     = secici.css_first("div.ozet-ic p")
-        description = desc_el.text(strip=True) if desc_el else ""
+        description = secici.select_text("div.ozet-ic p") or ""
 
-        tags = [a.text(strip=True) for a in secici.css("a[rel='category tag']") if a.text(strip=True)]
+        tags = secici.select_all_text("a[rel='category tag']")
 
         # Rating: normalize-space yerine doğrudan class ile ve son kelimeyi al
-        rating_el = secici.css_first("div.puanx-puan")
+        rating_text = secici.select_text("div.puanx-puan") or None
         rating = None
-        if rating_el:
-            rating_text = rating_el.text(strip=True)
-            if rating_text:
-                parts = rating_text.split()
-                rating = parts[-1] if parts else None
+        if rating_text:
+            parts = rating_text.split()
+            rating = parts[-1] if parts else None
 
         # Year: ilk yıl formatında değer
-        year_el = secici.css_first("div.dd a.category")
+        year_text = secici.select_text("div.dd a.category") or None
         year = None
-        if year_el:
-            year_text = year_el.text(strip=True)
-            if year_text:
-                parts = year_text.split()
-                year = parts[0] if parts else None
+        if year_text:
+            parts = year_text.split()
+            year = parts[0] if parts else None
 
         # Actors: nth-child yerine tüm li'leri alıp 2. index
-        lis = secici.css("div.film-info ul li")
+        lis = secici.select("div.film-info ul li")
         actors = []
         if len(lis) >= 2:
-            actors = [a.text(strip=True) for a in lis[1].css("a > span") if a.text(strip=True)]
+            actors = secici.select_all_text("a > span", lis[1])
 
-        duration_el = secici.css_first("span.sure")
         duration = "0"
-        if duration_el:
-            duration_text = duration_el.text(strip=True)
+        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"
 
@@ -149,18 +133,18 @@ class FullHDFilmizlesene(PluginBase):
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
         html_text = istek.text
 
         # İlk script'i al (xpath (//script)[1] yerine)
-        scripts = secici.css("script")
+        scripts = secici.select("script")
         script_content = scripts[0].text() if scripts else ""
 
-        scx_match = re.search(r"scx = (.*?);", script_content)
-        if not scx_match:
+        scx_json = HTMLHelper(script_content).regex_first(r"scx = (.*?);")
+        if not scx_json:
             return []
 
-        scx_data = json.loads(scx_match.group(1))
+        scx_data = json.loads(scx_json)
         scx_keys = list(scx_data.keys())
 
         link_list = []

KekikStream/Plugins/HDFilmCehennemi.py

@@ -1,14 +1,13 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, Subtitle, ExtractResult
-from selectolax.parser import HTMLParser
+from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, Subtitle, ExtractResult, HTMLHelper
 from Kekik.Sifreleme   import Packer, StreamDecoder
-import random, string, re
+import random, string
 
 class HDFilmCehennemi(PluginBase):
     name        = "HDFilmCehennemi"
     language    = "tr"
-    main_url    = "https://www.hdfilmcehennemi.ws"
+    main_url    = "https://www.hdfilmcehennemi.nl"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "Türkiye'nin en hızlı hd film izleme sitesi. Tek ve gerçek hdfilmcehennemi sitesi."
 
@@ -31,16 +30,13 @@ class HDFilmCehennemi(PluginBase):
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(f"{url}", follow_redirects=True)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("div.section-content a.poster"):
-            title_el = veri.css_first("strong.poster-title")
-            img_el   = veri.css_first("img")
-
-            title  = title_el.text(strip=True) if title_el else None
-            href   = veri.attrs.get("href")
-            poster = img_el.attrs.get("data-src") if img_el else None
+        for veri in secici.select("div.section-content a.poster"):
+            title = secici.select_text("strong.poster-title", veri)
+            href = veri.attrs.get("href")
+            poster = secici.select_attr("img", "data-src", veri)
 
             if title and href:
                 results.append(MainPageResult(
@@ -64,14 +60,10 @@ class HDFilmCehennemi(PluginBase):
 
         results = []
         for veri in istek.json().get("results", []):
-            secici = HTMLParser(veri)
-            title_el = secici.css_first("h4.title")
-            link_el  = secici.css_first("a")
-            img_el   = secici.css_first("img")
-
-            title  = title_el.text(strip=True) if title_el else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = (img_el.attrs.get("data-src") or img_el.attrs.get("src")) if img_el else None
+            secici = HTMLHelper(veri)
+            title  = secici.select_text("h4.title")
+            href   = secici.select_attr("a", "href")
+            poster = secici.select_attr("img", "data-src") or secici.select_attr("img", "src")
 
             if title and href:
                 results.append(SearchResult(
@@ -84,53 +76,47 @@ class HDFilmCehennemi(PluginBase):
 
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         istek  = await self.httpx.get(url, headers = {"Referer": f"{self.main_url}/"})
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
-        title_el = secici.css_first("h1.section-title")
-        title    = title_el.text(strip=True) if title_el else ""
+        title = secici.select_text("h1.section-title") or ""
 
-        poster_el = secici.css_first("aside.post-info-poster img.lazyload")
-        poster    = poster_el.attrs.get("data-src", "").strip() if poster_el else ""
+        poster = secici.select_attr("aside.post-info-poster img.lazyload", "data-src") or ""
+        poster = poster.strip()
 
-        desc_el     = secici.css_first("article.post-info-content > p")
-        description = desc_el.text(strip=True) if desc_el else ""
+        description = secici.select_text("article.post-info-content > p") or ""
 
-        tags   = [a.text(strip=True) for a in secici.css("div.post-info-genres a") if a.text(strip=True)]
+        tags = secici.select_all_text("div.post-info-genres a")
 
-        rating_el = secici.css_first("div.post-info-imdb-rating span")
-        rating    = rating_el.text(strip=True) if rating_el else ""
+        rating = secici.select_text("div.post-info-imdb-rating span") or ""
 
-        year_el = secici.css_first("div.post-info-year-country a")
-        year    = year_el.text(strip=True) if year_el else ""
+        year = secici.select_text("div.post-info-year-country a") or ""
 
-        actors = [a.text(strip=True) for a in secici.css("div.post-info-cast a > strong") if a.text(strip=True)]
+        actors = secici.select_all_text("div.post-info-cast a > strong")
 
-        duration_el = secici.css_first("div.post-info-duration")
-        duration_str = duration_el.text(strip=True) if duration_el else "0"
+        duration_str = secici.select_text("div.post-info-duration") or "0"
         duration_str = duration_str.replace("dakika", "").strip()
 
         try:
-            duration_match = re.search(r'\d+', duration_str)
-            duration_minutes = int(duration_match.group()) if duration_match else 0
+            duration_val = HTMLHelper(duration_str).regex_first(r'\d+')
+            duration_minutes = int(duration_val) if duration_val else 0
         except Exception:
             duration_minutes = 0
 
         # Dizi mi film mi kontrol et (Kotlin referansı: div.seasons kontrolü)
-        is_series = len(secici.css("div.seasons")) > 0
+        is_series = len(secici.select("div.seasons")) > 0
 
         if is_series:
             episodes = []
-            for ep in secici.css("div.seasons-tab-content a"):
-                ep_name_el = ep.css_first("h4")
-                ep_name = ep_name_el.text(strip=True) if ep_name_el else None
+            for ep in secici.select("div.seasons-tab-content a"):
+                ep_name = secici.select_text("h4", ep)
                 ep_href = ep.attrs.get("href")
 
                 if ep_name and ep_href:
                     # 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
+                    ep_val = HTMLHelper(ep_name).regex_first(r'(\d+)\.\s*Bölüm')
+                    sz_val = HTMLHelper(ep_name).regex_first(r'(\d+)\.\s*Sezon')
+                    ep_num = int(ep_val) if ep_val and ep_val.isdigit() else 1
+                    sz_num = int(sz_val) if sz_val and sz_val.isdigit() else 1
                     
                     episodes.append(Episode(
                         season  = sz_num,
@@ -208,19 +194,19 @@ class HDFilmCehennemi(PluginBase):
     def _extract_from_json_ld(self, html: str) -> str | None:
         """JSON-LD script tag'inden contentUrl'i çıkar (Kotlin versiyonundaki gibi)"""
         # Önce JSON-LD'den dene
-        json_ld_match = re.search(r'<script[^>]+type=["\']application/ld\+json["\'][^>]*>(.*?)</script>', html, re.DOTALL)
-        if json_ld_match:
+        json_ld = HTMLHelper(html).regex_first(r'(?s)<script[^>]+type=["\']application/ld\+json["\'][^>]*>(.*?)</script>')
+        if json_ld:
             try:
                 import json
-                data = json.loads(json_ld_match.group(1).strip())
+                data = json.loads(json_ld.strip())
                 if content_url := data.get("contentUrl"):
                     if content_url.startswith("http"):
                         return content_url
             except Exception:
                 # Regex ile contentUrl'i çıkarmayı dene
-                match = re.search(r'"contentUrl"\s*:\s*"([^"]+)"', html)
-                if match and match.group(1).startswith("http"):
-                    return match.group(1)
+                content_url = HTMLHelper(html).regex_first(r'"contentUrl"\s*:\s*"([^"]+)"')
+                if content_url and content_url.startswith("http"):
+                    return content_url
         return None
 
     async def invoke_local_source(self, iframe: str, source: str, url: str):
@@ -239,12 +225,12 @@ class HDFilmCehennemi(PluginBase):
         # Fallback: Packed JavaScript'ten çıkar
         if not video_url:
             # eval(function...) içeren packed script bul
-            eval_match = re.search(r'(eval\(function[\s\S]+)', istek.text)
-            if not eval_match:
+            eval_script = HTMLHelper(istek.text).regex_first(r'(eval\(function[\s\S]+)')
+            if not eval_script:
                 return await self.cehennempass(iframe.split("/")[-1])
 
             try:
-                unpacked = Packer.unpack(eval_match.group(1))
+                unpacked = Packer.unpack(eval_script)
                 video_url = StreamDecoder.extract_stream_url(unpacked)
             except Exception:
                 return await self.cehennempass(iframe.split("/")[-1])
@@ -255,10 +241,10 @@ class HDFilmCehennemi(PluginBase):
         subtitles = []
         try:
             sub_data = istek.text.split("tracks: [")[1].split("]")[0]
-            for sub in re.findall(r'file":"([^"]+)".*?"language":"([^"]+)"', sub_data, flags=re.DOTALL):
+            for file_url, lang in HTMLHelper(sub_data).regex_all(r'(?s)file":"([^\\"]+)".*?"language":"([^\\"]+)"'):
                 subtitles.append(Subtitle(
-                    name = sub[1].upper(),
-                    url  = self.fix_url(sub[0].replace("\\", "")),
+                    name = lang.upper(),
+                    url  = self.fix_url(file_url.replace("\\", "")),
                 ))
         except Exception:
             pass
@@ -272,13 +258,13 @@ class HDFilmCehennemi(PluginBase):
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for alternatif in secici.css("div.alternative-links"):
+        for alternatif in secici.select("div.alternative-links"):
             lang_code = alternatif.attrs.get("data-lang", "").upper()
 
-            for link in alternatif.css("button.alternative-link"):
+            for link in secici.select("button.alternative-link", alternatif):
                 source_text = link.text(strip=True).replace('(HDrip Xbet)', '').strip()
                 source   = f"{source_text} {lang_code}"
                 video_id = link.attrs.get("data-video")
@@ -295,8 +281,8 @@ class HDFilmCehennemi(PluginBase):
                     },
                 )
 
-                match  = re.search(r'data-src=\\\"([^"]+)', api_get.text)
-                iframe = match[1].replace("\\", "") if match else None
+                iframe = HTMLHelper(api_get.text).regex_first(r'data-src=\\\"([^\"]+)')
+                iframe = iframe.replace("\\", "") if iframe else None
 
                 if not iframe:
                     continue