KekikStream 2.3.9__py3-none-any.whl → 2.5.3__py3-none-any.whl

KekikStream/Extractors/PlayerFilmIzle.py

@@ -11,55 +11,36 @@ class PlayerFilmIzle(ExtractorBase):
         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
-        self.httpx.headers.update({"Referer": ext_ref})
+        ref = referer or self.main_url
+        self.httpx.headers.update({"Referer": ref})
         
-        istek     = await self.httpx.get(url)
-        video_req = istek.text
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
         subtitles = []
-        hp = HTMLHelper(video_req)
-        sub_yakala = hp.regex_first(r'(?i)playerjsSubtitle = "([^"]*)"')
-        if sub_yakala:
-            # Format örneği: [dil]url
-            if "]" in sub_yakala:
-                sub_lang_raw, sub_url = sub_yakala.split("]", 1)
-                sub_lang = sub_lang_raw.replace("[", "")
-                subtitles.append(Subtitle(name=sub_lang, url=sub_url))
+        if raw_subs := sel.regex_first(r'playerjsSubtitle\s*=\s*"([^"]*)"'):
+            for lang, link in HTMLHelper(raw_subs).regex_all(r'\[(.*?)\](https?://[^\s\",]+)'):
+                subtitles.append(Subtitle(name=lang.strip(), url=link.strip()))
 
-        # Packed script varsa unpack et
-        unpacked = Packer.unpack(video_req) if Packer.detect_packed(video_req) else video_req
-
-        # Data yakalama: FirePlayer("DATA", ...) formatından
-        data_val = HTMLHelper(unpacked).regex_first(r'(?i)FirePlayer\s*\(\s*["\']([a-f0-9]+)["\']')
+        content  = Packer.unpack(resp.text) if Packer.detect_packed(resp.text) else resp.text
+        data_val = HTMLHelper(content).regex_first(r'FirePlayer\s*\(\s*["\']([a-f0-9]+)["\']')
 
         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("\\", "")
-
-        m3u8_url = ""
-        m3u8_url = HTMLHelper(get_url).regex_first(r'(?i)"securedLink":"([^\\"]*)"') or m3u8_url
+             raise ValueError(f"PlayerFilmIzle: Data bulunamadı. {url}")
 
+        resp_vid = await self.httpx.post(
+            f"{self.main_url}/player/index.php?data={data_val}&do=getVideo",
+            data    = {"hash": data_val, "r": ""},
+            headers = {"X-Requested-With": "XMLHttpRequest"}
+        )
+        
+        m3u8_url = HTMLHelper(resp_vid.text).regex_first(r'"securedLink":"([^"]+)"')
         if not m3u8_url:
-            raise ValueError("PlayerFilmIzle: M3U8 linki bulunamadı")
+            raise ValueError(f"PlayerFilmIzle: Video URL bulunamadı. {url}")
 
         return ExtractResult(
-            name       = self.name,
-            url        = m3u8_url,
-            referer    = ext_ref,
-            user_agent = self.httpx.headers.get("User-Agent", None),
-            subtitles  = subtitles
+            name      = self.name,
+            url       = m3u8_url.replace("\\", ""),
+            referer   = ref,
+            subtitles = subtitles
         )

KekikStream/Extractors/RapidVid.py

@@ -14,57 +14,43 @@ class RapidVid(ExtractorBase):
     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:
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
         if referer:
             self.httpx.headers.update({"Referer": referer})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        subtitles        = []
-        hp = HTMLHelper(istek.text)
-        subtitle_matches = hp.regex_all(r'captions\",\"file\":\"([^\"]+)\",\"label\":\"([^\"]+)\"')
-        seen_subtitles   = set()
-
-        for sub_url, sub_lang in subtitle_matches:
-            if sub_url in seen_subtitles:
-                continue
-
-            seen_subtitles.add(sub_url)
-            decoded_lang = (
-                sub_lang.replace("\\u0131", "ı")
-                        .replace("\\u0130", "İ")
-                        .replace("\\u00fc", "ü")
-                        .replace("\\u00e7", "ç")
-            )
-            subtitles.append(Subtitle(name=decoded_lang, url=sub_url.replace("\\", "")))
+        subtitles = []
+        for s_url, s_lang in sel.regex_all(r'captions","file":"([^\"]+)","label":"([^\"]+)"'):
+            decoded_lang = s_lang.encode().decode('unicode_escape')
+            subtitles.append(Subtitle(name=decoded_lang, url=s_url.replace("\\", "")))
 
         try:
-            decoded_url = None
+            video_url = None
 
-            # Method 1: file": "..." pattern (HexCodec)
-            if extracted_value := hp.regex_first(r'file": "(.*)",'):
-                escaped_hex = extracted_value
-                decoded_url = HexCodec.decode(escaped_hex)
+            # Method 1: HexCodec pattern
+            if hex_data := sel.regex_first(r'file": "(.*)",'):
+                video_url = HexCodec.decode(hex_data)
 
             # Method 2: av('...') pattern
-            elif av_encoded := hp.regex_first(r"av\('([^']+)'\)"):
-                decoded_url = self.decode_secret(av_encoded)
+            elif av_data := sel.regex_first(r"av\('([^']+)'\)"):
+                video_url = self.decode_secret(av_data)
 
-            # 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)
+            # Method 3: Packed dc_*
+            elif Packer.detect_packed(resp.text):
+                unpacked  = Packer.unpack(resp.text)
+                video_url = StreamDecoder.extract_stream_url(unpacked)
 
-            if not decoded_url:
-                raise ValueError("No valid video URL pattern found.")
+            if not video_url:
+                raise ValueError(f"RapidVid: Video URL bulunamadı. {url}")
 
         except Exception as hata:
-            raise RuntimeError(f"Extraction failed: {hata}") from hata
+            raise RuntimeError(f"RapidVid: Extraction failed: {hata}") from hata
 
         return ExtractResult(
             name      = self.name,
-            url       = decoded_url,
+            url       = video_url,
             referer   = self.main_url,
             subtitles = subtitles
         )

KekikStream/Extractors/SetPlay.py

@@ -7,60 +7,35 @@ class SetPlay(ExtractorBase):
     name     = "SetPlay"
     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 ""
-
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
-        # Dinamik base URL kullan
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
         base_url = self.get_base_url(url)
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
-
-        hp = HTMLHelper(istek.text)
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        # videoUrl çıkar
-        video_url = hp.regex_first(r'videoUrl":"([^",]+)"')
-        if not video_url:
-            raise ValueError("videoUrl not found")
-        video_url = video_url.replace("\\", "")
+        v_url = sel.regex_first(r'videoUrl":"([^",]+)"')
+        v_srv = sel.regex_first(r'videoServer":"([^",]+)"')
+        if not v_url or not v_srv:
+            raise ValueError(f"SetPlay: Video url/server bulunamadı. {url}")
 
-        # videoServer çıkar
-        video_server = hp.regex_first(r'videoServer":"([^",]+)"')
-        if not video_server:
-            raise ValueError("videoServer not found")
-
-        # title çıkar (opsiyonel)
-        title_base = hp.regex_first(r'title":"([^",]+)"')
-        title_base = title_base.split(".")[-1] if title_base else "Unknown"
-        
-        # partKey logic
-        parsed = urlparse(url)
-        params = parse_qs(parsed.query)
-        part_key = params.get("partKey", [""])[0]
+        params   = parse_qs(urlparse(url).query)
+        part_key = params.get("partKey", [""])[0].lower()
         
-        name_suffix = ""
-        if "turkcedublaj" in part_key.lower():
-            name_suffix = "Dublaj"
-        elif "turkcealtyazi" in part_key.lower():
-            name_suffix = "Altyazı"
+        suffix = "Bilinmiyor"
+        if "turkcedublaj" in part_key: suffix = "Dublaj"
+        elif "turkcealtyazi" in part_key: suffix = "Altyazı"
         else:
-            name_suffix = title_base
-
-        # M3U8 link oluştur - base_url kullan (main_url yerine)
-        m3u_link = f"{base_url}{video_url}?s={video_server}"
+            title = sel.regex_first(r'title":"([^",]+)"')
+            if title: suffix = title.split(".")[-1]
 
         return ExtractResult(
-            name      = f"{self.name} - {name_suffix}",
-            url       = m3u_link,
-            referer   = url,
-            subtitles = []
+            name      = f"{self.name} - {suffix}",
+            url       = f"{base_url}{v_url.replace('\\', '')}?s={v_srv}",
+            referer   = url
         )

KekikStream/Extractors/SibNet.py

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

KekikStream/Extractors/Sobreatsesuyp.py

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

KekikStream/Extractors/TRsTX.py

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

KekikStream/Extractors/TurboImgz.py

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

KekikStream/Extractors/VCTPlay.py

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

KekikStream/Extractors/Veev.py

@@ -0,0 +1,145 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+from contextlib       import suppress
+
+class Veev(ExtractorBase):
+    name     = "Veev"
+    main_url = "https://veev.to"
+    
+    supported_domains = ["veev.to", "kinoger.to", "poophq.com", "doods.pro", "dood.so", "dood.li", "dood.wf", "dood.cx", "dood.sh", "dood.watch", "dood.pm", "dood.to", "dood.ws"]
+    
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
+    def veev_decode(self, encoded: str) -> str:
+        if not encoded:
+            return ""
+
+        result = []
+        # Python dictionary key integer, value string
+        # Başlangıçta 0-255 ascii karakterleri
+        lut = {i: chr(i) for i in range(256)}
+        n = 256
+
+        c = encoded[0]
+        result.append(c)
+
+        for char in encoded[1:]:
+            code = ord(char)
+            if code < 256:
+                nc = char
+            else:
+                nc = lut.get(code, c + c[0])
+
+            result.append(nc)
+            lut[n] = c + nc[0]
+            n += 1
+            c = nc
+
+        return "".join(result)
+
+    def build_array(self, encoded: str) -> list[list[int]]:
+        result   = []
+        iterator = iter(encoded)
+
+        def next_int_or_zero():
+            try:
+                char = next(iterator)
+                if char.isdigit():
+                    return int(char)
+                return 0
+            except StopIteration:
+                return 0
+
+        count = next_int_or_zero()
+        while count != 0:
+            row = []
+            for _ in range(count):
+                row.append(next_int_or_zero())
+            result.append(list(reversed(row)))
+            count = next_int_or_zero()
+
+        return result
+
+    def decode_url(self, encoded: str, rules: list[int]) -> str:
+        text = encoded
+        for r in rules:
+            if r == 1:
+                text = text[::-1]
+
+            # Hex decode
+            with suppress(Exception):
+                # remove optional whitespace just in case
+                clean_hex = "".join(text.split())
+                arr = bytes.fromhex(clean_hex)
+                # utf-8 decode, replace errors
+                text = arr.decode('utf-8', errors='replace')
+
+            text = text.replace("dXRmOA==", "")
+
+        return text
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        # URL'den ID çıkar
+        # https://veev.to/e/lla8v3k6arev
+        video_id = url.split("/")[-1]
+
+        # Sayfayı al
+        # Referer lazım mı? Genelde lazım olabilir.
+        page_url = f"{self.main_url}/e/{video_id}"
+        resp = await self.httpx.get(page_url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"})
+        html = resp.text
+
+        # Regex ile şifreli stringleri bul
+        # Regex: [.\s'](?:fc|_vvto\[[^]]*)(?:['\]]*)?\s*[:=]\s*['"]([^'"]+)
+        # Python regex için düzenleme gerekebilir.
+        found_values = HTMLHelper(html).regex_all(r"[.\s'](?:fc|_vvto\[[^]]*)(?:['\]]*)?\s*[:=]\s*['\"]([^'\"]+)")
+
+        if not found_values:
+            raise ValueError(f"Veev: Token bulunamadı. {url}")
+
+        # Kotlin kodunda sondan başlayıp deniyor (reversed)
+        for f in reversed(found_values):
+            try:
+                ch = self.veev_decode(f)
+                if ch == f:
+                    continue # Decode olmadıysa geç
+
+                # API Call
+                dl_url   = f"{self.main_url}/dl?op=player_api&cmd=gi&file_code={video_id}&r={self.main_url}&ch={ch}&ie=1"
+                api_resp = await self.httpx.get(dl_url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"})
+
+                data     = api_resp.json()
+                file_obj = data.get("file")
+                if not file_obj or file_obj.get("file_status") != "OK":
+                    continue
+
+                dv = file_obj.get("dv")
+                # dv json string içinde s key'inde olabilir (Kotlin: getString("s"))
+                # Ancak api yanıtını görmeden emin olamayız, json yapısına göre file->dv bir string mi object mi?
+                # Kotlin: file.getJSONArray("dv").getJSONObject(0).getString("s")
+                # Demek ki dv bir array
+
+                encoded_dv = None
+                if isinstance(dv, list) and len(dv) > 0:
+                     if isinstance(dv[0], dict):
+                         encoded_dv = dv[0].get("s")
+
+                if not encoded_dv:
+                    continue
+
+                # Decode
+                # rules = buildArray(ch)[0]
+                rules = self.build_array(ch)[0]
+
+                final_url = self.decode_url(self.veev_decode(encoded_dv), rules)
+
+                if final_url.startswith("http"):
+                     return ExtractResult(name=self.name, url=self.fix_url(final_url), referer=self.main_url)
+
+            except Exception as e:
+                # print(f"Veev Error: {e}")
+                continue
+
+        raise ValueError(f"Veev: Video URL'si çözülemedi. {url}")