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

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
+        )

KekikStream/Plugins/DDizi.py

@@ -0,0 +1,176 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, HTMLHelper
+from contextlib       import suppress
+
+class DDizi(PluginBase):
+    name        = "DDizi"
+    language    = "tr"
+    main_url    = "https://www.ddizi.im"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Ddizi, dizi izle, dizi seyret, yerli dizi izle, canlı dizi, türk dizi izle, dizi izle full, diziizle, eski diziler"
+
+    main_page   = {
+        f"{main_url}/yeni-eklenenler7" : "Son Eklenen Bölümler",
+        f"{main_url}/yabanci-dizi-izle" : "Yabancı Diziler",
+        f"{main_url}/eski.diziler"       : "Eski Diziler",
+        f"{main_url}/yerli-diziler"     : "Yerli Diziler"
+    }
+
+    async def get_articles(self, secici: HTMLHelper) -> list[dict]:
+        articles = []
+        for veri in secici.select("div.dizi-boxpost-cat, div.dizi-boxpost"):
+            title = secici.select_text("a", veri)
+            href  = secici.select_attr("a", "href", veri)
+            img   = secici.select_first("img.img-back, img.img-back-cat", veri)
+            poster = img.attrs.get("data-src") or img.attrs.get("src") if img else None
+
+            if title and href:
+                articles.append({
+                    "title" : self.clean_title(title),
+                    "url"   : self.fix_url(href),
+                    "poster": self.fix_url(poster),
+                })
+
+        return articles
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        # DDizi'de sayfalama /sayfa-X formatında (0'dan başlıyor)
+        if page > 1:
+            target_url = f"{url}/sayfa-{page-1}"
+        else:
+            target_url = url
+
+        istek      = await self.httpx.get(target_url, follow_redirects=True)
+        secici     = HTMLHelper(istek.text)
+        veriler    = await self.get_articles(secici)
+
+        return [MainPageResult(**veri, category=category) for veri in veriler if veri]
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek = await self.httpx.post(
+            url     = f"{self.main_url}/arama/",
+            headers = {"Referer": f"{self.main_url}/"},
+            data    = {"arama": query}
+        )
+        secici  = HTMLHelper(istek.text)
+        veriler = await self.get_articles(secici)
+
+        return [SearchResult(**veri) for veri in veriler if veri]
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.httpx.get(url)
+        secici = HTMLHelper(istek.text)
+
+        title       = self.clean_title(secici.select_text("h1, h2, div.dizi-boxpost-cat a"))
+        poster      = secici.select_poster("div.afis img, img.afis, img.img-back, img.img-back-cat")
+        description = secici.select_text("div.dizi-aciklama, div.aciklama, p")
+        rating      = secici.select_text("span.comments-ss") 
+        
+        # Meta verileri (DDizi'de pek yok ama deniyoruz)
+        # Year için sadece açıklama kısmına bakalım ki URL'deki ID'yi almasın
+        year   = HTMLHelper(description).regex_first(r"(\d{4})") if description else None
+        actors = secici.select_texts("div.oyuncular a, ul.bilgi li a")
+        
+        episodes = []
+        current_page = 1
+        has_next = True
+        
+        while has_next:
+            page_url = f"{url}/sayfa-{current_page}" if current_page > 1 else url
+            if current_page > 1:
+                istek = await self.httpx.get(page_url)
+                secici = HTMLHelper(istek.text)
+            
+            page_eps = secici.select("div.bolumler a, div.sezonlar a, div.dizi-arsiv a, div.dizi-boxpost-cat a")
+            if not page_eps:
+                break
+                
+            for ep in page_eps:
+                name = ep.text().strip()
+                href = ep.attrs.get("href")
+                if name and href:
+                    # 'Bölüm Final' gibi durumları temizleyelim
+                    clean_name = name.replace("Final", "").strip()
+                    s, e = secici.extract_season_episode(clean_name)
+                    episodes.append(Episode(
+                        season  = s or 1,
+                        episode = e or 1,
+                        title   = name,
+                        url     = self.fix_url(href)
+                    ))
+            
+            # Sonraki sayfa kontrolü
+            has_next = any("Sonraki" in a.text() for a in secici.select(".pagination a"))
+            current_page += 1
+            if current_page > 10: break # Emniyet kilidi
+
+        if not episodes:
+            s, e = secici.extract_season_episode(title)
+            episodes.append(Episode(
+                season  = s or 1,
+                episode = e or 1,
+                title   = title,
+                url     = url
+            ))
+
+        return SeriesInfo(
+            url         = url,
+            poster      = self.fix_url(poster),
+            title       = title,
+            description = description,
+            rating      = rating.strip() if rating else None,
+            year        = year,
+            actors      = actors,
+            episodes    = episodes
+        )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek  = await self.httpx.get(url)
+        secici = HTMLHelper(istek.text)
+
+        results = []
+        # og:video ve JWPlayer kontrolü
+        og_video = secici.select_attr("meta[property='og:video']", "content")
+        if og_video:
+            og_video = self.fix_url(og_video)
+            with suppress(Exception):
+                player_istek = await self.httpx.get(og_video, headers={"Referer": url})
+                player_secici = HTMLHelper(player_istek.text)
+                
+                # file: '...' logic
+                sources = player_secici.regex_all(r'file:\s*["\']([^"\']+)["\']')
+                for src in sources:
+                    src = self.fix_url(src)
+                    # Direkt link kontrolü - Extractor gerektirmeyenler
+                    is_direct = any(x in src.lower() for x in ["google", "twimg", "mncdn", "akamai", "streambox", ".m3u8", ".mp4", "master.txt"])
+                    
+                    if is_direct:
+                        results.append(ExtractResult(
+                            url        = src,
+                            name       = "Video",
+                            user_agent = "googleusercontent",
+                            referer    = "https://twitter.com/"
+                        ))
+                    else:
+                        res = await self.extract(src, referer=og_video)
+                        if res:
+                            if isinstance(res, list): results.extend(res)
+                            else: results.append(res)
+                
+                # Fallback to direct extraction if nothing found but we have og_video
+                if not results:
+                    if any(x in og_video.lower() for x in ["google", "twimg", "mncdn", "akamai", "streambox", ".m3u8", ".mp4", "master.txt"]):
+                        results.append(ExtractResult(
+                            url        = og_video,
+                            name       = "Video",
+                            user_agent = "googleusercontent",
+                            referer    = "https://twitter.com/"
+                        ))
+                    else:
+                        res = await self.extract(og_video)
+                        if res:
+                            if isinstance(res, list): results.extend(res)
+                            else: results.append(res)
+
+        return results