KekikStream 2.5.7__py3-none-any.whl → 2.5.9__py3-none-any.whl

KekikStream/Extractors/HotStream.py

@@ -1,7 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
-from Kekik.Sifreleme import AESManager
+from Kekik.Sifreleme  import AESManager
 import contextlib
 
 class HotStream(ExtractorBase):
@@ -24,4 +24,9 @@ class HotStream(ExtractorBase):
         if not m3u8_url:
             raise ValueError(f"HotStream: Video linki bulunamadı. {url}")
 
-        return ExtractResult(name=self.name, url=self.fix_url(m3u8_url), referer=url)
+        return ExtractResult(
+            name       = self.name,
+            url        = self.fix_url(m3u8_url),
+            referer    = url,
+            user_agent = self.httpx.headers.get("User-Agent")
+        )

KekikStream/Extractors/StreamWish.py

@@ -0,0 +1,80 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+from Kekik.Sifreleme  import Packer
+from contextlib       import suppress
+
+class StreamWish(ExtractorBase):
+    name     = "StreamWish"
+    main_url = "https://streamwish.to"
+
+    supported_domains = [
+        "streamwish.to", "streamwish.site", "streamwish.xyz", "streamwish.com",
+        "embedwish.com", "mwish.pro", "dwish.pro", "wishembed.pro", "wishembed.com",
+        "kswplayer.info", "wishfast.top", "sfastwish.com", "strwish.xyz", "strwish.com",
+        "flaswish.com", "awish.pro", "obeywish.com", "jodwish.com", "swhoi.com",
+        "multimovies.cloud", "uqloads.xyz", "doodporn.xyz", "cdnwish.com", "asnwish.com",
+        "nekowish.my.id", "neko-stream.click", "swdyu.com", "wishonly.site", "playerwish.com",
+        "streamhls.to", "hlswish.com"
+    ]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
+    def resolve_embed_url(self, url: str) -> str:
+        # Kotlin: /f/ -> /, /e/ -> /
+        if "/f/" in url:
+            return url.replace("/f/", "/")
+        if "/e/" in url:
+            return url.replace("/e/", "/")
+        return url
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        base_url  = self.get_base_url(url)
+        embed_url = self.resolve_embed_url(url)
+        istek = await self.httpx.get(
+            url     = embed_url,
+            headers = {
+                "Accept"     : "*/*",
+                "Connection" : "keep-alive",
+                "Referer"    : f"{base_url}/",
+                "Origin"     : f"{base_url}/",
+                "User-Agent" : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+            },
+            follow_redirects=True
+        )
+        text = istek.text
+
+        unpacked = ""
+        # Eval script bul
+        if eval_match := HTMLHelper(text).regex_first(r'(eval\s*\(\s*function[\s\S]+?)<\/script>'):
+            with suppress(Exception):
+                unpacked = Packer.unpack(eval_match)
+
+        content = unpacked or text
+        sel = HTMLHelper(content)
+
+        # Regex: file:\s*"(.*?m3u8.*?)"
+        m3u8_url = sel.regex_first(r'file:\s*["\']([^"\']+\.m3u8[^"\']*)["\']')
+
+        if not m3u8_url:
+            # Fallback to sources: Kotlin mantığı
+            m3u8_url = sel.regex_first(r'sources:\s*\[\s*{\s*file:\s*["\']([^"\']+)["\']')
+
+        if not m3u8_url:
+            # p,a,c,k,e,d içinde olabilir
+            m3u8_url = sel.regex_first(r'["\'](https?://[^"\']+\.m3u8[^"\']*)["\']')
+
+        if not m3u8_url:
+            # t.r.u.e pattern fallback
+            m3u8_url = sel.regex_first(r'file\s*:\s*["\']([^"\']+)["\']')
+
+        if not m3u8_url:
+            raise ValueError(f"StreamWish: m3u8 bulunamadı. {url}")
+
+        return ExtractResult(
+            name       = self.name,
+            url        = self.fix_url(m3u8_url),
+            referer    = f"{base_url}/",
+            user_agent = self.httpx.headers.get("User-Agent", "")
+        )

KekikStream/Extractors/VidHide.py

@@ -2,6 +2,7 @@
 
 from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 from Kekik.Sifreleme  import Packer
+from contextlib       import suppress
 import re
 
 class VidHide(ExtractorBase):
@@ -17,7 +18,7 @@ class VidHide(ExtractorBase):
         "kinoger.be",
         "smoothpre.com",
         "dhtpre.com",
-        "peytonepre.com"
+        "peytonepre.com",
     ]
 
     def can_handle_url(self, url: str) -> bool:
@@ -37,69 +38,70 @@ class VidHide(ExtractorBase):
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
         base_url = self.get_base_url(url)
-        self.httpx.headers.update({
-            "Referer" : referer or base_url,
-            "Origin"  : base_url,
-        })
-        
+        name     = "EarnVids" if any(x in base_url for x in ["smoothpre.com", "dhtpre.com", "peytonepre.com"]) else self.name
+
+        # Kotlin Headers
+        headers = {
+            "Sec-Fetch-Dest" : "empty",
+            "Sec-Fetch-Mode" : "cors",
+            "Sec-Fetch-Site" : "cross-site",
+            "Origin"         : f"{base_url}/",
+            "Referer"        : referer or f"{base_url}/",
+        }
+
         embed_url = self.get_embed_url(url)
-        istek     = await self.httpx.get(embed_url, follow_redirects=True)
+        istek     = await self.httpx.get(embed_url, headers=headers, follow_redirects=True)
         text      = istek.text
 
         # Silinmiş dosya kontrolü
-        if "File is no longer available" in text or "File Not Found" in text:
-             raise ValueError(f"VidHide: Video silinmiş. {url}")
+        if any(x in text for x in ["File is no longer available", "File Not Found", "Video silinmiş"]):
+             raise ValueError(f"{name}: Video silinmiş. {url}")
 
         # JS Redirect Kontrolü (OneUpload vb.)
         if js_redirect := HTMLHelper(text).regex_first(r"window\.location\.replace\(['\"]([^'\"]+)['\"]\)") or \
                           HTMLHelper(text).regex_first(r"window\.location\.href\s*=\s*['\"]([^'\"]+)['\"]"):
-            # Redirect url'i al
             target_url = js_redirect
-            # Bazen path relative olabilir ama genelde full url
             if not target_url.startswith("http"):
-                 # urljoin gerekebilir ama şimdilik doğrudan deneyelim veya fix_url
-                 target_url = self.fix_url(target_url) # fix_url base'e göre düzeltebilir mi? ExtractorBase.fix_url genelde şema ekler.
-                 pass
+                 target_url = self.fix_url(target_url)
 
-            # Yeniden istek at
             istek = await self.httpx.get(target_url, headers={"Referer": embed_url}, follow_redirects=True)
             text  = istek.text
 
         sel       = HTMLHelper(text)
 
         unpacked = ""
-        # Eval script bul (regex ile daha sağlam)
+        # Eval script bul
         if eval_match := sel.regex_first(r'(eval\s*\(\s*function[\s\S]+?)<\/script>'):
-            try:
+            with suppress(Exception):
                 unpacked = Packer.unpack(eval_match)
                 if "var links" in unpacked:
                      unpacked = unpacked.split("var links")[1]
-            except:
-                pass
         
         content  = unpacked or text
-
-        # Regex: Kotlin mantığı (: "url")
-        # Ayrıca sources: [...] mantığını da ekle
-        m3u8_url = HTMLHelper(content).regex_first(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"')
-
-        if not m3u8_url:
-            # Genel arama (hls:, file: vb.)
-            # Kotlin Regex: :\s*"(.*?m3u8.*?)"
-            match = HTMLHelper(content).regex_first(r':\s*["\']([^"\']+\.m3u8[^"\']*)["\']')
-            if match:
-                m3u8_url = match
-
-        if not m3u8_url:
-             # Son şans: herhangi bir m3u8 linki
-             m3u8_url = HTMLHelper(content).regex_first(r'["\']([^"\']+\.m3u8[^"\']*)["\']')
-
-        if not m3u8_url:
-            raise ValueError(f"VidHide: Video URL bulunamadı. {url}")
-
-        return ExtractResult(
-            name       = self.name,
-            url        = self.fix_url(m3u8_url),
-            referer    = f"{base_url}/",
-            user_agent = self.httpx.headers.get("User-Agent", "")
-        )
+        
+        # Kotlin Exact Regex: :\s*"(.*?m3u8.*?)"
+        m3u8_matches = re.findall(r':\s*["\']([^"\']+\.m3u8[^"\']*)["\']', content)
+        
+        results = []
+        for m3u8_url in m3u8_matches:
+            results.append(ExtractResult(
+                name       = name,
+                url        = self.fix_url(m3u8_url),
+                referer    = f"{base_url}/",
+                user_agent = self.httpx.headers.get("User-Agent", "")
+            ))
+
+        if not results:
+            # Fallback for non-m3u8 or different patterns
+            if m3u8_url := sel.regex_first(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"'):
+                results.append(ExtractResult(
+                    name       = name,
+                    url        = self.fix_url(m3u8_url),
+                    referer    = f"{base_url}/",
+                    user_agent = self.httpx.headers.get("User-Agent", "")
+                ))
+
+        if not results:
+            raise ValueError(f"{name}: Video URL bulunamadı. {url}")
+
+        return results[0] if len(results) == 1 else results

KekikStream/Extractors/VidStack.py

@@ -0,0 +1,88 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from Crypto.Cipher    import AES
+from Crypto.Util      import Padding
+import re
+
+class VidStack(ExtractorBase):
+    name     = "VidStack"
+    main_url = "https://vidstack.io"
+    requires_referer = True
+
+    supported_domains = [
+        "vidstack.io", "server1.uns.bio", "upns.one"
+    ]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
+    def decrypt_aes(self, input_hex: str, key: str, iv: str) -> str:
+        try:
+            cipher = AES.new(key.encode('utf-8'), AES.MODE_CBC, iv.encode('utf-8'))
+            raw_data = bytes.fromhex(input_hex)
+            decrypted = cipher.decrypt(raw_data)
+            unpadded = Padding.unpad(decrypted, AES.block_size)
+            return unpadded.decode('utf-8')
+        except Exception as e:
+            # print(f"DEBUG VidStack: {iv} -> {e}") # Debugging
+            return None
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult | list[ExtractResult]:
+        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0"}
+
+        # Hash ve Base URL çıkarma
+        hash_val = url.split("#")[-1].split("/")[-1]
+        base_url = self.get_base_url(url)
+
+        # API İsteği
+        api_url = f"{base_url}/api/v1/video?id={hash_val}"
+        istek   = await self.httpx.get(api_url, headers=headers)
+
+        # Bazen yanıt tırnak içinde gelebilir, temizleyelim
+        encoded_data = istek.text.strip().strip('"')
+
+        # AES Çözme
+        key = "kiemtienmua911ca"
+        ivs = ["1234567890oiuytr", "0123456789abcdef"]
+
+        decrypted_text = None
+        for iv in ivs:
+            decrypted_text = self.decrypt_aes(encoded_data, key, iv)
+            if decrypted_text and '"source":' in decrypted_text:
+                break
+
+        if not decrypted_text:
+            # Hata mesajını daha detaylı verelim (debug için tırnaklanmış hali)
+            raise ValueError(f"VidStack: AES çözme başarısız. {url} | Response: {istek.text[:50]}...")
+
+        # m3u8 ve Alt yazı çıkarma
+        # Kotlin'de "source":"(.*?)" regex'i kullanılıyor
+        m3u8_url = re.search(r'["\']source["\']\s*:\s*["\']([^"\']+)["\']', decrypted_text)
+        if m3u8_url:
+            m3u8_url = m3u8_url.group(1).replace("\\/", "/")
+        else:
+            raise ValueError(f"VidStack: m3u8 bulunamadı. {url}")
+
+        subtitles = []
+        # Kotlin: "subtitle":\{(.*?)\}
+        subtitle_section = re.search(r'["\']subtitle["\']\s*:\s*\{(.*?)\}', decrypted_text)
+        if subtitle_section:
+            section = subtitle_section.group(1)
+            # Regex: "([^"]+)":\s*"([^"]+)"
+            matches = re.finditer(r'["\']([^"\']+)["\']\s*:\s*["\']([^"\']+)["\']', section)
+            for match in matches:
+                lang = match.group(1)
+                raw_path = match.group(2).split("#")[0]
+                if raw_path:
+                    path = raw_path.replace("\\/", "/")
+                    sub_url = f"{self.main_url}{path}"
+                    subtitles.append(Subtitle(name=lang, url=self.fix_url(sub_url)))
+
+        return ExtractResult(
+            name       = self.name,
+            url        = self.fix_url(m3u8_url),
+            referer    = url,
+            user_agent = headers["User-Agent"],
+            subtitles  = subtitles
+        )