KekikStream 2.2.7__tar.gz → 2.2.9__tar.gz

kekikstream-2.2.9/KekikStream/Extractors/CloseLoad.py

@@ -0,0 +1,77 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle
+from Kekik.Sifreleme   import Packer, StreamDecoder
+from selectolax.parser import HTMLParser
+import re, json
+
+class CloseLoadExtractor(ExtractorBase):
+    name     = "CloseLoad"
+    main_url = "https://closeload.filmmakinesi.to"
+
+    def _extract_from_json_ld(self, html: str) -> str | None:
+        """JSON-LD script tag'inden contentUrl'i çıkar (Kotlin versiyonundaki gibi)"""
+        secici = HTMLParser(html)
+        for script in secici.css("script[type='application/ld+json']"):
+            try:
+                data = json.loads(script.text(strip=True))
+                if content_url := data.get("contentUrl"):
+                    if content_url.startswith("http"):
+                        return content_url
+            except (json.JSONDecodeError, TypeError):
+                # Regex ile contentUrl'i çıkarmayı dene
+                match = re.search(r'"contentUrl"\s*:\s*"([^"]+)"', script.text())
+                if match and match.group(1).startswith("http"):
+                    return match.group(1)
+        return None
+
+    def _extract_from_packed(self, html: str) -> str | None:
+        """Packed JavaScript'ten video URL'sini çıkar (fallback)"""
+        try:
+            eval_func = re.compile(r'\s*(eval\(function[\s\S].*)').findall(html)
+            if eval_func:
+                return StreamDecoder.extract_stream_url(Packer.unpack(eval_func[0]))
+        except Exception:
+            pass
+        return None
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+        
+        self.httpx.headers.update({
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0",
+            "Origin": self.main_url
+        })
+
+        istek = await self.httpx.get(url)
+        istek.raise_for_status()
+
+        # Önce JSON-LD'den dene (daha güvenilir - Kotlin versiyonu gibi)
+        m3u_link = self._extract_from_json_ld(istek.text)
+        
+        # Fallback: Packed JavaScript'ten çıkar
+        if not m3u_link:
+            m3u_link = self._extract_from_packed(istek.text)
+
+        if not m3u_link:
+            raise Exception("Video URL bulunamadı (ne JSON-LD ne de packed script'ten)")
+
+        # Subtitle'ları parse et (Kotlin referansı: track elementleri)
+        subtitles = []
+        secici = HTMLParser(istek.text)
+        for track in secici.css("track"):
+            raw_src = track.attrs.get("src") or ""
+            raw_src = raw_src.strip()
+            label   = track.attrs.get("label") or track.attrs.get("srclang") or "Altyazı"
+            
+            if raw_src:
+                full_url = raw_src if raw_src.startswith("http") else f"{self.main_url}{raw_src}"
+                subtitles.append(Subtitle(name=label, url=full_url))
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = self.main_url,
+            subtitles = subtitles
+        )

{kekikstream-2.2.7 → kekikstream-2.2.9}/KekikStream/Extractors/Filemoon.py

@@ -22,13 +22,14 @@ class Filemoon(ExtractorBase):
         return any(domain in url for domain in self.supported_domains)
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
-        headers = {
-            "Referer"        : url,
-            "Sec-Fetch-Dest" : "iframe",
-            "Sec-Fetch-Mode" : "navigate",
-            "Sec-Fetch-Site" : "cross-site",
+        default_headers = {
+            "Referer"         : url,
+            "Sec-Fetch-Dest"  : "iframe",
+            "Sec-Fetch-Mode"  : "navigate",
+            "Sec-Fetch-Site"  : "cross-site",
+            "User-Agent"      : "Mozilla/5.0 (X11; Linux x86_64; rv:137.0) Gecko/20100101 Firefox/137.0"
         }
-        self.httpx.headers.update(headers)
+        self.httpx.headers.update(default_headers)
 
         # İlk sayfayı al
         istek    = await self.httpx.get(url)
@@ -38,31 +39,44 @@ class Filemoon(ExtractorBase):
         # Eğer iframe varsa, iframe'e git
         iframe_el = secici.css_first("iframe")
         iframe_src = iframe_el.attrs.get("src") if iframe_el else None
-        if iframe_src:
-            iframe_url = self.fix_url(iframe_src)
-            self.httpx.headers.update({
-                "Accept-Language" : "en-US,en;q=0.5",
-                "Sec-Fetch-Dest"  : "iframe"
-            })
-            istek    = await self.httpx.get(iframe_url)
-            response = istek.text
-
-        # Packed script'i bul ve unpack et
+        
         m3u8_url = None
-
-        if Packer.detect_packed(response):
-            try:
-                unpacked = Packer.unpack(response)
-                # sources:[{file:"...» pattern'ını ara
-                if match := re.search(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"', unpacked):
+        
+        if not iframe_src:
+            # Fallback: Script içinde ara (Kotlin: selectFirst("script:containsData(function(p,a,c,k,e,d))"))
+            script_data = ""
+            for script in secici.css("script"):
+                if "function(p,a,c,k,e,d)" in script.text():
+                    script_data = script.text()
+                    break
+            
+            if script_data:
+                unpacked = Packer.unpack(script_data)
+                if match := re.search(r'sources:\[\{file:"(.*?)"', unpacked):
                     m3u8_url = match.group(1)
-                elif match := re.search(r'file:\s*"([^"]*?\.m3u8[^"]*)"', unpacked):
+        else:
+            # Iframe varsa devam et
+            iframe_url = self.fix_url(iframe_src)
+            iframe_headers = default_headers.copy()
+            iframe_headers["Accept-Language"] = "en-US,en;q=0.5"
+            
+            istek    = await self.httpx.get(iframe_url, headers=iframe_headers)
+            response = istek.text
+            secici   = HTMLParser(response)
+            
+            script_data = ""
+            for script in secici.css("script"):
+                if "function(p,a,c,k,e,d)" in script.text():
+                    script_data = script.text()
+                    break
+            
+            if script_data:
+                unpacked = Packer.unpack(script_data)
+                if match := re.search(r'sources:\[\{file:"(.*?)"', unpacked):
                     m3u8_url = match.group(1)
-            except Exception:
-                pass
 
-        # Fallback: Doğrudan response'ta ara
         if not m3u8_url:
+            # Son çare: Normal response içinde ara
             if match := re.search(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"', response):
                 m3u8_url = match.group(1)
             elif match := re.search(r'file:\s*"([^"]*?\.m3u8[^"]*)"', response):
@@ -75,5 +89,6 @@ class Filemoon(ExtractorBase):
             name      = self.name,
             url       = self.fix_url(m3u8_url),
             referer   = f"{self.main_url}/",
+            user_agent = default_headers["User-Agent"],
             subtitles = []
         )

{kekikstream-2.2.7 → kekikstream-2.2.9}/KekikStream/Plugins/Dizilla.py

@@ -142,44 +142,70 @@ class Dizilla(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLParser(istek.text)
 
-        # application/ld+json script'lerini al
-        ld_json_scripts = secici.css("script[type='application/ld+json']")
-        if not ld_json_scripts:
+        title = secici.css_first("div.poster.poster h2")
+        title = title.text(strip=True) if title else None
+        if not title:
             return None
 
-        # Son script'i al
-        last_script = ld_json_scripts[-1]
-        veri = loads(last_script.text(strip=True))
+        poster_el = secici.css_first("div.w-full.page-top.relative img")
+        poster = self.fix_url(poster_el.attrs.get("src")) if poster_el else None
 
-        title = veri.get("name")
-        if alt_title := veri.get("alternateName"):
-            title += f" - ({alt_title})"
+        # Year extraction (Kotlin: [1] index for w-fit min-w-fit)
+        info_boxes = secici.css("div.w-fit.min-w-fit")
+        year = None
+        if len(info_boxes) > 1:
+            year_el = info_boxes[1].css_first("span.text-sm.opacity-60")
+            if year_el:
+                year_text = year_el.text(strip=True)
+                year = year_text.split(" ")[-1] if " " in year_text else year_text
+
+        description_el = secici.css_first("div.mt-2.text-sm")
+        description = description_el.text(strip=True) if description_el else None
 
-        poster      = self.fix_url(veri.get("image"))
-        description = veri.get("description")
-        year        = veri.get("datePublished").split("-")[0]
-        
-        # Tags extraction from page content (h3 tag)
         tags_el = secici.css_first("div.poster.poster h3")
-        tags_raw = tags_el.text(strip=True) if tags_el else ""
-        tags     = [t.strip() for t in tags_raw.split(",")] if tags_raw else []
-
-        rating = veri.get("aggregateRating", {}).get("ratingValue")
-        actors = [actor.get("name") for actor in veri.get("actor", []) if actor.get("name")]
-
-        bolumler = []
-        sezonlar = veri.get("containsSeason") if isinstance(veri.get("containsSeason"), list) else [veri.get("containsSeason")]
-        for sezon in sezonlar:
-            episodes = sezon.get("episode")
-            if isinstance(episodes, dict):
-                episodes = [episodes]
+        tags = [t.strip() for t in tags_el.text(strip=True).split(",")] if tags_el else []
+
+        actors = [h5.text(strip=True) for h5 in secici.css("div.global-box h5")]
+
+        episodeses = []
+        # Seasons links iteration
+        season_links = secici.css("div.flex.items-center.flex-wrap.gap-2.mb-4 a")
+        for sezon in season_links:
+            sezon_href = self.fix_url(sezon.attrs.get("href"))
+            sezon_req = await self.httpx.get(sezon_href)
             
-            for bolum in episodes:
-                bolumler.append(Episode(
-                    season  = sezon.get("seasonNumber"),
-                    episode = bolum.get("episodeNumber"),
-                    title   = bolum.get("name"),
-                    url     = await self.url_base_degis(bolum.get("url"), self.main_url),
+            season_num = None
+            try:
+                # URL'den sezon numarasını çek: ...-sezon-X
+                season_match = re.search(r"sezon-(\d+)", sezon_href)
+                if season_match:
+                    season_num = int(season_match.group(1))
+            except:
+                pass
+
+            sezon_secici = HTMLParser(sezon_req.text)
+            for bolum in sezon_secici.css("div.episodes div.cursor-pointer"):
+                # Kotlin: bolum.select("a").last()
+                links = bolum.css("a")
+                if not links:
+                    continue
+                
+                ep_link = links[-1]
+                ep_name = ep_link.text(strip=True)
+                ep_href = self.fix_url(ep_link.attrs.get("href"))
+                
+                # Episode number (first link's text usually)
+                ep_num = None
+                try:
+                    ep_num = int(links[0].text(strip=True))
+                except:
+                    pass
+
+                episodeses.append(Episode(
+                    season  = season_num,
+                    episode = ep_num,
+                    title   = ep_name,
+                    url     = ep_href
                 ))
 
         return SeriesInfo(
@@ -188,9 +214,8 @@ class Dizilla(PluginBase):
             title       = title,
             description = description,
             tags        = tags,
-            rating      = rating,
-            year        = year,
-            episodes    = bolumler,
+            year        = str(year) if year else None,
+            episodes    = episodeses,
             actors      = actors
         )
 
@@ -212,7 +237,7 @@ class Dizilla(PluginBase):
 
         # Get first source (matching Kotlin)
         first_result = results[0]
-        source_content = first_result.get("source_content", "")
+        source_content = str(first_result.get("source_content", ""))
         
         # Clean the source_content string (matching Kotlin: .replace("\"", "").replace("\\", ""))
         cleaned_source = source_content.replace('"', '').replace('\\', '')
@@ -220,10 +245,12 @@ class Dizilla(PluginBase):
         # Parse cleaned HTML
         iframe_el = HTMLParser(cleaned_source).css_first("iframe")
         iframe_src = iframe_el.attrs.get("src") if iframe_el else None
+        
+        # Referer check (matching Kotlin: loadExtractor(iframe, "${mainUrl}/", ...))
         iframe_url = self.fix_url(iframe_src) if iframe_src else None
         
         if not iframe_url:
             return []
 
-        data = await self.extract(iframe_url, prefix=first_result.get('language_name', 'Unknown'))
+        data = await self.extract(iframe_url, referer=f"{self.main_url}/", prefix=first_result.get('language_name', 'Unknown'))
         return [data] if data else []

{kekikstream-2.2.7 → kekikstream-2.2.9}/KekikStream/Plugins/HDFilmCehennemi.py

@@ -205,30 +205,23 @@ class HDFilmCehennemi(PluginBase):
 
         return results
 
-    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.extract_stream_url(unpacked)
+    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:
+            try:
+                import json
+                data = json.loads(json_ld_match.group(1).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)
+        return None
 
     async def invoke_local_source(self, iframe: str, source: str, url: str):
         self.httpx.headers.update({
@@ -240,18 +233,21 @@ class HDFilmCehennemi(PluginBase):
         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])
+        # Önce JSON-LD'den dene (Kotlin versiyonu gibi - daha güvenilir)
+        video_url = self._extract_from_json_ld(istek.text)
 
-        try:
-            unpacked = Packer.unpack(eval_match.group(1))
-        except Exception:
-            return await self.cehennempass(iframe.split("/")[-1])
-
-        # HDFilmCehennemi özel decoder ile video URL'sini çıkar
-        video_url = self.extract_hdch_url(unpacked)
+        # 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:
+                return await self.cehennempass(iframe.split("/")[-1])
+
+            try:
+                unpacked = Packer.unpack(eval_match.group(1))
+                video_url = StreamDecoder.extract_stream_url(unpacked)
+            except Exception:
+                return await self.cehennempass(iframe.split("/")[-1])
         
         if not video_url:
             return await self.cehennempass(iframe.split("/")[-1])

{kekikstream-2.2.7 → kekikstream-2.2.9}/KekikStream/Plugins/SetFilmIzle.py

@@ -2,7 +2,7 @@
 
 from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult
 from selectolax.parser import HTMLParser
-import re, json
+import re, json, asyncio
 
 class SetFilmIzle(PluginBase):
     name        = "SetFilmIzle"
@@ -229,7 +229,7 @@ class SetFilmIzle(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLParser(istek.text)
 
-        nonce = self._get_nonce("video_nonce", referer=url)
+        nonce = secici.css_first("div#playex").attrs.get("data-nonce") if secici.css_first("div#playex") else ""
 
         # partKey to dil label mapping
         part_key_labels = {
@@ -238,46 +238,49 @@ class SetFilmIzle(PluginBase):
             "orijinal"      : "Orijinal"
         }
 
-        links = []
+        semaphore = asyncio.Semaphore(5)
+        tasks = []
+
+        async def fetch_and_extract(player):
+            async with semaphore:
+                source_id   = player.attrs.get("data-post-id")
+                player_name = player.attrs.get("data-player-name")
+                part_key    = player.attrs.get("data-part-key")
+
+                if not source_id or "event" in source_id or source_id == "":
+                    return None
+
+                try:
+                    resp = self.cloudscraper.post(
+                        f"{self.main_url}/wp-admin/admin-ajax.php",
+                        headers = {"Referer": url},
+                        data    = {
+                            "action"      : "get_video_url",
+                            "nonce"       : nonce,
+                            "post_id"     : source_id,
+                            "player_name" : player_name or "",
+                            "part_key"    : part_key or ""
+                        }
+                    )
+                    data = resp.json()
+                except:
+                    return None
+
+                iframe_url = data.get("data", {}).get("url")
+                if not iframe_url:
+                    return None
+
+                if "setplay" not in iframe_url and part_key:
+                    iframe_url = f"{iframe_url}?partKey={part_key}"
+
+                label = part_key_labels.get(part_key, "")
+                if not label and part_key:
+                    label = part_key.replace("_", " ").title()
+
+                return await self.extract(iframe_url, prefix=label if label else None)
+
         for player in secici.css("nav.player a"):
-            source_id   = player.attrs.get("data-post-id")
-            player_name = player.attrs.get("data-player-name")
-            part_key    = player.attrs.get("data-part-key")
-
-            if not source_id or "event" in source_id or source_id == "":
-                continue
-
-            try:
-                resp = self.cloudscraper.post(
-                    f"{self.main_url}/wp-admin/admin-ajax.php",
-                    headers = {"Referer": url},
-                    data    = {
-                        "action"      : "get_video_url",
-                        "nonce"       : nonce,
-                        "post_id"     : source_id,
-                        "player_name" : player_name or "",
-                        "part_key"    : part_key or ""
-                    }
-                )
-                data = resp.json()
-            except:
-                continue
-
-            iframe_url = data.get("data", {}).get("url")
-            if not iframe_url:
-                continue
-
-            # SetPlay URL'si için part_key ekleme
-            if "setplay" not in iframe_url and part_key:
-                iframe_url = f"{iframe_url}?partKey={part_key}"
-
-            # Dil etiketi oluştur
-            label = part_key_labels.get(part_key, "")
-            if not label and part_key:
-                label = part_key.replace("_", " ").title()
-
-            data = await self.extract(iframe_url, prefix=label if label else None)
-            if data:
-                links.append(data)
-
-        return links
+            tasks.append(fetch_and_extract(player))
+
+        results = await asyncio.gather(*tasks)
+        return [r for r in results if r]

{kekikstream-2.2.7 → kekikstream-2.2.9}/KekikStream/Plugins/SezonlukDizi.py

@@ -2,7 +2,7 @@
 
 from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult
 from selectolax.parser import HTMLParser
-import re
+import re, asyncio
 
 class SezonlukDizi(PluginBase):
     name        = "SezonlukDizi"
@@ -39,6 +39,16 @@ class SezonlukDizi(PluginBase):
         f"{main_url}/diziler.asp?siralama_tipi=id&tur=western&s="    : "Western"
     }
 
+    async def _get_asp_data(self) -> dict:
+        js_req = await self.httpx.get(f"{self.main_url}/js/site.min.js")
+        alt_match   = re.search(r"dataAlternatif(.*?)\.asp", js_req.text)
+        embed_match = re.search(r"dataEmbed(.*?)\.asp", js_req.text)
+        
+        return {
+            "alternatif": alt_match.group(1) if alt_match else "",
+            "embed":      embed_match.group(1) if embed_match else ""
+        }
+
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(f"{url}{page}")
         secici = HTMLParser(istek.text)
@@ -67,7 +77,7 @@ class SezonlukDizi(PluginBase):
         secici = HTMLParser(istek.text)
 
         results = []
-        for afis in secici.css("div.afis a.column"):
+        for afis in secici.css("div.afis a"):
             desc_el = afis.css_first("div.description")
             img_el  = afis.css_first("img")
 
@@ -169,64 +179,54 @@ class SezonlukDizi(PluginBase):
             actors      = actors
         )
 
-    async def get_asp_data(self) -> tuple[str, str]:
-        """Fetch dynamic ASP version numbers from site.min.js"""
-        try:
-            js_content = await self.httpx.get(f"{self.main_url}/js/site.min.js")
-            alternatif_match = re.search(r'dataAlternatif(.*?)\.asp', js_content.text)
-            embed_match = re.search(r'dataEmbed(.*?)\.asp', js_content.text)
-            
-            alternatif_ver = alternatif_match.group(1) if alternatif_match else "22"
-            embed_ver = embed_match.group(1) if embed_match else "22"
-            
-            return (alternatif_ver, embed_ver)
-        except Exception:
-            return ("22", "22")  # Fallback to default versions
-
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek  = await self.httpx.get(url)
         secici = HTMLParser(istek.text)
-
-        dilsec_el = secici.css_first("div#dilsec")
-        bid = dilsec_el.attrs.get("data-id") if dilsec_el else None
+        asp_data = await self._get_asp_data()
+        
+        bid = secici.css_first("div#dilsec").attrs.get("data-id") if secici.css_first("div#dilsec") else None
         if not bid:
             return []
 
-        # Get dynamic ASP versions
-        alternatif_ver, embed_ver = await self.get_asp_data()
+        semaphore = asyncio.Semaphore(5)
+        tasks = []
 
-        results = []
-        for dil, label in [("1", "Altyazı"), ("0", "Dublaj")]:
-            dil_istek = await self.httpx.post(
-                url     = f"{self.main_url}/ajax/dataAlternatif{alternatif_ver}.asp",
+        async def fetch_and_extract(veri, dil_etiketi):
+            async with semaphore:
+                try:
+                    embed_resp = await self.httpx.post(
+                        f"{self.main_url}/ajax/dataEmbed{asp_data['embed']}.asp",
+                        headers = {"X-Requested-With": "XMLHttpRequest"},
+                        data    = {"id": str(veri.get("id"))}
+                    )
+                    embed_secici = HTMLParser(embed_resp.text)
+                    iframe_el = embed_secici.css_first("iframe")
+                    iframe_src = iframe_el.attrs.get("src") if iframe_el else None
+                    
+                    if iframe_src:
+                        if "link.asp" in iframe_src:
+                            return None
+                            
+                        iframe_url = self.fix_url(iframe_src)
+                        return await self.extract(iframe_url, referer=f"{self.main_url}/", prefix=f"{dil_etiketi} - {veri.get('baslik')}")
+                except:
+                    pass
+                return None
+
+        for dil_kodu, dil_etiketi in [("1", "Altyazı"), ("0", "Dublaj")]:
+            altyazi_resp = await self.httpx.post(
+                f"{self.main_url}/ajax/dataAlternatif{asp_data['alternatif']}.asp",
                 headers = {"X-Requested-With": "XMLHttpRequest"},
-                data    = {"bid": bid, "dil": dil},
+                data    = {"bid": bid, "dil": dil_kodu}
             )
-
+            
             try:
-                dil_json = dil_istek.json()
-            except Exception:
+                data_json = altyazi_resp.json()
+                if data_json.get("status") == "success" and data_json.get("data"):
+                    for veri in data_json["data"]:
+                        tasks.append(fetch_and_extract(veri, dil_etiketi))
+            except:
                 continue
 
-            if dil_json.get("status") == "success":
-                for idx, veri in enumerate(dil_json.get("data", [])):
-                    veri_response = await self.httpx.post(
-                        url     = f"{self.main_url}/ajax/dataEmbed{embed_ver}.asp",
-                        headers = {"X-Requested-With": "XMLHttpRequest"},
-                        data    = {"id": veri.get("id")},
-                    )
-                    veri_secici = HTMLParser(veri_response.text)
-
-                    iframe_el = veri_secici.css_first("iframe")
-                    iframe = iframe_el.attrs.get("src") if iframe_el else None
-
-                    if iframe:
-                        if "link.asp" in iframe:
-                            continue
-                            
-                        iframe_url = self.fix_url(iframe)
-                        data = await self.extract(iframe_url, prefix=label)
-                        if data:
-                            results.append(data)
-
-        return results
+        results = await asyncio.gather(*tasks)
+        return [r for r in results if r]

{kekikstream-2.2.7 → kekikstream-2.2.9}/KekikStream.egg-info/PKG-INFO

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

{kekikstream-2.2.7 → kekikstream-2.2.9}/PKG-INFO

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

{kekikstream-2.2.7 → kekikstream-2.2.9}/setup.py

@@ -6,7 +6,7 @@ from io         import open
 setup(
     # ? Genel Bilgiler
     name         = "KekikStream",
-    version      = "2.2.7",
+    version      = "2.2.9",
     url          = "https://github.com/keyiflerolsun/KekikStream",
     description  = "terminal üzerinden medya içeriği aramanızı ve VLC/MPV gibi popüler medya oynatıcılar aracılığıyla doğrudan izlemenizi sağlayan modüler ve genişletilebilir bir bıdı bıdı",
     keywords     = ["KekikStream", "KekikAkademi", "keyiflerolsun"],

kekikstream-2.2.7/KekikStream/Extractors/CloseLoad.py

@@ -1,40 +0,0 @@
-# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
-
-from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle
-from Kekik.Sifreleme   import Packer, StreamDecoder
-from selectolax.parser import HTMLParser
-import re
-
-class CloseLoadExtractor(ExtractorBase):
-    name     = "CloseLoad"
-    main_url = "https://closeload.filmmakinesi.to"
-
-    async def extract(self, url, referer=None) -> ExtractResult:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
-
-        # Video URL'sini çıkar
-        eval_func = re.compile(r'\s*(eval\(function[\s\S].*)').findall(istek.text)[0]
-        m3u_link  = StreamDecoder.extract_stream_url(Packer.unpack(eval_func))
-
-        # Subtitle'ları parse et (Kotlin referansı: track elementleri)
-        subtitles = []
-        secici = HTMLParser(istek.text)
-        for track in secici.css("track"):
-            raw_src = track.attrs.get("src") or ""
-            raw_src = raw_src.strip()
-            label   = track.attrs.get("label") or track.attrs.get("srclang") or "Altyazı"
-            
-            if raw_src:
-                full_url = raw_src if raw_src.startswith("http") else f"{self.main_url}{raw_src}"
-                subtitles.append(Subtitle(name=label, url=full_url))
-
-        return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = self.main_url,
-            subtitles = subtitles
-        )