KekikStream 2.3.6__tar.gz → 2.4.0__tar.gz

{kekikstream-2.3.6 → kekikstream-2.4.0}/KekikStream/Core/HTMLHelper.py

@@ -113,8 +113,8 @@ class HTMLHelper:
             return int(m.group(1)), int(m.group(2))
 
         # Ayrı ayrı ara
-        s = re.search(r"(\d+)\.\s*[Ss]ezon|[Ss]ezon[- ]?(\d+)|-(\d+)-sezon", text, re.I)
-        e = re.search(r"(\d+)\.\s*[Bb]ölüm|[Bb]olum[- ]?(\d+)|-(\d+)-bolum|[Ee](\d+)", text, re.I)
+        s = re.search(r"(\d+)\.\s*[Ss]ezon|[Ss]ezon[- ]?(\d+)|-(\d+)-sezon|S(\d+)|(\d+)\.[Ss]", text, re.I)
+        e = re.search(r"(\d+)\.\s*[Bb][öo]l[üu]m|[Bb][öo]l[üu]m[- ]?(\d+)|-(\d+)-bolum|[Ee](\d+)", text, re.I)
 
         # İlk bulunan grubu al (None değilse)
         s_val = next((int(g) for g in s.groups() if g), None) if s else None

{kekikstream-2.3.6 → kekikstream-2.4.0}/KekikStream/Core/Plugin/PluginBase.py

@@ -31,11 +31,16 @@ class PluginBase(ABC):
         if proxy:
             self.cloudscraper.proxies = proxy if isinstance(proxy, dict) else {"http": proxy, "https": proxy}
 
+        # Convert dict proxy to string for httpx if necessary
+        httpx_proxy = proxy
+        if isinstance(proxy, dict):
+            httpx_proxy = proxy.get("https") or proxy.get("http")
+
         # httpx - lightweight and safe for most HTTP requests
         self.httpx = AsyncClient(
             timeout          = 3,
             follow_redirects = True,
-            proxy            = proxy
+            proxy            = httpx_proxy
         )
         self.httpx.headers.update(self.cloudscraper.headers)
         self.httpx.cookies.update(self.cloudscraper.cookies)

{kekikstream-2.3.6 → kekikstream-2.4.0}/KekikStream/Core/Plugin/PluginModels.py

@@ -51,9 +51,6 @@ class Episode(BaseModel):
         if not self.title:
             self.title = ""
 
-        if any(keyword in self.title.lower() for keyword in ["bölüm", "sezon", "episode"]):
-            self.title = ""
-
         return self
 
 class SeriesInfo(BaseModel):

kekikstream-2.4.0/KekikStream/Extractors/HDMomPlayer.py

@@ -0,0 +1,62 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+from Kekik.Sifreleme import AESManager
+import re
+import json
+
+class HDMomPlayer(ExtractorBase):
+    name     = "HDMomPlayer"
+    main_url = "hdmomplayer.com"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult | None:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        try:
+            response = await self.httpx.get(url)
+            page_source = response.text
+            
+            m3u_link = None
+            
+            # Regex for bePlayer matches
+            # Matches: bePlayer('PASS', '{DATA}');
+            helper = HTMLHelper(page_source)
+            be_matches = helper.regex_all(r"bePlayer\('([^']+)',\s*'(\{[^\}]+\})'\);")
+            
+            if be_matches:
+                pass_val, data_val = be_matches[0]
+                
+                try:
+                    # Use Kekik.Sifreleme.AESManager as requested
+                    decrypted = AESManager.decrypt(data_val, pass_val).replace("\\", "")
+                    
+                    # Search for video_location in decrypted string
+                    # Kotlin: video_location":"([^"]+)
+                    m_loc = re.search(r'video_location":"([^"]+)"', decrypted)
+                    if m_loc:
+                        m3u_link = m_loc.group(1).replace(r"\/", "/")
+                except Exception:
+                    pass
+
+            if not m3u_link:
+                # Fallback regex
+                # file:"..."
+                m_file = re.search(r'file:"([^"]+)"', page_source)
+                if m_file:
+                    m3u_link = m_file.group(1)
+            
+            if not m3u_link:
+                return None
+            
+            # Fix URL if needed
+            if m3u_link.startswith("//"):
+                m3u_link = "https:" + m3u_link
+                
+            return ExtractResult(
+                name    = "HDMomPlayer",
+                url     = m3u_link,
+                referer = url, 
+            )
+        except Exception:
+            return None

{kekikstream-2.3.6 → kekikstream-2.4.0}/KekikStream/Extractors/MolyStream.py

@@ -9,6 +9,7 @@ class MolyStream(ExtractorBase):
 
     # Birden fazla domain destekle
     supported_domains = [
+        "dbx.molystream.org",
         "ydx.molystream.org",
         "yd.sheila.stream",
         "ydf.popcornvakti.net",

{kekikstream-2.3.6 → kekikstream-2.4.0}/KekikStream/Extractors/VidMoly.py

@@ -24,6 +24,8 @@ class VidMoly(ExtractorBase):
 
         if ".me" in url:
             url = url.replace(".me", ".net")
+        if ".to" in url:
+            url = url.replace(".to", ".net")
 
         # VidMoly bazen redirect ediyor, takip et
         response = await self.httpx.get(url, follow_redirects=True)
@@ -70,6 +72,17 @@ class VidMoly(ExtractorBase):
                             if sub.get("kind") == "captions"
                 ]
 
+        if "#EXTM3U" in response.text:
+            for line in response.text.splitlines():
+                line = line.strip().replace('"', '').replace("'", "")
+                if line.startswith("http"):
+                    return ExtractResult(
+                        name      = self.name,
+                        url       = line,
+                        referer   = self.main_url,
+                        subtitles = subtitles
+                    )
+
         if script_str := resp_sec.regex_first(r"sources:\s*\[(.*?)\],", flags= re.DOTALL):
             script_content = script_str
             # Video kaynaklarını ayrıştır

kekikstream-2.4.0/KekikStream/Extractors/Videostr.py

@@ -0,0 +1,115 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper, Subtitle
+from urllib.parse import quote
+from json import loads
+
+class Videostr(ExtractorBase):
+    name     = "Videostr"
+    main_url = "videostr.net"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult | None:
+        headers = {
+            "Accept": "*/*",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": "https://videostr.net",
+        }
+        
+        # 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")
+        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)
+        
+        if not nonce:
+            return None
+            
+        # 2. Get Sources
+        api_url = f"https://videostr.net/embed-1/v3/e-1/getSources?id={id}&_k={nonce}"
+        
+        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
+            
+        m3u8_url = None
+        
+        if ".m3u8" in encrypted_file:
+            m3u8_url = encrypted_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
+
+        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
+        )

kekikstream-2.4.0/KekikStream/Plugins/DiziMom.py

@@ -0,0 +1,248 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, HTMLHelper
+from json             import dumps, loads
+import re
+
+class DiziMom(PluginBase):
+    name        = "DiziMom"
+    language    = "tr"
+    main_url    = "https://www.dizimom.one"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Binlerce yerli yabancı dizi arşivi, tüm sezonlar, kesintisiz bölümler. Sadece dizi izle, Dizimom heryerde seninle!"
+
+    main_page = {
+        f"{main_url}/tum-bolumler/page"        : "Son Bölümler",
+        f"{main_url}/yerli-dizi-izle/page"     : "Yerli Diziler",
+        f"{main_url}/yabanci-dizi-izle/page"   : "Yabancı Diziler",
+        f"{main_url}/tv-programlari-izle/page" : "TV Programları",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek   = await self.httpx.get(f"{url}/{page}/")
+        helper  = HTMLHelper(istek.text)
+
+        if "/tum-bolumler/" in url:
+            items = helper.select("div.episode-box")
+            results = []
+            for item in items:
+                name_el = helper.select_first("div.episode-name a", item)
+                if not name_el: continue
+                name = name_el.text(strip=True).split(" izle")[0]
+                title = name.replace(".Sezon ", "x").replace(".Bölüm", "")
+                
+                ep_href = self.fix_url(name_el.attrs.get("href"))
+                pass 
+            
+            # Revert to standard categories if "tum-bolumler" is complex
+            return [] 
+        else:
+            items = helper.select("div.single-item")
+            return [
+                MainPageResult(
+                    category = category,
+                    title    = helper.select_text("div.categorytitle a", item).split(" izle")[0],
+                    url      = self.fix_url(helper.select_attr("div.categorytitle a", "href", item)),
+                    poster   = self.fix_url(helper.select_attr("div.cat-img img", "src", item))
+                )
+                for item in items
+            ]
+
+    async def search(self, query: str) -> list[SearchResult]:
+        url = f"{self.main_url}/?s={query}"
+        istek = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+        items = helper.select("div.single-item")
+        
+        return [
+            SearchResult(
+                title  = helper.select_text("div.categorytitle a", item).split(" izle")[0],
+                url    = self.fix_url(helper.select_attr("div.categorytitle a", "href", item)),
+                poster = self.fix_url(helper.select_attr("div.cat-img img", "src", item))
+            )
+            for item in items
+        ]
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+
+        title_raw = helper.select_text("div.title h1")
+        title = title_raw.split(" izle")[0] if title_raw else "Bilinmiyor"
+        
+        poster = self.fix_url(helper.select_attr("div.category_image img", "src"))
+        
+        # Custom extraction for fields that were using xpath_text
+        year = None
+        rating = None
+        actors = None
+        
+        # Regex approach for specific fields might be safer/easier if structure varies
+        # Matches: Yapım Yılı : </span> 2025
+        year_val = helper.regex_first(r"Yapım Yılı\s*:\s*(?:</span>)?\s*(\d{4})")
+        if year_val:
+            year = int(year_val)
+            
+        rating_val = helper.regex_first(r"IMDB\s*:\s*([\d\.]+)")
+        if rating_val:
+            rating = rating_val
+            
+        actors_val = helper.regex_first(r"Oyuncular\s*:\s*(.+?)(?:</div>|<br|$)")
+        if not actors_val:
+             # Try selecting the div text directly if regex fails due to HTML tags
+             # Find div containing "Oyuncular :"
+             all_divs = helper.select("div")
+             for div in all_divs:
+                 txt = div.text()
+                 if "Oyuncular :" in txt:
+                     actors_val = txt.split("Oyuncular :")[1].strip()
+                     break
+        
+        if actors_val:
+             # Remove footer / junk from actors
+             if "IMDB :" in actors_val:
+                 actors_val = actors_val.split("IMDB :")[0].strip()
+                 
+             if "IMDB :" in actors_val:
+                 actors_val = actors_val.split("IMDB :")[0].strip()
+                 
+             # Remove '×' and other junk if present at end
+             if "×" in actors_val:
+                 actors_val = actors_val.split("×")[0].strip()
+
+             # Remove simple tags if any remaining
+             clean_actors = [a.strip() for a in actors_val.split(",")]
+             # Filter empty
+             clean_actors = [a for a in clean_actors if a]
+             
+             actors = ", ".join(clean_actors)
+             
+        description_raw = helper.select_text("div.category_desc")
+        description = None
+        if description_raw:
+             # Clean header "The Librarians izle..." etc. if present, usually it is fine.
+             # Clean "IMDB :" if attached
+             if "IMDB :" in description_raw:
+                 description_raw = description_raw.split("IMDB :")[0].strip()
+             
+             # Clean footer text start
+             # The footer block usually starts with "Dizimom, dizi ve film..."
+             # If we find "Dizimom," and it's not at the start (meaning it's part of the footer appended), split there.
+             # Note: The description might legitimately start with "Dizimom," strictly speaking, but unlikely for a series description.
+             if "Dizimom," in description_raw:
+                 description = description_raw.split("Dizimom,")[0].strip()
+             elif "dizi izle film izle" in description_raw:
+                 description = description_raw.split("dizi izle film izle")[0].strip()
+             else:
+                  description = description_raw
+
+             # Fallback cleanup for JSON
+             if description and "{" in description:
+                  description = description.split("{")[0].strip()
+
+        tags = helper.select_all_text("div.genres a")
+        
+        # Improved year regex
+        if not year:
+             # Look for "Yapım Yılı : 2014" pattern in ANY text
+             # Get all text from category_text which usually contains it
+             meta_text = helper.select_text("div.category_text")
+             if meta_text:
+                 match = re.search(r"Yapım Yılı\s*:\s*(\d{4})", meta_text)
+                 if match:
+                     year = int(match.group(1))
+
+        episodes = []
+        ep_items = helper.select("div.bolumust")
+        for item in ep_items:
+            ep_name_raw = helper.select_text("div.baslik", item)
+            ep_href = self.fix_url(helper.select_attr("a", "href", item))
+            
+            if ep_name_raw:
+                # 1.Sezon 1.Bölüm
+                s_m = re.search(r"(\d+)\.Sezon", ep_name_raw)
+                e_m = re.search(r"(\d+)\.Bölüm", ep_name_raw)
+                
+                season = int(s_m.group(1)) if s_m else 1
+                episode = int(e_m.group(1)) if e_m else 1
+                
+                name = ep_name_raw.split(" izle")[0].replace(title, "").strip()
+                
+                episodes.append(Episode(
+                    season  = season,
+                    episode = episode,
+                    title   = name,
+                    url     = ep_href
+                ))
+
+        return SeriesInfo(
+            url         = url,
+            poster      = poster,
+            title       = title,
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            year        = str(year) if year else None,
+            actors      = actors,
+            episodes    = episodes
+        )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        # Login simulation headers
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+            "sec-ch-ua": 'Not/A)Brand";v="8", "Chromium";v="137", "Google Chrome";v="137"',
+            "sec-ch-ua-mobile": "?1",
+            "sec-ch-ua-platform": "Android"
+        }
+        
+        # Simulate login (as seen in Kotlin)
+        login_url = f"{self.main_url}/wp-login.php"
+        login_data = {
+            "log": "keyiflerolsun",
+            "pwd": "12345",
+            "rememberme": "forever",
+            "redirect_to": self.main_url
+        }
+        
+        await self.httpx.post(login_url, headers=headers, data=login_data)
+        
+        istek = await self.httpx.get(url, headers=headers)
+        helper = HTMLHelper(istek.text)
+        
+        iframes = []
+        
+        main_iframe = helper.select_attr("iframe[src]", "src")
+        if main_iframe:
+            iframes.append(main_iframe)
+            
+        sources = helper.select("div.sources a")
+        for source in sources:
+            href = source.attrs.get("href")
+            if href:
+                sub_istek = await self.httpx.get(href, headers=headers)
+                sub_helper = HTMLHelper(sub_istek.text)
+                sub_iframe = sub_helper.select_attr("div.video p iframe", "src")
+                if sub_iframe:
+                    iframes.append(sub_iframe)
+                    
+        results = []
+        for iframe_url in iframes:
+            # Check for known extractors
+            if iframe_url.startswith("//"):
+                iframe_url = f"https:{iframe_url}"
+             
+            extract_result = await self.extract(iframe_url)
+            if extract_result:
+                if isinstance(extract_result, list):
+                    results.extend(extract_result)
+                else:
+                    results.append(extract_result)
+            else:
+                 results.append(ExtractResult(
+                    url  = iframe_url,
+                    name = f"{self.name} | External",
+                    referer = self.main_url
+                ))
+                
+        return results

{kekikstream-2.3.6 → kekikstream-2.4.0}/KekikStream/Plugins/DiziPal.py

@@ -127,18 +127,27 @@ class DiziPal(PluginBase):
 
         poster   = self.fix_url(secici.select_attr("meta[property='og:image']", "content")) if secici.select_attr("meta[property='og:image']", "content") else None
 
-        # XPath yerine regex ile HTML'den çıkarma
-        year = secici.regex_first(r'(?is)Yapım Yılı.*?<div[^>]*>(\d{4})</div>', secici.html)
-
-        description = secici.select_text("div.summary p")
+        # Sidebar bilgilerini topla
+        info = {}
+        for li in secici.select("li"):
+             key = secici.select_text("div.key", li)
+             val = secici.select_text("div.value", li)
+             if key and val:
+                 info[key.strip(":")] = val.strip()
+
+        year   = info.get("Yapım Yılı")
+        rating = info.get("IMDB Puanı")
+        
+        tags_raw = info.get("Türler", "")
+        tags = [t.strip() for t in tags_raw.split() if t.strip()] if tags_raw else None
 
-        rating = secici.regex_first(r'(?is)IMDB Puanı.*?<div[^>]*>([0-9.]+)</div>', secici.html)
+        actors_raw = info.get("Oyuncular")
+        actors = [a.strip() for a in actors_raw.split(",") if a.strip()] if actors_raw else None
 
-        tags_raw = secici.regex_first(r'(?is)Türler.*?<div[^>]*>([^<]+)</div>', secici.html)
-        tags = [t.strip() for t in tags_raw.split() if t.strip()] if tags_raw else None
+        description = secici.select_text("div.summary p")
 
-        duration_raw = secici.regex_first(r'(?is)Ortalama Süre.*?<div[^>]*>(\d+)', secici.html)
-        duration = int(duration_raw) if duration_raw else None
+        duration_raw = info.get("Ortalama Süre")
+        duration = int(secici.regex_first(r"(\d+)", duration_raw)) if duration_raw else None
 
         if "/dizi/" in url:
             title    = secici.select_text("div.cover h5")
@@ -177,6 +186,7 @@ class DiziPal(PluginBase):
                 year        = year,
                 duration    = duration,
                 episodes    = episodes if episodes else None,
+                actors      = actors,
             )
         else:
             # Film için title - g-title div'lerinin 2. olanı
@@ -192,6 +202,7 @@ class DiziPal(PluginBase):
                 rating      = rating,
                 year        = year,
                 duration    = duration,
+                actors      = actors,
             )
 
     async def load_links(self, url: str) -> list[ExtractResult]:

{kekikstream-2.3.6 → kekikstream-2.4.0}/KekikStream/Plugins/DiziYou.py

@@ -72,7 +72,7 @@ class DiziYou(PluginBase):
         html_text = istek.text
 
         # Title - div.title h1 içinde
-        title = secici.select_text("div.title h1")
+        title = (secici.select_text("div.title h1") or "").strip()
 
         # Fallback: Eğer title boşsa URL'den çıkar (telif kısıtlaması olan sayfalar için)
         if not title:
@@ -81,23 +81,19 @@ class DiziYou(PluginBase):
             title = slug.replace('-', ' ').title()
 
         # Poster
-        poster_src = secici.select_attr("div.category_image img", "src")
+        poster_src = secici.select_attr("div.category_image img", "src") or secici.select_attr("meta[property='og:image']", "content")
         poster = self.fix_url(poster_src) if poster_src else ""
 
         # Year - regex ile çıkarma (xpath yerine)
         year = secici.regex_first(r"(?is)Yapım Yılı.*?(\d{4})", secici.html)
 
-        description = None
-        # Extract inner HTML via regex and clean
-        desc_html = secici.regex_first(r'(?s)<div class="diziyou_desc">(.*?)</div>', secici.html)
-        if desc_html:
-            # Script taglarını kaldır
-            desc_html = HTMLHelper(desc_html).regex_replace(r"(?s)<script.*?</script>", "")
-            # div#icerikcat2 ve sonrasını kaldır (meta bilgileri içeriyor)
-            desc_html = HTMLHelper(desc_html).regex_replace(r"(?s)<div id=\"icerikcat2\".*", "")
-            # Kalan HTML'den text çıkar
-            clean_sel = HTMLHelper(desc_html)
-            description = clean_sel.select_text()
+        description_el = secici.select("div.diziyou_desc") or secici.select("div#icerikcat")
+        description = ""
+        if description_el:
+             # Scriptleri temizle
+             for script in secici.select("script", description_el[0]):
+                  script.decompose()
+             description = secici.select_text(None, description_el[0])
 
         tags = [secici.select_text(None, a) for a in secici.select("div.genres a") if secici.select_text(None, a)]
 
@@ -109,9 +105,9 @@ class DiziYou(PluginBase):
         actors = [actor.strip() for actor in actors_raw.split(",") if actor.strip()] if actors_raw else []
 
         episodes = []
-        # Episodes - daha fazla DOM/URL kalıbını destekle
-        for link in secici.select("a"):
-            ep_href = secici.select_attr("a", "href", link)
+        # Episodes - div#scrollbar-container a (kısıtlı alan)
+        for link in secici.select("div#scrollbar-container a"):
+            ep_href = secici.select_attr(None, "href", link)
             if not ep_href:
                 continue
 
@@ -179,9 +175,9 @@ class DiziYou(PluginBase):
         # Player src'den item_id çıkar - önce özel player seçicisini dene
         player_src = None
         # Yaygın locatorlar
-        for sel in ["iframe#diziyouPlayer", "div.player iframe", "iframe[src*='/episodes/']", "iframe"]:
+        for sel in ["iframe#diziyouPlayer", "div.player iframe", "iframe[src*='/player/']", "iframe[src*='/episodes/']", "iframe"]:
             p = secici.select_attr(sel, "src")
-            if p and "youtube.com" not in p.lower():
+            if p and any(x in p.lower() for x in ["/player/", "/episodes/", "diziyou"]):
                 player_src = p
                 break