KekikStream 2.0.3__py3-none-any.whl → 2.0.5__py3-none-any.whl

KekikStream/Extractors/ContentX.py

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

KekikStream/Extractors/DonilasPlay.py

@@ -0,0 +1,86 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from Kekik.Sifreleme   import AESManager
+import re, json
+
+class DonilasPlay(ExtractorBase):
+    name     = "DonilasPlay"
+    main_url = "https://donilasplay.com"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        istek = await self.httpx.get(url)
+        istek.raise_for_status()
+        i_source = istek.text
+
+        m3u_link   = None
+        subtitles  = []
+
+        # bePlayer pattern
+        be_player_match = re.search(r"bePlayer\('([^']+)',\s*'(\{[^}]+\})'\);", i_source)
+        if be_player_match:
+            be_player_pass = be_player_match.group(1)
+            be_player_data = be_player_match.group(2)
+
+            try:
+                # AES decrypt
+                decrypted = AESManager.decrypt(be_player_data, be_player_pass)
+                data      = json.loads(decrypted)
+
+                m3u_link = data.get("video_location")
+
+                # Altyazıları işle
+                str_subtitles = data.get("strSubtitles", [])
+                if str_subtitles:
+                    for sub in str_subtitles:
+                        label = sub.get("label", "")
+                        file  = sub.get("file", "")
+                        # Forced altyazıları hariç tut
+                        if "Forced" in label:
+                            continue
+                        if file:
+                            # Türkçe kontrolü
+                            keywords = ["tur", "tr", "türkçe", "turkce"]
+                            language = "Turkish" if any(k in label.lower() for k in keywords) else label
+                            subtitles.append(Subtitle(
+                                name = language,
+                                url  = self.fix_url(file)
+                            ))
+            except Exception:
+                pass
+
+        # Fallback: file pattern
+        if not m3u_link:
+            file_match = re.search(r'file:"([^"]+)"', i_source)
+            if file_match:
+                m3u_link = file_match.group(1)
+
+            # tracks pattern for subtitles
+            tracks_match = re.search(r'tracks:\[([^\]]+)', i_source)
+            if tracks_match:
+                try:
+                    tracks_str = f"[{tracks_match.group(1)}]"
+                    tracks = json.loads(tracks_str)
+                    for track in tracks:
+                        file_url = track.get("file")
+                        label    = track.get("label", "")
+                        if file_url and "Forced" not in label:
+                            subtitles.append(Subtitle(
+                                name = label,
+                                url  = self.fix_url(file_url)
+                            ))
+                except Exception:
+                    pass
+
+        if not m3u_link:
+            raise ValueError("m3u link not found")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = url,
+            subtitles = subtitles
+        )

KekikStream/Extractors/Odnoklassniki.py

@@ -7,6 +7,12 @@ class Odnoklassniki(ExtractorBase):
     name     = "Odnoklassniki"
     main_url = "https://odnoklassniki.ru"
 
+    # Birden fazla domain destekle
+    supported_domains = ["odnoklassniki.ru", "ok.ru"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     async def extract(self, url, referer=None) -> ExtractResult:
         if "/video/" in url:
             url = url.replace("/video/", "/videoembed/")

KekikStream/Extractors/PeaceMakerst.py

@@ -7,6 +7,12 @@ class PeaceMakerst(ExtractorBase):
     name     = "PeaceMakerst"
     main_url = "https://peacemakerst.com"
 
+    # Birden fazla domain destekle
+    supported_domains = ["peacemakerst.com", "hdstreamable.com"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
             self.httpx.headers.update({"Referer": referer})

KekikStream/Extractors/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/Extractors/SetPlay.py

@@ -5,7 +5,13 @@ 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 ""

KekikStream/Extractors/VCTPlay.py

@@ -0,0 +1,41 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from urllib.parse     import urlparse, parse_qs
+
+class VCTPlay(ExtractorBase):
+    name     = "VCTPlay"
+    main_url = "https://vctplay.site"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        # URL'den video ID'sini çıkar
+        # https://vctplay.site/video/2hjDGco5exdv -> 2hjDGco5exdv
+        video_id = url.split("/")[-1]
+        if "?" in video_id:
+            video_id = video_id.split("?")[0]
+
+        # Manifests URL oluştur
+        master_url = f"{self.main_url}/manifests/{video_id}/master.txt"
+
+        # partKey'den isim belirle
+        parsed   = urlparse(url)
+        params   = parse_qs(parsed.query)
+        part_key = params.get("partKey", [""])[0]
+
+        name_suffix = ""
+        if "turkcedublaj" in part_key.lower():
+            name_suffix = "Dublaj"
+        elif "turkcealtyazi" in part_key.lower():
+            name_suffix = "Altyazı"
+
+        display_name = f"{self.name} - {name_suffix}" if name_suffix else self.name
+
+        return ExtractResult(
+            name      = display_name,
+            url       = master_url,
+            referer   = f"{self.main_url}/",
+            subtitles = []
+        )

KekikStream/Extractors/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})

KekikStream/Plugins/BelgeselX.py

@@ -0,0 +1,204 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
+from parsel           import Selector
+import re
+
+class BelgeselX(PluginBase):
+    name        = "BelgeselX"
+    language    = "tr"
+    main_url    = "https://belgeselx.com"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "2022 yılında son çıkan belgeselleri belgeselx.com'da izle. En yeni belgeseller, türkçe altyazılı yada dublaj olarak 1080p kalitesinde hd belgesel izle."
+
+    main_page   = {
+        f"{main_url}/konu/turk-tarihi-belgeselleri&page=" : "Türk Tarihi",
+        f"{main_url}/konu/tarih-belgeselleri&page="       : "Tarih",
+        f"{main_url}/konu/seyehat-belgeselleri&page="     : "Seyahat",
+        f"{main_url}/konu/seri-belgeseller&page="         : "Seri",
+        f"{main_url}/konu/savas-belgeselleri&page="       : "Savaş",
+        f"{main_url}/konu/sanat-belgeselleri&page="       : "Sanat",
+        f"{main_url}/konu/psikoloji-belgeselleri&page="   : "Psikoloji",
+        f"{main_url}/konu/polisiye-belgeselleri&page="    : "Polisiye",
+        f"{main_url}/konu/otomobil-belgeselleri&page="    : "Otomobil",
+        f"{main_url}/konu/nazi-belgeselleri&page="        : "Nazi",
+        f"{main_url}/konu/muhendislik-belgeselleri&page=" : "Mühendislik",
+        f"{main_url}/konu/kultur-din-belgeselleri&page="  : "Kültür Din",
+        f"{main_url}/konu/kozmik-belgeseller&page="       : "Kozmik",
+        f"{main_url}/konu/hayvan-belgeselleri&page="      : "Hayvan",
+        f"{main_url}/konu/eski-tarih-belgeselleri&page="  : "Eski Tarih",
+        f"{main_url}/konu/egitim-belgeselleri&page="      : "Eğitim",
+        f"{main_url}/konu/dunya-belgeselleri&page="       : "Dünya",
+        f"{main_url}/konu/doga-belgeselleri&page="        : "Doğa",
+        f"{main_url}/konu/bilim-belgeselleri&page="       : "Bilim"
+    }
+
+    @staticmethod
+    def _to_title_case(text: str) -> str:
+        """Türkçe için title case dönüşümü."""
+        return " ".join(
+            word.lower().replace("i", "İ").capitalize() if word.lower().startswith("i") else word.capitalize()
+            for word in text.split()
+        )
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = self.cloudscraper.get(f"{url}{page}")
+        secici = Selector(istek.text)
+
+        results = []
+        for item in secici.css("div.gen-movie-contain > div.gen-info-contain > div.gen-movie-info"):
+            title  = item.css("div.gen-movie-info > h3 a::text").get()
+            href   = item.css("div.gen-movie-info > h3 a::attr(href)").get()
+            parent = item.xpath("../../..")
+            poster = parent.css("div.gen-movie-img > img::attr(src)").get()
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = self._to_title_case(title.strip()),
+                    url      = self.fix_url(href),
+                    poster   = self.fix_url(poster) if poster else None
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        # Google Custom Search API kullanıyor
+        cx = "016376594590146270301:iwmy65ijgrm"
+
+        token_resp = self.cloudscraper.get(f"https://cse.google.com/cse.js?cx={cx}")
+        token_text = token_resp.text
+
+        cse_lib_match = re.search(r'cselibVersion": "(.*)"', token_text)
+        cse_tok_match = re.search(r'cse_token": "(.*)"', token_text)
+
+        if not cse_lib_match or not cse_tok_match:
+            return []
+
+        cse_lib = cse_lib_match.group(1)
+        cse_tok = cse_tok_match.group(1)
+
+        search_url = (
+            f"https://cse.google.com/cse/element/v1?"
+            f"rsz=filtered_cse&num=100&hl=tr&source=gcsc&cselibv={cse_lib}&cx={cx}"
+            f"&q={query}&safe=off&cse_tok={cse_tok}&sort=&exp=cc%2Capo&oq={query}"
+            f"&callback=google.search.cse.api9969&rurl=https%3A%2F%2Fbelgeselx.com%2F"
+        )
+
+        resp = self.cloudscraper.get(search_url)
+        resp_text = resp.text
+
+        titles = re.findall(r'"titleNoFormatting": "(.*?)"', resp_text)
+        urls   = re.findall(r'"url": "(.*?)"', resp_text)
+        images = re.findall(r'"ogImage": "(.*?)"', resp_text)
+
+        results = []
+        for i, title in enumerate(titles):
+            url_val = urls[i] if i < len(urls) else None
+            poster  = images[i] if i < len(images) else None
+
+            if not url_val or "diziresimleri" not in url_val:
+                # URL'den belgesel linkini oluştur
+                if poster and "diziresimleri" in poster:
+                    file_name = poster.rsplit("/", 1)[-1]
+                    file_name = re.sub(r"\.(jpe?g|png|webp)$", "", file_name)
+                    url_val = f"{self.main_url}/belgeseldizi/{file_name}"
+                else:
+                    continue
+
+            clean_title = title.split("İzle")[0].strip()
+            results.append(SearchResult(
+                title  = self._to_title_case(clean_title),
+                url    = url_val,
+                poster = poster
+            ))
+
+        return results
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("h2.gen-title::text").get()
+        poster      = secici.css("div.gen-tv-show-top img::attr(src)").get()
+        description = secici.css("div.gen-single-tv-show-info p::text").get()
+
+        tags = []
+        for tag_link in secici.css("div.gen-socail-share a[href*='belgeselkanali']"):
+            tag_href = tag_link.css("::attr(href)").get()
+            if tag_href:
+                tag_name = tag_href.rsplit("/", 1)[-1].replace("-", " ")
+                tags.append(self._to_title_case(tag_name))
+
+        episodes = []
+        counter  = 0
+        for ep_item in secici.css("div.gen-movie-contain"):
+            ep_name = ep_item.css("div.gen-movie-info h3 a::text").get()
+            ep_href = ep_item.css("div.gen-movie-info h3 a::attr(href)").get()
+
+            if not ep_name or not ep_href:
+                continue
+
+            season_text   = ep_item.css("div.gen-single-meta-holder ul li::text").get() or ""
+            episode_match = re.search(r"Bölüm (\d+)", season_text)
+            season_match  = re.search(r"Sezon (\d+)", season_text)
+
+            ep_episode = int(episode_match.group(1)) if episode_match else counter
+            ep_season  = int(season_match.group(1)) if season_match else 1
+
+            counter += 1
+
+            episodes.append(Episode(
+                season  = ep_season,
+                episode = ep_episode,
+                title   = ep_name.strip(),
+                url     = self.fix_url(ep_href)
+            ))
+
+        return SeriesInfo(
+            url         = url,
+            poster      = self.fix_url(poster) if poster else None,
+            title       = self._to_title_case(title.strip()) if title else None,
+            description = description.strip() if description else None,
+            tags        = tags,
+            episodes    = episodes
+        )
+
+    async def load_links(self, url: str) -> list[dict]:
+        istek = await self.httpx.get(url)
+        text  = istek.text
+
+        # fnc_addWatch div'inden data-episode ID'sini al
+        ep_match = re.search(r'<div[^>]*class=["\'][^"\']*fnc_addWatch[^"\']*["\'][^>]*data-episode=["\'](\d+)["\']', text)
+        if not ep_match:
+            return []
+
+        episode_id  = ep_match.group(1)
+        iframe_url  = f"{self.main_url}/video/data/new4.php?id={episode_id}"
+
+        iframe_resp = await self.httpx.get(iframe_url, headers={"Referer": url})
+        iframe_text = iframe_resp.text
+
+        links = []
+        for match in re.finditer(r'file:"([^"]+)", label: "([^"]+)"', iframe_text):
+            video_url = match.group(1)
+            quality   = match.group(2)
+
+            source_name = "Google" if quality == "FULL" else self.name
+            quality_str = "1080p" if quality == "FULL" else quality
+
+            links.append({
+                "url"     : video_url,
+                "name"    : f"{source_name} | {quality_str}",
+                "referer" : url
+            })
+
+        return links
+
+    async def play(self, **kwargs):
+        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/Plugins/Dizilla.py

@@ -179,17 +179,25 @@ class Dizilla(PluginBase):
         decrypted   = await self.decrypt_response(secure_data)
         results     = decrypted.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
 
-        links = []
-        for result in results:
-            iframe_src = Selector(result.get("source_content")).css("iframe::attr(src)").get()
-            iframe_url = self.fix_url(iframe_src)
-            if not iframe_url:
-                continue
-
-            extractor = self.ex_manager.find_extractor(iframe_url)
-            links.append({
-                "url"  : iframe_url,
-                "name" : f"{extractor.name if extractor else 'Main Player'} | {result.get('language_name')}",
-            })
-
-        return links
+        if not results:
+            return []
+
+        # Get first source (matching Kotlin)
+        first_result = results[0]
+        source_content = first_result.get("source_content", "")
+        
+        # Clean the source_content string (matching Kotlin: .replace("\"", "").replace("\\", ""))
+        cleaned_source = source_content.replace('"', '').replace('\\', '')
+        
+        # Parse cleaned HTML
+        iframe_src = Selector(cleaned_source).css("iframe::attr(src)").get()
+        iframe_url = self.fix_url(iframe_src)
+        
+        if not iframe_url:
+            return []
+
+        extractor = self.ex_manager.find_extractor(iframe_url)
+        return [{
+            "url"  : iframe_url,
+            "name" : f"{extractor.name if extractor else 'Main Player'} | {first_result.get('language_name', 'Unknown')}",
+        }]

KekikStream/Plugins/FilmMakinesi.py

@@ -8,7 +8,7 @@ class FilmMakinesi(PluginBase):
     language    = "tr"
     main_url    = "https://filmmakinesi.to"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Film Makinesi, en yeni ve en güncel filmleri sitemizde full HD kalite farkı ile izleyebilirsiniz. HD film izle denildiğinde akla gelen en kaliteli film izleme sitesi."
+    description = "Film Makinesi ile en yeni ve güncel filmleri Full HD kalite farkı ile izleyebilirsiniz. Film izle denildiğinde akla gelen en kaliteli film sitesi."
 
     main_page   = {
         f"{main_url}/filmler-1/"                : "Son Filmler",

KekikStream/Plugins/FilmModu.py

@@ -9,7 +9,7 @@ class FilmModu(PluginBase):
     language    = "tr"
     main_url    = "https://www.filmmodu.ws"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "HD Film izle, Türkçe Dublaj ve Altyazılı filmler."
+    description = "Film modun geldiyse yüksek kalitede yeni filmleri izle, 1080p izleyebileceğiniz reklamsız tek film sitesi."
 
     main_page   = {
         f"{main_url}/hd-film-kategori/4k-film-izle?page=SAYFA"          : "4K",
@@ -91,9 +91,13 @@ class FilmModu(PluginBase):
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
+        alternates = secici.css("div.alternates a")
+        if not alternates:
+            return []  # No alternates available
+
         results = []
 
-        for alternatif in secici.css("div.alternates a"):
+        for alternatif in alternates:
             alt_link = self.fix_url(alternatif.css("::attr(href)").get())
             alt_name = alternatif.css("::text").get()
 

KekikStream/Plugins/FullHDFilmizlesene.py

@@ -10,7 +10,7 @@ class FullHDFilmizlesene(PluginBase):
     language    = "tr"
     main_url    = "https://www.fullhdfilmizlesene.tv"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Sinema zevkini evinize kadar getirdik. Türkiye'nin lider Film sitesinde, en yeni filmleri Full HD izleyin."
+    description = "Türkiye'nin ilk ve lider HD film izleme platformu, kaliteli ve sorunsuz hizmetiyle sinema keyfini zirveye taşır."
 
     main_page   = {
         f"{main_url}/en-cok-izlenen-hd-filmler/"            : "En Çok izlenen Filmler",

KekikStream/Plugins/HDFilmCehennemi.py

@@ -10,7 +10,7 @@ class HDFilmCehennemi(PluginBase):
     language    = "tr"
     main_url    = "https://www.hdfilmcehennemi.ws"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Türkiye'nin en hızlı hd film izleme sitesi"
+    description = "Türkiye'nin en hızlı hd film izleme sitesi. Tek ve gerçek hdfilmcehennemi sitesi."
     
 
 

KekikStream/Plugins/JetFilmizle.py

@@ -8,7 +8,7 @@ class JetFilmizle(PluginBase):
     language    = "tr"
     main_url    = "https://jetfilmizle.website"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Binlerce Film İzleme Seçeneğiyle En İyi Film İzleme Sitesi"
+    description = "Film izle, Yerli, Yabancı film izle, Türkçe dublaj, alt yazılı seçenekleriyle ödül almış filmleri Full HD kalitesiyle ve jetfilmizle hızıyla donmadan ücretsizce izleyebilirsiniz."
 
     main_page   = {
         f"{main_url}/page/"                                     : "Son Filmler",

KekikStream/Plugins/KultFilmler.py

@@ -9,7 +9,7 @@ class KultFilmler(PluginBase):
     language    = "tr"
     main_url    = "https://kultfilmler.net"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Kült film ve dizi izleme sitesi."
+    description = "Kült Filmler özenle en iyi filmleri derler ve iyi bir altyazılı film izleme deneyimi sunmayı amaçlar. Reklamsız 1080P Altyazılı Film izle..."
 
     main_page   = {
         f"{main_url}/category/aile-filmleri-izle"       : "Aile",

KekikStream/Plugins/RoketDizi.py

@@ -185,6 +185,7 @@ class RoketDizi(PluginBase):
             # secureData içindeki RelatedResults -> getEpisodeSources -> result dizisini al
             sources = decoded_json.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
 
+            seen_urls = set()
             results = []
             for source in sources:
                 source_content = source.get("source_content", "")
@@ -195,35 +196,27 @@ class RoketDizi(PluginBase):
                     continue
 
                 iframe_url = iframe_match.group(1)
-                if "http" not in iframe_url:
-                     if iframe_url.startswith("//"):
-                         iframe_url = "https:" + iframe_url
-                     else:
-                         iframe_url = "https://" + iframe_url
+                
+                # Fix URL protocol
+                if not iframe_url.startswith("http"):
+                    if iframe_url.startswith("//"):
+                        iframe_url = "https:" + iframe_url
+                    else:
+                        iframe_url = "https://" + iframe_url
+
+                iframe_url = self.fix_url(iframe_url)
+                
+                # Deduplicate  
+                if iframe_url in seen_urls:
+                    continue
+                seen_urls.add(iframe_url)
 
                 # Check extractor
                 extractor = self.ex_manager.find_extractor(iframe_url)
-                ext_name  = extractor.name if extractor else ""
-
-                # Metadata'dan bilgileri al
-                source_name   = source.get("source_name", "")
-                language_name = source.get("language_name", "")
-                quality_name  = source.get("quality_name", "")
-
-                # İsmi oluştur
-                name_parts = []
-                if source_name:
-                    name_parts.append(source_name)
-                if ext_name:
-                    name_parts.append(ext_name)
-                if language_name:
-                    name_parts.append(language_name)
-                if quality_name:
-                    name_parts.append(quality_name)
-
+                
                 results.append({
                     "url"  : iframe_url,
-                    "name" : " | ".join(name_parts)
+                    "name" : extractor.name if extractor else "Player"
                 })
 
             return results