KekikStream 2.3.9__py3-none-any.whl → 2.4.1__py3-none-any.whl

KekikStream/Core/HTMLHelper.py

@@ -113,8 +113,8 @@ class HTMLHelper:
             return int(m.group(1)), int(m.group(2))
 
         # Ayrı ayrı ara
-        s = re.search(r"(\d+)\.\s*[Ss]ezon|[Ss]ezon[- ]?(\d+)|-(\d+)-sezon", text, re.I)
-        e = re.search(r"(\d+)\.\s*[Bb]ölüm|[Bb]olum[- ]?(\d+)|-(\d+)-bolum|[Ee](\d+)", text, re.I)
+        s = re.search(r"(\d+)\.\s*[Ss]ezon|[Ss]ezon[- ]?(\d+)|-(\d+)-sezon|S(\d+)|(\d+)\.[Ss]", text, re.I)
+        e = re.search(r"(\d+)\.\s*[Bb][öo]l[üu]m|[Bb][öo]l[üu]m[- ]?(\d+)|-(\d+)-bolum|[Ee](\d+)", text, re.I)
 
         # İlk bulunan grubu al (None değilse)
         s_val = next((int(g) for g in s.groups() if g), None) if s else None

KekikStream/Core/Plugin/PluginModels.py

@@ -51,9 +51,6 @@ class Episode(BaseModel):
         if not self.title:
             self.title = ""
 
-        if any(keyword in self.title.lower() for keyword in ["bölüm", "sezon", "episode"]):
-            self.title = ""
-
         return self
 
 class SeriesInfo(BaseModel):

KekikStream/Extractors/HDMomPlayer.py

@@ -0,0 +1,62 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+from Kekik.Sifreleme import AESManager
+import re
+import json
+
+class HDMomPlayer(ExtractorBase):
+    name     = "HDMomPlayer"
+    main_url = "hdmomplayer.com"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult | None:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        try:
+            response = await self.httpx.get(url)
+            page_source = response.text
+            
+            m3u_link = None
+            
+            # Regex for bePlayer matches
+            # Matches: bePlayer('PASS', '{DATA}');
+            helper = HTMLHelper(page_source)
+            be_matches = helper.regex_all(r"bePlayer\('([^']+)',\s*'(\{[^\}]+\})'\);")
+            
+            if be_matches:
+                pass_val, data_val = be_matches[0]
+                
+                try:
+                    # Use Kekik.Sifreleme.AESManager as requested
+                    decrypted = AESManager.decrypt(data_val, pass_val).replace("\\", "")
+                    
+                    # Search for video_location in decrypted string
+                    # Kotlin: video_location":"([^"]+)
+                    m_loc = re.search(r'video_location":"([^"]+)"', decrypted)
+                    if m_loc:
+                        m3u_link = m_loc.group(1).replace(r"\/", "/")
+                except Exception:
+                    pass
+
+            if not m3u_link:
+                # Fallback regex
+                # file:"..."
+                m_file = re.search(r'file:"([^"]+)"', page_source)
+                if m_file:
+                    m3u_link = m_file.group(1)
+            
+            if not m3u_link:
+                return None
+            
+            # Fix URL if needed
+            if m3u_link.startswith("//"):
+                m3u_link = "https:" + m3u_link
+                
+            return ExtractResult(
+                name    = "HDMomPlayer",
+                url     = m3u_link,
+                referer = url, 
+            )
+        except Exception:
+            return None

KekikStream/Extractors/HotStream.py

@@ -0,0 +1,45 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+from Kekik.Sifreleme import AESManager
+import re
+import json
+
+class HotStream(ExtractorBase):
+    name     = "HotStream"
+    main_url = "https://hotstream.club"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult | None:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        istek = await self.httpx.get(url)
+        html = istek.text
+        helper = HTMLHelper(html)
+
+        m = re.search(r"bePlayer\('([^']+)',\s*'(\{[^']+\})'\)", html)
+        if not m:
+             # Try double quotes just in case
+             m = re.search(r'bePlayer\("([^"]+)",\s*"(\{[^"]+\})"\)', html)
+             
+        if m:
+            pass_val = m.group(1)
+            data_val = m.group(2)
+            
+            try:
+                decrypted = AESManager.decrypt(data_val, pass_val)
+                if decrypted:
+                    decrypted = decrypted.replace("\\", "")
+                    # Search for video_location in decrypted string
+                    m_loc = re.search(r'"video_location":"([^"]+)"', decrypted)
+                    if m_loc:
+                        video_url = m_loc.group(1).replace(r"\/", "/")
+                        return ExtractResult(
+                            name    = self.name,
+                            url     = video_url,
+                            referer = url
+                        )
+            except Exception:
+                pass
+
+        return None

KekikStream/Extractors/Videostr.py

@@ -0,0 +1,115 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper, Subtitle
+from urllib.parse import quote
+from json import loads
+
+class Videostr(ExtractorBase):
+    name     = "Videostr"
+    main_url = "videostr.net"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult | None:
+        headers = {
+            "Accept": "*/*",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "https://videostr.net",
+        }
+        
+        # 1. Get nonce page
+        # Kotlin: url.substringAfterLast("/").substringBefore("?")
+        id = url.split("?")[0].split("/")[-1]
+        
+        istek = await self.httpx.get(url, headers=headers)
+        if istek.status_code != 200:
+            return None
+            
+        responsenonce = istek.text
+        
+        # Find nonce
+        # Regex: \b[a-zA-Z0-9]{48}\b
+        # Or 3 blocks of 16 chars
+        helper = HTMLHelper(responsenonce)
+        nonce = helper.regex_first(r"\b[a-zA-Z0-9]{48}\b")
+        if not nonce:
+            # Fallback regex as per Kotlin: \b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b
+            # In Python we can just look for the combined matches if regex_first handles grouping poorly or try finding all
+            import re
+            m = re.search(r"\b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b", responsenonce, re.DOTALL)
+            if m:
+                nonce = m.group(1) + m.group(2) + m.group(3)
+        
+        if not nonce:
+            return None
+            
+        # 2. Get Sources
+        api_url = f"https://videostr.net/embed-1/v3/e-1/getSources?id={id}&_k={nonce}"
+        
+        api_resp = await self.httpx.get(api_url, headers=headers)
+        if api_resp.status_code != 200:
+            return None
+            
+        # Parse JSON
+        try:
+            data = api_resp.json()
+        except:
+            return None
+            
+        sources = data.get("sources", [])
+        if not sources:
+            return None
+            
+        encrypted_file = sources[0].get("file")
+        if not encrypted_file:
+            return None
+            
+        m3u8_url = None
+        
+        if ".m3u8" in encrypted_file:
+            m3u8_url = encrypted_file
+        else:
+            # Decrypt
+            # Need key from github
+            key_url = "https://raw.githubusercontent.com/yogesh-hacker/MegacloudKeys/refs/heads/main/keys.json"
+            key_resp = await self.httpx.get(key_url)
+            if key_resp.status_code == 200:
+                try:
+                    keys = key_resp.json()
+                    vidstr_key = keys.get("vidstr") # As per Kotlin code: gson.fromJson(keyJson, Megakey::class.java)?.vidstr
+                    
+                    if vidstr_key:
+                        # Use Google Script to decrypt
+                        decode_url = "https://script.google.com/macros/s/AKfycbxHbYHbrGMXYD2-bC-C43D3njIbU-wGiYQuJL61H4vyy6YVXkybMNNEPJNPPuZrD1gRVA/exec"
+                        
+                        full_url = f"{decode_url}?encrypted_data={quote(encrypted_file)}&nonce={quote(nonce)}&secret={quote(vidstr_key)}"
+                        
+                        decrypted_resp = await self.httpx.get(full_url)
+                        if decrypted_resp.status_code == 200:
+                            # Response is JSON {"file": "..."} usually or text?
+                            # Kotlin says: Regex("\"file\":\"(.*?)\"").find(decryptedResponse)
+                            m_file = re.search(r'"file":"(.*?)"', decrypted_resp.text)
+                            if m_file:
+                                m3u8_url = m_file.group(1).replace(r"\/", "/")
+                except Exception as e:
+                    # print(f"Decryption error: {e}")
+                    pass
+
+        if not m3u8_url:
+            return None
+            
+        # Subtitles
+        # Kotlin: response.tracks
+        subtitles = []
+        tracks = data.get("tracks", [])
+        for t in tracks:
+            if t.get("kind") in ["captions", "subtitles"]:
+                subtitles.append(Subtitle(
+                    name = t.get("label", "Altyazı"),
+                    url  = t.get("file")
+                ))
+                
+        return ExtractResult(
+            name     = "Videostr",
+            url      = m3u8_url,
+            referer  = "https://videostr.net/",
+            subtitles= subtitles
+        )

KekikStream/Extractors/Vidoza.py

@@ -0,0 +1,25 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+
+class Vidoza(ExtractorBase):
+    name     = "Vidoza"
+    main_url = "https://vidoza.net"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult | None:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        istek  = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+        
+        video_url = helper.select_attr("source", "src")
+        
+        if video_url:
+            return ExtractResult(
+                name    = self.name,
+                url     = video_url,
+                referer = url
+            )
+            
+        return None

KekikStream/Plugins/DiziMom.py

@@ -0,0 +1,247 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, HTMLHelper
+from json             import dumps, loads
+import re
+
+class DiziMom(PluginBase):
+    name        = "DiziMom"
+    language    = "tr"
+    main_url    = "https://www.dizimom.one"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Binlerce yerli yabancı dizi arşivi, tüm sezonlar, kesintisiz bölümler. Sadece dizi izle, Dizimom heryerde seninle!"
+
+    main_page = {
+        f"{main_url}/tum-bolumler/page"        : "Son Bölümler",
+        f"{main_url}/yerli-dizi-izle/page"     : "Yerli Diziler",
+        f"{main_url}/yabanci-dizi-izle/page"   : "Yabancı Diziler",
+        f"{main_url}/tv-programlari-izle/page" : "TV Programları",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek   = await self.httpx.get(f"{url}/{page}/")
+        helper  = HTMLHelper(istek.text)
+
+        if "/tum-bolumler/" in url:
+            items = helper.select("div.episode-box")
+            results = []
+            for item in items:
+                name_el = helper.select_first("div.episode-name a", item)
+                if not name_el: continue
+                name = name_el.text(strip=True).split(" izle")[0]
+                title = name.replace(".Sezon ", "x").replace(".Bölüm", "")
+                
+                ep_href = self.fix_url(name_el.attrs.get("href"))
+                pass 
+            
+            # Revert to standard categories if "tum-bolumler" is complex
+            return [] 
+        else:
+            items = helper.select("div.single-item")
+            return [
+                MainPageResult(
+                    category = category,
+                    title    = helper.select_text("div.categorytitle a", item).split(" izle")[0],
+                    url      = self.fix_url(helper.select_attr("div.categorytitle a", "href", item)),
+                    poster   = self.fix_url(helper.select_attr("div.cat-img img", "src", item))
+                )
+                for item in items
+            ]
+
+    async def search(self, query: str) -> list[SearchResult]:
+        url = f"{self.main_url}/?s={query}"
+        istek = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+        items = helper.select("div.single-item")
+        
+        return [
+            SearchResult(
+                title  = helper.select_text("div.categorytitle a", item).split(" izle")[0],
+                url    = self.fix_url(helper.select_attr("div.categorytitle a", "href", item)),
+                poster = self.fix_url(helper.select_attr("div.cat-img img", "src", item))
+            )
+            for item in items
+        ]
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+
+        title_raw = helper.select_text("div.title h1")
+        title = title_raw.split(" izle")[0] if title_raw else "Bilinmiyor"
+        
+        poster = self.fix_url(helper.select_attr("div.category_image img", "src"))
+        
+        # Custom extraction for fields that were using xpath_text
+        year = None
+        rating = None
+        actors = None
+        
+        # Regex approach based on debug output (multiline support)
+        # Context: <span class="dizimeta"><i class="fas fa-globe"></i> Yapım Yılı : </span>\n 2022
+        year_val_all = helper.regex_all(r"Yapım Yılı\s*:\s*(?:</span>)?\s*(\d{4})", flags=re.DOTALL)
+        if year_val_all:
+             year = int(year_val_all[0])
+            
+        # Context: <span class="dizimeta"><i class="fas fa-star"></i> IMDB : </span>\n 4.5
+        rating_val_all = helper.regex_all(r"IMDB\s*:\s*(?:</span>)?\s*([\d\.]+)", flags=re.DOTALL)
+        if rating_val_all:
+            rating = rating_val_all[0]
+            
+        actors_val = helper.regex_first(r"Oyuncular\s*:\s*(.+?)(?:</div>|<br|$)")
+        if not actors_val:
+             # Try selecting the div text directly if regex fails due to HTML tags
+             # Find div containing "Oyuncular :"
+             all_divs = helper.select("div")
+             for div in all_divs:
+                 txt = div.text()
+                 if "Oyuncular :" in txt:
+                     actors_val = txt.split("Oyuncular :")[1].strip()
+                     break
+        
+        if actors_val:
+             # Remove footer / junk from actors
+             if "IMDB :" in actors_val:
+                 actors_val = actors_val.split("IMDB :")[0].strip()
+                 
+             if "IMDB :" in actors_val:
+                 actors_val = actors_val.split("IMDB :")[0].strip()
+                 
+             # Remove '×' and other junk if present at end
+             if "×" in actors_val:
+                 actors_val = actors_val.split("×")[0].strip()
+
+             # Remove simple tags if any remaining
+             clean_actors = [a.strip() for a in actors_val.split(",")]
+             # Filter empty
+             clean_actors = [a for a in clean_actors if a]
+             
+             actors = ", ".join(clean_actors)
+             
+        description_raw = helper.select_text("div.category_desc")
+        description = None
+        if description_raw:
+             # Clean header "The Librarians izle..." etc. if present, usually it is fine.
+             # Clean "IMDB :" if attached
+             if "IMDB :" in description_raw:
+                 description_raw = description_raw.split("IMDB :")[0].strip()
+             
+             # Clean footer text start
+             # The footer block usually starts with "Dizimom, dizi ve film..."
+             if "Dizimom," in description_raw:
+                 description = description_raw.split("Dizimom,")[0].strip()
+             elif "dizi izle film izle" in description_raw:
+                 description = description_raw.split("dizi izle film izle")[0].strip()
+             else:
+                  description = description_raw
+
+             # Fallback cleanup for JSON
+             if description and "{" in description:
+                  description = description.split("{")[0].strip()
+
+        tags = helper.select_all_text("div.genres a")
+        
+        # Improved year regex
+        if not year:
+             # Look for "Yapım Yılı : 2014" pattern in ANY text
+             # Get all text from category_text which usually contains it
+             meta_text = helper.select_text("div.category_text")
+             if meta_text:
+                 match = re.search(r"Yapım Yılı\s*:\s*(\d{4})", meta_text)
+                 if match:
+                     year = int(match.group(1))
+
+        episodes = []
+        ep_items = helper.select("div.bolumust")
+        for item in ep_items:
+            ep_name_raw = helper.select_text("div.baslik", item)
+            ep_href = self.fix_url(helper.select_attr("a", "href", item))
+            
+            if ep_name_raw:
+                # 1.Sezon 1.Bölüm
+                s_m = re.search(r"(\d+)\.Sezon", ep_name_raw)
+                e_m = re.search(r"(\d+)\.Bölüm", ep_name_raw)
+                
+                season = int(s_m.group(1)) if s_m else 1
+                episode = int(e_m.group(1)) if e_m else 1
+                
+                name = ep_name_raw.split(" izle")[0].replace(title, "").strip()
+                
+                episodes.append(Episode(
+                    season  = season,
+                    episode = episode,
+                    title   = name,
+                    url     = ep_href
+                ))
+
+        return SeriesInfo(
+            url         = url,
+            poster      = poster,
+            title       = title,
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            year        = str(year) if year else None,
+            actors      = actors,
+            episodes    = episodes
+        )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        # Login simulation headers
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+            "sec-ch-ua": 'Not/A)Brand";v="8", "Chromium";v="137", "Google Chrome";v="137"',
+            "sec-ch-ua-mobile": "?1",
+            "sec-ch-ua-platform": "Android"
+        }
+        
+        # Simulate login (as seen in Kotlin)
+        login_url = f"{self.main_url}/wp-login.php"
+        login_data = {
+            "log": "keyiflerolsun",
+            "pwd": "12345",
+            "rememberme": "forever",
+            "redirect_to": self.main_url
+        }
+        
+        await self.httpx.post(login_url, headers=headers, data=login_data)
+        
+        istek = await self.httpx.get(url, headers=headers)
+        helper = HTMLHelper(istek.text)
+        
+        iframes = []
+        
+        main_iframe = helper.select_attr("iframe[src]", "src")
+        if main_iframe:
+            iframes.append(main_iframe)
+            
+        sources = helper.select("div.sources a")
+        for source in sources:
+            href = source.attrs.get("href")
+            if href:
+                sub_istek = await self.httpx.get(href, headers=headers)
+                sub_helper = HTMLHelper(sub_istek.text)
+                sub_iframe = sub_helper.select_attr("div.video p iframe", "src")
+                if sub_iframe:
+                    iframes.append(sub_iframe)
+                    
+        results = []
+        for iframe_url in iframes:
+            # Check for known extractors
+            if iframe_url.startswith("//"):
+                iframe_url = f"https:{iframe_url}"
+             
+            extract_result = await self.extract(iframe_url)
+            if extract_result:
+                if isinstance(extract_result, list):
+                    results.extend(extract_result)
+                else:
+                    results.append(extract_result)
+            else:
+                 results.append(ExtractResult(
+                    url  = iframe_url,
+                    name = f"{self.name} | External",
+                    referer = self.main_url
+                ))
+                
+        return results

KekikStream/Plugins/FilmEkseni.py

@@ -0,0 +1,140 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, ExtractResult, HTMLHelper
+from json             import dumps, loads
+import re
+
+class FilmEkseni(PluginBase):
+    name        = "FilmEkseni"
+    language    = "tr"
+    main_url    = "https://filmekseni.cc"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Film Ekseni ⚡️ Vizyonda ki, en güncel ve en yeni filmleri full hd kalitesinde türkçe dublaj ve altyazı seçenekleriyle 1080p olarak izleyebileceğiniz adresiniz."
+
+    main_page = {
+        f"{main_url}/tur/aile-filmleri/page"        : "Aile Filmleri",
+        f"{main_url}/tur/aksiyon-filmleri/page"     : "Aksiyon Filmleri",
+        f"{main_url}/tur/animasyon-film-izle/page"  : "Animasyon Filmleri",
+        f"{main_url}/tur/bilim-kurgu-filmleri/page" : "Bilim Kurgu Filmleri",
+        f"{main_url}/tur/biyografi-filmleri/page"   : "Biyografi Filmleri",
+        f"{main_url}/tur/dram-filmleri-izle/page"   : "Dram Filmleri",
+        f"{main_url}/tur/fantastik-filmler/page"    : "Fantastik Filmleri",
+        f"{main_url}/tur/gerilim-filmleri/page"     : "Gerilim Filmleri",
+        f"{main_url}/tur/gizem-filmleri/page"       : "Gizem Filmleri",
+        f"{main_url}/tur/komedi-filmleri/page"      : "Komedi Filmleri",
+        f"{main_url}/tur/korku-filmleri/page"       : "Korku Filmleri",
+        f"{main_url}/tur/macera-filmleri/page"      : "Macera Filmleri",
+        f"{main_url}/tur/romantik-filmler/page"     : "Romantik Filmleri",
+        f"{main_url}/tur/savas-filmleri/page"       : "Savaş Filmleri",
+        f"{main_url}/tur/suc-filmleri/page"         : "Suç Filmleri",
+        f"{main_url}/tur/tarih-filmleri/page"       : "Tarih Filmleri",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek   = await self.httpx.get(f"{url}/{page}/")
+        helper  = HTMLHelper(istek.text)
+        posters = helper.select("div.poster")
+
+        return [
+            MainPageResult(
+                category = category,
+                title    = self.clean_title(helper.select_text("h2", veri)),
+                url      = helper.select_attr("a", "href", veri),
+                poster   = helper.select_attr("img", "data-src", veri)
+            )
+            for veri in posters
+        ]
+
+    async def search(self, query: str) -> list[SearchResult]:
+        url = f"{self.main_url}/search/"
+        headers = {
+            "X-Requested-With" : "XMLHttpRequest",
+            "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+            "Referer"          : self.main_url,
+        }
+        data = {"query": query}
+        
+        istek = await self.httpx.post(url, headers=headers, data=data)
+        veriler = istek.json().get("result", [])
+
+        return [
+            SearchResult(
+                title  = veri.get("title"),
+                url    = f"{self.main_url}/{veri.get('slug')}",
+                poster = f"{self.main_url}/uploads/poster/{veri.get('cover')}" if veri.get('cover') else None,
+            )
+            for veri in veriler
+        ]
+
+    async def load_item(self, url: str) -> MovieInfo:
+        istek  = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+
+        raw_title = helper.select_text("div.page-title h1")
+        title = raw_title.replace(" izle", "").strip() if raw_title else "Bilinmiyor"
+        
+        poster = helper.select_attr("picture.poster-auto > source:nth-child(2)", "data-srcset")
+        description = helper.select_text("article.text-white")
+        year = helper.select_text("strong a")
+        
+        tags_raw = helper.select_all_text("div.pb-2")
+        tags = []
+        for tag_str in tags_raw:
+            if tag_str.startswith("Tür:"):
+                tags.extend([t.strip() for t in tag_str.replace("Tür:", "").split(",")])
+
+        rating = helper.select_text("div.rate")
+        
+        duration = None
+        duration_text = helper.select_text("div.d-flex.flex-column.text-nowrap")
+        if duration_text:
+            m = re.search(r"(\d+)", duration_text)
+            if m:
+                duration = int(m.group(1))
+
+        actors_raw = helper.select("div.card-body.p-0.pt-2 .story-item")
+        actors = []
+        for actor in actors_raw:
+            name = helper.select_text(".story-item-title", actor)
+            if name:
+                actors.append(name)
+        
+        return MovieInfo(
+            url         = url,
+            poster      = self.fix_url(poster),
+            title       = title,
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            year        = year,
+            actors      = actors if actors else None,
+            duration    = duration
+        )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek  = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+        
+        iframe = helper.select_first("div.card-video iframe")
+        if not iframe:
+            return []
+            
+        iframe_url = iframe.attrs.get("data-src") or iframe.attrs.get("src")
+        if not iframe_url:
+            return []
+            
+        if iframe_url.startswith("//"):
+            iframe_url = f"https:{iframe_url}"
+            
+        video_id = iframe_url.split("/")[-1]
+        master_url = f"https://eksenload.site/uploads/encode/{video_id}/master.m3u8"
+        
+        results = [
+            ExtractResult(
+                url     = master_url,
+                name    = f"{self.name} | 1080p",
+                referer = self.main_url
+            )
+        ]
+        
+        return results