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

KekikStream/Extractors/JetTv.py

@@ -1,45 +1,32 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
-import json
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+import contextlib
 
 class JetTv(ExtractorBase):
     name     = "JetTv"
     main_url = "https://jetv.xyz"
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
-        istek    = await self.httpx.get(url)
-        document = istek.text
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
 
-        # 1. Yöntem: API üzerinden alma
-        master_url = ""
-        final_ref  = f"{self.main_url}/"
+        m3u8_url = None
+        final_ref = self.main_url
 
         if "id=" in url:
-            vid_id = url.split("id=")[-1]
-            api_url = f"https://jetv.xyz/apollo/get_video.php?id={vid_id}"
-            try:
-                # Referer olarak video sayfasının kendisi gönderilmeli
-                api_resp = await self.httpx.get(api_url, headers={"Referer": url})
-                api_json = api_resp.json()
-                
-                if api_json.get("success"):
-                     master_url = api_json.get("masterUrl", "")
-                     final_ref  = api_json.get("referrerUrl") or final_ref
-            except Exception:
-                pass
-
-        # 2. Yöntem: Regex Fallback
-        if not master_url:
-             hp = HTMLHelper(document)
-             master_url = hp.regex_first(r"(?i)file: '([^']*)'") or master_url
-        
-        if not master_url:
-            raise ValueError(f"JetTv: Video kaynağı bulunamadı. {url}")
-
-        return ExtractResult(
-            name      = self.name,
-            url       = master_url,
-            referer   = final_ref,
-            subtitles = []
-        )
+            v_id = url.split("id=")[-1]
+            with contextlib.suppress(Exception):
+                api_resp = await self.httpx.get(f"{self.main_url}/apollo/get_video.php?id={v_id}", headers={"Referer": url})
+                data     = api_resp.json()
+                if data.get("success"):
+                    m3u8_url  = data.get("masterUrl")
+                    final_ref = data.get("referrerUrl") or final_ref
+
+        if not m3u8_url:
+            m3u8_url = sel.regex_first(r"(?i)file: '([^']*)'")
+
+        if not m3u8_url:
+            raise ValueError(f"JetTv: Video URL bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=final_ref)

KekikStream/Extractors/JetV.py

@@ -0,0 +1,55 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+import json, re
+
+class JetV(ExtractorBase):
+    name     = "JetV"
+    main_url = "https://jetv.xyz"
+
+    async def extract(self, url: str, referer: str = None) -> list[ExtractResult]:
+        istek = await self.httpx.get(url, headers={"Referer": referer} if referer else None)
+        text  = istek.text
+
+        # Script içindeki sources kısmını bul
+        # "sources": [ ... ]
+        sources_str = HTMLHelper(text).regex_first(r'"sources":\s*(\[.*?\])')
+        if not sources_str:
+             # Altenatif: sources: [ ... ] (tırnaksız sources)
+             sources_str = HTMLHelper(text).regex_first(r'sources:\s*(\[.*?\])')
+
+        if not sources_str:
+            raise ValueError(f"JetV: Sources bulunamadı. {url}")
+
+        # file: -> "file":
+        clean_json = re.sub(r'(\w+):', r'"\1":', sources_str)
+        # ' -> "
+        clean_json = clean_json.replace("'", '"')
+
+        try:
+            sources = json.loads(clean_json)
+        except:
+            # Basit parser yetmediyse, manuel parse deneyelim (tek kaynak varsa)
+            file_url = HTMLHelper(sources_str).regex_first(r'file["\']?:\s*["\']([^"\']+)["\']')
+            label    = HTMLHelper(sources_str).regex_first(r'label["\']?:\s*["\']([^"\']+)["\']')
+            if file_url:
+                sources = [{"file": file_url, "label": label or "Unknown"}]
+            else:
+                raise ValueError("JetV: JSON parse hatası")
+
+        results = []
+        for source in sources:
+            file_path = source.get("file")
+            label     = source.get("label", "Unknown")
+
+            if not file_path:
+                continue
+
+            results.append(ExtractResult(
+                name       = f"{self.name} | {label}",
+                url        = self.fix_url(file_path),
+                referer    = url,
+                user_agent = self.httpx.headers.get("User-Agent", "")
+            ))
+
+        return results

KekikStream/Extractors/MailRu.py

@@ -2,37 +2,19 @@
 
 from KekikStream.Core import ExtractorBase, ExtractResult
 
-class MailRuExtractor(ExtractorBase):
+class MailRu(ExtractorBase):
     name     = "MailRu"
     main_url = "https://my.mail.ru"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        vid_id         = url.split("video/embed/")[-1].strip()
-        video_meta_url = f"{self.main_url}/+/video/meta/{vid_id}"
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        v_id = url.split("video/embed/")[-1].strip()
+        if referer: self.httpx.headers.update({"Referer": referer})
 
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
+        resp = await self.httpx.get(f"{self.main_url}/+/video/meta/{v_id}")
+        data = resp.json()
+        
+        v_url = data.get("videos", [{}])[0].get("url")
+        if not v_url:
+            raise ValueError(f"MailRu: Video URL bulunamadı. {url}")
 
-        istek = await self.httpx.get(video_meta_url)
-        istek.raise_for_status()
-
-        video_key = istek.cookies.get("video_key")
-        if not video_key:
-            raise ValueError("Video key bulunamadı.")
-
-        video_data = istek.json()
-        videos     = video_data.get("videos", [])
-        if not videos:
-            raise ValueError("Videolar bulunamadı.")
-
-        video     = videos[0]
-        video_url = video["url"]
-        if video_url.startswith("//"):
-            video_url = f"https:{video_url}"
-
-        return ExtractResult(
-            name      = self.name,
-            url       = video_url,
-            referer   = self.main_url,
-            subtitles = []
-        )
+        return ExtractResult(name=self.name, url=self.fix_url(v_url), referer=self.main_url)

KekikStream/Extractors/MixPlayHD.py

@@ -8,34 +8,21 @@ class MixPlayHD(ExtractorBase):
     name     = "MixPlayHD"
     main_url = "https://mixplayhd.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) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or self.main_url})
 
-        istek = await self.httpx.get(url)
-        istek.raise_for_status()
-
-        hp = HTMLHelper(istek.text)
-        be_player_matches = hp.regex_all(r"bePlayer\('([^']+)',\s*'(\{[^\}]+\})'\);")
-        if not be_player_matches:
-            raise ValueError("bePlayer not found in the response.")
-
-        be_player_pass, be_player_data = be_player_matches[0]
+        resp = await self.httpx.get(url)
+        match = HTMLHelper(resp.text).regex_first(r"bePlayer\('([^']+)',\s*'(\{[^\}]+\})'\);", group=None)
+        if not match:
+            raise ValueError(f"MixPlayHD: bePlayer bulunamadı. {url}")
 
+        pass_val, data_val = match
         try:
-            decrypted_data = AESManager.decrypt(be_player_data, be_player_pass).replace("\\", "")
-            decrypted_json = json.loads(decrypted_data)
-        except Exception as hata:
-            raise RuntimeError(f"Decryption failed: {hata}") from hata
-
-        client_str = decrypted_json.get("schedule", {}).get("client", "")
-        video_url = HTMLHelper(client_str).regex_first(r'"video_location":"([^"]+)"')
-        if video_url:
-            return ExtractResult(
-                name      = self.name,
-                url       = video_url,
-                referer   = self.main_url,
-                subtitles = []
-            )
-        else:
-            raise ValueError("M3U8 video URL not found in the decrypted data.")
+            data = json.loads(AESManager.decrypt(data_val, pass_val))
+            v_url = HTMLHelper(data.get("schedule", {}).get("client", "")).regex_first(r'"video_location":"([^"]+)"')
+            if v_url:
+                return ExtractResult(name=self.name, url=v_url, referer=self.main_url)
+        except Exception as e:
+            raise ValueError(f"MixPlayHD: Decryption failed. {e}")
+
+        raise ValueError(f"MixPlayHD: Video URL bulunamadı. {url}")

KekikStream/Extractors/MixTiger.py

@@ -6,52 +6,29 @@ class MixTiger(ExtractorBase):
     name     = "MixTiger"
     main_url = "https://www.mixtiger.com"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        ext_ref  = referer or ""
-        post_url = f"{url}?do=getVideo"
-        vid_id   = url.split("video/")[-1] if "video/" in url else ""
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        ref = referer or self.main_url
+        v_id = url.split("video/")[-1] if "video/" in url else ""
 
-        response = await self.httpx.post(
-            url     = post_url,
-            data    = {"hash": vid_id, "r": ext_ref, "s": ""},
+        resp = await self.httpx.post(
+            f"{url}?do=getVideo",
+            data    = {"hash": v_id, "r": ref, "s": ""},
             headers = {
-                "Referer"          : ext_ref,
-                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
-                "X-Requested-With" : "XMLHttpRequest"
+                "Referer": ref,
+                "X-Requested-With": "XMLHttpRequest"
             }
         )
-        response.raise_for_status()
+        data = resp.json()
 
-        video_data = response.json()
+        m3u8_url = data.get("videoSrc")
+        if not m3u8_url and data.get("videoSources"):
+            m3u8_url = data["videoSources"][-1].get("file")
 
-        # videoSrc varsa doğrudan kullan
-        if video_data.get("videoSrc"):
-            m3u_link = video_data["videoSrc"]
-        # videoSources listesi varsa son elemanı al
-        elif video_data.get("videoSources"):
-            sources  = video_data["videoSources"]
-            m3u_link = sources[-1].get("file") if sources else None
-        else:
-            m3u_link = None
-
-        if not m3u_link:
-            raise ValueError("Video URL not found in response")
-
-        # Recursive extraction check - başka extractor kullanılabilir mi?
-        try:
-            from KekikStream.Core.Extractor.ExtractorManager import ExtractorManager
-            manager = ExtractorManager()
-            if nested_extractor := manager.find_extractor(m3u_link):
-                # Nested extractor ile çıkar
-                return await nested_extractor.extract(m3u_link, referer=ext_ref)
-        except Exception:
-            # Recursive extraction başarısız olursa standart sonucu döndür
-            pass
+        if not m3u8_url:
+            raise ValueError(f"MixTiger: Video linki bulunamadı. {url}")
 
         return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = None if "disk.yandex" in m3u_link else ext_ref,
-            subtitles = []
+            name    = self.name,
+            url     = m3u8_url,
+            referer = None if "disk.yandex" in m3u8_url else ref
         )
-

KekikStream/Extractors/MolyStream.py

@@ -1,7 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
-import re
 
 class MolyStream(ExtractorBase):
     name     = "MolyStream"
@@ -9,34 +8,31 @@ class MolyStream(ExtractorBase):
 
     # Birden fazla domain destekle
     supported_domains = [
-        "dbx.molystream.org",
-        "ydx.molystream.org",
-        "yd.sheila.stream",
-        "ydf.popcornvakti.net",
+        "dbx.molystream.org", "ydx.molystream.org",
+        "yd.sheila.stream", "ydf.popcornvakti.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, referer=None) -> ExtractResult:
-        if "doctype html" in url:
-            secici   = HTMLHelper(url)
-            video    = secici.select_attr("video#sheplayer source", "src")
-        else:
-            video = url
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or self.main_url})
 
-        resp_sec = HTMLHelper(url)
-        matches = resp_sec.regex_all(r"addSrtFile\(['\"]([^'\"]+\.srt)['\"]\s*,\s*['\"][a-z]{2}['\"]\s*,\s*['\"]([^'\"]+)['\"]")
+        # Eğer url zaten bir HTML kaynağıysa (doctype html içeriyorsa)
+        if "doctype html" in url.lower():
+            sel   = HTMLHelper(url)
+            v_url = sel.select_attr("video#sheplayer source", "src")
+        else:
+            v_url = url
 
-        subtitles = [
-            Subtitle(name = name, url = self.fix_url(url))
-                for url, name in matches
-        ]
+        subtitles = []
+        for s_url, s_name in HTMLHelper(url).regex_all(r"addSrtFile\(['\"]([^'\"]+\.srt)['\"]\s*,\s*['\"][a-z]{2}['\"]\s*,\s*['\"]([^'\"]+)['\"]"):
+            subtitles.append(Subtitle(name=s_name, url=self.fix_url(s_url)))
 
         return ExtractResult(
-            name       = self.name,
-            url        = video,
-            referer    = video.replace("/sheila", "") if video else None,
+            name      = self.name,
+            url       = v_url,
+            referer   = v_url.replace("/sheila", "") if v_url else None,
             user_agent = "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0",
-            subtitles  = subtitles
+            subtitles = subtitles
         )

KekikStream/Extractors/Odnoklassniki.py

@@ -1,117 +1,53 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
-import re, json
+import json, html
 
 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/")
-
-        headers = {
-            "Accept"         : "*/*",
-            "Connection"     : "keep-alive",
-            "Sec-Fetch-Dest" : "empty",
-            "Sec-Fetch-Mode" : "cors",
-            "Sec-Fetch-Site" : "cross-site",
-            "Origin"         : self.main_url,
-            "User-Agent"     : "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0",
-        }
-        self.httpx.headers.update(headers)
-
-        try:
-            istek = await self.fetch_with_redirects(url)
-            istek.raise_for_status()
-        except Exception as hata:
-            raise RuntimeError(f"Failed to fetch the URL: {url}, Error: {hata}") from hata
-
-        response_text = (
-            istek.text.replace("\\"", "\"")
-                      .replace("\\\\", "\\")
-                      .replace(r"\\u", "\\u")
-        )
-        response_text = re.sub(
-            r"\\u([0-9A-Fa-f]{4})", 
-            lambda match: chr(int(match[1], 16)), 
-            response_text
-        )
-
-        videos_json = HTMLHelper(response_text).regex_first(r'"videos":(\[.*?\])')
-        if not videos_json:
-            raise ValueError("No video data found in the response.")
-
-        try:
-            videos = json.loads(videos_json)
-        except json.JSONDecodeError as hata:
-            raise ValueError("Failed to parse video data.") from hata
-
-        quality_order = {
-            "ULTRA": 6,  # 4K veya daha yüksek
-            "QUAD": 5,   # 1440p
-            "FULL": 4,   # 1080p
-            "HD": 3,     # 720p
-            "SD": 2,     # 480p
-            "LOW": 1,    # 360p
-            "MOBILE": 0  # 144p
-        }
-
-        # Kaliteye göre en iyi videoyu seçme
-        best_video = None
-        best_quality_score = -1
-
-        for video in videos:
-            video_url    = video.get("url")
-            quality_name = video.get("name", "").upper()
-
-            if not video_url or not quality_name:
-                continue
-
-            # Kalite sıralamasına göre puanla
-            quality_score = quality_order.get(quality_name, -1)
-            if quality_score > best_quality_score:
-                best_quality_score = quality_score
-                best_video         = video_url
-
-        if not best_video:
-            raise ValueError("No valid video URLs found.")
-
-        if best_video.startswith("//"):
-            best_video = f"https:{best_video}"
-
-        return ExtractResult(
-            name       = self.name,
-            url        = best_video,
-            referer    = referer,
-            user_agent = headers.get("User-Agent", None),
-            subtitles  = []
-        )
-
-    async def fetch_with_redirects(self, url, max_redirects=5):
-        """Yönlendirmeleri takip eden bir fonksiyon"""
-        redirects = 0
-        while redirects < max_redirects:
-            istek = await self.httpx.get(url, follow_redirects=False)
-
-            if istek.status_code not in [301, 302]:
-                break  # Yönlendirme yoksa çık
-
-            redirected_url = istek.headers.get("Location")
-            if not redirected_url:
-                raise ValueError("Redirect location not found.")
-
-            url = redirected_url if redirected_url.startswith("http") else f"https://{redirected_url}"
-            redirects += 1
-
-        if redirects == max_redirects:
-            raise RuntimeError(f"Max redirects ({max_redirects}) reached.")
-
-        return istek
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        if "/video/" in url: url = url.replace("/video/", "/videoembed/")
+        self.httpx.headers.update({"Origin": self.main_url})
+
+        resp = await self.httpx.get(url, follow_redirects=True)
+        sel  = HTMLHelper(resp.text)
+        
+        # Metadata içinden videos array'ini al (esnek regex)
+        v_data = sel.regex_first(r'videos[^:]+:(\[.*?\])')
+        if not v_data:
+            if "Видео заблокировано" in resp.text or "copyrightsRestricted" in resp.text:
+                raise ValueError("Odnoklassniki: Video telif nedeniyle silinmiş/erişilemiyor.")
+            raise ValueError(f"Odnoklassniki: Video verisi bulunamadı. {url}")
+
+        # Kalite sıralaması (En yüksekten düşüğe)
+        order = ["ULTRA", "QUAD", "FULL", "HD", "SD", "LOW", "MOBILE"]
+        # Escaped string'i temizle
+        v_data = html.unescape(v_data)
+        v_data = v_data.replace('\\"', '"').replace('\\/', '/')
+        videos = json.loads(v_data)
+        
+        best_url = None
+        for q in order:
+            best_url = next((v.get("url") for v in videos if v.get("name", "").upper() == q), None)
+            if best_url: break
+        
+        if not best_url:
+            best_url = videos[0].get("url") if videos else None
+
+        if not best_url:
+            raise ValueError("Odnoklassniki: Geçerli video URL'si bulunamadı.")
+
+        # URL temizliği (u0026 -> & ve olası unicode kaçışları)
+        best_url = best_url.replace("u0026", "&").replace("\\u0026", "&")
+        # Eğer hala \uXXXX formatında unicode kaçışları varsa çöz
+        if "\\u" in best_url:
+            best_url = best_url.encode().decode('unicode-escape')
+
+        return ExtractResult(name=self.name, url=self.fix_url(best_url), referer=referer)

KekikStream/Extractors/PeaceMakerst.py

@@ -7,57 +7,30 @@ 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})
-
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
         self.httpx.headers.update({
-            "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+            "Referer"          : referer or url,
             "X-Requested-With" : "XMLHttpRequest"
         })
 
-        response = await self.httpx.post(
-            url  = f"{url}?do=getVideo",
-            data = {
-                "hash" : url.split("video/")[-1],
-                "r"    : referer or "",
-                "s"    : ""
-            }
-        )
-        response.raise_for_status()
-
-        response_text = response.text
-        m3u_link      = None
-
-        if "teve2.com.tr\\/embed\\/" in response_text:
-            teve2_id = HTMLHelper(response_text).regex_first(r"teve2\.com\.tr\\\/embed\\\/(\d+)")
-            teve2_url = f"https://www.teve2.com.tr/action/media/{teve2_id}"
-
-            teve2_response = await self.httpx.get(teve2_url, headers={"Referer": f"https://www.teve2.com.tr/embed/{teve2_id}"})
-            teve2_response.raise_for_status()
-            teve2_json = teve2_response.json()
-
-            m3u_link = f"{teve2_json['Media']['Link']['ServiceUrl']}//{teve2_json['Media']['Link']['SecurePath']}"
-        else:
-            try:
-                video_response = response.json()
-                if video_sources := video_response.get("videoSources", []):
-                    m3u_link = video_sources[-1]["file"]
-            except (json.JSONDecodeError, KeyError) as hata:
-                raise ValueError("Peace response is invalid or null.") from hata
-
-        if not m3u_link:
-            raise ValueError("m3u link not found.")
-
-        return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = url,
-            subtitles = []
-        )
+        resp = await self.httpx.post(f"{url}?do=getVideo", data={"hash": url.split("video/")[-1], "r": referer or "", "s": ""})
+        data = resp.json()
+
+        m3u8_url = None
+        if "teve2.com.tr" in resp.text:
+            v_id = HTMLHelper(resp.text).regex_first(r"teve2\.com\.tr\\\/embed\\\/(\d+)")
+            t_resp = await self.httpx.get(f"https://www.teve2.com.tr/action/media/{v_id}")
+            t_data = t_resp.json()
+            m3u8_url = f"{t_data['Media']['Link']['ServiceUrl']}//{t_data['Media']['Link']['SecurePath']}"
+        elif sources := data.get("videoSources"):
+            m3u8_url = sources[-1]["file"]
+
+        if not m3u8_url:
+            raise ValueError(f"PeaceMakerst: Video linki bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=url)

KekikStream/Extractors/PixelDrain.py

@@ -6,23 +6,15 @@ class PixelDrain(ExtractorBase):
     name     = "PixelDrain"
     main_url = "https://pixeldrain.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) -> ExtractResult:
+        if referer: self.httpx.headers.update({"Referer": referer})
 
-        hp = HTMLHelper(url)
-        matches = hp.regex_all(r"/u/([^/?]+)|([^\/]+)(?=\?download)")
-        if not matches:
-            raise ValueError("PixelDrain bağlantısından ID çıkarılamadı.")
-
-        m = matches[0]
-        pixel_id = next((g for g in m if g), None)
-        download_link = f"{self.main_url}/api/file/{pixel_id}?download"
-        referer_link  = f"{self.main_url}/u/{pixel_id}?download"
+        p_id = HTMLHelper(url).regex_first(r"/u/([^/?]+)|([^\/]+)(?=\?download)")
+        if not p_id:
+            raise ValueError(f"PixelDrain: ID bulunamadı. {url}")
 
         return ExtractResult(
-            name      = f"{self.name} - {pixel_id}",
-            url       = download_link,
-            referer   = referer_link,
-            subtitles = []
+            name    = f"{self.name} - {p_id}",
+            url     = f"{self.main_url}/api/file/{p_id}?download",
+            referer = f"{self.main_url}/u/{p_id}?download"
         )