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

KekikStream/Core/Extractor/ExtractorBase.py

@@ -5,7 +5,7 @@ from cloudscraper     import CloudScraper
 from httpx            import AsyncClient
 from typing           import Optional
 from .ExtractorModels import ExtractResult
-from urllib.parse     import urljoin
+from urllib.parse     import urljoin, urlparse
 
 class ExtractorBase(ABC):
     # Çıkarıcının temel özellikleri
@@ -29,6 +29,11 @@ class ExtractorBase(ABC):
         # URL'nin bu çıkarıcı tarafından işlenip işlenemeyeceğini kontrol et
         return self.main_url in url
 
+    def get_base_url(self, url: str) -> str:
+        """URL'den base URL'i çıkar (scheme + netloc)"""
+        parsed = urlparse(url)
+        return f"{parsed.scheme}://{parsed.netloc}"
+
     @abstractmethod
     async def extract(self, url: str, referer: Optional[str] = None) -> ExtractResult:
         # Alt sınıflar tarafından uygulanacak medya çıkarma fonksiyonu
@@ -46,4 +51,4 @@ class ExtractorBase(ABC):
         if url.startswith("http") or url.startswith("{\""):
             return url
 
-        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)

KekikStream/Core/Plugin/PluginBase.py

@@ -1,11 +1,13 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
+from ...CLI                       import konsol
 from abc                          import ABC, abstractmethod
 from cloudscraper                 import CloudScraper
 from httpx                        import AsyncClient
-from .PluginModels                import MainPageResult, SearchResult, MovieInfo
+from .PluginModels                import MainPageResult, SearchResult, MovieInfo, SeriesInfo
 from ..Media.MediaHandler         import MediaHandler
 from ..Extractor.ExtractorManager import ExtractorManager
+from ..Extractor.ExtractorModels  import ExtractResult
 from urllib.parse                 import urljoin
 import re
 
@@ -53,31 +55,31 @@ class PluginBase(ABC):
         pass
 
     @abstractmethod
-    async def load_item(self, url: str) -> MovieInfo:
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         """Bir medya öğesi hakkında detaylı bilgi döndürür."""
         pass
 
     @abstractmethod
-    async def load_links(self, url: str) -> list[dict]:
+    async def load_links(self, url: str) -> list[ExtractResult]:
         """
         Bir medya öğesi için oynatma bağlantılarını döndürür.
-        
+
         Args:
             url: Medya URL'si
-            
+
         Returns:
-            Dictionary listesi, her biri şu alanları içerir:
+            ExtractResult listesi, her biri şu alanları içerir:
             - url (str, zorunlu): Video URL'si
             - name (str, zorunlu): Gösterim adı (tüm bilgileri içerir)
             - referer (str, opsiyonel): Referer header
-            - subtitles (list, opsiyonel): Altyazı listesi
-        
+            - subtitles (list[Subtitle], opsiyonel): Altyazı listesi
+
         Example:
             [
-                {
-                    "url": "https://example.com/video.m3u8",
-                    "name": "HDFilmCehennemi | 1080p TR Dublaj"
-                }
+                ExtractResult(
+                    url="https://example.com/video.m3u8",
+                    name="HDFilmCehennemi | 1080p TR Dublaj"
+                )
             ]
         """
         pass
@@ -95,6 +97,40 @@ class PluginBase(ABC):
 
         return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
 
+    async def extract(self, url: str, referer: str = None, prefix: str | None = None) -> ExtractResult | None:
+        """
+        Extractor ile video URL'sini çıkarır.
+
+        Args:
+            url: Iframe veya video URL'si
+            referer: Referer header (varsayılan: plugin main_url)
+            prefix: İsmin başına eklenecek opsiyonel etiket (örn: "Türkçe Dublaj")
+
+        Returns:
+            ExtractResult: Extractor sonucu (name prefix ile birleştirilmiş) veya None
+
+        Extractor bulunamadığında veya hata oluştuğunda uyarı verir.
+        """
+        if referer is None:
+            referer = f"{self.main_url}/"
+
+        extractor = self.ex_manager.find_extractor(url)
+        if not extractor:
+            konsol.log(f"[magenta][?] {self.name} » Extractor bulunamadı: {url}")
+            return None
+
+        try:
+            data = await extractor.extract(url, referer=referer)
+
+            # prefix varsa name'e ekle
+            if prefix and data.name:
+                data.name = f"{prefix} | {data.name}"
+
+            return data
+        except Exception as hata:
+            konsol.log(f"[red][!] {self.name} » Extractor hatası ({extractor.name}): {hata}")
+            return None
+
     @staticmethod
     def clean_title(title: str) -> str:
         suffixes = [
@@ -119,4 +155,16 @@ class PluginBase(ABC):
         for suffix in suffixes:
             cleaned_title = re.sub(f"{re.escape(suffix)}.*$", "", cleaned_title, flags=re.IGNORECASE).strip()
 
-        return cleaned_title
+        return cleaned_title
+
+    async def play(self, **kwargs):
+        """
+        Varsayılan oynatma metodu.
+        Tüm pluginlerde ortak kullanılır.
+        """
+        extract_result = ExtractResult(**kwargs)
+        self.media_handler.title = kwargs.get("name")
+        if self.name not in self.media_handler.title:
+            self.media_handler.title = f"{self.name} | {self.media_handler.title}"
+
+        self.media_handler.play_media(extract_result)

KekikStream/Extractors/CloseLoad.py

@@ -1,7 +1,8 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
 from Kekik.Sifreleme  import Packer, StreamDecoder
+from parsel           import Selector
 import re
 
 class CloseLoadExtractor(ExtractorBase):
@@ -15,12 +16,26 @@ class CloseLoadExtractor(ExtractorBase):
         istek = await self.httpx.get(url)
         istek.raise_for_status()
 
+        # Video URL'sini çıkar
         eval_func = re.compile(r'\s*(eval\(function[\s\S].*)\s*').findall(istek.text)[0]
         m3u_link  = StreamDecoder.extract_stream_url(Packer.unpack(eval_func))
 
+        # Subtitle'ları parse et (Kotlin referansı: track elementleri)
+        subtitles = []
+        secici = Selector(istek.text)
+        for track in secici.css("track"):
+            raw_src = track.css("::attr(src)").get() or ""
+            raw_src = raw_src.strip()
+            label   = track.css("::attr(label)").get() or track.css("::attr(srclang)").get() or "Altyazı"
+            
+            if raw_src:
+                full_url = raw_src if raw_src.startswith("http") else f"{self.main_url}{raw_src}"
+                subtitles.append(Subtitle(name=label, url=full_url))
+
         return ExtractResult(
             name      = self.name,
             url       = m3u_link,
             referer   = self.main_url,
-            subtitles = []
+            subtitles = subtitles
         )
+

KekikStream/Extractors/ContentX.py

@@ -7,10 +7,26 @@ class ContentX(ExtractorBase):
     name     = "ContentX"
     main_url = "https://contentx.me"
 
+    # Birden fazla domain destekle
+    supported_domains = [
+        "contentx.me", "four.contentx.me",
+        "dplayer82.site", "sn.dplayer82.site", "four.dplayer82.site", "org.dplayer82.site",
+        "dplayer74.site", "sn.dplayer74.site",
+        "hotlinger.com", "sn.hotlinger.com",
+        "playru.net", "four.playru.net",
+        "pichive.online", "four.pichive.online", "pichive.me", "four.pichive.me"
+    ]
+
+    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})
 
+        # Dinamik base URL kullan
+        base_url = self.get_base_url(url)
+
         istek = await self.httpx.get(url)
         istek.raise_for_status()
         i_source = istek.text
@@ -39,7 +55,8 @@ class ContentX(ExtractorBase):
                 )
             )
 
-        vid_source_request = await self.httpx.get(f"{self.main_url}/source2.php?v={i_extract_value}", headers={"Referer": referer or self.main_url})
+        # 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
@@ -59,7 +76,7 @@ class ContentX(ExtractorBase):
 
         if i_dublaj := re.search(r',\"([^"]+)\",\"Türkçe"', i_source):
             dublaj_value          = i_dublaj[1]
-            dublaj_source_request = await self.httpx.get(f"{self.main_url}/source2.php?v={dublaj_value}", headers={"Referer": referer or self.main_url})
+            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

KekikStream/Extractors/DonilasPlay.py

@@ -0,0 +1,86 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from Kekik.Sifreleme   import AESManager
+import re, json
+
+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
+        be_player_match = re.search(r"bePlayer\('([^']+)',\s*'(\{[^}]+\})'\);", i_source)
+        if be_player_match:
+            be_player_pass = be_player_match.group(1)
+            be_player_data = be_player_match.group(2)
+
+            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 = re.search(r'file:"([^"]+)"', i_source)
+            if file_match:
+                m3u_link = file_match.group(1)
+
+            # tracks pattern for subtitles
+            tracks_match = re.search(r'tracks:\[([^\]]+)', i_source)
+            if tracks_match:
+                try:
+                    tracks_str = f"[{tracks_match.group(1)}]"
+                    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
+        )

KekikStream/Extractors/Filemoon.py

@@ -0,0 +1,78 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from Kekik.Sifreleme  import Packer
+from parsel           import Selector
+import re
+
+class Filemoon(ExtractorBase):
+    name     = "Filemoon"
+    main_url = "https://filemoon.to"
+
+    # Filemoon'un farklı domainlerini destekle
+    supported_domains = [
+        "filemoon.to",
+        "filemoon.in",
+        "filemoon.sx",
+        "filemoon.nl",
+        "filemoon.com"
+    ]
+
+    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:
+        headers = {
+            "Referer"        : url,
+            "Sec-Fetch-Dest" : "iframe",
+            "Sec-Fetch-Mode" : "navigate",
+            "Sec-Fetch-Site" : "cross-site",
+        }
+        self.httpx.headers.update(headers)
+
+        # İlk sayfayı al
+        istek    = await self.httpx.get(url)
+        response = istek.text
+        secici   = Selector(response)
+
+        # Eğer iframe varsa, iframe'e git
+        iframe_src = secici.css("iframe::attr(src)").get()
+        if iframe_src:
+            iframe_url = self.fix_url(iframe_src)
+            self.httpx.headers.update({
+                "Accept-Language" : "en-US,en;q=0.5",
+                "Sec-Fetch-Dest"  : "iframe"
+            })
+            istek    = await self.httpx.get(iframe_url)
+            response = istek.text
+
+        # Packed script'i bul ve unpack et
+        m3u8_url = None
+
+        if Packer.detect_packed(response):
+            try:
+                unpacked = Packer.unpack(response)
+                # sources:[{file:"..." pattern'ını ara
+                if match := re.search(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"', unpacked):
+                    m3u8_url = match.group(1)
+                elif match := re.search(r'file:\s*"([^"]*?\.m3u8[^"]*)"', unpacked):
+                    m3u8_url = match.group(1)
+            except Exception:
+                pass
+
+        # Fallback: Doğrudan response'ta ara
+        if not m3u8_url:
+            if match := re.search(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"', response):
+                m3u8_url = match.group(1)
+            elif match := re.search(r'file:\s*"([^"]*?\.m3u8[^"]*)"', response):
+                m3u8_url = match.group(1)
+
+        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}/",
+            subtitles = []
+        )

KekikStream/Extractors/MixTiger.py

@@ -37,16 +37,15 @@ class MixTiger(ExtractorBase):
         if not m3u_link:
             raise ValueError("Video URL not found in response")
 
-        # Recursive extraction check
+        # Recursive extraction check - başka extractor kullanılabilir mi?
         try:
             from KekikStream.Core.Extractor.ExtractorManager import ExtractorManager
-            # Import inside method to avoid circular dependency
             manager = ExtractorManager()
             if nested_extractor := manager.find_extractor(m3u_link):
-                # Use recursive extraction
-                return await nested_extractor.extract(m3u_link, referer=final_referer)
+                # Nested extractor ile çıkar
+                return await nested_extractor.extract(m3u_link, referer=ext_ref)
         except Exception:
-            # If recursion fails, fallback to standard result
+            # Recursive extraction başarısız olursa standart sonucu döndür
             pass
 
         return ExtractResult(
@@ -55,3 +54,4 @@ class MixTiger(ExtractorBase):
             referer   = None if "disk.yandex" in m3u_link else ext_ref,
             subtitles = []
         )
+

KekikStream/Extractors/Odnoklassniki.py

@@ -7,6 +7,12 @@ class Odnoklassniki(ExtractorBase):
     name     = "Odnoklassniki"
     main_url = "https://odnoklassniki.ru"
 
+    # Birden fazla domain destekle
+    supported_domains = ["odnoklassniki.ru", "ok.ru"]
+
+    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) -> ExtractResult:
         if "/video/" in url:
             url = url.replace("/video/", "/videoembed/")

KekikStream/Extractors/PeaceMakerst.py

@@ -7,6 +7,12 @@ class PeaceMakerst(ExtractorBase):
     name     = "PeaceMakerst"
     main_url = "https://peacemakerst.com"
 
+    # Birden fazla domain destekle
+    supported_domains = ["peacemakerst.com", "hdstreamable.com"]
+
+    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) -> ExtractResult:
         if referer:
             self.httpx.headers.update({"Referer": referer})

KekikStream/Extractors/PlayerFilmIzle.py

@@ -1,12 +1,15 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
-import re, json
+import re
 
 class PlayerFilmIzle(ExtractorBase):
     name     = "PlayerFilmIzle"
     main_url = "https://player.filmizle.in"
 
+    def can_handle_url(self, url: str) -> bool:
+        return "filmizle.in" in url or "fireplayer" in url.lower()
+
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
         # Kotlin tarafında referer mainUrl olarak zorlanmış
         ext_ref = self.main_url
@@ -29,20 +32,20 @@ class PlayerFilmIzle(ExtractorBase):
         # Data yakalama: FirePlayer|DATA|...
         data_match = re.search(r'FirePlayer\|([^|]+)\|', video_req, re.IGNORECASE)
         data_val   = data_match.group(1) if data_match else None
-        
+
         if not data_val:
              raise ValueError("PlayerFilmIzle: Data bulunamadı")
 
         url_post = f"{self.main_url}/player/index.php?data={data_val}&do=getVideo"
-        
+
         post_headers = {
             "Referer": ext_ref,
             "X-Requested-With": "XMLHttpRequest"
         }
-        
+
         # Kotlin'de post data: "hash" -> data, "r" -> ""
         post_data = {"hash": data_val, "r": ""}
-        
+
         response = await self.httpx.post(url_post, data=post_data, headers=post_headers)
         get_url  = response.text.replace("\\", "")
 

KekikStream/Extractors/RapidVid.py

@@ -1,13 +1,19 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
-from Kekik.Sifreleme  import Packer, HexCodec
+from Kekik.Sifreleme  import Packer, HexCodec, StreamDecoder
 import re, base64
 
 class RapidVid(ExtractorBase):
     name     = "RapidVid"
     main_url = "https://rapidvid.net"
 
+    # Birden fazla domain destekle
+    supported_domains = ["rapidvid.net", "rapid.filmmakinesi.to"]
+
+    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) -> ExtractResult:
         if referer:
             self.httpx.headers.update({"Referer": referer})
@@ -33,15 +39,25 @@ class RapidVid(ExtractorBase):
             subtitles.append(Subtitle(name=decoded_lang, url=sub_url.replace("\\", "")))
 
         try:
+            decoded_url = None
+
+            # Method 1: file": "..." pattern (HexCodec)
             if extracted_value := re.search(r'file": "(.*)",', istek.text):
                 escaped_hex = extracted_value[1]
                 decoded_url = HexCodec.decode(escaped_hex)
-            else:
-                av_encoded = re.search(r"av\('([^']+)'\)", istek.text)
-                if not av_encoded:
-                    raise ValueError("AV encoding not found.")
 
+            # Method 2: av('...') pattern
+            elif av_encoded := re.search(r"av\('([^']+)'\)", istek.text):
                 decoded_url = self.decode_secret(av_encoded[1])
+
+            # Method 3: Packed script with dc_* function (StreamDecoder)
+            elif Packer.detect_packed(istek.text):
+                unpacked    = Packer.unpack(istek.text)
+                decoded_url = StreamDecoder.extract_stream_url(unpacked)
+
+            if not decoded_url:
+                raise ValueError("No valid video URL pattern found.")
+
         except Exception as hata:
             raise RuntimeError(f"Extraction failed: {hata}") from hata
 

KekikStream/Extractors/SetPlay.py

@@ -1,11 +1,18 @@
 # 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 SetPlay(ExtractorBase):
     name     = "SetPlay"
-    main_url = "https://setplay.cfd"
+    main_url = "https://setplay.shop"
+
+    # Birden fazla domain destekle
+    supported_domains = ["setplay.cfd", "setplay.shop", "setplay.site"]
+
+    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) -> ExtractResult:
         ext_ref = referer or ""
@@ -13,6 +20,9 @@ class SetPlay(ExtractorBase):
         if referer:
             self.httpx.headers.update({"Referer": referer})
 
+        # Dinamik base URL kullan
+        base_url = self.get_base_url(url)
+
         istek = await self.httpx.get(url)
         istek.raise_for_status()
 
@@ -33,7 +43,6 @@ class SetPlay(ExtractorBase):
         title_base = title_match[1].split(".")[-1] if title_match else "Unknown"
         
         # partKey logic
-        from urllib.parse import urlparse, parse_qs
         parsed = urlparse(url)
         params = parse_qs(parsed.query)
         part_key = params.get("partKey", [""])[0]
@@ -46,8 +55,8 @@ class SetPlay(ExtractorBase):
         else:
             name_suffix = title_base
 
-        # M3U8 link oluştur
-        m3u_link = f"{self.main_url}{video_url}?s={video_server}"
+        # M3U8 link oluştur - base_url kullan (main_url yerine)
+        m3u_link = f"{base_url}{video_url}?s={video_server}"
 
         return ExtractResult(
             name      = f"{self.name} - {name_suffix}",

KekikStream/Extractors/VCTPlay.py

@@ -0,0 +1,41 @@
+# 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
+
+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})
+
+        # 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
+
+        return ExtractResult(
+            name      = display_name,
+            url       = master_url,
+            referer   = f"{self.main_url}/",
+            subtitles = []
+        )

KekikStream/Extractors/VidHide.py

@@ -9,6 +9,12 @@ class VidHide(ExtractorBase):
     name     = "VidHide"
     main_url = "https://vidhidepro.com"
 
+    # Birden fazla domain destekle
+    supported_domains = ["vidhidepro.com", "vidhide.com", "rubyvidhub.com"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     def get_embed_url(self, url: str) -> str:
         if "/d/" in url:
             return url.replace("/d/", "/v/")
@@ -20,6 +26,9 @@ 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})
 
@@ -27,7 +36,7 @@ class VidHide(ExtractorBase):
             "Sec-Fetch-Dest" : "empty",
             "Sec-Fetch-Mode" : "cors",
             "Sec-Fetch-Site" : "cross-site",
-            "Origin"         : self.main_url,
+            "Origin"         : base_url,
         })
         
         embed_url = self.get_embed_url(url)
@@ -66,7 +75,7 @@ class VidHide(ExtractorBase):
         return ExtractResult(
             name       = self.name,
             url        = self.fix_url(m3u8_url),
-            referer    = f"{self.main_url}/",
+            referer    = f"{base_url}/",
             user_agent = self.httpx.headers.get("User-Agent", ""),
             subtitles  = []
         )