KekikStream 2.2.9__py3-none-any.whl → 2.5.3__py3-none-any.whl

KekikStream/Plugins/UgurFilm.py

@@ -1,8 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult
-from selectolax.parser import HTMLParser
-import re
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, HTMLHelper
+import asyncio, contextlib
 
 class UgurFilm(PluginBase):
     name        = "UgurFilm"
@@ -26,46 +25,36 @@ class UgurFilm(PluginBase):
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(f"{url}{page}", follow_redirects=True)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("div.icerik div"):
+        for veri in secici.select("div.icerik div"):
             # Title is in the second span (a.baslik > span), not the first span (class="sol" which is empty)
-            title_el = veri.css_first("a.baslik span")
-            title = title_el.text(strip=True) if title_el else None
+            title = secici.select_text("a.baslik span", veri)
             if not title:
                 continue
 
-            link_el = veri.css_first("a")
-            img_el  = veri.css_first("img")
-
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = img_el.attrs.get("src") if img_el else None
+            href   = secici.select_attr("a", "href", veri)
+            poster = secici.select_attr("img", "src", veri)
 
             results.append(MainPageResult(
                 category = category,
                 title    = title,
                 url      = self.fix_url(href) if href else "",
-                poster   = self.fix_url(poster) if poster else None,
+                poster   = self.fix_url(poster),
             ))
 
         return results
 
     async def search(self, query: str) -> list[SearchResult]:
         istek  = await self.httpx.get(f"{self.main_url}/?s={query}")
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for film in secici.css("div.icerik div"):
-            # Title is in a.baslik > span, not the first span
-            title_el = film.css_first("a.baslik span")
-            title = title_el.text(strip=True) if title_el else None
-
-            link_el = film.css_first("a")
-            img_el  = film.css_first("img")
-
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = img_el.attrs.get("src") if img_el else None
+        for film in secici.select("div.icerik div"):
+            title  = secici.select_text("a.baslik span", film)
+            href   = secici.select_attr("a", "href", film)
+            poster = secici.select_attr("img", "src", film)
 
             if title and href:
                 results.append(SearchResult(
@@ -78,68 +67,101 @@ class UgurFilm(PluginBase):
 
     async def load_item(self, url: str) -> MovieInfo:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
-
-        title_el = secici.css_first("div.bilgi h2")
-        title    = title_el.text(strip=True) if title_el else ""
-
-        poster_el = secici.css_first("div.resim img")
-        poster    = poster_el.attrs.get("src", "").strip() if poster_el else ""
-
-        desc_el     = secici.css_first("div.slayt-aciklama")
-        description = desc_el.text(strip=True) if desc_el else ""
+        secici = HTMLHelper(istek.text)
 
-        tags = [a.text(strip=True) for a in secici.css("p.tur a[href*='/category/']") if a.text(strip=True)]
-
-        # re_first yerine re.search
-        year_el   = secici.css_first("a[href*='/yil/']")
-        year_text = year_el.text(strip=True) if year_el else ""
-        year_match = re.search(r"\d+", year_text)
-        year = year_match.group() if year_match else None
-
-        actors = []
-        for actor in secici.css("li.oyuncu-k"):
-            span_el = actor.css_first("span")
-            if span_el and span_el.text(strip=True):
-                actors.append(span_el.text(strip=True))
+        title       = secici.select_text("div.bilgi h2")
+        poster      = secici.select_poster("div.resim img")
+        description = secici.select_text("div.slayt-aciklama")
+        rating      = secici.select_text("b#puandegistir")
+        tags        = secici.select_texts("p.tur a[href*='/category/']")
+        year        = secici.extract_year("a[href*='/yil/']")
+        actors      = secici.select_texts("li.oyuncu-k span")
+        duration    = secici.regex_first(r"(\d+) Dakika", secici.select_text("div.bilgi b"))
 
         return MovieInfo(
-            url         = self.fix_url(url),
-            poster      = self.fix_url(poster) if poster else None,
+            url         = url,
+            poster      = self.fix_url(poster),
             title       = title,
             description = description,
+            rating      = rating,
             tags        = tags,
             year        = year,
             actors      = actors,
+            duration    = duration
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek   = await self.httpx.get(url)
-        secici  = HTMLParser(istek.text)
+        secici  = HTMLHelper(istek.text)
         results = []
 
-        part_links = [a.attrs.get("href") for a in secici.css("li.parttab a") if a.attrs.get("href")]
-
-        for part_link in part_links:
-            sub_response = await self.httpx.get(part_link)
-            sub_selector = HTMLParser(sub_response.text)
+        part_links = secici.select_attrs("li.parttab a", "href")
+        if not part_links:
+            part_links = [url]
 
-            iframe_el = sub_selector.css_first("div#vast iframe")
-            iframe = iframe_el.attrs.get("src") if iframe_el else None
-
-            if iframe and self.main_url in iframe:
-                post_data = {
-                    "vid"         : iframe.split("vid=")[-1],
-                    "alternative" : "vidmoly",
-                    "ord"         : "0",
-                }
-                player_response = await self.httpx.post(
+        async def process_alt(vid: str, alt_name: str, ord_val: str) -> list[ExtractResult]:
+            """Alternatif player kaynağından video linkini çıkarır."""
+            with contextlib.suppress(Exception):
+                resp = await self.httpx.post(
                     url  = f"{self.main_url}/player/ajax_sources.php",
-                    data = post_data
+                    data = {"vid": vid, "alternative": alt_name, "ord": ord_val}
                 )
-                iframe = self.fix_url(player_response.json().get("iframe"))
-                data = await self.extract(iframe)
-                if data:
-                    results.append(data)
-
-        return results
+                if iframe_url := resp.json().get("iframe"):
+                    data = await self.extract(self.fix_url(iframe_url))
+                    if not data:
+                        return []
+
+                    return data if isinstance(data, list) else [data]
+
+            return []
+
+        async def process_part(part_url: str) -> list[ExtractResult]:
+            """Her bir part sayfasını ve alternatiflerini işler."""
+            try:
+                # Elimizde zaten olan ana sayfayı tekrar çekmemek için
+                if part_url == url:
+                    sub_sec = secici
+                else:
+                    sub_resp = await self.httpx.get(part_url)
+                    sub_sec  = HTMLHelper(sub_resp.text)
+
+                iframe = sub_sec.select_attr("div#vast iframe", "src")
+                if not iframe:
+                    return []
+
+                if self.main_url not in iframe:
+                    data = await self.extract(self.fix_url(iframe))
+                    if not data:
+                        return []
+
+                    return data if isinstance(data, list) else [data]
+
+                # İç kaynaklı ise 3 alternatif için paralel istek at
+                vid = iframe.split("vid=")[-1]
+                tasks = [
+                    process_alt(vid, "vidmoly", "0"),
+                    process_alt(vid, "ok.ru", "1"),
+                    process_alt(vid, "mailru", "2")
+                ]
+
+                alt_results = await asyncio.gather(*tasks)
+
+                return [item for sublist in alt_results for item in sublist]
+            except Exception:
+                return []
+
+        # Tüm partları paralel işle
+        groups = await asyncio.gather(*(process_part(p) for p in part_links))
+
+        for group in groups:
+            results.extend(group)
+
+        # Duplicate Temizliği
+        unique_results = []
+        seen = set()
+        for res in results:
+            if res.url and res.url not in seen:
+                unique_results.append(res)
+                seen.add(res.url)
+
+        return unique_results

KekikStream/Plugins/Watch32.py

@@ -0,0 +1,160 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, HTMLHelper
+
+class Watch32(PluginBase):
+    name        = "Watch32"
+    language    = "en"
+    main_url    = "https://watch32.sx"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64" 
+    description = "Watch Your Favorite Movies & TV Shows Online - Streaming For Free. With Movies & TV Shows Full HD. Find Your Movies & Watch NOW!"
+
+    main_page = {
+        # Main Categories
+        f"{main_url}/movie?page="           : "Popular Movies",
+        f"{main_url}/tv-show?page="         : "Popular TV Shows",
+        f"{main_url}/coming-soon?page="     : "Coming Soon",
+        f"{main_url}/top-imdb?page="        : "Top IMDB Rating",
+        # Genre Categories
+        f"{main_url}/genre/action?page="    : "Action",
+        f"{main_url}/genre/adventure?page=" : "Adventure",
+        f"{main_url}/genre/animation?page=" : "Animation",
+        f"{main_url}/genre/biography?page=" : "Biography",
+        f"{main_url}/genre/comedy?page="    : "Comedy",
+        f"{main_url}/genre/crime?page="     : "Crime",
+        f"{main_url}/genre/documentary?page=" : "Documentary",
+        f"{main_url}/genre/drama?page="     : "Drama",
+        f"{main_url}/genre/family?page="    : "Family",
+        f"{main_url}/genre/fantasy?page="   : "Fantasy",
+        f"{main_url}/genre/history?page="   : "History",
+        f"{main_url}/genre/horror?page="    : "Horror",
+        f"{main_url}/genre/music?page="     : "Music",
+        f"{main_url}/genre/mystery?page="   : "Mystery",
+        f"{main_url}/genre/romance?page="   : "Romance",
+        f"{main_url}/genre/science-fiction?page=" : "Science Fiction",
+        f"{main_url}/genre/thriller?page="  : "Thriller",
+        f"{main_url}/genre/war?page="       : "War",
+        f"{main_url}/genre/western?page="   : "Western",
+    }
+
+    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)
+        items  = helper.select("div.flw-item")
+
+        return [
+            MainPageResult(
+                category = category,
+                title    = helper.select_attr("h2.film-name a", "title", veri),
+                url      = self.fix_url(helper.select_attr("h2.film-name a", "href", veri)),
+                poster   = helper.select_attr("img.film-poster-img", "data-src", veri)
+            )
+                for veri in items
+        ]
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek  = await self.httpx.get(f"{self.main_url}/search/{query.replace(' ', '-')}")
+        secici = HTMLHelper(istek.text)
+
+        return [
+            SearchResult(
+                title  = secici.select_attr("h2.film-name a", "title", veri),
+                url    = self.fix_url(secici.select_attr("h2.film-name a", "href", veri)),
+                poster = secici.select_attr("img.film-poster-img", "data-src", veri)
+            )
+                for veri in secici.select("div.flw-item")
+        ]
+
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        istek  = await self.httpx.get(url)
+        secici = HTMLHelper(istek.text)
+
+        content_id  = secici.select_attr("div.detail_page-watch", "data-id")
+        details     = secici.select_first("div.detail_page-infor")
+        name        = secici.select_text("h2.heading-name > a", details)
+        poster      = secici.select_poster("div.film-poster > img", details)
+        description = secici.select_text("div.description", details)
+        year        = str(secici.extract_year())
+        tags        = secici.meta_list("Genre", container_selector="div.row-line")
+        rating      = secici.select_text("button.btn-imdb").replace("N/A", "").split(":")[-1].strip() if secici.select_text("button.btn-imdb") else None
+        actors      = secici.meta_list("Casts", container_selector="div.row-line")
+
+        common_info = {
+            "url"         : url,
+            "poster"      : self.fix_url(poster),
+            "title"       : name,
+            "description" : description,
+            "tags"        : tags,
+            "rating"      : rating,
+            "year"        : year,
+            "actors"      : actors
+        }
+
+        if "movie" in url:
+            return MovieInfo(**common_info)
+        
+        episodes = []
+        seasons_resp = await self.httpx.get(f"{self.main_url}/ajax/season/list/{content_id}")
+        sh = HTMLHelper(seasons_resp.text)
+
+        for season in sh.select("a.dropdown-item"):
+            season_id = season.attrs.get("data-id")
+            s_val, _  = sh.extract_season_episode(season.text())
+
+            e_resp = await self.httpx.get(f"{self.main_url}/ajax/season/episodes/{season_id}")
+            eh     = HTMLHelper(e_resp.text)
+
+            for ep in eh.select("a.eps-item"):
+                ep_id    = ep.attrs.get("data-id")
+                ep_title = ep.attrs.get("title", "")
+                _, e_val = eh.extract_season_episode(ep_title)
+
+                episodes.append(Episode(
+                    season  = s_val or 1,
+                    episode = e_val or 1,
+                    title   = ep_title,
+                    url     = f"servers/{ep_id}"
+                ))
+
+        return SeriesInfo(**common_info, episodes=episodes)
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        # url in load_links might be the full page URL for movies or "servers/epId" for episodes
+        if "servers/" in url:
+            data = url.split("/")[-1]
+            servers_url = f"servers/{data}"
+        elif "list/" in url:
+            data = url.split("/")[-1]
+            servers_url = f"list/{data}"
+        else:
+             # Re-fetch page to get contentId only if we don't have list/ or servers/
+             istek      = await self.httpx.get(url)
+             secici     = HTMLHelper(istek.text)
+             content_id = secici.select_attr("div.detail_page-watch", "data-id")
+             if not content_id:
+                return []
+             servers_url = f"list/{content_id}"
+
+        servers_resp = await self.httpx.get(f"{self.main_url}/ajax/episode/{servers_url}")
+        sh           = HTMLHelper(servers_resp.text)
+        servers      = sh.select("a.link-item")
+
+        results = []
+        for server in servers:
+            server_name = server.text(strip=True)
+            link_id     = server.attrs.get("data-linkid") or server.attrs.get("data-id")
+            source_resp = await self.httpx.get(f"{self.main_url}/ajax/episode/sources/{link_id}")
+            source_data = source_resp.json()
+            video_url   = source_data.get("link")
+
+            if video_url:
+                extract_result = await self.extract(video_url, name_override=server_name)
+                if extract_result:
+                    results.extend(extract_result if isinstance(extract_result, list) else [extract_result])
+                else:
+                    results.append(ExtractResult(
+                        url  = video_url,
+                        name = f"{self.name} | {server_name}"
+                    ))
+
+        return results

KekikStream/Plugins/YabanciDizi.py

@@ -0,0 +1,250 @@
+# 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 asyncio, time, json
+
+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]:
+        istek   = await self.httpx.get(
+            url     = url if page == 1 else f"{url}/{page}",
+            headers = {"Referer": f"{self.main_url}/"}
+        )
+        secici  = HTMLHelper(istek.text)
+
+        results = []
+        for item in secici.select("li.mb-lg, li.segment-poster"):
+            title  = secici.select_text("h2", item)
+            href   = secici.select_attr("a", "href", item)
+            poster = secici.select_attr("img", "src", item)
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = title,
+                    url      = self.fix_url(href),
+                    poster   = self.fix_url(poster),
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek = await self.httpx.post(
+            url     = f"{self.main_url}/search?qr={query}",
+            headers = {
+                "X-Requested-With" : "XMLHttpRequest",
+                "Referer"          : f"{self.main_url}/"
+            }
+        )
+        
+        try:
+            raw = istek.json()
+            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)
+                    ))
+            return results
+        except Exception:
+            return []
+
+    async def load_item(self, url: str) -> SeriesInfo | MovieInfo:
+        istek  = await self.httpx.get(url, follow_redirects=True)
+        secici = HTMLHelper(istek.text)
+
+        title       = (secici.select_attr("meta[property='og:title']", "content") or "").split("|")[0].strip() or secici.select_text("h1")
+        poster      = secici.select_poster("meta[property='og:image']")
+        description = secici.select_text("p#tv-series-desc")
+        year        = secici.extract_year("td div.truncate")
+        tags        = secici.meta_list("Türü", container_selector="div.item")
+        rating      = secici.meta_value("IMDb Puanı", container_selector="div.item")
+        duration    = int(secici.regex_first(r"(\d+)", secici.meta_value("Süre", container_selector="div.item")) or 0)
+        actors      = secici.meta_list("Oyuncular", container_selector="div.item") or secici.select_texts("div#common-cast-list div.item h5")
+
+        common_info = {
+            "url"         : url,
+            "poster"      : self.fix_url(poster),
+            "title"       : title,
+            "description" : description,
+            "tags"        : tags,
+            "rating"      : rating,
+            "year"        : year,
+            "actors"      : actors,
+            "duration"    : duration
+        }
+
+        if "/film/" in url:
+            return MovieInfo(**common_info)
+
+        episodes = []
+        for bolum in secici.select("div.episodes-list div.ui td:has(h6)"):
+            link = secici.select_first("a", bolum)
+            if link:
+                href = link.attrs.get("href")
+                name = secici.select_text("h6", bolum) or link.text(strip=True)
+                s, e = secici.extract_season_episode(href)
+                episodes.append(Episode(
+                    season  = s or 1,
+                    episode = e or 1,
+                    title   = name,
+                    url     = self.fix_url(href)
+                ))
+
+        if episodes and (episodes[0].episode or 0) > (episodes[-1].episode or 0):
+            episodes.reverse()
+
+        return SeriesInfo(**common_info, episodes=episodes)
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        loop = asyncio.get_event_loop()
+
+        # 1. Ana sayfayı çek
+        istek = await loop.run_in_executor(None, lambda: self.cloudscraper.get(url, headers={"Referer": f"{self.main_url}/"}))
+        secici = HTMLHelper(istek.text)
+
+        results = []
+        timestamp_ms = int(time.time() * 1000) - 50000
+
+        # 2. Dil Tablarını Bul
+        tabs = secici.select("div#series-tabs a")
+
+        async def process_tab(tab_el):
+            data_eid  = tab_el.attrs.get("data-eid")
+            data_type = tab_el.attrs.get("data-type") # 1: Altyazı, 2: Dublaj
+            if not data_eid or not data_type:
+                return []
+
+            dil_adi = "Dublaj" if data_type == "2" else "Altyazı"
+
+            try:
+                post_resp = await loop.run_in_executor(None, lambda: self.cloudscraper.post(
+                    url     = f"{self.main_url}/ajax/service",
+                    headers = {
+                        "X-Requested-With" : "XMLHttpRequest",
+                        "Referer"          : url
+                    },
+                    data    = {
+                        "lang"    : data_type,
+                        "episode" : data_eid,
+                        "type"    : "langTab"
+                    },
+                    cookies = {"udys": str(timestamp_ms)}
+                ))
+
+                res_json = post_resp.json()
+                if not res_json.get("data"): return []
+
+                res_sel = HTMLHelper(res_json["data"])
+                sources = []
+
+                for item in res_sel.select("div.item"):
+                    name      = item.text(strip=True)
+                    data_link = item.attrs.get("data-link")
+                    if not data_link: continue
+
+                    # Link normalizasyonu
+                    safe_link = data_link.replace("/", "_").replace("+", "-")
+
+                    # API Endpoint belirleme
+                    api_path = None
+                    if "VidMoly" in name:
+                        api_path = "moly"
+                    elif "Okru" in name:
+                        api_path = "ruplay"
+                    elif "Mac" in name:
+                        api_path = "drive"
+
+                    if api_path:
+                        sources.append({
+                            "name"    : name,
+                            "api_url" : f"{self.main_url}/api/{api_path}/{safe_link}",
+                            "dil"     : dil_adi
+                        })
+
+                tab_results = []
+                for src in sources:
+                    try:
+                        # API sayfasını çekip içindeki iframe'i bulalım
+                        api_resp = await loop.run_in_executor(None, lambda: self.cloudscraper.get(
+                            src["api_url"], 
+                            headers={"Referer": f"{self.main_url}/"},
+                            cookies={"udys": str(timestamp_ms)}
+                        ))
+
+                        api_sel = HTMLHelper(api_resp.text)
+                        iframe  = api_sel.select_attr("iframe", "src")
+
+                        if not iframe and "drive" in src["api_url"]:
+                            t_sec = int(time.time())
+                            drives_url = f"{src['api_url'].replace('/api/drive/', '/api/drives/')}?t={t_sec}"
+                            api_resp = await loop.run_in_executor(None, lambda: self.cloudscraper.get(
+                                drives_url,
+                                headers={"Referer": src["api_url"]},
+                                cookies={"udys": str(timestamp_ms)}
+                            ))
+                            api_sel = HTMLHelper(api_resp.text)
+                            iframe  = api_sel.select_attr("iframe", "src")
+
+                        if iframe:
+                            prefix = f"{src['dil']} | {src['name']}"
+                            extracted = await self.extract(self.fix_url(iframe), prefix=prefix)
+                            if extracted:
+                                tab_results.extend(extracted if isinstance(extracted, list) else [extracted])
+                    except Exception:
+                        continue
+                return tab_results
+
+            except Exception:
+                return []
+
+        if tabs:
+            results_groups = await asyncio.gather(*(process_tab(tab) for tab in tabs))
+            for group in results_groups:
+                results.extend(group)
+        else:
+            # Tab yoksa mevcut sayfada iframe ara
+            iframe = secici.select_attr("iframe", "src")
+            if iframe:
+                extracted = await self.extract(self.fix_url(iframe), name_override="Main")
+                if extracted:
+                    results.extend(extracted if isinstance(extracted, list) else [extracted])
+
+        # Duplicate kontrolü
+        unique_results = []
+        seen = set()
+        for res in results:
+            if res.url and res.url not in seen:
+                unique_results.append(res)
+                seen.add(res.url)
+
+        return unique_results

{kekikstream-2.2.9.dist-info → kekikstream-2.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KekikStream
-Version: 2.2.9
+Version: 2.5.3
 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