KekikStream 2.4.2__py3-none-any.whl → 2.4.4__py3-none-any.whl

KekikStream/Extractors/DzenRu.py

@@ -6,33 +6,19 @@ class DzenRu(ExtractorBase):
     name     = "DzenRu"
     main_url = "https://dzen.ru"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
         video_key = url.split("/")[-1]
-        video_url = f"{self.main_url}/embed/{video_key}"
+        v_url     = f"{self.main_url}/embed/{video_key}"
 
         if referer:
             self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.httpx.get(video_url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(v_url)
+        sel  = HTMLHelper(resp.text)
+        
+        # Benzersiz okcdn.ru linklerini bul ve en yüksek kaliteyi (genelde sonuncu) seç
+        links = sel.regex_all(r'https://vd\d+\.okcdn\.ru/\?[^"\'\\\s]+')
+        if not links:
+            raise ValueError(f"DzenRu: Video linki bulunamadı. {url}")
 
-        # okcdn.ru linklerini bul
-        hp = HTMLHelper(istek.text)
-        matches = hp.regex_all(r'https://vd\d+\.okcdn\.ru/\?[^"\'\\\s]+')
-
-        if not matches:
-            raise ValueError("DzenRu video link not found")
-
-        # Benzersiz linkleri al, son kaliteyi kullan
-        unique_links = list(set(matches))
-        best_link    = unique_links[-1] if unique_links else None
-
-        if not best_link:
-            raise ValueError("No valid video URL found")
-
-        return ExtractResult(
-            name      = self.name,
-            url       = best_link,
-            referer   = self.main_url,
-            subtitles = []
-        )
+        return ExtractResult(name=self.name, url=list(set(links))[-1], referer=self.main_url)

KekikStream/Extractors/ExPlay.py

@@ -1,53 +1,35 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
 from urllib.parse import urlparse, parse_qs
 
 class ExPlay(ExtractorBase):
     name     = "ExPlay"
     main_url = "https://explay.store"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        ext_ref = referer or ""
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
         
-        # URL parsing for partKey
-        parsed = urlparse(url)
-        params = parse_qs(parsed.query)
-        part_key = params.get("partKey", [""])[0]
-        clean_url = url.split("?partKey=")[0]
-
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
-        istek = await self.httpx.get(clean_url)
-        istek.raise_for_status()
-
-        hp = HTMLHelper(istek.text)
+        # Clean URL from partKey for initial request
+        clean_url = url.split("?")[0]
+        resp = await self.httpx.get(clean_url)
+        sel  = HTMLHelper(resp.text)
 
-        # videoUrl çıkar
-        video_url = hp.regex_first(r'videoUrl":"([^",]+)"')
-        if not video_url:
-            raise ValueError("videoUrl not found")
-        video_url = video_url.replace("\\", "")
+        v_url = sel.regex_first(r'videoUrl":"([^",]+)"')
+        v_srv = sel.regex_first(r'videoServer":"([^",]+)"')
+        if not v_url or not v_srv:
+            raise ValueError(f"ExPlay: Video url/server bulunamadı. {url}")
 
-        # videoServer çıkar
-        video_server = hp.regex_first(r'videoServer":"([^",]+)"')
-        if not video_server:
-            raise ValueError("videoServer not found")
-
-        # title çıkar
-        title = hp.regex_first(r'title":"([^",]+)"')
-        title = title.split(".")[-1] if title else "Unknown"
+        params   = parse_qs(urlparse(url).query)
+        part_key = params.get("partKey", [""])[0]
         
-        if part_key and "turkce" in part_key.lower():
-             title = part_key # Or nicer formatting like SetPlay
-
-        # M3U8 link oluştur
-        m3u_link = f"{self.main_url}{video_url}?s={video_server}"
+        suffix = part_key or "Bilinmiyor"
+        if not part_key:
+            title = sel.regex_first(r'title":"([^",]+)"')
+            if title: suffix = title.split(".")[-1]
 
         return ExtractResult(
-            name      = f"{self.name} - {title}",
-            url       = m3u_link,
-            referer   = clean_url, 
-            subtitles = []
+            name    = f"{self.name} - {suffix}",
+            url     = f"{self.main_url}{v_url.replace('\\', '')}?s={v_srv}",
+            referer = clean_url
         )

KekikStream/Extractors/Filemoon.py

@@ -30,60 +30,34 @@ class Filemoon(ExtractorBase):
         self.httpx.headers.update(default_headers)
 
         # İlk sayfayı al
-        istek    = await self.httpx.get(url)
-        response = istek.text
-        secici   = HTMLHelper(response)
+        istek  = await self.httpx.get(url)
+        secici = HTMLHelper(istek.text)
 
         # Eğer iframe varsa, iframe'e git
         iframe_src = secici.select_attr("iframe", "src")
+        m3u8_url   = None
         
-        m3u8_url = None
-        
-        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)
-                unpacked_sec = HTMLHelper(unpacked)
-                m3u8_url = unpacked_sec.regex_first(r'sources:\[\{file:"(.*?)"')
-        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   = HTMLHelper(response)
-            
-            script_data = ""
-            for script in secici.select("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)
-                unpacked_sec = HTMLHelper(unpacked)
-                m3u8_url = unpacked_sec.regex_first(r'sources:\[\{file:"(.*?)"')
+        if iframe_src:
+            url    = self.fix_url(iframe_src)
+            istek  = await self.httpx.get(url)
+            secici = HTMLHelper(istek.text)
+
+        # script p,a,c,k,e,d içinde ara
+        script_data = secici.regex_first(r"(eval\(function\(p,a,c,k,e,d\).+?)\s*</script>")
+        if script_data:
+            unpacked = Packer.unpack(script_data)
+            m3u8_url = HTMLHelper(unpacked).regex_first(r'sources:\[\{file:"(.*?)"')
 
         if not m3u8_url:
-            # Son çare: Normal response içinde ara
-            resp_sec = HTMLHelper(response)
-            m3u8_url = resp_sec.regex_first(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"') or resp_sec.regex_first(r'file:\s*"([^\"]*?\.m3u8[^"]*)"')
+            # Fallback
+            m3u8_url = secici.regex_first(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"') or secici.regex_first(r'file:\s*"([^\"]*?\.m3u8[^"]*)"')
 
         if not m3u8_url:
             raise ValueError(f"Filemoon: Video URL bulunamadı. {url}")
 
         return ExtractResult(
-            name      = self.name,
-            url       = self.fix_url(m3u8_url),
-            referer   = f"{self.main_url}/",
-            user_agent = default_headers["User-Agent"],
-            subtitles = []
+            name       = self.name,
+            url        = self.fix_url(m3u8_url),
+            referer    = f"{self.get_base_url(url)}/",
+            user_agent = default_headers["User-Agent"]
         )

KekikStream/Extractors/HDMomPlayer.py

@@ -1,62 +1,30 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+from KekikStream.Core  import ExtractorBase, ExtractResult, HTMLHelper
 from Kekik.Sifreleme import AESManager
-import re
-import json
+import contextlib, 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
+    main_url = "https://hdmomplayer.com"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
+
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+
+        m3u8_url = None
+        if match := sel.regex_first(r"bePlayer\('([^']+)',\s*'(\{[^\}]+\})'\);", group=None):
+            pass_val, data_val = match
+            with contextlib.suppress(Exception):
+                decrypted = AESManager.decrypt(data_val, pass_val)
+                m3u8_url  = HTMLHelper(decrypted).regex_first(r'video_location":"([^"]+)"')
+
+        if not m3u8_url:
+            m3u8_url = sel.regex_first(r'file:"([^"]+)"')
+
+        if not m3u8_url:
+            raise ValueError(f"HDMomPlayer: Video linki bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=self.fix_url(m3u8_url), referer=url)

KekikStream/Extractors/HDPlayerSystem.py

@@ -6,36 +6,18 @@ class HDPlayerSystem(ExtractorBase):
     name     = "HDPlayerSystem"
     main_url = "https://hdplayersystem.com"
 
-    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"HDPlayerSystem: 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   = url,
-            subtitles = []
-        )
+        return ExtractResult(name=self.name, url=m3u8_url, referer=url)

KekikStream/Extractors/HotStream.py

@@ -2,44 +2,26 @@
 
 from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
 from Kekik.Sifreleme import AESManager
-import re
-import json
+import contextlib
 
 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})
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
 
-        istek = await self.httpx.get(url)
-        html = istek.text
-        helper = HTMLHelper(html)
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        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:
+        m3u8_url = None
+        if match := sel.regex_first(r"bePlayer\('([^']+)',\s*'(\{[^']+\})'\)", group=None):
+            pass_val, data_val = match
+            with contextlib.suppress(Exception):
                 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
+                m3u8_url  = HTMLHelper(decrypted).regex_first(r'"video_location":"([^"]+)"')
 
-        return None
+        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)

KekikStream/Extractors/JFVid.py

@@ -1,7 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult
-import re
 
 class JFVid(ExtractorBase):
     name     = "JFVid"
@@ -14,27 +13,7 @@ class JFVid(ExtractorBase):
         return any(domain in url for domain in self.supported_domains)
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
-        # Dinamik base URL kullan
         base_url = self.get_base_url(url)
-
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
-        # /play/ endpoint'inden encodedId'yi al
-        # URL format: https://xxx.jfvid.com/play/{encodedId}
-        if "/play/" in url:
-            encoded_id = url.split("/play/")[-1]
-            stream_url = f"{base_url}/stream/{encoded_id}"
-        elif "/stream/" in url:
-            # Zaten stream URL ise doğrudan kullan
-            stream_url = url
-        else:
-            raise ValueError(f"JFVid: Desteklenmeyen URL formatı. {url}")
-
-        # Stream endpoint'i direkt m3u8 master playlist döndürür
-        return ExtractResult(
-            name      = self.name,
-            url       = stream_url,
-            referer   = referer,
-            subtitles = []
-        )
+        v_id     = url.split("/play/")[-1] if "/play/" in url else url.split("/stream/")[-1]
+        
+        return ExtractResult(name=self.name, url=f"{base_url}/stream/{v_id}", referer=referer or base_url)

KekikStream/Extractors/JetTv.py

@@ -1,45 +1,32 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
-import json
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+import contextlib
 
 class JetTv(ExtractorBase):
     name     = "JetTv"
     main_url = "https://jetv.xyz"
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
-        istek    = await self.httpx.get(url)
-        document = istek.text
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        # 1. Yöntem: API üzerinden alma
-        master_url = ""
-        final_ref  = f"{self.main_url}/"
+        m3u8_url = None
+        final_ref = self.main_url
 
         if "id=" in url:
-            vid_id = url.split("id=")[-1]
-            api_url = f"https://jetv.xyz/apollo/get_video.php?id={vid_id}"
-            try:
-                # Referer olarak video sayfasının kendisi gönderilmeli
-                api_resp = await self.httpx.get(api_url, headers={"Referer": url})
-                api_json = api_resp.json()
-                
-                if api_json.get("success"):
-                     master_url = api_json.get("masterUrl", "")
-                     final_ref  = api_json.get("referrerUrl") or final_ref
-            except Exception:
-                pass
-
-        # 2. Yöntem: Regex Fallback
-        if not master_url:
-             hp = HTMLHelper(document)
-             master_url = hp.regex_first(r"(?i)file: '([^']*)'") or master_url
-        
-        if not master_url:
-            raise ValueError(f"JetTv: Video kaynağı bulunamadı. {url}")
-
-        return ExtractResult(
-            name      = self.name,
-            url       = master_url,
-            referer   = final_ref,
-            subtitles = []
-        )
+            v_id = url.split("id=")[-1]
+            with contextlib.suppress(Exception):
+                api_resp = await self.httpx.get(f"{self.main_url}/apollo/get_video.php?id={v_id}", headers={"Referer": url})
+                data     = api_resp.json()
+                if data.get("success"):
+                    m3u8_url  = data.get("masterUrl")
+                    final_ref = data.get("referrerUrl") or final_ref
+
+        if not m3u8_url:
+            m3u8_url = sel.regex_first(r"(?i)file: '([^']*)'")
+
+        if not m3u8_url:
+            raise ValueError(f"JetTv: Video URL bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=final_ref)

KekikStream/Extractors/MailRu.py

@@ -2,37 +2,19 @@
 
 from KekikStream.Core import ExtractorBase, ExtractResult
 
-class MailRuExtractor(ExtractorBase):
+class MailRu(ExtractorBase):
     name     = "MailRu"
     main_url = "https://my.mail.ru"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        vid_id         = url.split("video/embed/")[-1].strip()
-        video_meta_url = f"{self.main_url}/+/video/meta/{vid_id}"
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        v_id = url.split("video/embed/")[-1].strip()
+        if referer: self.httpx.headers.update({"Referer": referer})
 
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
+        resp = await self.httpx.get(f"{self.main_url}/+/video/meta/{v_id}")
+        data = resp.json()
+        
+        v_url = data.get("videos", [{}])[0].get("url")
+        if not v_url:
+            raise ValueError(f"MailRu: Video URL bulunamadı. {url}")
 
-        istek = await self.httpx.get(video_meta_url)
-        istek.raise_for_status()
-
-        video_key = istek.cookies.get("video_key")
-        if not video_key:
-            raise ValueError("Video key bulunamadı.")
-
-        video_data = istek.json()
-        videos     = video_data.get("videos", [])
-        if not videos:
-            raise ValueError("Videolar bulunamadı.")
-
-        video     = videos[0]
-        video_url = video["url"]
-        if video_url.startswith("//"):
-            video_url = f"https:{video_url}"
-
-        return ExtractResult(
-            name      = self.name,
-            url       = video_url,
-            referer   = self.main_url,
-            subtitles = []
-        )
+        return ExtractResult(name=self.name, url=self.fix_url(v_url), referer=self.main_url)

KekikStream/Extractors/MixPlayHD.py

@@ -8,34 +8,21 @@ class MixPlayHD(ExtractorBase):
     name     = "MixPlayHD"
     main_url = "https://mixplayhd.com"
 
-    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) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or self.main_url})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
-
-        hp = HTMLHelper(istek.text)
-        be_player_matches = hp.regex_all(r"bePlayer\('([^']+)',\s*'(\{[^\}]+\})'\);")
-        if not be_player_matches:
-            raise ValueError("bePlayer not found in the response.")
-
-        be_player_pass, be_player_data = be_player_matches[0]
+        resp = await self.httpx.get(url)
+        match = HTMLHelper(resp.text).regex_first(r"bePlayer\('([^']+)',\s*'(\{[^\}]+\})'\);", group=None)
+        if not match:
+            raise ValueError(f"MixPlayHD: bePlayer bulunamadı. {url}")
 
+        pass_val, data_val = match
         try:
-            decrypted_data = AESManager.decrypt(be_player_data, be_player_pass).replace("\\", "")
-            decrypted_json = json.loads(decrypted_data)
-        except Exception as hata:
-            raise RuntimeError(f"Decryption failed: {hata}") from hata
-
-        client_str = decrypted_json.get("schedule", {}).get("client", "")
-        video_url = HTMLHelper(client_str).regex_first(r'"video_location":"([^"]+)"')
-        if video_url:
-            return ExtractResult(
-                name      = self.name,
-                url       = video_url,
-                referer   = self.main_url,
-                subtitles = []
-            )
-        else:
-            raise ValueError("M3U8 video URL not found in the decrypted data.")
+            data = json.loads(AESManager.decrypt(data_val, pass_val))
+            v_url = HTMLHelper(data.get("schedule", {}).get("client", "")).regex_first(r'"video_location":"([^"]+)"')
+            if v_url:
+                return ExtractResult(name=self.name, url=v_url, referer=self.main_url)
+        except Exception as e:
+            raise ValueError(f"MixPlayHD: Decryption failed. {e}")
+
+        raise ValueError(f"MixPlayHD: Video URL bulunamadı. {url}")