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

KekikStream/Extractors/VidMoly.py

@@ -9,22 +9,28 @@ class VidMoly(ExtractorBase):
     name     = "VidMoly"
     main_url = "https://vidmoly.to"
 
+    # Birden fazla domain destekle
+    supported_domains = ["vidmoly.to", "vidmoly.me", "vidmoly.net"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     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",
         })
 
-        if self.main_url.endswith(".me"):
-            self.main_url = self.main_url.replace(".me", ".net")
+        if ".me" in url:
             url = url.replace(".me", ".net")
 
-        response = await self.cffi.get(url)
+        # VidMoly bazen redirect ediyor, takip et
+        response = await self.httpx.get(url, follow_redirects=True)
         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(),
@@ -33,21 +39,10 @@ class VidMoly(ExtractorBase):
                     "ts"        : secici.css("input[name='ts']::attr(value)").get(),
                     "nonce"     : secici.css("input[name='nonce']::attr(value)").get(),
                     "ctok"      : secici.css("input[name='ctok']::attr(value)").get()
-                }
+                },
+                follow_redirects=True
             )
 
-        script_match   = re.search(r"sources:\s*\[(.*?)\],", response.text, re.DOTALL)
-        script_content = script_match[1] if script_match else None
-
-        if not script_content:
-            raise ValueError("Gerekli script bulunamadı.")
-
-        # Video kaynaklarını ayrıştır
-        video_data = self._add_marks(script_content, "file")
-        try:
-            video_sources = json.loads(f"[{video_data}]")
-        except json.JSONDecodeError as hata:
-            raise ValueError("Video kaynakları ayrıştırılamadı.") from hata
 
         # Altyazı kaynaklarını ayrıştır
         subtitles = []
@@ -66,23 +61,49 @@ class VidMoly(ExtractorBase):
                         for sub in subtitle_sources
                             if sub.get("kind") == "captions"
                 ]
-        # İlk video kaynağını al
-        video_url = None
-        for source in video_sources:
-            if file_url := source.get("file"):
-                video_url = file_url
-                break
 
-        if not video_url:
-            raise ValueError("Video URL bulunamadı.")
+        script_match = re.search(r"sources:\s*\[(.*?)\],", response.text, re.DOTALL)
+        if script_match:
+            script_content = script_match[1]
+            # 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 := re.search(r'file\s*:\s*["\']([^"\']+\.m3u8[^"\']*)["\']', response.text):
+            return ExtractResult(
+                name      = self.name,
+                url       = file_match.group(1),
+                referer   = self.main_url,
+                subtitles = subtitles
+            )
+            
+        # Fallback 2: Herhangi bir file (m3u8 olma şartı olmadan ama tercihen)
+        if file_match := re.search(r'file\s*:\s*["\']([^"\']+)["\']', response.text):
+            url_candidate = file_match.group(1)
+            # 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
+                )
 
-        return ExtractResult(
-            name      = self.name,
-            url       = video_url,
-            referer   = self.main_url,
-            headers   = {},
-            subtitles = subtitles
-        )
+        raise ValueError("Video URL bulunamadı.")
 
     def _add_marks(self, text: str, field: str) -> str:
         """

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,211 @@
+# 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)
+
+    _POPULAR_TLDS = {
+        "com", "net", "org", "tv", "io", "co", "me", "ly", "ru", "fr", "de", "es", "it",
+        "nl", "be", "ch", "at", "uk", "ca", "au", "jp", "kr", "cn", "in", "br", "mx",
+        "ar", "tr", "gov", "edu", "mil", "int", "info", "biz", "name", "pro", "aero",
+        "coop", "museum", "onion"
+    }
+
+    # 1. Literal TLD Regex: youtube\.com, vimeo\.com
+    # sorted by reverse length to prevent partial matches (e.g. 'co' matching 'com')
+    _LITERAL_TLD_RE = re.compile(
+        rf"([a-z0-9][-a-z0-9]*(?:\\\.[-a-z0-9]+)*\\\.(?:{'|'.join(sorted(_POPULAR_TLDS, key=len, reverse=True))}))",
+        re.IGNORECASE
+    )
+
+    # 2. Regex TLD Regex: dailymotion\.[a-z]{2,3}
+    _REGEX_TLD_RE = re.compile(
+        r"([a-z0-9][-a-z0-9]*)\\\.\[a-z\]\{?\d*,?\d*\}?",
+        re.IGNORECASE
+    )
+
+    # 3. Alternation TLD Regex: \.(?:com|net|org)
+    _ALT_TLD_RE = re.compile(
+        r"\\\.\(\?:([a-z|]+)\)",
+        re.IGNORECASE
+    )
+
+    # Kelime yakalayıcı (domain bulmak için)
+    _DOMAIN_WORD_RE = re.compile(
+        r"([a-z0-9][-a-z0-9]*)",
+        re.IGNORECASE
+    )
+
+    @classmethod
+    def _extract_literal_domains(cls, valid_url: str) -> set[str]:
+        """Pattern 1: Literal TLD domainlerini (youtube.com) çıkarır."""
+        return {
+            m.replace(r"\.", ".").lower()
+            for m in cls._LITERAL_TLD_RE.findall(valid_url)
+        }
+
+    @classmethod
+    def _extract_regex_tld_domains(cls, valid_url: str) -> set[str]:
+        """Pattern 2: Regex TLD domainlerini (dailymotion.[...]) çıkarır ve popüler TLD'lerle birleştirir."""
+        domains = set()
+        for base in cls._REGEX_TLD_RE.findall(valid_url):
+            base_domain = base.lower()
+            for tld in cls._POPULAR_TLDS:
+                domains.add(f"{base_domain}.{tld}")
+        return domains
+
+    @classmethod
+    def _extract_alternation_domains(cls, valid_url: str) -> set[str]:
+        """Pattern 3: Alternation TLD domainlerini (pornhub.(?:com|net)) çıkarır."""
+        domains = set()
+        for m in cls._ALT_TLD_RE.finditer(valid_url):
+            tlds = m.group(1).split("|")
+            start = m.start()
+
+            # Geriye doğru git ve domain'i bul
+            before = valid_url[:start]
+
+            # 1. Named Groups (?P<name> temizle
+            before = re.sub(r"\(\?P<[^>]+>", "", before)
+
+            # 2. Simple Non-Capturing Groups (?:xxx)? temizle (sadece alphanumeric ve escape)
+            before = re.sub(r"\(\?:[a-z0-9-]+\)\??", "", before)
+
+            # Son domain-like kelimeyi al
+            words = cls._DOMAIN_WORD_RE.findall(before)
+            if not words:
+                continue
+
+            base = words[-1].lower()
+            for tld in tlds:
+                tld = tld.strip().lower()
+                if tld and len(tld) <= 6:
+                    domains.add(f"{base}.{tld}")
+
+        return domains
+
+    @classmethod
+    def _init_fast_domain_regex(cls):
+        """
+        Fast domain regex'i initialize et
+        """
+        if cls._FAST_DOMAIN_RE is not None:
+            return
+
+        domains = set()
+        extractors = get_ytdlp_extractors()
+
+        for ie in extractors:
+            valid = getattr(ie, "_VALID_URL", None)
+            if not valid or not isinstance(valid, str):
+                continue
+
+            domains |= cls._extract_literal_domains(valid)
+            domains |= cls._extract_regex_tld_domains(valid)
+            domains |= cls._extract_alternation_domains(valid)
+
+        # 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
+
+        joined = "|".join(re.escape(d) for d in sorted(domains))
+        cls._FAST_DOMAIN_RE = re.compile(rf"(?:^|.*\.)(?:{joined})$", 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
+        """
+        # 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
+
+        # 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

KekikStream/Extractors/YildizKisaFilm.py

@@ -0,0 +1,41 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+
+class YildizKisaFilm(ExtractorBase):
+    name     = "YildizKisaFilm"
+    main_url = "https://yildizkisafilm.org"
+
+    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"
+            }
+        )
+        response.raise_for_status()
+
+        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   = ext_ref,
+            subtitles = []
+        )