KekikStream 2.4.2__py3-none-any.whl → 2.4.3__py3-none-any.whl

KekikStream/Extractors/VidPapi.py

@@ -4,84 +4,54 @@ from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 
 
 class VidPapi(ExtractorBase):
-    name     = "VidApi"
+    name     = "VidPapi"
     main_url = "https://vidpapi.xyz"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        ext_ref = referer or ""
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        ref = referer or self.main_url
         
-        # URL parsing
+        # ID tespiti
         if "video/" in url:
             vid_id = url.split("video/")[-1]
         else:
             vid_id = url.split("?data=")[-1]
             
-        # 1. Altyazıları çek
-        sub_url = f"{self.main_url}/player/index.php?data={vid_id}"
-        sub_headers = {
+        headers = {
             "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
             "X-Requested-With" : "XMLHttpRequest",
-            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0",
-            "Referer"          : ext_ref or "https://kultfilmler.pro/"
+            "Referer"          : ref
         }
         
+        # 1. Altyazıları çek
         subtitles = []
         try:
-            sub_istek = await self.httpx.post(
-                url     = sub_url,
-                headers = sub_headers,
-                data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+            sub_resp = await self.httpx.post(
+                f"{self.main_url}/player/index.php?data={vid_id}",
+                headers = headers,
+                data    = {"hash": vid_id, "r": ref}
             )
-            
-            raw_subs = HTMLHelper(sub_istek.text).regex_first(r'var playerjsSubtitle\s*=\s*"([^"]*)"', flags=0)
-            if raw_subs:
-                found_subs = HTMLHelper(raw_subs).regex_all(r'\[(.*?)\](.*?)(?:,|$)')
-                for lang, sub_link in found_subs:
-                    lang = lang.strip()
-                    if "Türkçe" in lang:
-                        lang_code = "tr"
-                        lang_name = "Turkish"
-                    elif "İngilizce" in lang:
-                        lang_code = "en"
-                        lang_name = "English"
-                    else:
-                        lang_code = lang[:2].lower()
-                        lang_name = lang
-                        
-                    subtitles.append(Subtitle(
-                        name = lang_name,
-                        url  = sub_link.strip()
-                    ))
-                    
-        except Exception as e:
+            sel = HTMLHelper(sub_resp.text)
+            if raw_subs := sel.regex_first(r'var playerjsSubtitle\s*=\s*"([^"]*)"'):
+                for lang, link in HTMLHelper(raw_subs).regex_all(r'\[(.*?)\](https?://[^\s\",]+)'):
+                    subtitles.append(Subtitle(name=lang.strip(), url=link.strip()))
+        except:
             pass
 
         # 2. Videoyu çek
-        video_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
-        video_headers = sub_headers.copy()
-        
-        response = await self.httpx.post(
-            url     = video_url,
-            headers = video_headers,
-            data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+        resp = await self.httpx.post(
+            f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo",
+            headers = headers,
+            data    = {"hash": vid_id, "r": ref}
         )
-        response.raise_for_status()
-        
-        try:
-            video_data = response.json()
-        except Exception:
-            return None
+        data = resp.json()
 
-        stream_url = video_data.get("securedLink")
-        if not stream_url or not stream_url.strip():
-            stream_url = video_data.get("videoSource")
-            
+        stream_url = data.get("securedLink") or data.get("videoSource")
         if not stream_url:
-            raise ValueError("No video link found in VidPapi response")
+            raise ValueError(f"VidPapi: Video URL bulunamadı. {url}")
 
         return ExtractResult(
             name      = self.name,
             url       = stream_url,
-            referer   = ext_ref or self.main_url,
+            referer   = ref,
             subtitles = subtitles
         )

KekikStream/Extractors/VideoSeyred.py

@@ -1,4 +1,4 @@
-# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
 import json
@@ -7,47 +7,26 @@ class VideoSeyred(ExtractorBase):
     name     = "VideoSeyred"
     main_url = "https://videoseyred.in"
 
-    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:
+        v_id = url.split("embed/")[1].split("?")[0]
+        if len(v_id) > 10:
+            resp = await self.httpx.get(url)
+            v_id = HTMLHelper(resp.text).regex_first(r"playlist\/(.*)\.json")
 
-        video_id  = url.split("embed/")[1].split("?")[0]
-        if len(video_id) > 10:
-            kontrol = await self.httpx.get(url)
-            kontrol.raise_for_status()
-
-            video_id = HTMLHelper(kontrol.text).regex_first(r"playlist\/(.*)\.json")
-
-        video_url = f"{self.main_url}/playlist/{video_id}.json"
-
-        response = await self.httpx.get(video_url)
-        response.raise_for_status()
-
-        try:
-            if response_list := json.loads(response.text):
-                response_data = response_list[0]
-            else:
-                raise ValueError("Empty response from VideoSeyred.")
-
-        except (json.JSONDecodeError, IndexError) as hata:
-            raise RuntimeError(f"Failed to parse response: {hata}") from hata
+        json_resp = await self.httpx.get(f"{self.main_url}/playlist/{v_id}.json")
+        data = json_resp.json()[0]
 
         subtitles = [
-            Subtitle(name=track["label"], url=self.fix_url(track["file"]))
-                for track in response_data.get("tracks", [])
-                    if track.get("kind") == "captions" and track.get("label")
+            Subtitle(name=t["label"], url=self.fix_url(t["file"]))
+            for t in data.get("tracks", []) if t.get("kind") == "captions"
+        ]
+
+        results = [
+            ExtractResult(name=self.name, url=self.fix_url(s["file"]), referer=self.main_url, subtitles=subtitles)
+            for s in data.get("sources", [])
         ]
 
-        if video_links := [
-            ExtractResult(
-                name      = self.name,
-                url       = self.fix_url(source["file"]),
-                referer   = self.main_url,
-                subtitles = subtitles,
-            )
-                for source in response_data.get("sources", [])
-        ]:
-            # En yüksek kaliteli videoyu döndür (varsayılan olarak ilk video)
-            return video_links[0] if len(video_links) == 1 else video_links
-        else:
-            raise ValueError("No video links found in the response.")
+        if not results:
+            raise ValueError(f"VideoSeyred: Video bulunamadı. {url}")
+
+        return results[0] if len(results) == 1 else results

KekikStream/Extractors/Videostr.py

@@ -2,114 +2,57 @@
 
 from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper, Subtitle
 from urllib.parse import quote
-from json import loads
+import re
 
 class Videostr(ExtractorBase):
     name     = "Videostr"
-    main_url = "videostr.net"
+    main_url = "https://videostr.net"
 
-    async def extract(self, url: str, referer: str = None) -> ExtractResult | None:
-        headers = {
-            "Accept": "*/*",
-            "X-Requested-With": "XMLHttpRequest",
-            "Referer": "https://videostr.net",
-        }
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        v_id = url.split("?")[0].split("/")[-1]
+        headers = {"Referer": self.main_url, "X-Requested-With": "XMLHttpRequest"}
         
-        # 1. Get nonce page
-        # Kotlin: url.substringAfterLast("/").substringBefore("?")
-        id = url.split("?")[0].split("/")[-1]
-        
-        istek = await self.httpx.get(url, headers=headers)
-        if istek.status_code != 200:
-            return None
-            
-        responsenonce = istek.text
-        
-        # Find nonce
-        # Regex: \b[a-zA-Z0-9]{48}\b
-        # Or 3 blocks of 16 chars
-        helper = HTMLHelper(responsenonce)
-        nonce = helper.regex_first(r"\b[a-zA-Z0-9]{48}\b")
+        resp = await self.httpx.get(url, headers=headers)
+        sel  = HTMLHelper(resp.text)
+
+        # Nonce Bulma
+        nonce = sel.regex_first(r"\b[a-zA-Z0-9]{48}\b")
         if not nonce:
-            # Fallback regex as per Kotlin: \b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b
-            # In Python we can just look for the combined matches if regex_first handles grouping poorly or try finding all
-            import re
-            m = re.search(r"\b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b", responsenonce, re.DOTALL)
-            if m:
-                nonce = m.group(1) + m.group(2) + m.group(3)
-        
+            m = re.search(r"\b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b.*?\b([a-zA-Z0-9]{16})\b", resp.text, re.DOTALL)
+            if m: nonce = m.group(1) + m.group(2) + m.group(3)
+
         if not nonce:
-            return None
-            
-        # 2. Get Sources
-        api_url = f"https://videostr.net/embed-1/v3/e-1/getSources?id={id}&_k={nonce}"
+            raise ValueError(f"Videostr: Nonce bulunamadı. {url}")
+
+        # Kaynakları Çek
+        api_resp = await self.httpx.get(f"{self.main_url}/embed-1/v3/e-1/getSources?id={v_id}&_k={nonce}", headers=headers)
+        data = api_resp.json()
         
-        api_resp = await self.httpx.get(api_url, headers=headers)
-        if api_resp.status_code != 200:
-            return None
-            
-        # Parse JSON
-        try:
-            data = api_resp.json()
-        except:
-            return None
-            
-        sources = data.get("sources", [])
-        if not sources:
-            return None
-            
-        encrypted_file = sources[0].get("file")
-        if not encrypted_file:
-            return None
-            
+        enc_file = data.get("sources", [{}])[0].get("file")
+        if not enc_file:
+            raise ValueError("Videostr: Kaynak bulunamadı.")
+
         m3u8_url = None
-        
-        if ".m3u8" in encrypted_file:
-            m3u8_url = encrypted_file
+        if ".m3u8" in enc_file:
+            m3u8_url = enc_file
         else:
-            # Decrypt
-            # Need key from github
-            key_url = "https://raw.githubusercontent.com/yogesh-hacker/MegacloudKeys/refs/heads/main/keys.json"
-            key_resp = await self.httpx.get(key_url)
-            if key_resp.status_code == 200:
-                try:
-                    keys = key_resp.json()
-                    vidstr_key = keys.get("vidstr") # As per Kotlin code: gson.fromJson(keyJson, Megakey::class.java)?.vidstr
-                    
-                    if vidstr_key:
-                        # Use Google Script to decrypt
-                        decode_url = "https://script.google.com/macros/s/AKfycbxHbYHbrGMXYD2-bC-C43D3njIbU-wGiYQuJL61H4vyy6YVXkybMNNEPJNPPuZrD1gRVA/exec"
-                        
-                        full_url = f"{decode_url}?encrypted_data={quote(encrypted_file)}&nonce={quote(nonce)}&secret={quote(vidstr_key)}"
-                        
-                        decrypted_resp = await self.httpx.get(full_url)
-                        if decrypted_resp.status_code == 200:
-                            # Response is JSON {"file": "..."} usually or text?
-                            # Kotlin says: Regex("\"file\":\"(.*?)\"").find(decryptedResponse)
-                            m_file = re.search(r'"file":"(.*?)"', decrypted_resp.text)
-                            if m_file:
-                                m3u8_url = m_file.group(1).replace(r"\/", "/")
-                except Exception as e:
-                    # print(f"Decryption error: {e}")
-                    pass
+            # Decryption Flow (External Keys)
+            with contextlib.suppress(Exception):
+                key_resp = await self.httpx.get("https://raw.githubusercontent.com/yogesh-hacker/MegacloudKeys/refs/heads/main/keys.json")
+                v_key = key_resp.json().get("vidstr")
+                if v_key:
+                    decode_api = "https://script.google.com/macros/s/AKfycbxHbYHbrGMXYD2-bC-C43D3njIbU-wGiYQuJL61H4vyy6YVXkybMNNEPJNPPuZrD1gRVA/exec"
+                    dec_resp = await self.httpx.get(f"{decode_api}?encrypted_data={quote(enc_file)}&nonce={quote(nonce)}&secret={quote(v_key)}")
+                    m3u8_url = re.search(r'"file":"(.*?)"', dec_resp.text).group(1).replace("\\/", "/")
 
         if not m3u8_url:
-            return None
-            
-        # Subtitles
-        # Kotlin: response.tracks
-        subtitles = []
-        tracks = data.get("tracks", [])
-        for t in tracks:
-            if t.get("kind") in ["captions", "subtitles"]:
-                subtitles.append(Subtitle(
-                    name = t.get("label", "Altyazı"),
-                    url  = t.get("file")
-                ))
-                
-        return ExtractResult(
-            name     = "Videostr",
-            url      = m3u8_url,
-            referer  = "https://videostr.net/",
-            subtitles= subtitles
-        )
+            raise ValueError(f"Videostr: Video URL bulunamadı. {url}")
+
+        subtitles = [
+            Subtitle(name=t.get("label", "Altyazı"), url=t.get("file"))
+            for t in data.get("tracks", []) if t.get("kind") in ["captions", "subtitles"]
+        ]
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=f"{self.main_url}/", subtitles=subtitles)
+
+import contextlib

KekikStream/Extractors/Vidoza.py

@@ -6,20 +6,13 @@ class Vidoza(ExtractorBase):
     name     = "Vidoza"
     main_url = "https://vidoza.net"
 
-    async def extract(self, url: str, referer: str = None) -> ExtractResult | None:
-        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)
-        helper = HTMLHelper(istek.text)
+        resp = await self.httpx.get(url)
+        v_url = HTMLHelper(resp.text).select_attr("source", "src")
         
-        video_url = helper.select_attr("source", "src")
-        
-        if video_url:
-            return ExtractResult(
-                name    = self.name,
-                url     = video_url,
-                referer = url
-            )
-            
-        return None
+        if not v_url:
+            raise ValueError(f"Vidoza: Video bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=v_url, referer=url)

KekikStream/Extractors/YildizKisaFilm.py

@@ -6,36 +6,18 @@ class YildizKisaFilm(ExtractorBase):
     name     = "YildizKisaFilm"
     main_url = "https://yildizkisafilm.org"
 
-    async def extract(self, url, referer=None) -> ExtractResult:
-        ext_ref = referer or ""
-
-        if "video/" in url:
-            vid_id = url.split("video/")[-1]
-        else:
-            vid_id = url.split("?data=")[-1]
-
-        post_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
-
-        response = await self.httpx.post(
-            url     = post_url,
-            data    = {"hash": vid_id, "r": ext_ref},
-            headers = {
-                "Referer"          : ext_ref,
-                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
-                "X-Requested-With" : "XMLHttpRequest"
-            }
+    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 url.split("?data=")[-1]
+
+        resp = await self.httpx.post(
+            f"{self.main_url}/player/index.php?data={v_id}&do=getVideo",
+            data    = {"hash": v_id, "r": ref},
+            headers = {"Referer": ref, "X-Requested-With": "XMLHttpRequest"}
         )
-        response.raise_for_status()
+        
+        m3u8_url = resp.json().get("securedLink")
+        if not m3u8_url:
+            raise ValueError(f"YildizKisaFilm: Video URL bulunamadı. {url}")
 
-        video_data = response.json()
-        m3u_link   = video_data.get("securedLink")
-
-        if not m3u_link:
-            raise ValueError("securedLink not found in response")
-
-        return ExtractResult(
-            name      = self.name,
-            url       = m3u_link,
-            referer   = ext_ref,
-            subtitles = []
-        )
+        return ExtractResult(name=self.name, url=m3u8_url, referer=ref)

KekikStream/Plugins/BelgeselX.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, HTMLHelper
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, HTMLHelper
 
 class BelgeselX(PluginBase):
     name        = "BelgeselX"
@@ -70,7 +70,7 @@ class BelgeselX(PluginBase):
         token_resp = self.cloudscraper.get(f"https://cse.google.com/cse.js?cx={cx}")
         token_text = token_resp.text
 
-        secici = HTMLHelper(token_text)
+        secici  = HTMLHelper(token_text)
         cse_lib = secici.regex_first(r'cselibVersion": "(.*)"')
         cse_tok = secici.regex_first(r'cse_token": "(.*)"')
 
@@ -84,13 +84,13 @@ class BelgeselX(PluginBase):
             f"&callback=google.search.cse.api9969&rurl=https%3A%2F%2Fbelgeselx.com%2F"
         )
 
-        resp = self.cloudscraper.get(search_url)
+        resp      = self.cloudscraper.get(search_url)
         resp_text = resp.text
 
         secici2 = HTMLHelper(resp_text)
-        titles = secici2.regex_all(r'"titleNoFormatting": "(.*?)"')
-        urls   = secici2.regex_all(r'"url": "(.*?)"')
-        images = secici2.regex_all(r'"ogImage": "(.*?)"')
+        titles  = secici2.regex_all(r'"titleNoFormatting": "(.*?)"')
+        urls    = secici2.regex_all(r'"url": "(.*?)"')
+        images  = secici2.regex_all(r'"ogImage": "(.*?)"')
 
         results = []
         for i, title in enumerate(titles):
@@ -101,8 +101,7 @@ class BelgeselX(PluginBase):
                 # URL'den belgesel linkini oluştur
                 if poster and "diziresimleri" in poster:
                     file_name = poster.rsplit("/", 1)[-1]
-                    secici3 = HTMLHelper(file_name)
-                    file_name = secici3.regex_replace(r"\.(jpe?g|png|webp)$", "")
+                    file_name = HTMLHelper(file_name).regex_replace(r"\.(jpe?g|png|webp)$", "")
                     url_val = f"{self.main_url}/belgeseldizi/{file_name}"
                 else:
                     continue
@@ -120,85 +119,80 @@ class BelgeselX(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        title = secici.select_text("h2.gen-title")
-
-        poster = secici.select_attr("div.gen-tv-show-top img", "src")
-
+        title       = self._to_title_case(secici.select_text("h2.gen-title"))
+        poster      = secici.select_poster("div.gen-tv-show-top img")
         description = secici.select_text("div.gen-single-tv-show-info p")
-
-        tags = []
-        for tag_link in secici.select("div.gen-socail-share a[href*='belgeselkanali']"):
-            tag_href = secici.select_attr("a", "href", tag_link)
-            if tag_href:
-                tag_name = tag_href.rsplit("/", 1)[-1].replace("-", " ")
-                tags.append(self._to_title_case(tag_name))
+        tags        = [self._to_title_case(t.rsplit("/", 1)[-1].replace("-", " ")) for t in secici.select_attrs("div.gen-socail-share a[href*='belgeselkanali']", "href")]
+
+        # Meta bilgilerinden yıl ve puanı çıkar
+        meta_items = secici.select_texts("div.gen-single-meta-holder ul li")
+        year   = None
+        rating = None
+        for item in meta_items:
+            if not year:
+                if y_match := secici.regex_first(r"\b((?:19|20)\d{2})\b", item):
+                    year = int(y_match)
+            if not rating:
+                if r_match := secici.regex_first(r"%\s*(\d+)\s*Puan", item):
+                    rating = float(r_match) / 10
 
         episodes = []
-        counter  = 0
-        for ep_item in secici.select("div.gen-movie-contain"):
-            ep_name = secici.select_text("div.gen-movie-info h3 a", ep_item)
-            ep_href = secici.select_attr("div.gen-movie-info h3 a", "href", ep_item)
-
-            if not ep_name or not ep_href:
-                continue
-
-            season_text = secici.select_text("div.gen-single-meta-holder ul li", ep_item)
-
-            episode_num = secici.regex_first(r"Bölüm (\d+)", season_text)
-            season_num  = secici.regex_first(r"Sezon (\d+)", season_text)
-
-            ep_episode = int(episode_num) if episode_num else counter
-            ep_season  = int(season_num) if season_num else 1
-
-            counter += 1
-
-            episodes.append(Episode(
-                season  = ep_season,
-                episode = ep_episode,
-                title   = ep_name,
-                url     = self.fix_url(ep_href)
-            ))
+        for i, ep in enumerate(secici.select("div.gen-movie-contain")):
+            name    = secici.select_text("div.gen-movie-info h3 a", ep)
+            href    = secici.select_attr("div.gen-movie-info h3 a", "href", ep)
+            item_id = secici.select_attr("div.gen-movie-info h3 a", "id", ep)
+            if name and href:
+                s, e = secici.extract_season_episode(secici.select_text("div.gen-single-meta-holder ul li", ep))
+                # ID'yi URL'ye ekle ki load_links doğru bölümü çekebilsin
+                final_url = self.fix_url(href)
+                if item_id:
+                    final_url = f"{final_url}?id={item_id}"
+                
+                episodes.append(Episode(season=s or 1, episode=e or (i + 1), title=name, url=final_url))
 
         return SeriesInfo(
-            url         = url,
-            poster      = self.fix_url(poster) if poster else None,
-            title       = self._to_title_case(title) if title else None,
-            description = description,
-            tags        = tags,
-            episodes    = episodes
+            url=url, poster=self.fix_url(poster) if poster else None, title=title or "Bilinmiyor",
+            description=description, tags=tags, year=year, rating=rating, episodes=episodes
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
-        istek = await self.httpx.get(url)
-        text  = istek.text
+        # URL'den ID'yi ayıkla
+        params     = dict([x.split('=') for x in url.split('?')[-1].split('&')]) if '?' in url else {}
+        episode_id = params.get('id')
+        main_url   = url.split('?')[0]
+
+        istek  = await self.httpx.get(main_url)
+        secici = HTMLHelper(istek.text)
 
-        secici = HTMLHelper(text)
-        # fnc_addWatch div'inden data-episode ID'sini al
-        episode_id = secici.regex_first(r'<div[^>]*class=["\'][^"\']*fnc_addWatch[^"\']*["\'][^>]*data-episode=["\'](\d+)["\']')
         if not episode_id:
-            return []
+            episode_id = secici.regex_first(r'data-episode=["\'](\d+)["\']')
 
-        iframe_url  = f"{self.main_url}/video/data/new4.php?id={episode_id}"
+        if not episode_id:
+            return []
 
-        iframe_resp = await self.httpx.get(iframe_url, headers={"Referer": url})
-        iframe_text = iframe_resp.text
+        iframe_resp = await self.httpx.get(f"{self.main_url}/video/data/new4.php?id={episode_id}", headers={"Referer": main_url})
+        secici      = HTMLHelper(iframe_resp.text)
 
-        secici2 = HTMLHelper(iframe_text)
-        # file:"url", label: "quality" patternlerini al
-        file_matches = secici2.regex_all(r'file:"([^"]+)"')
-        label_matches = secici2.regex_all(r'label: "([^"]+)"')
+        links  = []
+        files  = secici.regex_all(r'file:"([^"]+)"')
+        labels = secici.regex_all(r'label: "([^"]+)"')
 
-        links = []
-        for i, video_url in enumerate(file_matches):
-            quality = label_matches[i] if i < len(label_matches) else "Unknown"
+        for i, video_url in enumerate(files):
+            quality = labels[i] if i < len(labels) else "HD"
 
-            source_name = "Google" if quality == "FULL" else self.name
-            quality_str = "1080p" if quality == "FULL" else quality
+            # belgeselx.php redirect'ini çöz
+            if "belgeselx.php" in video_url or "belgeselx2.php" in video_url:
+                try:
+                    # HEAD isteği ile lokasyonu alalım
+                    resp = await self.httpx.head(video_url, headers={"Referer": main_url}, follow_redirects=True)
+                    video_url = str(resp.url)
+                except:
+                    pass
 
             links.append(ExtractResult(
                 url     = video_url,
-                name    = f"{source_name} | {quality_str}",
-                referer = url
+                name    = f"{'Google' if 'google' in video_url.lower() or 'blogspot' in video_url.lower() or quality == 'FULL' else self.name} | {'1080p' if quality == 'FULL' else quality}",
+                referer = main_url
             ))
 
         return links