KekikStream 1.7.1__py3-none-any.whl → 2.0.2__py3-none-any.whl

KekikStream/Extractors/SetPrime.py

@@ -0,0 +1,45 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from urllib.parse import urlparse, parse_qs
+import re
+
+class SetPrime(ExtractorBase):
+    name     = "SetPrime"
+    main_url = "https://setplay.site"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        # URL parsing
+        parsed = urlparse(url)
+        params = parse_qs(parsed.query)
+        part_key = params.get("partKey", [""])[0].upper()
+        clean_url = url.split("?partKey=")[0]
+        
+        # POST URL: embed?i= -> embed/get?i=
+        post_url = clean_url.replace("embed?i=", "embed/get?i=")
+        
+        response = await self.httpx.post(
+            url     = post_url,
+            headers = {"Referer": clean_url}
+        )
+        response.raise_for_status()
+        
+        # Links parse
+        links_match = re.search(r'Links":\["([^"\]]+)"', response.text)
+        if not links_match:
+            raise ValueError("Links not found in SetPrime response")
+            
+        link_suffix = links_match.group(1)
+        if not link_suffix.startswith("/"):
+            raise ValueError("Links not valid (must start with /)")
+            
+        m3u_link = f"{self.main_url}{link_suffix}"
+        
+        display_name = f"{self.name} - {part_key}" if part_key else self.name
+
+        return ExtractResult(
+            name      = display_name,
+            url       = m3u_link,
+            referer   = clean_url,
+            subtitles = []
+        )

KekikStream/Extractors/SibNet.py

@@ -9,9 +9,9 @@ class SibNet(ExtractorBase):
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        response = await self.cffi.get(url)
+        response = await self.httpx.get(url)
         response.raise_for_status()
 
         match = re.search(r'player\.src\(\[\{src: \"([^\"]+)\"', response.text)
@@ -24,6 +24,5 @@ class SibNet(ExtractorBase):
             name      = self.name,
             url       = m3u_link,
             referer   = url,
-            headers   = {},
             subtitles = []
         )

KekikStream/Extractors/Sobreatsesuyp.py

@@ -9,9 +9,9 @@ class Sobreatsesuyp(ExtractorBase):
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.cffi.get(url)
+        istek = await self.httpx.get(url)
         istek.raise_for_status()
 
         file_match = re.search(r'file\":\"([^\"]+)', istek.text)
@@ -21,7 +21,7 @@ class Sobreatsesuyp(ExtractorBase):
         file_path = file_match[1].replace("\\", "")
         post_link = f"{self.main_url}/{file_path}"
 
-        post_istek = await self.cffi.post(post_link)
+        post_istek = await self.httpx.post(post_link)
         post_istek.raise_for_status()
 
         try:
@@ -41,7 +41,7 @@ class Sobreatsesuyp(ExtractorBase):
                 continue
 
             playlist_url     = f"{self.main_url}/playlist/{file.lstrip('/')}.txt"
-            playlist_request = await self.cffi.post(playlist_url, headers={"Referer": referer or self.main_url})
+            playlist_request = await self.httpx.post(playlist_url, headers={"Referer": referer or self.main_url})
             playlist_request.raise_for_status()
 
             all_results.append(
@@ -49,7 +49,6 @@ class Sobreatsesuyp(ExtractorBase):
                     name      = f"{self.name} - {title}",
                     url       = playlist_request.text,
                     referer   = self.main_url,
-                    headers   = {},
                     subtitles = []
                 )
             )

KekikStream/Extractors/TRsTX.py

@@ -9,9 +9,9 @@ class TRsTX(ExtractorBase):
 
     async def extract(self, url, referer=None) -> list[ExtractResult]:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.cffi.get(url)
+        istek = await self.httpx.get(url)
         istek.raise_for_status()
 
         file_match = re.search(r'file\":\"([^\"]+)', istek.text)
@@ -21,7 +21,7 @@ class TRsTX(ExtractorBase):
         file_path = file_match[1].replace("\\", "")
         post_link = f"{self.main_url}/{file_path}"
 
-        post_istek = await self.cffi.post(post_link)
+        post_istek = await self.httpx.post(post_link)
         post_istek.raise_for_status()
 
         try:
@@ -42,7 +42,7 @@ class TRsTX(ExtractorBase):
                 continue
 
             playlist_url = f"{self.main_url}/playlist/{file.lstrip('/')}.txt"
-            playlist_request = await self.cffi.post(playlist_url, headers={"Referer": referer or self.main_url})
+            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
@@ -57,7 +57,6 @@ class TRsTX(ExtractorBase):
                     name      = f"{self.name} - {title}",
                     url       = video_data,
                     referer   = self.main_url,
-                    headers   = {},
                     subtitles = []
                 )
             )

KekikStream/Extractors/TauVideo.py

@@ -8,12 +8,12 @@ class TauVideo(ExtractorBase):
 
     async def extract(self, url, referer=None) -> list[ExtractResult]:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
         video_key = url.split("/")[-1]
         api_url   = f"{self.main_url}/api/video/{video_key}"
 
-        response = await self.cffi.get(api_url)
+        response = await self.httpx.get(api_url)
         response.raise_for_status()
 
         api_data = response.json()
@@ -26,7 +26,6 @@ class TauVideo(ExtractorBase):
                     name      = f"{self.name} - {video['label']}",
                     url       = video["url"],
                     referer   = referer or self.main_url,
-                    headers   = {},
                     subtitles = []
                 )
                     for video in api_data["urls"]

KekikStream/Extractors/TurboImgz.py

@@ -9,9 +9,9 @@ class TurboImgz(ExtractorBase):
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.cffi.get(url)
+        istek = await self.httpx.get(url)
         istek.raise_for_status()
 
         if video_match := re.search(r'file: "(.*)",', istek.text):
@@ -19,7 +19,6 @@ class TurboImgz(ExtractorBase):
                 name      = self.name,
                 url       = video_match[1],
                 referer   = referer or self.main_url,
-                headers   = {},
                 subtitles = []
             )
         else:

KekikStream/Extractors/TurkeyPlayer.py

@@ -0,0 +1,34 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re, json
+
+class TurkeyPlayer(ExtractorBase):
+    name     = "TurkeyPlayer"
+    main_url = "https://watch.turkeyplayer.com/"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+        
+        istek       = await self.httpx.get(url)
+        page_content = istek.text
+
+        video_json_match = re.search(r'var\s+video\s*=\s*(\{.*?\});', page_content, re.DOTALL)
+        if not video_json_match:
+             raise ValueError("TurkeyPlayer: Video JSON bulunamadı")
+
+        video_data = json.loads(video_json_match.group(1))
+        
+        video_id  = video_data.get("id")
+        video_md5 = video_data.get("md5")
+
+        master_url = f"https://watch.turkeyplayer.com/m3u8/8/{video_md5}/master.txt?s=1&id={video_id}&cache=1"
+        
+        return ExtractResult(
+            name       = self.name,
+            url        = master_url,
+            referer    = referer or url,
+            user_agent = self.httpx.headers.get("User-Agent", ""),
+            subtitles  = []
+        )

KekikStream/Extractors/VidHide.py

@@ -0,0 +1,72 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from Kekik.Sifreleme  import Packer
+from parsel           import Selector
+import re
+
+class VidHide(ExtractorBase):
+    name     = "VidHide"
+    main_url = "https://vidhidepro.com"
+
+    def get_embed_url(self, url: str) -> str:
+        if "/d/" in url:
+            return url.replace("/d/", "/v/")
+        elif "/download/" in url:
+            return url.replace("/download/", "/v/")
+        elif "/file/" in url:
+            return url.replace("/file/", "/v/")
+        else:
+            return url.replace("/f/", "/v/")
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        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"         : self.main_url,
+        })
+        
+        embed_url = self.get_embed_url(url)
+        istek     = await self.httpx.get(embed_url)
+        response  = istek.text
+
+        script = None
+        if "eval(function" in response:
+            try:
+                unpacked = Packer.unpack(response)
+                if "var links" in unpacked:
+                    script = unpacked.split("var links")[1]
+                else:
+                    script = unpacked
+            except Exception:
+                pass
+        
+        if not script:
+             if matches := re.search(r'sources:\s*(\[.*?\])', response, re.DOTALL):
+                 script = matches.group(1)
+
+        m3u8_url = None
+        if script:
+            # m3u8 urls could be prefixed by 'file:', 'hls2:' or 'hls4:', so we just match ':'
+            if match := re.search(r':\s*"([^"]*?m3u8[^"]*?)"', script):
+                 m3u8_url = match.group(1)
+
+        if not m3u8_url:
+            # Fallback direct search in response if unpacking failed or structure changed
+            if match := re.search(r'file:"(.*?\.m3u8.*?)"', response):
+                m3u8_url = match.group(1)
+        
+        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"{self.main_url}/",
+            user_agent = self.httpx.headers.get("User-Agent", ""),
+            subtitles  = []
+        )

KekikStream/Extractors/VidMoly.py

@@ -11,9 +11,9 @@ class VidMoly(ExtractorBase):
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        self.cffi.headers.update({
+        self.httpx.headers.update({
             "Sec-Fetch-Dest" : "iframe",
         })
 
@@ -21,10 +21,10 @@ class VidMoly(ExtractorBase):
             self.main_url = self.main_url.replace(".me", ".net")
             url = url.replace(".me", ".net")
 
-        response = await self.cffi.get(url)
+        response = await self.httpx.get(url)
         if "Select number" in response.text:
             secici = Selector(response.text)
-            response = await self.cffi.post(
+            response = await self.httpx.post(
                 url  = url,
                 data = {
                     "op"        : secici.css("input[name='op']::attr(value)").get(),
@@ -80,7 +80,6 @@ class VidMoly(ExtractorBase):
             name      = self.name,
             url       = video_url,
             referer   = self.main_url,
-            headers   = {},
             subtitles = subtitles
         )
 

KekikStream/Extractors/{VidMolyMe.py → VidMoly_.py}

@@ -4,4 +4,4 @@ from KekikStream.Extractors.VidMoly import VidMoly
 
 class VidMolyMe(VidMoly):
     name     = "VidMolyMe"
-    main_url = "https://vidmoly.me"
+    main_url = "https://vidmoly.me"

KekikStream/Extractors/VidMoxy.py

@@ -10,9 +10,9 @@ class VidMoxy(ExtractorBase):
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.cffi.get(url)
+        istek = await self.httpx.get(url)
         istek.raise_for_status()
 
         subtitles        = []
@@ -45,6 +45,5 @@ class VidMoxy(ExtractorBase):
             name      = self.name,
             url       = m3u_link,
             referer   = self.main_url,
-            headers   = {},
             subtitles = subtitles
         )

KekikStream/Extractors/VidPapi.py

@@ -0,0 +1,89 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re
+
+class VidPapi(ExtractorBase):
+    name     = "VidApi"
+    main_url = "https://vidpapi.xyz"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref = referer or ""
+        
+        # URL parsing
+        if "video/" in url:
+            vid_id = url.split("video/")[-1]
+        else:
+            vid_id = url.split("?data=")[-1]
+            
+        # 1. Altyazıları çek
+        sub_url = f"{self.main_url}/player/index.php?data={vid_id}"
+        sub_headers = {
+            "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+            "X-Requested-With" : "XMLHttpRequest",
+            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0",
+            "Referer"          : ext_ref or "https://kultfilmler.pro/"
+        }
+        
+        subtitles = []
+        try:
+            sub_istek = await self.httpx.post(
+                url     = sub_url,
+                headers = sub_headers,
+                data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+            )
+            
+            subtitle_match = re.search(r'var playerjsSubtitle = "([^"]*)"', sub_istek.text, re.IGNORECASE)
+            if subtitle_match and subtitle_match.group(1):
+                raw_subs = subtitle_match.group(1)
+                
+                found_subs = re.findall(r'\[(.*?)\](.*?)(?:,|$)', raw_subs)
+                for lang, sub_link in found_subs:
+                    lang = lang.strip()
+                    if "Türkçe" in lang:
+                        lang_code = "tr"
+                        lang_name = "Turkish"
+                    elif "İngilizce" in lang:
+                        lang_code = "en"
+                        lang_name = "English"
+                    else:
+                        lang_code = lang[:2].lower()
+                        lang_name = lang
+                        
+                    subtitles.append(Subtitle(
+                        name = lang_name,
+                        url  = sub_link.strip()
+                    ))
+                    
+        except Exception as e:
+            pass
+
+        # 2. Videoyu çek
+        video_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
+        video_headers = sub_headers.copy()
+        
+        response = await self.httpx.post(
+            url     = video_url,
+            headers = video_headers,
+            data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+        )
+        response.raise_for_status()
+        
+        try:
+            video_data = response.json()
+        except Exception:
+            return None
+
+        stream_url = video_data.get("securedLink")
+        if not stream_url or not stream_url.strip():
+            stream_url = video_data.get("videoSource")
+            
+        if not stream_url:
+            raise ValueError("No video link found in VidPapi response")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = stream_url,
+            referer   = ext_ref or self.main_url,
+            subtitles = subtitles
+        )

KekikStream/Extractors/VideoSeyred.py

@@ -9,18 +9,18 @@ class VideoSeyred(ExtractorBase):
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
-            self.cffi.headers.update({"Referer": referer})
+            self.httpx.headers.update({"Referer": referer})
 
         video_id  = url.split("embed/")[1].split("?")[0]
         if len(video_id) > 10:
-            kontrol = await self.cffi.get(url)
+            kontrol = await self.httpx.get(url)
             kontrol.raise_for_status()
 
             video_id = re.search(r"playlist\/(.*)\.json", kontrol.text)[1]
 
         video_url = f"{self.main_url}/playlist/{video_id}.json"
 
-        response = await self.cffi.get(video_url)
+        response = await self.httpx.get(video_url)
         response.raise_for_status()
 
         try:
@@ -43,7 +43,6 @@ class VideoSeyred(ExtractorBase):
                 name      = self.name,
                 url       = self.fix_url(source["file"]),
                 referer   = self.main_url,
-                headers   = {},
                 subtitles = subtitles,
             )
                 for source in response_data.get("sources", [])

KekikStream/Extractors/YTDLP.py

@@ -0,0 +1,177 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, get_ytdlp_extractors
+from urllib.parse     import urlparse
+import yt_dlp, re, sys, os
+
+class YTDLP(ExtractorBase):
+    name     = "yt-dlp"
+    main_url = ""  # Universal - tüm siteleri destekler
+
+    _FAST_DOMAIN_RE = None  # compiled mega-regex (host üstünden)
+
+    @classmethod
+    def _init_fast_domain_regex(cls):
+        """
+        Fast domain regex'i initialize et
+        """
+        if cls._FAST_DOMAIN_RE is not None:
+            return
+
+        domains = set()
+
+        # Merkezi cache'den extractorları al
+        extractors = get_ytdlp_extractors()
+
+        # yt-dlp extractor'larının _VALID_URL regex'lerinden domain yakala
+        # Regex metinlerinde domainler genelde "\." şeklinde geçer.
+        domain_pat = re.compile(r"(?:[a-z0-9-]+\\\.)+[a-z]{2,}", re.IGNORECASE)
+
+        for ie in extractors:
+            valid = getattr(ie, "_VALID_URL", None)
+            if not valid or not isinstance(valid, str):
+                continue
+
+            for m in domain_pat.findall(valid):
+                d = m.replace(r"\.", ".").lower()
+
+                # Çok agresif/şüpheli şeyleri elemek istersen burada filtre koyabilirsin
+                # (genelde gerek kalmıyor)
+                domains.add(d)
+
+        # Hiç domain çıkmazsa (çok uç durum) fallback: boş regex
+        if not domains:
+            cls._FAST_DOMAIN_RE = re.compile(r"$^")  # hiçbir şeye match etmez
+            return
+
+        # Host eşleştirmesi: subdomain destekli (m.youtube.com, player.vimeo.com vs.)
+        # (?:^|.*\.) (domain1|domain2|...) $
+        joined = "|".join(sorted(re.escape(d) for d in domains))
+        pattern = rf"(?:^|.*\.)(?:{joined})$"
+        cls._FAST_DOMAIN_RE = re.compile(pattern, re.IGNORECASE)
+
+    def __init__(self):
+        self.__class__._init_fast_domain_regex()
+
+    def can_handle_url(self, url: str) -> bool:
+        """
+        Fast-path: URL host'unu tek mega-regex ile kontrol et (loop yok)
+        Slow-path: gerekirse mevcut extract_info tabanlı kontrolün
+        """
+        # URL parse + host al
+        try:
+            parsed = urlparse(url)
+            host = (parsed.hostname or "").lower()
+        except Exception:
+            host = ""
+
+        # Şemasız URL desteği: "youtube.com/..." gibi
+        if not host and "://" not in url:
+            try:
+                parsed = urlparse("https://" + url)
+                host = (parsed.hostname or "").lower()
+            except Exception:
+                host = ""
+
+        # Fast-path
+        if host and self.__class__._FAST_DOMAIN_RE.search(host):
+            return True
+
+        # SLOW PATH: Diğer siteler için yt-dlp'nin native kontrolü
+        try:
+            # stderr'ı geçici olarak kapat (hata mesajlarını gizle)
+            old_stderr = sys.stderr
+            sys.stderr = open(os.devnull, "w")
+
+            try:
+                ydl_opts = {
+                    "simulate"              : True,  # Download yok, sadece tespit
+                    "quiet"                 : True,  # Log kirliliği yok
+                    "no_warnings"           : True,  # Uyarı mesajları yok
+                    "extract_flat"          : True,  # Minimal işlem
+                    "no_check_certificates" : True,
+                    "ignoreerrors"          : True,  # Hataları yoksay
+                    "socket_timeout"        : 3,
+                    "retries"               : 1
+                }
+
+                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                    # URL'yi işleyebiliyor mu kontrol et
+                    info = ydl.extract_info(url, download=False, process=False)
+
+                    # Generic extractor ise atla
+                    if info and info.get("extractor_key") != "Generic":
+                        return True
+
+                    return False
+            finally:
+                # stderr'ı geri yükle
+                sys.stderr.close()
+                sys.stderr = old_stderr
+
+        except Exception:
+            # yt-dlp işleyemezse False döndür
+            return False
+
+    async def extract(self, url: str, referer: str | None = None) -> ExtractResult:
+        ydl_opts = {
+            "quiet"                 : True,
+            "no_warnings"           : True,
+            "extract_flat"          : False,   # Tam bilgi al
+            "format"                : "best",  # En iyi kalite
+            "no_check_certificates" : True,
+            "socket_timeout"        : 3,
+            "retries"               : 1
+        }
+
+        # Referer varsa header olarak ekle
+        if referer:
+            ydl_opts["http_headers"] = {"Referer": referer}
+
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=False)
+
+            if not info:
+                raise ValueError("yt-dlp video bilgisi döndürmedi")
+
+            # Video URL'sini al
+            video_url = info.get("url")
+            if not video_url:
+                # Bazen formatlar listesinde olabilir
+                formats = info.get("formats", [])
+                if formats:
+                    video_url = formats[-1].get("url")  # Son format (genellikle en iyi)
+
+            if not video_url:
+                raise ValueError("Video URL bulunamadı")
+
+            # Altyazıları çıkar
+            subtitles = []
+            if subtitle_data := info.get("subtitles"):
+                for lang, subs in subtitle_data.items():
+                    for sub in subs:
+                        if sub_url := sub.get("url"):
+                            subtitles.append(
+                                Subtitle(
+                                    name=f"{lang} ({sub.get('ext', 'unknown')})",
+                                    url=sub_url
+                                )
+                            )
+
+            # User-Agent al
+            user_agent = None
+            http_headers = info.get("http_headers", {})
+            if http_headers:
+                user_agent = http_headers.get("User-Agent")
+
+            return ExtractResult(
+                name       = self.name,
+                url        = video_url,
+                referer    = referer or info.get("webpage_url"),
+                user_agent = user_agent,
+                subtitles  = subtitles
+            )
+
+    async def close(self):
+        """yt-dlp için cleanup gerekmez"""
+        pass