KekikStream 2.3.9__py3-none-any.whl → 2.5.4__py3-none-any.whl

KekikStream/Extractors/ContentX.py

@@ -19,81 +19,36 @@ class ContentX(ExtractorBase):
     def can_handle_url(self, url: str) -> bool:
         return any(domain in url for domain in self.supported_domains)
 
-    async def extract(self, url, referer=None) -> list[ExtractResult]:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
+    async def extract(self, url: str, referer: str = None) -> list[ExtractResult] | ExtractResult:
+        ref = referer or self.get_base_url(url)
+        self.httpx.headers.update({"Referer": ref})
 
-        # Dinamik base URL kullan
-        base_url = self.get_base_url(url)
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
-        i_source = istek.text
-
-        i_extract_value = HTMLHelper(i_source).regex_first(r"window\.openPlayer\('([^']+)'")
-        if not i_extract_value:
-            raise ValueError("i_extract is null")
+        v_id = sel.regex_first(r"window\.openPlayer\('([^']+)'")
+        if not v_id:
+            raise ValueError(f"ContentX: ID bulunamadı. {url}")
 
         subtitles = []
-        sub_urls  = set()
-        for sub_url, sub_lang in HTMLHelper(i_source).regex_all(r'"file":"([^\"]+)","label":"([^\"]+)"'):
-
-            if sub_url in sub_urls:
-                continue
-
-            sub_urls.add(sub_url)
-            subtitles.append(
-                Subtitle(
-                    name = sub_lang.replace("\\u0131", "ı")
-                                 .replace("\\u0130", "İ")
-                                 .replace("\\u00fc", "ü")
-                                 .replace("\\u00e7", "ç")
-                                 .replace("\\u011f", "ğ")
-                                 .replace("\\u015f", "ş")
-                                 .replace("\\u011e", "Ğ")
-                                 .replace("\\u015e", "Ş"),
-                    url  = self.fix_url(sub_url.replace("\\/", "/").replace("\\", ""))
-                )
-            )
-
-        # base_url kullan (contentx.me yerine)
-        vid_source_request = await self.httpx.get(f"{base_url}/source2.php?v={i_extract_value}", headers={"Referer": referer or base_url})
-        vid_source_request.raise_for_status()
-
-        vid_source  = vid_source_request.text
-        m3u_link = HTMLHelper(vid_source).regex_first(r'file":"([^\"]+)"')
-        if not m3u_link:
-            raise ValueError("vidExtract is null")
-
-        m3u_link = m3u_link.replace("\\", "").replace("/m.php", "/master.m3u8")
-        results  = [
-            ExtractResult(
-                name      = self.name,
-                url       = m3u_link,
-                referer   = url,
-                subtitles = subtitles
-            )
-        ]
-
-        dublaj_value = HTMLHelper(i_source).regex_first(r'["\']([^"\']+)["\'],["\']Türkçe["\']')
-        if dublaj_value:
-            try:
-                dublaj_source_request = await self.httpx.get(f"{base_url}/source2.php?v={dublaj_value}", headers={"Referer": referer or base_url})
-                dublaj_source_request.raise_for_status()
-
-                dublaj_source  = dublaj_source_request.text
-                dublaj_link = HTMLHelper(dublaj_source).regex_first(r'file":"([^\"]+)"')
-                if dublaj_link:
-                    dublaj_link = dublaj_link.replace("\\", "")
-                    results.append(
-                        ExtractResult(
-                            name      = f"{self.name} Türkçe Dublaj",
-                            url       = dublaj_link,
-                            referer   = url,
-                            subtitles = []
-                        )
-                    )
-            except Exception:
-                pass
+        for s_url, s_lang in sel.regex_all(r'"file":"([^\"]+)","label":"([^\"]+)"'):
+            decoded_lang = s_lang.encode().decode('unicode_escape')
+            subtitles.append(Subtitle(name=decoded_lang, url=self.fix_url(s_url.replace("\\", ""))))
+
+        results = []
+        # Base m3u8
+        vid_resp = await self.httpx.get(f"{self.get_base_url(url)}/source2.php?v={v_id}", headers={"Referer": url})
+        if m3u8_link := HTMLHelper(vid_resp.text).regex_first(r'file":"([^\"]+)"'):
+            m3u8_link = m3u8_link.replace("\\", "").replace("/m.php", "/master.m3u8")
+            results.append(ExtractResult(name=self.name, url=m3u8_link, referer=url, subtitles=subtitles))
+
+        # Dublaj Kontrolü
+        if dub_id := sel.regex_first(r'["\']([^"\']+)["\'],["\']Türkçe["\']'):
+            dub_resp = await self.httpx.get(f"{self.get_base_url(url)}/source2.php?v={dub_id}", headers={"Referer": url})
+            if dub_link := HTMLHelper(dub_resp.text).regex_first(r'file":"([^\"]+)"'):
+                results.append(ExtractResult(name=f"{self.name} Türkçe Dublaj", url=dub_link.replace("\\", ""), referer=url))
+
+        if not results:
+            raise ValueError(f"ContentX: Video linki bulunamadı. {url}")
 
         return results[0] if len(results) == 1 else results

KekikStream/Extractors/DonilasPlay.py

@@ -2,85 +2,41 @@
 
 from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 from Kekik.Sifreleme   import AESManager
-import json
+import json, contextlib
 
 class DonilasPlay(ExtractorBase):
     name     = "DonilasPlay"
     main_url = "https://donilasplay.com"
 
-    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()
-        i_source = istek.text
-
-        m3u_link   = None
-        subtitles  = []
-
-        # bePlayer pattern
-        hp = HTMLHelper(i_source)
-        be_player_matches = hp.regex_all(r"bePlayer\('([^']+)',\s*'(\{[^}]+\})'\);")
-        if be_player_matches:
-            be_player_pass, be_player_data = be_player_matches[0]
-
-            try:
-                # AES decrypt
-                decrypted = AESManager.decrypt(be_player_data, be_player_pass)
-                data      = json.loads(decrypted)
-
-                m3u_link = data.get("video_location")
-
-                # Altyazıları işle
-                str_subtitles = data.get("strSubtitles", [])
-                if str_subtitles:
-                    for sub in str_subtitles:
-                        label = sub.get("label", "")
-                        file  = sub.get("file", "")
-                        # Forced altyazıları hariç tut
-                        if "Forced" in label:
-                            continue
-                        if file:
-                            # Türkçe kontrolü
-                            keywords = ["tur", "tr", "türkçe", "turkce"]
-                            language = "Turkish" if any(k in label.lower() for k in keywords) else label
-                            subtitles.append(Subtitle(
-                                name = language,
-                                url  = self.fix_url(file)
-                            ))
-            except Exception:
-                pass
-
-        # Fallback: file pattern
-        if not m3u_link:
-            file_match = hp.regex_first(r'file:"([^"]+)"')
-            if file_match:
-                m3u_link = file_match
-
-            # tracks pattern for subtitles
-            tracks_match = hp.regex_first(r'tracks:\[([^\]]+)')
-            if tracks_match:
-                try:
-                    tracks_str = f"[{tracks_match}]"
-                    tracks = json.loads(tracks_str)
-                    for track in tracks:
-                        file_url = track.get("file")
-                        label    = track.get("label", "")
-                        if file_url and "Forced" not in label:
-                            subtitles.append(Subtitle(
-                                name = label,
-                                url  = self.fix_url(file_url)
-                            ))
-                except Exception:
-                    pass
-
-        if not m3u_link:
-            raise ValueError("m3u link not found")
-
-        return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = url,
-            subtitles = subtitles
-        )
+    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
+        subtitles = []
+
+        # 1. bePlayer (AES)
+        if be_match := sel.regex_first(r"bePlayer\('([^']+)',\s*'(\{[^}]+\})'\);", group=None):
+            pass_val, data_val = be_match
+            with contextlib.suppress(Exception):
+                data = json.loads(AESManager.decrypt(data_val, pass_val))
+                m3u8_url = data.get("video_location")
+                for sub in data.get("strSubtitles", []):
+                    if "Forced" not in sub.get("label", ""):
+                        subtitles.append(Subtitle(name=sub.get("label"), url=self.fix_url(sub.get("file"))))
+
+        # 2. Fallback
+        if not m3u8_url:
+            m3u8_url = sel.regex_first(r'file:"([^"]+)"')
+            if tracks_match := sel.regex_first(r'tracks:\[([^\]]+)'):
+                with contextlib.suppress(Exception):
+                    for track in json.loads(f"[{tracks_match}]"):
+                        if "Forced" not in track.get("label", ""):
+                            subtitles.append(Subtitle(name=track.get("label"), url=self.fix_url(track.get("file"))))
+
+        if not m3u8_url:
+            raise ValueError(f"DonilasPlay: Video linki bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=url, subtitles=subtitles)

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

@@ -13,7 +13,8 @@ class Filemoon(ExtractorBase):
         "filemoon.in",
         "filemoon.sx",
         "filemoon.nl",
-        "filemoon.com"
+        "filemoon.com",
+        "bysejikuar.com"
     ]
 
     def can_handle_url(self, url: str) -> bool:
@@ -30,60 +31,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

@@ -0,0 +1,30 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core  import ExtractorBase, ExtractResult, HTMLHelper
+from Kekik.Sifreleme import AESManager
+import contextlib, json
+
+class HDMomPlayer(ExtractorBase):
+    name     = "HDMomPlayer"
+    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

@@ -0,0 +1,27 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+from Kekik.Sifreleme import AESManager
+import contextlib
+
+class HotStream(ExtractorBase):
+    name     = "HotStream"
+    main_url = "https://hotstream.club"
+
+    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:
+            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)