KekikStream 2.2.9__py3-none-any.whl → 2.5.3__py3-none-any.whl

KekikStream/Extractors/VidPapi.py

@@ -1,89 +1,57 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
-import re
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+
 
 class VidPapi(ExtractorBase):
-    name     = "VidApi"
+    name     = "VidPapi"
     main_url = "https://vidpapi.xyz"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        ext_ref = referer or ""
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        ref = referer or self.main_url
         
-        # URL parsing
+        # ID tespiti
         if "video/" in url:
             vid_id = url.split("video/")[-1]
         else:
             vid_id = url.split("?data=")[-1]
             
-        # 1. Altyazıları çek
-        sub_url = f"{self.main_url}/player/index.php?data={vid_id}"
-        sub_headers = {
+        headers = {
             "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
             "X-Requested-With" : "XMLHttpRequest",
-            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0",
-            "Referer"          : ext_ref or "https://kultfilmler.pro/"
+            "Referer"          : ref
         }
         
+        # 1. Altyazıları çek
         subtitles = []
         try:
-            sub_istek = await self.httpx.post(
-                url     = sub_url,
-                headers = sub_headers,
-                data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+            sub_resp = await self.httpx.post(
+                f"{self.main_url}/player/index.php?data={vid_id}",
+                headers = headers,
+                data    = {"hash": vid_id, "r": ref}
             )
-            
-            subtitle_match = re.search(r'var playerjsSubtitle = "([^"]*)"', sub_istek.text, re.IGNORECASE)
-            if subtitle_match and subtitle_match.group(1):
-                raw_subs = subtitle_match.group(1)
-                
-                found_subs = re.findall(r'\[(.*?)\](.*?)(?:,|$)', raw_subs)
-                for lang, sub_link in found_subs:
-                    lang = lang.strip()
-                    if "Türkçe" in lang:
-                        lang_code = "tr"
-                        lang_name = "Turkish"
-                    elif "İngilizce" in lang:
-                        lang_code = "en"
-                        lang_name = "English"
-                    else:
-                        lang_code = lang[:2].lower()
-                        lang_name = lang
-                        
-                    subtitles.append(Subtitle(
-                        name = lang_name,
-                        url  = sub_link.strip()
-                    ))
-                    
-        except Exception as e:
+            sel = HTMLHelper(sub_resp.text)
+            if raw_subs := sel.regex_first(r'var playerjsSubtitle\s*=\s*"([^"]*)"'):
+                for lang, link in HTMLHelper(raw_subs).regex_all(r'\[(.*?)\](https?://[^\s\",]+)'):
+                    subtitles.append(Subtitle(name=lang.strip(), url=link.strip()))
+        except:
             pass
 
         # 2. Videoyu çek
-        video_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
-        video_headers = sub_headers.copy()
-        
-        response = await self.httpx.post(
-            url     = video_url,
-            headers = video_headers,
-            data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+        resp = await self.httpx.post(
+            f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo",
+            headers = headers,
+            data    = {"hash": vid_id, "r": ref}
         )
-        response.raise_for_status()
-        
-        try:
-            video_data = response.json()
-        except Exception:
-            return None
+        data = resp.json()
 
-        stream_url = video_data.get("securedLink")
-        if not stream_url or not stream_url.strip():
-            stream_url = video_data.get("videoSource")
-            
+        stream_url = data.get("securedLink") or data.get("videoSource")
         if not stream_url:
-            raise ValueError("No video link found in VidPapi response")
+            raise ValueError(f"VidPapi: Video URL bulunamadı. {url}")
 
         return ExtractResult(
             name      = self.name,
             url       = stream_url,
-            referer   = ext_ref or self.main_url,
+            referer   = ref,
             subtitles = subtitles
         )

KekikStream/Extractors/VideoSeyred.py

@@ -1,53 +1,32 @@
-# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
-import json, re
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+import json
 
 class VideoSeyred(ExtractorBase):
     name     = "VideoSeyred"
     main_url = "https://videoseyred.in"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
+    async def extract(self, url: str, referer: str = None) -> list[ExtractResult] | ExtractResult:
+        v_id = url.split("embed/")[1].split("?")[0]
+        if len(v_id) > 10:
+            resp = await self.httpx.get(url)
+            v_id = HTMLHelper(resp.text).regex_first(r"playlist\/(.*)\.json")
 
-        video_id  = url.split("embed/")[1].split("?")[0]
-        if len(video_id) > 10:
-            kontrol = await self.httpx.get(url)
-            kontrol.raise_for_status()
-
-            video_id = re.search(r"playlist\/(.*)\.json", kontrol.text)[1]
-
-        video_url = f"{self.main_url}/playlist/{video_id}.json"
-
-        response = await self.httpx.get(video_url)
-        response.raise_for_status()
-
-        try:
-            if response_list := json.loads(response.text):
-                response_data = response_list[0]
-            else:
-                raise ValueError("Empty response from VideoSeyred.")
-
-        except (json.JSONDecodeError, IndexError) as hata:
-            raise RuntimeError(f"Failed to parse response: {hata}") from hata
+        json_resp = await self.httpx.get(f"{self.main_url}/playlist/{v_id}.json")
+        data = json_resp.json()[0]
 
         subtitles = [
-            Subtitle(name=track["label"], url=self.fix_url(track["file"]))
-                for track in response_data.get("tracks", [])
-                    if track.get("kind") == "captions" and track.get("label")
+            Subtitle(name=t["label"], url=self.fix_url(t["file"]))
+            for t in data.get("tracks", []) if t.get("kind") == "captions"
+        ]
+
+        results = [
+            ExtractResult(name=self.name, url=self.fix_url(s["file"]), referer=self.main_url, subtitles=subtitles)
+            for s in data.get("sources", [])
         ]
 
-        if video_links := [
-            ExtractResult(
-                name      = self.name,
-                url       = self.fix_url(source["file"]),
-                referer   = self.main_url,
-                subtitles = subtitles,
-            )
-                for source in response_data.get("sources", [])
-        ]:
-            # En yüksek kaliteli videoyu döndür (varsayılan olarak ilk video)
-            return video_links[0] if len(video_links) == 1 else video_links
-        else:
-            raise ValueError("No video links found in the response.")
+        if not results:
+            raise ValueError(f"VideoSeyred: Video bulunamadı. {url}")
+
+        return results[0] if len(results) == 1 else results

KekikStream/Extractors/Videostr.py

@@ -0,0 +1,58 @@
+# 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
+import re
+
+class Videostr(ExtractorBase):
+    name     = "Videostr"
+    main_url = "https://videostr.net"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        v_id = url.split("?")[0].split("/")[-1]
+        headers = {"Referer": self.main_url, "X-Requested-With": "XMLHttpRequest"}
+        
+        resp = await self.httpx.get(url, headers=headers)
+        sel  = HTMLHelper(resp.text)
+
+        # Nonce Bulma
+        nonce = sel.regex_first(r"\b[a-zA-Z0-9]{48}\b")
+        if not nonce:
+            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", resp.text, re.DOTALL)
+            if m: nonce = m.group(1) + m.group(2) + m.group(3)
+
+        if not nonce:
+            raise ValueError(f"Videostr: Nonce bulunamadı. {url}")
+
+        # Kaynakları Çek
+        api_resp = await self.httpx.get(f"{self.main_url}/embed-1/v3/e-1/getSources?id={v_id}&_k={nonce}", headers=headers)
+        data = api_resp.json()
+        
+        enc_file = data.get("sources", [{}])[0].get("file")
+        if not enc_file:
+            raise ValueError("Videostr: Kaynak bulunamadı.")
+
+        m3u8_url = None
+        if ".m3u8" in enc_file:
+            m3u8_url = enc_file
+        else:
+            # Decryption Flow (External Keys)
+            with contextlib.suppress(Exception):
+                key_resp = await self.httpx.get("https://raw.githubusercontent.com/yogesh-hacker/MegacloudKeys/refs/heads/main/keys.json")
+                v_key = key_resp.json().get("vidstr")
+                if v_key:
+                    decode_api = "https://script.google.com/macros/s/AKfycbxHbYHbrGMXYD2-bC-C43D3njIbU-wGiYQuJL61H4vyy6YVXkybMNNEPJNPPuZrD1gRVA/exec"
+                    dec_resp = await self.httpx.get(f"{decode_api}?encrypted_data={quote(enc_file)}&nonce={quote(nonce)}&secret={quote(v_key)}")
+                    m3u8_url = re.search(r'"file":"(.*?)"', dec_resp.text).group(1).replace("\\/", "/")
+
+        if not m3u8_url:
+            raise ValueError(f"Videostr: Video URL bulunamadı. {url}")
+
+        subtitles = [
+            Subtitle(name=t.get("label", "Altyazı"), url=t.get("file"))
+            for t in data.get("tracks", []) if t.get("kind") in ["captions", "subtitles"]
+        ]
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=f"{self.main_url}/", subtitles=subtitles)
+
+import contextlib

KekikStream/Extractors/Vidoza.py

@@ -0,0 +1,18 @@
+# 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:
+        self.httpx.headers.update({"Referer": referer or url})
+
+        resp = await self.httpx.get(url)
+        v_url = HTMLHelper(resp.text).select_attr("source", "src")
+        
+        if not v_url:
+            raise ValueError(f"Vidoza: Video bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=v_url, referer=url)

KekikStream/Extractors/Vtbe.py

@@ -0,0 +1,38 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+from Kekik.Sifreleme  import Packer
+
+class Vtbe(ExtractorBase):
+    name     = "Vtbe"
+    main_url = "https://vtbe.to"
+
+    async def extract(self, url: str, referer: str = None) -> list[ExtractResult]:
+        # Iframe ise embed url'i düzeltmek gerekebilir ama genelde embed-xxxx.html formatı
+        istek = await self.httpx.get(url, headers={"Referer": referer or self.main_url})
+        text  = istek.text
+
+        # Packed script bul: function(p,a,c,k,e,d)
+        packed = HTMLHelper(text).regex_first(r'(eval\s*\(\s*function[\s\S]+?)<\/script>')
+
+        if not packed:
+            raise ValueError(f"Vtbe: Packed script bulunamadı. {url}")
+
+        unpacked = ""
+        try:
+            unpacked = Packer.unpack(packed)
+        except:
+             raise ValueError("Vtbe: Unpack hatası")
+
+        # sources:[{file:"..."
+        file_url = HTMLHelper(unpacked).regex_first(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"')
+
+        if not file_url:
+            raise ValueError("Vtbe: Video URL (file) bulunamadı")
+
+        return ExtractResult(
+            name       = self.name,
+            url        = self.fix_url(file_url),
+            referer    = url,
+            user_agent = self.httpx.headers.get("User-Agent", "")
+        )

KekikStream/Extractors/YTDLP.py

@@ -151,8 +151,8 @@ class YTDLP(ExtractorBase):
         ydl_opts = {
             "quiet"                 : True,
             "no_warnings"           : True,
-            "extract_flat"          : False,   # Tam bilgi al
-            "format"                : "best",  # En iyi kalite
+            "extract_flat"          : False,       # Tam bilgi al
+            "format"                : "best/all",  # En iyi kalite, yoksa herhangi biri
             "no_check_certificates" : True,
             "socket_timeout"        : 3,
             "retries"               : 1

KekikStream/Extractors/YildizKisaFilm.py

@@ -6,36 +6,18 @@ class YildizKisaFilm(ExtractorBase):
     name     = "YildizKisaFilm"
     main_url = "https://yildizkisafilm.org"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        ext_ref = referer or ""
-
-        if "video/" in url:
-            vid_id = url.split("video/")[-1]
-        else:
-            vid_id = url.split("?data=")[-1]
-
-        post_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
-
-        response = await self.httpx.post(
-            url     = post_url,
-            data    = {"hash": vid_id, "r": ext_ref},
-            headers = {
-                "Referer"          : ext_ref,
-                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
-                "X-Requested-With" : "XMLHttpRequest"
-            }
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        ref = referer or self.main_url
+        v_id = url.split("video/")[-1] if "video/" in url else url.split("?data=")[-1]
+
+        resp = await self.httpx.post(
+            f"{self.main_url}/player/index.php?data={v_id}&do=getVideo",
+            data    = {"hash": v_id, "r": ref},
+            headers = {"Referer": ref, "X-Requested-With": "XMLHttpRequest"}
         )
-        response.raise_for_status()
+        
+        m3u8_url = resp.json().get("securedLink")
+        if not m3u8_url:
+            raise ValueError(f"YildizKisaFilm: Video URL bulunamadı. {url}")
 
-        video_data = response.json()
-        m3u_link   = video_data.get("securedLink")
-
-        if not m3u_link:
-            raise ValueError("securedLink not found in response")
-
-        return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = ext_ref,
-            subtitles = []
-        )
+        return ExtractResult(name=self.name, url=m3u8_url, referer=ref)

KekikStream/Extractors/Zeus.py

@@ -0,0 +1,61 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+
+class Zeus(ExtractorBase):
+    name     = "Zeus"
+    main_url = "https://d2rs.com"
+
+    async def extract(self, url: str, referer: str = None) -> list[ExtractResult]:
+        # Iframe içeriğini al
+        istek = await self.httpx.get(url, headers={"Referer": referer} if referer else None)
+        text  = istek.text
+
+        # 'q' parametresini bul
+        # form.append("q", "...")
+        q_param = HTMLHelper(text).regex_first(r'form\.append\("q",\s*"([^"]+)"\)')
+
+        if not q_param:
+            raise ValueError(f"Zeus: 'q' parametresi bulunamadı. {url}")
+
+        # API'ye POST at
+        resp = await self.httpx.post(
+            url     = "https://d2rs.com/zeus/api.php", 
+            data    = {"q": q_param}, 
+            headers = {"Referer": url}
+        )
+
+        try:
+            sources = resp.json()
+        except:
+             raise ValueError("Zeus: API yanıtı geçersiz JSON")
+
+        results = []
+        # [{"file": "...", "label": "Full HD", "type": "video/mp4"}, ...]
+        for i, source in enumerate(sources, 1):
+            file_path = source.get("file")
+            label     = source.get("label") or ""
+            type_     = source.get("type", "")
+
+            if not file_path:
+                continue
+
+            full_url = f"https://d2rs.com/zeus/{file_path}"
+
+            # İsimlendirme
+            if label:
+                source_name = f"{self.name} | {label}"
+            else:
+                source_name = f"{self.name} | Kaynak {i}"
+
+            results.append(ExtractResult(
+                name       = source_name,
+                url        = self.fix_url(full_url),
+                referer    = url,
+                user_agent = self.httpx.headers.get("User-Agent", "")
+            ))
+
+        if not results:
+            raise ValueError("Zeus: Kaynak bulunamadı")
+
+        return results