KekikStream 2.3.9__py3-none-any.whl → 2.5.4__py3-none-any.whl

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

@@ -1,7 +1,7 @@
 # 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
+import asyncio, time, json
 
 class YabanciDizi(PluginBase):
     name        = "YabanciDizi"
@@ -19,52 +19,50 @@ class YabanciDizi(PluginBase):
     }
 
     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)
+        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 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)
+        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) if poster else None,
+                    poster   = self.fix_url(poster),
                 ))
 
         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)
+        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 = resp.json()
-            # Kotlin mapping: JsonResponse -> Data -> ResultItem
+            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:
@@ -74,212 +72,179 @@ class YabanciDizi(PluginBase):
                     results.append(SearchResult(
                         title  = title,
                         url    = self.fix_url(href),
-                        poster = self.fix_url(poster) if poster else None
+                        poster = self.fix_url(poster)
                     ))
             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")
-        
-        # Try to extract year from table first
-        year_cell = sel.select_text("td div.truncate")
-        year = None
-        if year_cell:
-            year_match = sel.regex_first(r"(\d{4})", year_cell)
-            if year_match:
-                year = year_match
-            
-        tags = []
-        rating = None
-        duration = 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
+        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(
-                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
-
+            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  = ep_season,
-                    episode = ep_episode,
-                    title   = bolum_name,
-                    url     = self.fix_url(bolum_href)
+                    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(
-                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
-            )
+        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]:
-        # Use cloudscraper to bypass Cloudflare
-        resp = self.cloudscraper.get(url, headers={"Referer": f"{self.main_url}/"})
-        sel  = HTMLHelper(resp.text)
-        
+        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 = []
-        
-        # Method 1: alternatives-for-this (include active too)
-        for alt in sel.select("div.alternatives-for-this div.item"):
-            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
-            
+        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 = self.cloudscraper.post(
-                    f"{self.main_url}/ajax/service",
-                    data = {
-                        "link"      : data_link,
-                        "hash"      : data_hash,
-                        "querytype" : q_type,
-                        "type"      : "videoGet"
-                    },
+                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"          : f"{self.main_url}/"
+                        "Referer"          : 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 = self.cloudscraper.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}/"
+                    data    = {
+                        "lang"    : data_type,
+                        "episode" : data_eid,
+                        "type"    : "langTab"
                     },
-                    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
+                    cookies = {"udys": str(timestamp_ms)}
+                ))
 
-        return results
+                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
 
-    def _fetch_and_extract_sync(self, iframe_url, prefix=""):
-        """Synchronous helper for _fetch_and_extract using cloudscraper."""
-        # Initial fetch
-        resp = self.cloudscraper.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:
-            import time as time_module
-            time_module.sleep(1)
-            timestamp = int(time_module.time())
-            # Retry with t=timestamp as in Kotlin
-            sep = "&" if "?" in iframe_url else "?"
-            resp = self.cloudscraper.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")
-        
-        return final_iframe
+            except Exception:
+                return []
 
-    async def _fetch_and_extract(self, iframe_url, prefix=""):
-        final_iframe = self._fetch_and_extract_sync(iframe_url, prefix)
-        
-        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
+        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.3.9.dist-info → kekikstream-2.5.4.dist-info}/METADATA

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