KekikStream 2.0.3__tar.gz → 2.1.7__tar.gz

{kekikstream-2.0.3 → kekikstream-2.1.7}/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-2.0.3 → kekikstream-2.1.7}/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-2.0.3 → kekikstream-2.1.7}/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-2.0.3 → kekikstream-2.1.7}/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-2.1.7/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-2.0.3 → kekikstream-2.1.7}/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-2.0.3 → kekikstream-2.1.7}/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-2.0.3 → kekikstream-2.1.7}/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-2.0.3 → kekikstream-2.1.7}/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-2.0.3 → kekikstream-2.1.7}/KekikStream/Extractors/RapidVid.py

@@ -8,6 +8,12 @@ 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})

{kekikstream-2.0.3 → kekikstream-2.1.7}/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-2.1.7/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-2.0.3 → kekikstream-2.1.7}/KekikStream/Extractors/VidMoly.py

@@ -9,6 +9,12 @@ 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.httpx.headers.update({"Referer": referer})
@@ -17,11 +23,11 @@ class VidMoly(ExtractorBase):
             "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.httpx.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.httpx.post(
@@ -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,22 +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,
-            subtitles = subtitles
-        )
+        raise ValueError("Video URL bulunamadı.")
 
     def _add_marks(self, text: str, field: str) -> str:
         """