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

KekikStream/Extractors/SibNet.py

@@ -6,22 +6,12 @@ class SibNet(ExtractorBase):
     name     = "SibNet"
     main_url = "https://video.sibnet.ru"
 
-    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 url})
 
-        response = await self.httpx.get(url)
-        response.raise_for_status()
+        resp = await self.httpx.get(url)
+        path = HTMLHelper(resp.text).regex_first(r'player\.src\(\[\{src: "([^\"]+)"')
+        if not path:
+            raise ValueError(f"SibNet: Video yolu bulunamadı. {url}")
 
-        m3u_suffix = HTMLHelper(response.text).regex_first(r'player\.src\(\[\{src: "([^\"]+)"')
-        if not m3u_suffix:
-            raise ValueError("m3u bağlantısı bulunamadı.")
-
-        m3u_link = f"{self.main_url}{m3u_suffix}"
-
-        return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = url,
-            subtitles = []
-        )
+        return ExtractResult(name=self.name, url=f"{self.main_url}{path}", referer=url)

KekikStream/Extractors/Sobreatsesuyp.py

@@ -7,53 +7,31 @@ class Sobreatsesuyp(ExtractorBase):
     name     = "Sobreatsesuyp"
     main_url = "https://sobreatsesuyp.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) -> list[ExtractResult] | ExtractResult:
+        ref = referer or self.main_url
+        self.httpx.headers.update({"Referer": ref})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        path = HTMLHelper(resp.text).regex_first(r'file":"([^\"]+)')
+        if not path:
+            raise ValueError(f"Sobreatsesuyp: File path bulunamadı. {url}")
 
-        file_path = HTMLHelper(istek.text).regex_first(r'file":"([^\"]+)')
-        if not file_path:
-            raise ValueError("File not found in response.")
+        post_resp = await self.httpx.post(f"{self.main_url}/{path.replace('\\', '')}")
+        data_list = post_resp.json()[1:] if isinstance(post_resp.json(), list) else []
 
-        file_path = file_path.replace("\\", "")
-        post_link = f"{self.main_url}/{file_path}"
-
-        post_istek = await self.httpx.post(post_link)
-        post_istek.raise_for_status()
-
-        try:
-            post_json = json.loads(post_istek.text)
-        except json.JSONDecodeError as hata:
-            raise ValueError("Failed to parse JSON response.") from hata
-
-        video_data_list = post_json[1:] if isinstance(post_json, list) else []
-
-        all_results = []
-
-        for item in video_data_list:
+        results = []
+        for item in data_list:
             title = item.get("title")
             file  = item.get("file")
-
-            if not title or not file:
-                continue
-
-            playlist_url     = f"{self.main_url}/playlist/{file.lstrip('/')}.txt"
-            playlist_request = await self.httpx.post(playlist_url, headers={"Referer": referer or self.main_url})
-            playlist_request.raise_for_status()
-
-            all_results.append(
-                ExtractResult(
-                    name      = f"{self.name} - {title}",
-                    url       = playlist_request.text,
-                    referer   = self.main_url,
-                    subtitles = []
-                )
-            )
-
-        if not all_results:
-            raise ValueError("No videos found in response.")
-
-        return all_results[0] if len(all_results) == 1 else all_results
+            if title and file:
+                playlist_resp = await self.httpx.post(f"{self.main_url}/playlist/{file.lstrip('/')}.txt")
+                results.append(ExtractResult(
+                    name    = f"{self.name} - {title}",
+                    url     = playlist_resp.text,
+                    referer = self.main_url
+                ))
+
+        if not results:
+            raise ValueError(f"Sobreatsesuyp: Video bulunamadı. {url}")
+
+        return results[0] if len(results) == 1 else results

KekikStream/Extractors/TRsTX.py

@@ -7,61 +7,31 @@ class TRsTX(ExtractorBase):
     name     = "TRsTX"
     main_url = "https://trstx.org"
 
-    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.main_url
+        self.httpx.headers.update({"Referer": ref})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        path = HTMLHelper(resp.text).regex_first(r'file":"([^\"]+)')
+        if not path:
+            raise ValueError(f"TRsTX: File path bulunamadı. {url}")
 
-        file_path = HTMLHelper(istek.text).regex_first(r'file":"([^\"]+)')
-        if not file_path:
-            raise ValueError("File not found in response.")
+        post_resp = await self.httpx.post(f"{self.main_url}/{path.replace('\\', '')}")
+        data_list = post_resp.json()[1:] if isinstance(post_resp.json(), list) else []
 
-        file_path = file_path.replace("\\", "")
-        post_link = f"{self.main_url}/{file_path}"
-
-        post_istek = await self.httpx.post(post_link)
-        post_istek.raise_for_status()
-
-        try:
-            post_json = json.loads(post_istek.text)
-        except json.JSONDecodeError as hata:
-            raise ValueError("Failed to parse JSON response.") from hata
-
-        video_data_list = post_json[1:] if isinstance(post_json, list) else []
-
-        video_links = set()
-        all_results = []
-
-        for item in video_data_list:
+        results = []
+        for item in data_list:
             title = item.get("title")
             file  = item.get("file")
-
-            if not title or not file:
-                continue
-
-            playlist_url = f"{self.main_url}/playlist/{file.lstrip('/')}.txt"
-            playlist_request = await self.httpx.post(playlist_url, headers={"Referer": referer or self.main_url})
-            playlist_request.raise_for_status()
-
-            video_data = playlist_request.text
-
-            if video_data in video_links:
-                continue
-
-            video_links.add(video_data)
-
-            all_results.append(
-                ExtractResult(
-                    name      = f"{self.name} - {title}",
-                    url       = video_data,
-                    referer   = self.main_url,
-                    subtitles = []
-                )
-            )
-
-        if not all_results:
-            raise ValueError("No videos found in response.")
-
-        return all_results[0] if len(all_results) == 1 else all_results
+            if title and file:
+                playlist_resp = await self.httpx.post(f"{self.main_url}/playlist/{file.lstrip('/')}.txt")
+                results.append(ExtractResult(
+                    name    = f"{self.name} - {title}",
+                    url     = playlist_resp.text,
+                    referer = self.main_url
+                ))
+
+        if not results:
+            raise ValueError(f"TRsTX: Video bulunamadı. {url}")
+
+        return results[0] if len(results) == 1 else results

KekikStream/Extractors/TurboImgz.py

@@ -6,19 +6,12 @@ class TurboImgz(ExtractorBase):
     name     = "TurboImgz"
     main_url = "https://turbo.imgz.me"
 
-    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 url})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        v_url = HTMLHelper(resp.text).regex_first(r'file: "(.*)",')
+        if not v_url:
+            raise ValueError(f"TurboImgz: Video bulunamadı. {url}")
 
-        if video := HTMLHelper(istek.text).regex_first(r'file: "(.*)",'):
-            return ExtractResult(
-                name      = self.name,
-                url       = video,
-                referer   = referer or self.main_url,
-                subtitles = []
-            )
-        else:
-            raise ValueError("File not found in response.")
+        return ExtractResult(name=self.name, url=v_url, referer=referer or self.main_url)

KekikStream/Extractors/VCTPlay.py

@@ -7,35 +7,17 @@ class VCTPlay(ExtractorBase):
     name     = "VCTPlay"
     main_url = "https://vctplay.site"
 
-    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:
+        v_id = url.split("/")[-1].split("?")[0]
+        params = parse_qs(urlparse(url).query)
+        part_key = params.get("partKey", [""])[0].lower()
 
-        # URL'den video ID'sini çıkar
-        # https://vctplay.site/video/2hjDGco5exdv -> 2hjDGco5exdv
-        video_id = url.split("/")[-1]
-        if "?" in video_id:
-            video_id = video_id.split("?")[0]
-
-        # Manifests URL oluştur
-        master_url = f"{self.main_url}/manifests/{video_id}/master.txt"
-
-        # partKey'den isim belirle
-        parsed   = urlparse(url)
-        params   = parse_qs(parsed.query)
-        part_key = params.get("partKey", [""])[0]
-
-        name_suffix = ""
-        if "turkcedublaj" in part_key.lower():
-            name_suffix = "Dublaj"
-        elif "turkcealtyazi" in part_key.lower():
-            name_suffix = "Altyazı"
-
-        display_name = f"{self.name} - {name_suffix}" if name_suffix else self.name
+        suffix = ""
+        if "turkcedublaj" in part_key: suffix = "Dublaj"
+        elif "turkcealtyazi" in part_key: suffix = "Altyazı"
 
         return ExtractResult(
-            name      = display_name,
-            url       = master_url,
-            referer   = f"{self.main_url}/",
-            subtitles = []
+            name    = f"{self.name} - {suffix}" if suffix else self.name,
+            url     = f"{self.main_url}/manifests/{v_id}/master.txt",
+            referer = f"{self.main_url}/"
         )

KekikStream/Extractors/VidHide.py

@@ -25,46 +25,26 @@ class VidHide(ExtractorBase):
             return url.replace("/f/", "/v/")
 
     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})
-
         self.httpx.headers.update({
-            "Sec-Fetch-Dest" : "empty",
-            "Sec-Fetch-Mode" : "cors",
-            "Sec-Fetch-Site" : "cross-site",
-            "Origin"         : base_url,
+            "Referer" : referer or base_url,
+            "Origin"  : base_url,
         })
         
         embed_url = self.get_embed_url(url)
         istek     = await self.httpx.get(embed_url)
-        response  = istek.text
+        sel       = HTMLHelper(istek.text)
 
-        script = None
-        if "eval(function" in response:
+        unpacked = ""
+        if "eval(function" in istek.text:
             try:
-                unpacked = Packer.unpack(response)
-                if "var links" in unpacked:
-                    script = unpacked.split("var links")[1]
-                else:
-                    script = unpacked
-            except Exception:
+                unpacked = Packer.unpack(istek.text)
+            except:
                 pass
         
-        if not script:
-             script = HTMLHelper(response).regex_first(r'(?s)sources:\s*(\[.*?\])')
-
-        m3u8_url = None
-        if script:
-            # m3u8 urls could be prefixed by 'file:', 'hls2:' or 'hls4:', so we just match ':'
-            m3u8_url = HTMLHelper(script).regex_first(r':\s*"([^\"]*?m3u8[^\"]*?)"')
+        content  = unpacked or istek.text
+        m3u8_url = HTMLHelper(content).regex_first(r'[:"]\s*["\']([^"\']+\.m3u8[^"\']*)["\']')
 
-        if not m3u8_url:
-            # Fallback direct search in response if unpacking failed or structure changed
-            m3u8_url = HTMLHelper(response).regex_first(r'file:"(.*?\.m3u8.*?)"')
-        
         if not m3u8_url:
             raise ValueError(f"VidHide: Video URL bulunamadı. {url}")
 
@@ -72,6 +52,5 @@ class VidHide(ExtractorBase):
             name       = self.name,
             url        = self.fix_url(m3u8_url),
             referer    = f"{base_url}/",
-            user_agent = self.httpx.headers.get("User-Agent", ""),
-            subtitles  = []
+            user_agent = self.httpx.headers.get("User-Agent", "")
         )

KekikStream/Extractors/VidMoly.py

@@ -9,7 +9,7 @@ class VidMoly(ExtractorBase):
     main_url = "https://vidmoly.to"
 
     # Birden fazla domain destekle
-    supported_domains = ["vidmoly.to", "vidmoly.me", "vidmoly.net"]
+    supported_domains = ["vidmoly.to", "vidmoly.me", "vidmoly.net", "vidmoly.biz"]
 
     def can_handle_url(self, url: str) -> bool:
         return any(domain in url for domain in self.supported_domains)
@@ -18,112 +18,78 @@ class VidMoly(ExtractorBase):
         if referer:
             self.httpx.headers.update({"Referer": referer})
 
-        self.httpx.headers.update({
-            "Sec-Fetch-Dest" : "iframe",
-        })
-
-        if ".me" in url:
-            url = url.replace(".me", ".net")
-        if ".to" in url:
-            url = url.replace(".to", ".net")
-
-        # VidMoly bazen redirect ediyor, takip et
-        response = await self.httpx.get(url, follow_redirects=True)
-        if "Select number" in response.text:
-            secici = HTMLHelper(response.text)
-
-            op_val        = secici.select_attr("input[name='op']", "value")
-            file_code_val = secici.select_attr("input[name='file_code']", "value")
-            answer_val    = secici.select_text("div.vhint b")
-            ts_val        = secici.select_attr("input[name='ts']", "value")
-            nonce_val     = secici.select_attr("input[name='nonce']", "value")
-            ctok_val      = secici.select_attr("input[name='ctok']", "value")
-
-            response = await self.httpx.post(
-                url  = url,
-                data = {
-                    "op"        : op_val,
-                    "file_code" : file_code_val,
-                    "answer"    : answer_val,
-                    "ts"        : ts_val,
-                    "nonce"     : nonce_val,
-                    "ctok"      : ctok_val
-                },
-                follow_redirects=True
-            )
-
+        self.httpx.headers.update({"Sec-Fetch-Dest" : "iframe"})
+
+        # Domain normalleştirme
+        url = url.replace(".me", ".net").replace(".to", ".net")
+
+        resp = await self.httpx.get(url, follow_redirects=True)
+        sel  = HTMLHelper(resp.text)
+
+        # "Select number" kontrolü (Bot koruması)
+        if "Select number" in resp.text:
+            op_val        = sel.select_attr("input[name='op']", "value")
+            file_code_val = sel.select_attr("input[name='file_code']", "value")
+            answer_val    = sel.select_text("div.vhint b")
+            ts_val        = sel.select_attr("input[name='ts']", "value")
+            nonce_val     = sel.select_attr("input[name='nonce']", "value")
+            ctok_val      = sel.select_attr("input[name='ctok']", "value")
+
+            resp = await self.httpx.post(url, data={
+                "op"        : op_val,
+                "file_code" : file_code_val,
+                "answer"    : answer_val,
+                "ts"        : ts_val,
+                "nonce"     : nonce_val,
+                "ctok"      : ctok_val
+            }, follow_redirects=True)
+            sel = HTMLHelper(resp.text)
 
         # Altyazı kaynaklarını ayrıştır
         subtitles = []
-        resp_sec = HTMLHelper(response.text)
-        if subtitle_str := resp_sec.regex_first(r"tracks:\s*\[(.*?)\]", flags= re.DOTALL):
-            subtitle_data = self._add_marks(subtitle_str, "file")
-            subtitle_data = self._add_marks(subtitle_data, "label")
-            subtitle_data = self._add_marks(subtitle_data, "kind")
+        if sub_str := sel.regex_first(r"tracks:\s*\[(.*?)\]", flags=re.DOTALL):
+            sub_data = self._add_marks(sub_str, "file")
+            sub_data = self._add_marks(sub_data, "label")
+            sub_data = self._add_marks(sub_data, "kind")
 
             with contextlib.suppress(json.JSONDecodeError):
-                subtitle_sources = json.loads(f"[{subtitle_data}]")
+                sub_sources = json.loads(f"[{sub_data}]")
                 subtitles = [
-                    Subtitle(
-                        name = sub.get("label"),
-                        url  = self.fix_url(sub.get("file")),
-                    )
-                        for sub in subtitle_sources
-                            if sub.get("kind") == "captions"
+                    Subtitle(name=sub.get("label"), url=self.fix_url(sub.get("file")))
+                    for sub in sub_sources if sub.get("kind") == "captions"
                 ]
 
-        if "#EXTM3U" in response.text:
-            for line in response.text.splitlines():
-                line = line.strip().replace('"', '').replace("'", "")
-                if line.startswith("http"):
-                    return ExtractResult(
-                        name      = self.name,
-                        url       = line,
-                        referer   = self.main_url,
-                        subtitles = subtitles
-                    )
-
-        if script_str := resp_sec.regex_first(r"sources:\s*\[(.*?)\],", flags= re.DOTALL):
-            script_content = script_str
-            # Video kaynaklarını ayrıştır
-            video_data = self._add_marks(script_content, "file")
-            try:
-                video_sources = json.loads(f"[{video_data}]")
-                # İlk video kaynağını al
-                for source in video_sources:
-                    if file_url := source.get("file"):
-                        return ExtractResult(
-                            name      = self.name,
-                            url       = file_url,
-                            referer   = self.main_url,
-                            subtitles = subtitles
-                        )
-            except json.JSONDecodeError:
-                pass
-
-        # Fallback: Doğrudan file regex ile ara (Kotlin mantığı)
-        # file:"..." veya file: "..."
-        if file_match := resp_sec.regex_first(r'file\s*:\s*["\']([^"\']+\.m3u8[^"\']*)["\']'):
-            return ExtractResult(
-                name      = self.name,
-                url       = file_match,
-                referer   = self.main_url,
-                subtitles = subtitles
-            )
-            
-        # Fallback 2: Herhangi bir file (m3u8 olma şartı olmadan ama tercihen)
-        if file_match := resp_sec.regex_first(r'file\s*:\s*["\']([^"\']+)["\']'):
-            url_candidate = file_match
-            # Resim dosyalarını hariç tut
-            if not url_candidate.endswith(('.jpg', '.png', '.jpeg')):
-                return ExtractResult(
-                    name      = self.name,
-                    url       = url_candidate,
-                    referer   = self.main_url,
-                    subtitles = subtitles
-                )
-
-        raise ValueError("Video URL bulunamadı.")
+        # Video URL Bulma
+        video_url = None
+        if "#EXTM3U" in resp.text:
+            for line in resp.text.splitlines():
+                if line.strip().startswith("http"):
+                    video_url = line.strip().replace('"', '').replace("'", "")
+                    break
+
+        if not video_url:
+            if src_str := sel.regex_first(r"sources:\s*\[(.*?)\],", flags=re.DOTALL):
+                vid_data = self._add_marks(src_str, "file")
+                with contextlib.suppress(json.JSONDecodeError):
+                    vid_sources = json.loads(f"[{vid_data}]")
+                    for source in vid_sources:
+                        if source.get("file"):
+                            video_url = source.get("file")
+                            break
+
+        if not video_url:
+            video_url = sel.regex_first(r'file\s*:\s*["\']([^"\']+\.m3u8[^"\']*)["\']') or \
+                        sel.regex_first(r'file\s*:\s*["\']([^"\']+\.mp4[^"\']*)["\']')
+
+        if not video_url:
+            raise ValueError(f"VidMoly: Video URL bulunamadı. {url}")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = video_url,
+            referer   = f"{self.get_base_url(url)}/",
+            subtitles = subtitles
+        )
 
     def _add_marks(self, text: str, field: str) -> str:
         """

KekikStream/Extractors/VidMoxy.py

@@ -7,42 +7,31 @@ class VidMoxy(ExtractorBase):
     name     = "VidMoxy"
     main_url = "https://vidmoxy.com"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
         if referer:
             self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        subtitles        = []
-        subtitle_matches = HTMLHelper(istek.text).regex_all(r'captions","file":"([^\"]+)","label":"([^\"]+)"')
-        seen_subtitles   = set()
+        subtitles = []
+        for s_url, s_lang in sel.regex_all(r'captions","file":"([^\"]+)","label":"([^\"]+)"'):
+            decoded_lang = s_lang.encode().decode('unicode_escape')
+            subtitles.append(Subtitle(name=decoded_lang, url=s_url.replace("\\", "")))
 
-        for sub_url, sub_lang in subtitle_matches:
-            if sub_url in seen_subtitles:
-                continue
+        hex_data = sel.regex_first(r'file": "(.*)",')
+        if not hex_data:
+            eval_data = sel.regex_first(r'\};\s*(eval\(function[\s\S]*?)var played = \d+;')
+            if eval_data:
+                unpacked = Packer.unpack(Packer.unpack(eval_data))
+                hex_data = HTMLHelper(unpacked).regex_first(r'file":"(.*)","label')
 
-            seen_subtitles.add(sub_url)
-            decoded_lang = (
-                sub_lang.replace("\\u0131", "ı")
-                        .replace("\\u0130", "İ")
-                        .replace("\\u00fc", "ü")
-                        .replace("\\u00e7", "ç")
-            )
-            subtitles.append(Subtitle(name=decoded_lang, url=sub_url.replace("\\", "")))
-
-        escaped_hex = HTMLHelper(istek.text).regex_first(r'file": "(.*)",')
-        if not escaped_hex:
-            eval_jwsetup = HTMLHelper(istek.text).regex_first(r'\};\s*(eval\(function[\s\S]*?)var played = \d+;')
-            jwsetup      = Packer.unpack(Packer.unpack(eval_jwsetup)) if eval_jwsetup else None
-            if jwsetup:
-                escaped_hex  = HTMLHelper(jwsetup).regex_first(r'file":"(.*)","label')
-
-        m3u_link = HexCodec.decode(escaped_hex)
+        if not hex_data:
+            raise ValueError(f"VidMoxy: Hex data bulunamadı. {url}")
 
         return ExtractResult(
             name      = self.name,
-            url       = m3u_link,
+            url       = HexCodec.decode(hex_data),
             referer   = self.main_url,
             subtitles = subtitles
         )