KekikStream 1.8.1__py3-none-any.whl → 1.9.2__py3-none-any.whl

KekikStream/Core/Extractor/ExtractorBase.py

@@ -1,7 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from abc              import ABC, abstractmethod
-from curl_cffi        import AsyncSession
 from cloudscraper     import CloudScraper
 from httpx            import AsyncClient
 from typing           import Optional
@@ -12,7 +11,6 @@ class ExtractorBase(ABC):
     # Çıkarıcının temel özellikleri
     name     = "Extractor"
     main_url = ""
-    requires_cffi = False
 
     def __init__(self):
         # cloudscraper - for bypassing Cloudflare
@@ -21,19 +19,11 @@ class ExtractorBase(ABC):
         # httpx - lightweight and safe for most HTTP requests
         self.httpx = AsyncClient(
             timeout          = 3,
-            follow_redirects = True,
+            follow_redirects = True
         )
         self.httpx.headers.update(self.cloudscraper.headers)
         self.httpx.cookies.update(self.cloudscraper.cookies)
 
-        # curl_cffi - only initialize if needed for anti-bot bypass
-        self.cffi = None
-
-        if self.requires_cffi:
-            self.cffi = AsyncSession(impersonate="firefox135")
-            self.cffi.cookies.update(self.cloudscraper.cookies)
-            self.cffi.headers.update({"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:135.0) Gecko/20100101 Firefox/135.0"})
-
     def can_handle_url(self, url: str) -> bool:
         # URL'nin bu çıkarıcı tarafından işlenip işlenemeyeceğini kontrol et
         return self.main_url in url
@@ -44,10 +34,8 @@ class ExtractorBase(ABC):
         pass
 
     async def close(self):
-        """Close both HTTP clients if they exist."""
+        """Close HTTP client."""
         await self.httpx.aclose()
-        if self.cffi:
-            await self.cffi.close()
 
     def fix_url(self, url: str) -> str:
         # Eksik URL'leri düzelt ve tam URL formatına çevir

KekikStream/Core/Extractor/ExtractorManager.py

@@ -9,23 +9,44 @@ class ExtractorManager:
         self.extractor_loader = ExtractorLoader(extractor_dir)
         self.extractors       = self.extractor_loader.load_all()
 
-    def find_extractor(self, link) -> ExtractorBase:
-        # Verilen bağlantıyı işleyebilecek çıkarıcıyı bul
+        # Extractor instance'larını cache'le
+        self._extractor_instances = []
+        self._ytdlp_extractor     = None
+
         for extractor_cls in self.extractors:
-            extractor:ExtractorBase = extractor_cls()
+            instance = extractor_cls()
+
+            # YTDLP'yi ayrı tut
+            if instance.name == "yt-dlp":
+                self._ytdlp_extractor = instance
+            else:
+                self._extractor_instances.append(instance)
+
+        # YTDLP'yi EN BAŞA ekle
+        if self._ytdlp_extractor:
+            self._extractor_instances.insert(0, self._ytdlp_extractor)
+
+    def find_extractor(self, link) -> ExtractorBase:
+        """
+        Verilen bağlantıyı işleyebilecek çıkarıcıyı bul
+        """
+        # Cached instance'ları kullan
+        for extractor in self._extractor_instances:
             if extractor.can_handle_url(link):
                 return extractor
 
         return None
 
     def map_links_to_extractors(self, links) -> dict:
-        # Bağlantıları uygun çıkarıcılarla eşleştir
+        """
+        Bağlantıları uygun çıkarıcılarla eşleştir
+        """
         mapping = {}
         for link in links:
-            for extractor_cls in self.extractors:
-                extractor:ExtractorBase = extractor_cls()
+            # Cached instance'ları kullan
+            for extractor in self._extractor_instances:
                 if extractor.can_handle_url(link):
                     mapping[link] = f"{extractor.name:<30} » {link.replace(extractor.main_url, '')}"
-                    break
+                    break  # İlk eşleşmede dur
 
-        return mapping
+        return mapping

KekikStream/Core/Media/MediaHandler.py

@@ -18,19 +18,34 @@ class MediaHandler:
         if extract_data.referer:
             self.headers["referer"] = extract_data.referer
 
-        # Google Drive gibi özel durumlar için yt-dlp kullan
+        # Özel Durumlar (RecTV vs. Googleusercontent)
         if user_agent in ["googleusercontent", "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0"]:
             return self.play_with_ytdlp(extract_data)
 
-        # İşletim sistemine göre oynatıcı seç
+        # İşletim sistemine göre oynatıcı seç (Android durumu)
         if subprocess.check_output(['uname', '-o']).strip() == b'Android':
             return self.play_with_android_mxplayer(extract_data)
 
-        # Alt yazılar varsa mpv kullan
-        if extract_data.subtitles:
-            return self.play_with_mpv(extract_data)
+        # Oynatıcı öncelik sırası (fallback zincirleme)
+        players = [
+            ("MPV", self.play_with_mpv),
+            ("VLC", self.play_with_vlc),
+            ("yt-dlp", self.play_with_ytdlp)
+        ]
+
+        # Fallback zincirleme
+        for player_name, player_func in players:
+            try:
+                result = player_func(extract_data)
+                if result or result is None:  # None = MPV (exception yok)
+                    konsol.log(f"[green][✓] {player_name} ile başarılı[/green]")
+                    return True
+            except Exception as e:
+                konsol.log(f"[yellow][⚠] {player_name} hatası: {e}[/yellow]")
+                continue
 
-        return self.play_with_vlc(extract_data) or self.play_with_mpv(extract_data)
+        konsol.print("[red][✗] Hiçbir oynatıcı çalışmadı![/red]")
+        return False
 
     def play_with_vlc(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] VLC ile Oynatılıyor : {extract_data.url}")
@@ -88,12 +103,15 @@ class MediaHandler:
             with open(os.devnull, "w") as devnull:
                 subprocess.run(mpv_command, stdout=devnull, stderr=devnull, check=True)
 
+            return True
         except subprocess.CalledProcessError as hata:
             konsol.print(f"[red]mpv oynatma hatası: {hata}[/red]")
             konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
         except FileNotFoundError:
             konsol.print("[red]mpv bulunamadı! mpv kurulu olduğundan emin olun.[/red]")
             konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
 
     def play_with_ytdlp(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] yt-dlp ile Oynatılıyor : {extract_data.url}")
@@ -121,12 +139,15 @@ class MediaHandler:
             with subprocess.Popen(ytdlp_command, stdout=subprocess.PIPE) as ytdlp_proc:
                 subprocess.run(mpv_command, stdin=ytdlp_proc.stdout, check=True)
 
+            return True
         except subprocess.CalledProcessError as hata:
             konsol.print(f"[red]Oynatma hatası: {hata}[/red]")
             konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
         except FileNotFoundError:
             konsol.print("[red]yt-dlp veya mpv bulunamadı! Kurulumlarından emin olun.[/red]")
             konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
 
     def play_with_android_mxplayer(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] MxPlayer ile Oynatılıyor : {extract_data.url}")
@@ -151,11 +172,12 @@ class MediaHandler:
                 with open(os.devnull, "w") as devnull:
                     subprocess.run(android_command, stdout=devnull, stderr=devnull, check=True)
 
-                return
-
+                return True
             except subprocess.CalledProcessError as hata:
                 konsol.print(f"[red]{paket} oynatma hatası: {hata}[/red]")
                 konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+                return False
             except FileNotFoundError:
                 konsol.print(f"Paket: {paket}, Hata: MX Player kurulu değil")
                 konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+                return False

KekikStream/Core/Plugin/PluginBase.py

@@ -1,7 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from abc                          import ABC, abstractmethod
-from curl_cffi                    import AsyncSession
 from cloudscraper                 import CloudScraper
 from httpx                        import AsyncClient
 from .PluginModels                import MainPageResult, SearchResult, MovieInfo
@@ -17,8 +16,6 @@ class PluginBase(ABC):
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "No description provided."
 
-    requires_cffi = False
-
     main_page   = {}
 
     async def url_update(self, new_url: str):
@@ -33,19 +30,11 @@ class PluginBase(ABC):
         # httpx - lightweight and safe for most HTTP requests
         self.httpx = AsyncClient(
             timeout          = 3,
-            follow_redirects = True,
+            follow_redirects = True
         )
         self.httpx.headers.update(self.cloudscraper.headers)
         self.httpx.cookies.update(self.cloudscraper.cookies)
 
-        # curl_cffi - only initialize if needed for anti-bot bypass
-        self.cffi = None
-
-        if self.requires_cffi:
-            self.cffi = AsyncSession(impersonate="firefox135")
-            self.cffi.cookies.update(self.cloudscraper.cookies)
-            self.cffi.headers.update({"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:135.0) Gecko/20100101 Firefox/135.0"})
-
         self.media_handler = MediaHandler()
         self.ex_manager    = ExtractorManager()
 
@@ -90,10 +79,8 @@ class PluginBase(ABC):
         pass
 
     async def close(self):
-        """Close both HTTP clients if they exist."""
+        """Close HTTP client."""
         await self.httpx.aclose()
-        if self.cffi:
-            await self.cffi.close()
 
     def fix_url(self, url: str) -> str:
         if not url:

KekikStream/Extractors/YTDLP.py

@@ -0,0 +1,172 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from urllib.parse     import urlparse
+from yt_dlp.extractor import gen_extractors
+import yt_dlp, re, sys, os
+
+class YTDLP(ExtractorBase):
+    name     = "yt-dlp"
+    main_url = ""  # Universal - tüm siteleri destekler
+
+    _FAST_DOMAIN_RE = None  # compiled mega-regex (host üstünden)
+
+    @classmethod
+    def _init_fast_domain_regex(cls):
+        if cls._FAST_DOMAIN_RE is not None:
+            return
+
+        domains = set()
+
+        # yt-dlp extractor'larının _VALID_URL regex'lerinden domain yakala
+        # Regex metinlerinde domainler genelde "\." şeklinde geçer.
+        domain_pat = re.compile(r"(?:[a-z0-9-]+\\\.)+[a-z]{2,}", re.IGNORECASE)
+
+        for ie in gen_extractors():
+            # Generic'i fast-path'e dahil etmiyoruz
+            if getattr(ie, "IE_NAME", "").lower() == "generic":
+                continue
+
+            valid = getattr(ie, "_VALID_URL", None)
+            if not valid or not isinstance(valid, str):
+                continue
+
+            for m in domain_pat.findall(valid):
+                d = m.replace(r"\.", ".").lower()
+
+                # Çok agresif/şüpheli şeyleri elemek istersen burada filtre koyabilirsin
+                # (genelde gerek kalmıyor)
+                domains.add(d)
+
+        # Hiç domain çıkmazsa (çok uç durum) fallback: boş regex
+        if not domains:
+            cls._FAST_DOMAIN_RE = re.compile(r"$^")  # hiçbir şeye match etmez
+            return
+
+        # Host eşleştirmesi: subdomain destekli (m.youtube.com, player.vimeo.com vs.)
+        # (?:^|.*\.) (domain1|domain2|...) $
+        joined = "|".join(sorted(re.escape(d) for d in domains))
+        pattern = rf"(?:^|.*\.)(?:{joined})$"
+        cls._FAST_DOMAIN_RE = re.compile(pattern, re.IGNORECASE)
+
+    def __init__(self):
+        self.__class__._init_fast_domain_regex()
+
+    def can_handle_url(self, url: str) -> bool:
+        """
+        Fast-path: URL host'unu tek mega-regex ile kontrol et (loop yok)
+        Slow-path: gerekirse mevcut extract_info tabanlı kontrolün
+        """
+        # URL parse + host al
+        try:
+            parsed = urlparse(url)
+            host = (parsed.hostname or "").lower()
+        except Exception:
+            host = ""
+
+        # Şemasız URL desteği: "youtube.com/..." gibi
+        if not host and "://" not in url:
+            try:
+                parsed = urlparse("https://" + url)
+                host = (parsed.hostname or "").lower()
+            except Exception:
+                host = ""
+
+        # Fast-path
+        if host and self.__class__._FAST_DOMAIN_RE.search(host):
+            return True
+
+        # SLOW PATH: Diğer siteler için yt-dlp'nin native kontrolü
+        try:
+            # stderr'ı geçici olarak kapat (hata mesajlarını gizle)
+            old_stderr = sys.stderr
+            sys.stderr = open(os.devnull, "w")
+
+            try:
+                ydl_opts = {
+                    "simulate"              : True,  # Download yok, sadece tespit
+                    "quiet"                 : True,  # Log kirliliği yok
+                    "no_warnings"           : True,  # Uyarı mesajları yok
+                    "extract_flat"          : True,  # Minimal işlem
+                    "no_check_certificates" : True,
+                    "ignoreerrors"          : True   # Hataları yoksay
+                }
+
+                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                    # URL'yi işleyebiliyor mu kontrol et
+                    info = ydl.extract_info(url, download=False, process=False)
+
+                    # Generic extractor ise atla
+                    if info and info.get("extractor_key") != "Generic":
+                        return True
+
+                    return False
+            finally:
+                # stderr'ı geri yükle
+                sys.stderr.close()
+                sys.stderr = old_stderr
+
+        except Exception:
+            # yt-dlp işleyemezse False döndür
+            return False
+
+    async def extract(self, url: str, referer: str | None = None) -> ExtractResult:
+        ydl_opts = {
+            "quiet"                 : True,
+            "no_warnings"           : True,
+            "extract_flat"          : False,   # Tam bilgi al
+            "format"                : "best",  # En iyi kalite
+            "no_check_certificates" : True
+        }
+
+        # Referer varsa header olarak ekle
+        if referer:
+            ydl_opts["http_headers"] = {"Referer": referer}
+
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=False)
+
+            if not info:
+                raise ValueError("yt-dlp video bilgisi döndürmedi")
+
+            # Video URL'sini al
+            video_url = info.get("url")
+            if not video_url:
+                # Bazen formatlar listesinde olabilir
+                formats = info.get("formats", [])
+                if formats:
+                    video_url = formats[-1].get("url")  # Son format (genellikle en iyi)
+
+            if not video_url:
+                raise ValueError("Video URL bulunamadı")
+
+            # Altyazıları çıkar
+            subtitles = []
+            if subtitle_data := info.get("subtitles"):
+                for lang, subs in subtitle_data.items():
+                    for sub in subs:
+                        if sub_url := sub.get("url"):
+                            subtitles.append(
+                                Subtitle(
+                                    name=f"{lang} ({sub.get('ext', 'unknown')})",
+                                    url=sub_url
+                                )
+                            )
+
+            # User-Agent al
+            user_agent = None
+            http_headers = info.get("http_headers", {})
+            if http_headers:
+                user_agent = http_headers.get("User-Agent")
+
+            return ExtractResult(
+                name       = self.name,
+                url        = video_url,
+                referer    = referer or info.get("webpage_url"),
+                user_agent = user_agent,
+                subtitles  = subtitles
+            )
+
+    async def close(self):
+        """yt-dlp için cleanup gerekmez"""
+        pass

KekikStream/Plugins/DiziBox.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import kekik_cache, PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
 from Kekik.Sifreleme  import CryptoJS
 from parsel           import Selector
 import re, urllib.parse, base64, contextlib, asyncio, time
@@ -40,7 +40,6 @@ class DiziBox(PluginBase):
         f"{main_url}/dizi-arsivi/page/SAYFA/?tur[0]=yarisma&yil&imdb"    : "Yarışma"
     }
 
-    #@kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         self.httpx.cookies.update({
             "isTrustedUser" : "true",
@@ -62,7 +61,6 @@ class DiziBox(PluginBase):
                 for veri in secici.css("article.detailed-article")
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
         self.httpx.cookies.update({
             "isTrustedUser" : "true",
@@ -80,7 +78,6 @@ class DiziBox(PluginBase):
                 for item in secici.css("article.detailed-article")
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> SeriesInfo:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
@@ -127,7 +124,6 @@ class DiziBox(PluginBase):
             actors      = actors,
         )
 
-    #@kekik_cache(ttl=60*60)
     async def _iframe_decode(self, name:str, iframe_link:str, referer:str) -> list[str]:
         results = []
 
@@ -178,7 +174,6 @@ class DiziBox(PluginBase):
 
         return results
 
-    #@kekik_cache(ttl=15*60)
     async def load_links(self, url: str) -> list[dict]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
@@ -214,4 +209,4 @@ class DiziBox(PluginBase):
                             "name" : f"{extractor.name if extractor else alt_name}"
                         })
 
-        return results
+        return results

KekikStream/Plugins/DiziPal.py

@@ -9,7 +9,7 @@ class DiziPal(PluginBase):
     language    = "tr"
     main_url    = "https://dizipal1223.com"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
-    description = "Yabancı Dizi ve Film izle."
+    description = "dizipal güncel, dizipal yeni ve gerçek adresi. dizipal en yeni dizi ve filmleri güvenli ve hızlı şekilde sunar."
 
     main_page   = {
         f"{main_url}/diziler/son-bolumler"              : "Son Bölümler",

KekikStream/Plugins/DiziYou.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import kekik_cache, PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, Subtitle, ExtractResult
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, Subtitle, ExtractResult
 from parsel           import Selector
 import re
 
@@ -29,7 +29,6 @@ class DiziYou(PluginBase):
         f"{main_url}/dizi-arsivi/page/SAYFA/?tur=Vah%C5%9Fi+Bat%C4%B1" : "Vahşi Batı"
     }
 
-    #@kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(f"{url.replace('SAYFA', str(page))}")
         secici = Selector(istek.text)
@@ -44,7 +43,6 @@ class DiziYou(PluginBase):
                 for veri in secici.css("div.single-item")
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
         istek  = await self.httpx.get(f"{self.main_url}/?s={query}")
         secici = Selector(istek.text)
@@ -53,18 +51,28 @@ class DiziYou(PluginBase):
             SearchResult(
                 title  = afis.css("div#categorytitle a::text").get().strip(),
                 url    = self.fix_url(afis.css("div#categorytitle a::attr(href)").get()),
-                poster = self.fix_url(afis.css("img::attr(src)").get()),
+                poster = self.fix_url(afis.css("img::attr(src)").get() or afis.css("img::attr(data-src)").get())
             )
                 for afis in secici.css("div.incontent div#list-series")
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> SeriesInfo:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
-        title       = secici.css("h1::text").get().strip()
-        poster      = self.fix_url(secici.css("div.category_image img::attr(src)").get().strip())
+        # Title - div.title h1 içinde
+        title_raw   = secici.css("div.title h1::text").get()
+        title       = title_raw.strip() if title_raw else ""
+        
+        # Fallback: Eğer title boşsa URL'den çıkar (telif kısıtlaması olan sayfalar için)
+        if not title:
+            # URL'den slug'ı al: https://www.diziyou.one/jasmine/ -> jasmine -> Jasmine
+            slug = url.rstrip('/').split('/')[-1]
+            title = slug.replace('-', ' ').title()
+        
+        # Poster
+        poster_raw  = secici.css("div.category_image img::attr(src)").get()
+        poster      = self.fix_url(poster_raw) if poster_raw else ""
         year        = secici.xpath("//span[contains(., 'Yapım Yılı')]/following-sibling::text()[1]").get()
         description = secici.css("div.diziyou_desc::text").get()
         if description:
@@ -75,13 +83,21 @@ class DiziYou(PluginBase):
         actors      = [actor.strip() for actor in _actors.split(",")] if _actors else []
 
         episodes    = []
-        for it in secici.css("div.bolumust"):
-            ep_name = it.css("div.baslik::text").get().strip()
-            ep_href = it.xpath("ancestor::a/@href").get()
-            if not ep_name or not ep_href:
+        # Episodes - bolumust her bölüm için bir <a> içinde
+        # :has() parsel'de çalışmıyor, XPath kullanıyoruz
+        for link in secici.xpath('//a[div[@class="bolumust"]]'):
+            ep_name_raw = link.css("div.baslik::text").get()
+            if not ep_name_raw:
+                continue
+            ep_name = ep_name_raw.strip()
+            
+            ep_href = self.fix_url(link.css("::attr(href)").get())
+            if not ep_href:
                 continue
 
-            ep_name_clean = it.css("div.bolumismi::text").get().strip().replace("(", "").replace(")", "").strip() if it.css("div.bolumismi::text").get() else ep_name
+            # Bölüm ismi varsa al
+            ep_name_raw_clean = link.css("div.bolumismi::text").get()
+            ep_name_clean = ep_name_raw_clean.strip().replace("(", "").replace(")", "").strip() if ep_name_raw_clean else ep_name
 
             ep_episode = re.search(r"(\d+)\. Bölüm", ep_name)[1]
             ep_season  = re.search(r"(\d+)\. Sezon", ep_name)[1]
@@ -107,14 +123,23 @@ class DiziYou(PluginBase):
             actors      = actors
         )
 
-    #@kekik_cache(ttl=15*60)
     async def load_links(self, url: str) -> list[dict]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
-        item_title = secici.css("div.title h1::text").get()
-        ep_name    = secici.css("div#bolum-ismi::text").get().strip()
-        item_id    = secici.css("iframe#diziyouPlayer::attr(src)").get().split("/")[-1].replace(".html", "")
+        # Title ve episode name - None kontrolü ekle
+        item_title_raw = secici.css("div.title h1::text").get()
+        item_title = item_title_raw.strip() if item_title_raw else ""
+        
+        ep_name_raw = secici.css("div#bolum-ismi::text").get()
+        ep_name = ep_name_raw.strip() if ep_name_raw else ""
+        
+        # Player src'den item_id çıkar
+        player_src = secici.css("iframe#diziyouPlayer::attr(src)").get()
+        if not player_src:
+            return []  # Player bulunamadıysa boş liste döndür
+        
+        item_id = player_src.split("/")[-1].replace(".html", "")
 
         subtitles   = []
         stream_urls = []