KekikStream 2.3.4__tar.gz → 2.3.5__tar.gz

{kekikstream-2.3.4 → kekikstream-2.3.5}/KekikStream/Core/Plugin/PluginBase.py

@@ -122,7 +122,14 @@ class PluginBase(ABC):
         try:
             data = await extractor.extract(url, referer=referer)
 
-            # prefix varsa name'e ekle
+            # Liste ise her bir öğe için prefix ekle
+            if isinstance(data, list):
+                for item in data:
+                    if prefix and item.name:
+                        item.name = f"{prefix} | {item.name}"
+                return data
+
+            # Tekil öğe ise
             if prefix and data.name:
                 data.name = f"{prefix} | {data.name}"
 

{kekikstream-2.3.4 → kekikstream-2.3.5}/KekikStream/Extractors/ContentX.py

@@ -30,7 +30,7 @@ class ContentX(ExtractorBase):
         istek.raise_for_status()
         i_source = istek.text
 
-        i_extract_value = HTMLHelper(i_source).regex_first(r"window\.openPlayer\('([^']+)'\)")
+        i_extract_value = HTMLHelper(i_source).regex_first(r"window\.openPlayer\('([^']+)'")
         if not i_extract_value:
             raise ValueError("i_extract is null")
 
@@ -47,8 +47,12 @@ class ContentX(ExtractorBase):
                     name = sub_lang.replace("\\u0131", "ı")
                                  .replace("\\u0130", "İ")
                                  .replace("\\u00fc", "ü")
-                                 .replace("\\u00e7", "ç"),
-                    url  = self.fix_url(sub_url.replace("\\", ""))
+                                 .replace("\\u00e7", "ç")
+                                 .replace("\\u011f", "ğ")
+                                 .replace("\\u015f", "ş")
+                                 .replace("\\u011e", "Ğ")
+                                 .replace("\\u015e", "Ş"),
+                    url  = self.fix_url(sub_url.replace("\\/", "/").replace("\\", ""))
                 )
             )
 
@@ -61,7 +65,7 @@ class ContentX(ExtractorBase):
         if not m3u_link:
             raise ValueError("vidExtract is null")
 
-        m3u_link = m3u_link.replace("\\", "")
+        m3u_link = m3u_link.replace("\\", "").replace("/m.php", "/master.m3u8")
         results  = [
             ExtractResult(
                 name      = self.name,
@@ -71,24 +75,25 @@ class ContentX(ExtractorBase):
             )
         ]
 
-        dublaj_value = HTMLHelper(i_source).regex_first(r',\"([^\"]+)\",\"Türkçe\"')
+        dublaj_value = HTMLHelper(i_source).regex_first(r'["\']([^"\']+)["\'],["\']Türkçe["\']')
         if dublaj_value:
-            dublaj_source_request = await self.httpx.get(f"{base_url}/source2.php?v={dublaj_value}", headers={"Referer": referer or base_url})
-            dublaj_source_request.raise_for_status()
-
-            dublaj_source  = dublaj_source_request.text
-            dublaj_link = HTMLHelper(dublaj_source).regex_first(r'file":"([^\"]+)"')
-            if not dublaj_link:
-                raise ValueError("dublajExtract is null")
-
-            dublaj_link = dublaj_link.replace("\\", "")
-            results.append(
-                ExtractResult(
-                    name      = f"{self.name} Türkçe Dublaj",
-                    url       = dublaj_link,
-                    referer   = url,
-                    subtitles = []
-                )
-            )
+            try:
+                dublaj_source_request = await self.httpx.get(f"{base_url}/source2.php?v={dublaj_value}", headers={"Referer": referer or base_url})
+                dublaj_source_request.raise_for_status()
+
+                dublaj_source  = dublaj_source_request.text
+                dublaj_link = HTMLHelper(dublaj_source).regex_first(r'file":"([^\"]+)"')
+                if dublaj_link:
+                    dublaj_link = dublaj_link.replace("\\", "")
+                    results.append(
+                        ExtractResult(
+                            name      = f"{self.name} Türkçe Dublaj",
+                            url       = dublaj_link,
+                            referer   = url,
+                            subtitles = []
+                        )
+                    )
+            except Exception:
+                pass
 
         return results[0] if len(results) == 1 else results

{kekikstream-2.3.4 → kekikstream-2.3.5}/KekikStream/Extractors/MolyStream.py

@@ -7,6 +7,16 @@ class MolyStream(ExtractorBase):
     name     = "MolyStream"
     main_url = "https://dbx.molystream.org"
 
+    # Birden fazla domain destekle
+    supported_domains = [
+        "ydx.molystream.org",
+        "yd.sheila.stream",
+        "ydf.popcornvakti.net",
+    ]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     async def extract(self, url, referer=None) -> ExtractResult:
         if "doctype html" in url:
             secici   = HTMLHelper(url)

kekikstream-2.3.5/KekikStream/Plugins/DiziWatch.py

@@ -0,0 +1,217 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, HTMLHelper
+import urllib.parse
+
+class DiziWatch(PluginBase):
+    name        = "DiziWatch"
+    language    = "tr"
+    main_url    = "https://diziwatch.to"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Diziwatch; en güncel yabancı dizileri ve animeleri, Türkçe altyazılı ve dublaj seçenekleriyle izleyebileceğiniz platform."
+
+    main_page = {
+        f"{main_url}/episodes" : "Yeni Bölümler",
+        "9"   : "Aksiyon", 
+        "17"  : "Animasyon",
+        "5"   : "Bilim Kurgu",
+        "2"   : "Dram",
+        "12"  : "Fantastik",
+        "3"   : "Gizem",
+        "4"   : "Komedi",
+        "8"   : "Korku",
+        "24"  : "Macera",
+        "14"  : "Müzik",
+        "7"   : "Romantik",
+        "23"  : "Spor",
+        "1"   : "Suç",
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.c_key   = None
+        self.c_value = None
+
+    async def _init_session(self):
+        if self.c_key and self.c_value:
+            return
+        
+        # Fetch anime-arsivi to get CSRF tokens
+        resp = await self.httpx.get(f"{self.main_url}/anime-arsivi")
+        sel  = HTMLHelper(resp.text)
+        
+        # form.bg-[rgba(255,255,255,.15)] > input
+        # We can just look for the first two inputs in that specific form
+        inputs = sel.select("form.bg-\\[rgba\\(255\\,255\\,255\\,\\.15\\)\\] input")
+        if len(inputs) >= 2:
+            self.c_key   = inputs[0].attrs.get("value")
+            self.c_value = inputs[1].attrs.get("value")
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        await self._init_session()
+        
+        if url.startswith("https://"):
+            full_url = f"{url}?page={page}"
+            resp = await self.httpx.get(full_url, headers={"Referer": f"{self.main_url}/"})
+            sel  = HTMLHelper(resp.text)
+            items = sel.select("div.swiper-slide a")
+        else:
+            # Category ID based
+            full_url = f"{self.main_url}/anime-arsivi?category={url}&minImdb=&name=&release_year=&sort=date_desc&page={page}"
+            resp = await self.httpx.get(full_url, headers={"Referer": f"{self.main_url}/"})
+            sel  = HTMLHelper(resp.text)
+            items = sel.select("div.content-inner a")
+
+        results = []
+        for item in items:
+            title  = sel.select_text("h2", item)
+            href   = item.attrs.get("href") if item.tag == "a" else sel.select_attr("a", "href", item)
+            poster = sel.select_attr("img", "src", item) or sel.select_attr("img", "data-src", item)
+
+            if title and href:
+                # If it's an episode link, clean it to get show link
+                # Regex in Kotlin: /sezon-\d+/bolum-\d+/?$
+                clean_href = HTMLHelper(href).regex_replace(r"/sezon-\d+/bolum-\d+/?$", "")
+                
+                # If cleaning changed something, it was an episode link, maybe add it to title
+                if clean_href != href:
+                    se_info = sel.select_text("div.flex.gap-1.items-center", item)
+                    if se_info:
+                        title = f"{title} - {se_info}"
+
+                results.append(MainPageResult(
+                    category = category,
+                    title    = title,
+                    url      = self.fix_url(clean_href),
+                    poster   = self.fix_url(poster) if poster else None
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        await self._init_session()
+        
+        post_url = f"{self.main_url}/bg/searchcontent"
+        data = {
+            "cKey"       : self.c_key,
+            "cValue"     : self.c_value,
+            "searchterm" : query
+        }
+        
+        headers = {
+            "X-Requested-With" : "XMLHttpRequest",
+            "Accept"           : "application/json, text/javascript, */*; q=0.01",
+            "Referer"          : f"{self.main_url}/"
+        }
+        
+        resp = await self.httpx.post(post_url, data=data, headers=headers)
+        
+        try:
+            raw = resp.json()
+            # Kotlin maps this to ApiResponse -> DataWrapper -> Icerikler
+            res_array = raw.get("data", {}).get("result", [])
+            
+            results = []
+            for item in res_array:
+                title  = item.get("object_name", "").replace("\\", "")
+                slug   = item.get("used_slug", "").replace("\\", "")
+                poster = item.get("object_poster_url", "")
+                
+                # Cleanup poster URL as in Kotlin
+                if poster:
+                    poster = poster.replace("images-macellan-online.cdn.ampproject.org/i/s/", "") \
+                                   .replace("file.dizilla.club", "file.macellan.online") \
+                                   .replace("images.dizilla.club", "images.macellan.online") \
+                                   .replace("images.dizimia4.com", "images.macellan.online") \
+                                   .replace("file.dizimia4.com", "file.macellan.online")
+                    poster = HTMLHelper(poster).regex_replace(r"(file\.)[\w\.]+\/?", r"\1macellan.online/")
+                    poster = HTMLHelper(poster).regex_replace(r"(images\.)[\w\.]+\/?", r"\1macellan.online/")
+                    poster = poster.replace("/f/f/", "/630/910/")
+
+                if title and slug:
+                    results.append(SearchResult(
+                        title  = title,
+                        url    = self.fix_url(slug),
+                        poster = self.fix_url(poster) if poster else None
+                    ))
+            return results
+        except Exception:
+            return []
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+
+        title    = sel.select_text("h2")
+        poster   = sel.select_attr("img.rounded-md", "src")
+        description = sel.select_text("div.text-sm")
+        
+        year = sel.regex_first(r"Yap\u0131m Y\u0131l\u0131\s*:\s*(\d+)", resp.text)
+        
+        tags = []
+        tags_raw = sel.regex_first(r"T\u00fcr\s*:\s*([^<]+)", resp.text)
+        if tags_raw:
+            tags = [t.strip() for t in tags_raw.split(",")]
+
+        rating = sel.select_text(".font-semibold.text-white")
+        if rating:
+            rating = rating.replace(",", ".").strip()
+
+        actors = [a.text(strip=True) for a in sel.select("span.valor a")]
+        
+        trailer_match = sel.regex_first(r"embed\/(.*)\?rel", resp.text)
+        trailer = f"https://www.youtube.com/embed/{trailer_match}" if trailer_match else None
+
+        duration_text = sel.select_text("span.runtime")
+        duration = duration_text.split(" ")[0] if duration_text else None
+
+        episodes = []
+        # ul a handles episodes
+        for ep_link in sel.select("ul a"):
+            href = ep_link.attrs.get("href")
+            if not href or "/sezon-" not in href:
+                continue
+                
+            ep_name = sel.select_text("span.hidden.sm\\:block", ep_link)
+            
+            season_match = sel.regex_first(r"sezon-(\d+)", href)
+            episode_match = sel.regex_first(r"bolum-(\d+)", href)
+            
+            season = season_match if season_match else None
+            episode_num = episode_match if episode_match else None
+
+            episodes.append(Episode(
+                season  = int(season) if season and season.isdigit() else None,
+                episode = int(episode_num) if episode_num and episode_num.isdigit() else None,
+                title   = ep_name if ep_name else f"{season}x{episode_num}",
+                url     = self.fix_url(href)
+            ))
+
+        return SeriesInfo(
+            title       = title,
+            url         = url,
+            poster      = self.fix_url(poster) if poster else None,
+            description = description,
+            rating      = rating,
+            tags        = tags,
+            actors      = actors,
+            year        = year,
+            episodes    = episodes,
+            duration    = int(duration) if duration and str(duration).isdigit() else None
+        )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+        
+        iframe = sel.select_attr("iframe", "src")
+        if not iframe:
+            return []
+            
+        iframe_url = self.fix_url(iframe)
+        data = await self.extract(iframe_url, referer=f"{self.main_url}/")
+        
+        if not data:
+            return []
+            
+        return data if isinstance(data, list) else [data]

{kekikstream-2.3.4 → kekikstream-2.3.5}/KekikStream/Plugins/Dizilla.py

@@ -248,4 +248,6 @@ class Dizilla(PluginBase):
             return []
 
         data = await self.extract(iframe_url, referer=f"{self.main_url}/", prefix=first_result.get('language_name', 'Unknown'))
-        return [data] if data else []
+        if not data:
+            return []
+        return data if isinstance(data, list) else [data]

{kekikstream-2.3.4 → kekikstream-2.3.5}/KekikStream/Plugins/SezonlukDizi.py

@@ -75,9 +75,9 @@ class SezonlukDizi(PluginBase):
 
         results = []
         for afis in secici.select("div.afis a"):
-            title  = secici.select_text("div.description", veri)
-            href   = secici.select_attr("a", "href", veri)
-            poster = secici.select_attr("img", "data-src", veri)
+            title  = secici.select_text("div.description", afis)
+            href   = secici.select_attr("a", "href", afis)
+            poster = secici.select_attr("img", "data-src", afis)
 
             if title and href:
                 results.append(SearchResult(

{kekikstream-2.3.4 → kekikstream-2.3.5}/KekikStream/Plugins/Sinefy.py

@@ -159,6 +159,11 @@ class Sinefy(PluginBase):
         actors = [h5.text(strip=True) for h5 in sel.select("div.content h5") if h5.text(strip=True)]
 
         year    = sel.select_text("span.item.year")
+        if not year and title:
+            # Try to extract year from title like "Movie Name(2024)"
+            year_match = sel.regex_first(r"\((\d{4})\)", title)
+            if year_match:
+                year = year_match
         
         episodes = []
         episodes_box_list = sel.select("section.episodes-box")

kekikstream-2.3.5/KekikStream/Plugins/YabanciDizi.py

@@ -0,0 +1,274 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, MovieInfo, Episode, ExtractResult, HTMLHelper
+import json, asyncio, time
+
+class YabanciDizi(PluginBase):
+    name        = "YabanciDizi"
+    language    = "tr"
+    main_url    = "https://yabancidizi.so"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Yabancidizi.so platformu üzerinden en güncel yabancı dizileri ve filmleri izleyebilir, favori içeriklerinizi takip edebilirsiniz."
+
+    main_page = {
+        f"{main_url}/kesfet/eyJvcmRlciI6ImRhdGVfYm90dG9tIiwia2F0ZWdvcnkiOlsiMTciXX0=" : "Diziler",
+        f"{main_url}/kesfet/eyJvcmRlciI6ImRhdGVfYm90dG9tIiwia2F0ZWdvcnkiOlsiMTgiXX0=" : "Filmler",
+        f"{main_url}/kesfet/eyJvcmRlciI6ImRhdGVfYm90dG9tIiwiY291bnRyeSI6eyJLUiI6IktSIn19" : "Kdrama",
+        f"{main_url}/kesfet/eyJvcmRlciI6ImRhdGVfYm90dG9tIiwiY291bnRyeSI6eyJKUCI6IkpQIn0sImNhdGVnb3J5IjpbXX0=" : "Jdrama",
+        f"{main_url}/kesfet/eyJvcmRlciI6ImRhdGVfYm90dG9tIiwiY2F0ZWdvcnkiOnsiMyI6IjMifX0=" : "Animasyon",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        full_url = url if page == 1 else f"{url}/{page}"
+        
+        resp = await self.httpx.get(full_url, headers={"Referer": f"{self.main_url}/"})
+        sel  = HTMLHelper(resp.text)
+
+        results = []
+        for item in sel.select("li.mb-lg, li.segment-poster"):
+            title  = sel.select_text("h2", item)
+            href   = sel.select_attr("a", "href", item)
+            poster = sel.select_attr("img", "src", item)
+            score  = sel.select_text("span.rating", item)
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = title,
+                    url      = self.fix_url(href),
+                    poster   = self.fix_url(poster) if poster else None,
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        search_url = f"{self.main_url}/search?qr={query}"
+        
+        headers = {
+            "X-Requested-With" : "XMLHttpRequest",
+            "Referer"          : f"{self.main_url}/"
+        }
+        
+        resp = await self.httpx.post(search_url, headers=headers)
+        
+        try:
+            raw = resp.json()
+            # Kotlin mapping: JsonResponse -> Data -> ResultItem
+            res_array = raw.get("data", {}).get("result", [])
+            
+            results = []
+            for item in res_array:
+                title  = item.get("s_name")
+                image  = item.get("s_image")
+                slug   = item.get("s_link")
+                s_type = item.get("s_type") # 0: dizi, 1: film
+                
+                poster = f"{self.main_url}/uploads/series/{image}" if image else None
+                
+                if s_type == "1":
+                    href = f"{self.main_url}/film/{slug}"
+                else:
+                    href = f"{self.main_url}/dizi/{slug}"
+
+                if title and slug:
+                    results.append(SearchResult(
+                        title  = title,
+                        url    = self.fix_url(href),
+                        poster = self.fix_url(poster) if poster else None
+                    ))
+            return results
+        except Exception:
+            return []
+
+    async def load_item(self, url: str) -> SeriesInfo | MovieInfo:
+        resp = await self.httpx.get(url, follow_redirects=True)
+        sel  = HTMLHelper(resp.text)
+
+        og_title = sel.select_attr("meta[property='og:title']", "content")
+        title    = og_title.split("|")[0].strip() if og_title else sel.select_text("h1")
+        
+        poster   = sel.select_attr("meta[property='og:image']", "content")
+        description = sel.select_text("p#tv-series-desc")
+        
+        year = sel.select_text("td div.truncate")
+        if year:
+            year = year.strip()
+            
+        tags = []
+        rating = None
+        duration = None
+        year = None
+        actors = []
+        for item in sel.select("div.item"):
+            text = item.text(strip=True)
+            if "T\u00fcr\u00fc:" in text:
+                tags = [t.strip() for t in text.replace("T\u00fcr\u00fc:", "").split(",")]
+            elif "IMDb Puan\u0131" in text:
+                rating = text.replace("IMDb Puan\u0131", "").strip()
+            elif "Yap\u0131m Y\u0131l\u0131" in text:
+                year_match = sel.regex_first(r"(\d{4})", text)
+                if year_match:
+                    year = year_match
+            elif "Takip\u00e7iler" in text:
+                continue
+            elif "S\u00fcre" in text:
+                dur_match = sel.regex_first(r"(\d+)", text)
+                if dur_match:
+                    duration = dur_match
+            elif "Oyuncular:" in text:
+                actors = [a.text(strip=True) for a in sel.select("a", item)]
+        
+        if not actors:
+            actors = [a.text(strip=True) for a in sel.select("div#common-cast-list div.item h5")]
+        
+        trailer_match = sel.regex_first(r"embed\/(.*)\?rel", resp.text)
+        trailer = f"https://www.youtube.com/embed/{trailer_match}" if trailer_match else None
+
+        if "/film/" in url:
+            return MovieInfo(
+                title       = title,
+                url         = url,
+                poster      = self.fix_url(poster) if poster else None,
+                description = description,
+                rating      = rating,
+                tags        = tags,
+                actors      = actors,
+                year        = year,
+                duration    = int(duration) if duration and duration.isdigit() else None
+            )
+        else:
+            episodes = []
+            for bolum_item in sel.select("div.episodes-list div.ui td:has(h6)"):
+                link_el = sel.select_first("a", bolum_item)
+                if not link_el: continue
+                
+                bolum_href = link_el.attrs.get("href")
+                bolum_name = sel.select_text("h6", bolum_item) or link_el.text(strip=True)
+                
+                season = sel.regex_first(r"sezon-(\d+)", bolum_href)
+                episode = sel.regex_first(r"bolum-(\d+)", bolum_href)
+
+                ep_season = int(season) if season and season.isdigit() else None
+                ep_episode = int(episode) if episode and episode.isdigit() else None
+
+                episodes.append(Episode(
+                    season  = ep_season,
+                    episode = ep_episode,
+                    title   = bolum_name,
+                    url     = self.fix_url(bolum_href)
+                ))
+
+            if episodes and (episodes[0].episode or 0) > (episodes[-1].episode or 0):
+                episodes.reverse()
+
+            return SeriesInfo(
+                title       = title,
+                url         = url,
+                poster      = self.fix_url(poster) if poster else None,
+                description = description,
+                rating      = rating,
+                tags        = tags,
+                actors      = actors,
+                year        = year,
+                episodes    = episodes
+            )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        resp = await self.httpx.get(url, headers={"Referer": f"{self.main_url}/"})
+        sel  = HTMLHelper(resp.text)
+        
+        results = []
+        
+        # Method 1: alternatives-for-this
+        for alt in sel.select("div.alternatives-for-this div.item:not(.active)"):
+            data_hash = alt.attrs.get("data-hash")
+            data_link = alt.attrs.get("data-link")
+            q_type    = alt.attrs.get("data-querytype")
+            
+            if not data_hash or not data_link: continue
+            
+            try:
+                post_resp = await self.httpx.post(
+                    f"{self.main_url}/ajax/service",
+                    data = {
+                        "link"      : data_link,
+                        "hash"      : data_hash,
+                        "querytype" : q_type,
+                        "type"      : "videoGet"
+                    },
+                    headers = {
+                        "X-Requested-With" : "XMLHttpRequest",
+                        "Referer"          : f"{self.main_url}/"
+                    },
+                    cookies = {"udys": "1760709729873", "level": "1"}
+                )
+                
+                service_data = post_resp.json()
+                api_iframe   = service_data.get("api_iframe")
+                if api_iframe:
+                    extract_res = await self._fetch_and_extract(api_iframe, prefix="Alt")
+                    if extract_res:
+                        results.extend(extract_res if isinstance(extract_res, list) else [extract_res])
+            except Exception:
+                continue
+
+        # Method 2: pointing[data-eid]
+        for id_el in sel.select("a.ui.pointing[data-eid]"):
+            dil = id_el.text(strip=True)
+            v_lang = "tr" if "Dublaj" in dil else "en"
+            data_eid = id_el.attrs.get("data-eid")
+            
+            try:
+                post_resp = await self.httpx.post(
+                    f"{self.main_url}/ajax/service",
+                    data = {
+                        "e_id"   : data_eid,
+                        "v_lang" : v_lang,
+                        "type"   : "get_whatwehave"
+                    },
+                    headers = {
+                        "X-Requested-With" : "XMLHttpRequest",
+                        "Referer"          : f"{self.main_url}/"
+                    },
+                    cookies = {"udys": "1760709729873", "level": "1"}
+                )
+                
+                service_data = post_resp.json()
+                api_iframe   = service_data.get("api_iframe")
+                if api_iframe:
+                    extract_res = await self._fetch_and_extract(api_iframe, prefix=dil)
+                    if extract_res:
+                        results.extend(extract_res if isinstance(extract_res, list) else [extract_res])
+            except Exception:
+                continue
+
+        return results
+
+    async def _fetch_and_extract(self, iframe_url, prefix=""):
+        # Initial fetch
+        resp = await self.httpx.get(
+            iframe_url,
+            headers = {"Referer": f"{self.main_url}/"},
+            cookies = {"udys": "1760709729873", "level": "1"}
+        )
+        
+        # Handle "Lütfen bekleyiniz" check from Kotlin
+        if "Lütfen bekleyiniz" in resp.text:
+            await asyncio.sleep(1)
+            timestamp = int(time.time())
+            # Retry with t=timestamp as in Kotlin
+            sep = "&" if "?" in iframe_url else "?"
+            resp = await self.httpx.get(
+                f"{iframe_url}{sep}t={timestamp}",
+                headers = {"Referer": f"{self.main_url}/"},
+                cookies = resp.cookies # Use cookies from first response
+            )
+
+        sel = HTMLHelper(resp.text)
+        final_iframe = sel.select_attr("iframe", "src")
+        
+        if final_iframe:
+            final_url = self.fix_url(final_iframe)
+            return await self.extract(final_url, referer=f"{self.main_url}/", prefix=prefix)
+        
+        return None

{kekikstream-2.3.4 → kekikstream-2.3.5}/KekikStream.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KekikStream
-Version: 2.3.4
+Version: 2.3.5
 Summary: terminal üzerinden medya içeriği aramanızı ve VLC/MPV gibi popüler medya oynatıcılar aracılığıyla doğrudan izlemenizi sağlayan modüler ve genişletilebilir bir bıdı bıdı
 Home-page: https://github.com/keyiflerolsun/KekikStream
 Author: keyiflerolsun

{kekikstream-2.3.4 → kekikstream-2.3.5}/KekikStream.egg-info/SOURCES.txt

@@ -64,6 +64,7 @@ KekikStream/Extractors/YildizKisaFilm.py
 KekikStream/Plugins/BelgeselX.py
 KekikStream/Plugins/DiziBox.py
 KekikStream/Plugins/DiziPal.py
+KekikStream/Plugins/DiziWatch.py
 KekikStream/Plugins/DiziYou.py
 KekikStream/Plugins/Dizilla.py
 KekikStream/Plugins/FilmBip.py
@@ -84,4 +85,5 @@ KekikStream/Plugins/Sinefy.py
 KekikStream/Plugins/SinemaCX.py
 KekikStream/Plugins/Sinezy.py
 KekikStream/Plugins/SuperFilmGeldi.py
-KekikStream/Plugins/UgurFilm.py
+KekikStream/Plugins/UgurFilm.py
+KekikStream/Plugins/YabanciDizi.py

{kekikstream-2.3.4 → kekikstream-2.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KekikStream
-Version: 2.3.4
+Version: 2.3.5
 Summary: terminal üzerinden medya içeriği aramanızı ve VLC/MPV gibi popüler medya oynatıcılar aracılığıyla doğrudan izlemenizi sağlayan modüler ve genişletilebilir bir bıdı bıdı
 Home-page: https://github.com/keyiflerolsun/KekikStream
 Author: keyiflerolsun

{kekikstream-2.3.4 → kekikstream-2.3.5}/setup.py

@@ -6,7 +6,7 @@ from io         import open
 setup(
     # ? Genel Bilgiler
     name         = "KekikStream",
-    version      = "2.3.4",
+    version      = "2.3.5",
     url          = "https://github.com/keyiflerolsun/KekikStream",
     description  = "terminal üzerinden medya içeriği aramanızı ve VLC/MPV gibi popüler medya oynatıcılar aracılığıyla doğrudan izlemenizi sağlayan modüler ve genişletilebilir bir bıdı bıdı",
     keywords     = ["KekikStream", "KekikAkademi", "keyiflerolsun"],