KekikStream 1.7.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

KekikStream/Plugins/RoketDizi.py

@@ -0,0 +1,222 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, MovieInfo
+from parsel           import Selector
+import re, base64, json
+
+class RoketDizi(PluginBase):
+    name        = "RoketDizi"
+    lang        = "tr"
+    main_url    = "https://roketdizi.to"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Türkiye'nin en tatlış yabancı dizi izleme sitesi. Türkçe dublaj, altyazılı, eski ve yeni yabancı dizilerin yanı sıra kore (asya) dizileri izleyebilirsiniz."
+
+    main_page = {
+       f"{main_url}/dizi/tur/aksiyon"     : "Aksiyon",
+       f"{main_url}/dizi/tur/bilim-kurgu" : "Bilim Kurgu",
+       f"{main_url}/dizi/tur/gerilim"     : "Gerilim",
+       f"{main_url}/dizi/tur/fantastik"   : "Fantastik",
+       f"{main_url}/dizi/tur/komedi"      : "Komedi",
+       f"{main_url}/dizi/tur/korku"       : "Korku",
+       f"{main_url}/dizi/tur/macera"      : "Macera",
+       f"{main_url}/dizi/tur/suc"         : "Suç"
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = await self.httpx.get(f"{url}?&page={page}")
+        secici = Selector(istek.text)
+
+        results = []
+
+        for item in secici.css("div.w-full.p-4 span.bg-\\[\\#232323\\]"):
+            title  = item.css("span.font-normal.line-clamp-1::text").get()
+            href   = item.css("a::attr(href)").get()
+            poster = item.css("img::attr(src)").get()
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = self.clean_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}/api/bg/searchContent?searchterm={query}",
+            headers = {
+                "Accept"           : "application/json, text/javascript, */*; q=0.01",
+                "X-Requested-With" : "XMLHttpRequest",
+                "Referer"          : f"{self.main_url}/",
+            }
+        )
+        
+        try:
+            veri    = istek.json()
+            encoded = veri.get("response", "")
+            if not encoded:
+                return []
+
+            decoded = base64.b64decode(encoded).decode("utf-8")
+            veri    = json.loads(decoded)
+
+            if not veri.get("state"):
+                return []
+
+            results = []
+
+            for item in veri.get("result", []):
+                title  = item.get("object_name", "")
+                slug   = item.get("used_slug", "")
+                poster = item.get("object_poster_url", "")
+
+                if title and slug:
+                    results.append(SearchResult(
+                        title  = self.clean_title(title.strip()),
+                        url    = self.fix_url(f"{self.main_url}/{slug}"),
+                        poster = self.fix_url(poster) if poster else None
+                    ))
+
+            return results
+
+        except Exception:
+            return []
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        # Note: Handling both Movie and Series logic in one, returning SeriesInfo generally or MovieInfo
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+
+        title       = sel.css("h1.text-white::text").get()
+        poster      = sel.css("div.w-full.page-top img::attr(src)").get()
+        description = sel.css("div.mt-2.text-sm::text").get()
+
+        # Tags - genre bilgileri (Detaylar bölümünde)
+        tags = []
+        genre_text = sel.css("h3.text-white.opacity-90::text").get()
+        if genre_text:
+            tags = [t.strip() for t in genre_text.split(",")]
+
+        # Rating
+        rating = sel.css("span.text-white.text-sm.font-bold::text").get()
+
+        # Year ve Actors - Detaylar (Details) bölümünden
+        year = None
+        actors = []
+
+        # Detaylar bölümündeki tüm flex-col div'leri al
+        detail_items = sel.css("div.flex.flex-col")
+        for item in detail_items:
+            # Label ve value yapısı: span.text-base ve span.text-sm.opacity-90
+            label = item.css("span.text-base::text").get()
+            value = item.css("span.text-sm.opacity-90::text").get()
+            
+            if label and value:
+                label = label.strip()
+                value = value.strip()
+                
+                # Yayın tarihi (yıl)
+                if label == "Yayın tarihi":
+                    # "16 Ekim 2018" formatından yılı çıkar
+                    year_match = re.search(r'\d{4}', value)
+                    if year_match:
+                        year = year_match.group()
+                
+                # Yaratıcılar veya Oyuncular
+                elif label in ["Yaratıcılar", "Oyuncular"]:
+                    if value:
+                        actors.append(value)
+
+        # Check urls for episodes
+        all_urls = re.findall(r'"url":"([^"]*)"', resp.text)
+        is_series = any("bolum-" in u for u in all_urls)
+
+        episodes = []
+        if is_series:
+            # Dict kullanarak duplicate'leri önle ama sıralı tut
+            episodes_dict = {}
+            for u in all_urls:
+                if "bolum" in u and u not in episodes_dict:
+                    season_match = re.search(r'/sezon-(\d+)', u)
+                    ep_match     = re.search(r'/bolum-(\d+)', u)
+
+                    season = int(season_match.group(1)) if season_match else 1
+                    episode_num = int(ep_match.group(1)) if ep_match else 1
+
+                    # Key olarak (season, episode) tuple kullan
+                    key = (season, episode_num)
+                    episodes_dict[key] = Episode(
+                        season  = season,
+                        episode = episode_num,
+                        title   = f"{season}. Sezon {episode_num}. Bölüm",
+                        url     = self.fix_url(u)
+                    )
+
+            # Sıralı liste oluştur
+            episodes = [episodes_dict[key] for key in sorted(episodes_dict.keys())]
+
+        return SeriesInfo(
+            title       = title,
+            url         = url,
+            poster      = self.fix_url(poster),
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            actors      = actors,
+            episodes    = episodes,
+            year        = year
+        )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+        
+        next_data = sel.css("script#__NEXT_DATA__::text").get()
+        if not next_data:
+            return []
+
+        try:
+            data = json.loads(next_data)
+            secure_data = data["props"]["pageProps"]["secureData"]
+            decoded_json = json.loads(base64.b64decode(secure_data).decode('utf-8'))
+
+            # secureData içindeki RelatedResults -> getEpisodeSources -> result dizisini al
+            sources = decoded_json.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
+
+            seen_urls = set()
+            results = []
+            for source in sources:
+                source_content = source.get("source_content", "")
+
+                # iframe URL'ini source_content'ten çıkar
+                iframe_match = re.search(r'<iframe[^>]*src=["\']([^"\']*)["\']', source_content)
+                if not iframe_match:
+                    continue
+
+                iframe_url = iframe_match.group(1)
+                
+                # Fix URL protocol
+                if not iframe_url.startswith("http"):
+                    if iframe_url.startswith("//"):
+                        iframe_url = "https:" + iframe_url
+                    else:
+                        iframe_url = "https://" + iframe_url
+
+                iframe_url = self.fix_url(iframe_url)
+                
+                # Deduplicate  
+                if iframe_url in seen_urls:
+                    continue
+                seen_urls.add(iframe_url)
+
+                # Extract with helper
+                data = await self.extract(iframe_url)
+                if data:
+                    results.append(data)
+
+            return results
+
+        except Exception:
+            return []

KekikStream/Plugins/SelcukFlix.py

@@ -0,0 +1,328 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult
+from parsel           import Selector
+import re, base64, json, urllib.parse
+
+class SelcukFlix(PluginBase):
+    name        = "SelcukFlix"
+    lang        = "tr"
+    main_url    = "https://selcukflix.net"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Selcukflix'te her türden en yeni ve en popüler dizi ve filmleri izlemenin keyfini çıkarın. Aksiyondan romantiğe, bilim kurgudan dramaya, geniş kütüphanemizde herkes için bir şey var."
+
+    main_page = {
+        f"{main_url}/tum-bolumler" : "Yeni Eklenen Bölümler",
+        ""                         : "Yeni Diziler",
+        ""                         : "Kore Dizileri",
+        ""                         : "Yerli Diziler",
+        "15"                       : "Aile",
+        "17"                       : "Animasyon",
+        "9"                        : "Aksiyon",
+        "5"                        : "Bilim Kurgu",
+        "2"                        : "Dram",
+        "12"                       : "Fantastik",
+        "18"                       : "Gerilim",
+        "3"                        : "Gizem",
+        "8"                        : "Korku",
+        "4"                        : "Komedi",
+        "7"                        : "Romantik"
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        results = []
+        if "tum-bolumler" in url:
+            try:
+                resp = await self.httpx.get(url)
+                sel  = Selector(resp.text)
+
+                for item in sel.css("div.col-span-3 a"):
+                    name    = item.css("h2::text").get()
+                    ep_info = item.css("div.opacity-80::text").get()
+                    href    = item.css("::attr(href)").get()
+                    poster  = item.css("div.image img::attr(src)").get()
+
+                    if name and href:
+                        title     = f"{name} - {ep_info}" if ep_info else name
+                        final_url = self.fix_url(href)
+
+                        if "/dizi/" in final_url and "/sezon-" in final_url:
+                            final_url = final_url.split("/sezon-")[0]
+
+                        results.append(MainPageResult(
+                            category = category,
+                            title    = title,
+                            url      = final_url,
+                            poster   = self.fix_url(poster)
+                        ))
+            except Exception:
+                pass
+            return results
+        
+        base_api = f"{self.main_url}/api/bg/findSeries"
+
+        params = {
+            "releaseYearStart"   : "1900",
+            "releaseYearEnd"     : "2026",
+            "imdbPointMin"       : "1",
+            "imdbPointMax"       : "10",
+            "categoryIdsComma"   : "",
+            "countryIdsComma"    : "",
+            "orderType"          : "date_desc",
+            "languageId"         : "-1",
+            "currentPage"        : page,
+            "currentPageCount"   : "24",
+            "queryStr"           : "",
+            "categorySlugsComma" : "",
+            "countryCodesComma"  : ""
+        }
+
+        if "Yerli Diziler" in category:
+            params["imdbPointMin"]    = "5"
+            params["countryIdsComma"] = "29"
+        elif "Kore Dizileri" in category:
+            params["countryIdsComma"]   = "21"
+            params["countryCodesComma"] = "KR"
+        else:
+            params["categoryIdsComma"] = url
+
+        full_url = f"{base_api}?{urllib.parse.urlencode(params)}"
+
+        headers = {
+            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0",
+            "Accept"           : "application/json, text/plain, */*",
+            "Accept-Language"  : "en-US,en;q=0.5",
+            "X-Requested-With" : "XMLHttpRequest",
+            "Sec-Fetch-Site"   : "same-origin",
+            "Sec-Fetch-Mode"   : "cors",
+            "Sec-Fetch-Dest"   : "empty",
+            "Referer"          : f"{self.main_url}/"
+        }
+
+        try:
+            post_resp     = await self.httpx.post(full_url, headers=headers)
+            resp_json     = post_resp.json()
+            response_data = resp_json.get("response")
+
+            raw_data = base64.b64decode(response_data)
+            try:
+                decoded_str = raw_data.decode('utf-8')
+            except UnicodeDecodeError:
+                decoded_str = raw_data.decode('iso-8859-1').encode('utf-8').decode('utf-8')
+
+            data = json.loads(decoded_str)
+
+            for item in data.get("result", []):
+                title  = item.get("title")
+                slug   = item.get("slug")
+                poster = item.get("poster")
+
+                if poster:
+                    poster = self.clean_image_url(poster)
+
+                if slug:
+                    results.append(MainPageResult(
+                        category = category,
+                        title    = title,
+                        url      = self.fix_url(slug),
+                        poster   = poster
+                    ))
+
+        except Exception:
+            pass
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        search_url = f"{self.main_url}/api/bg/searchcontent?searchterm={query}"
+
+        headers = {
+            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0",
+            "Accept"           : "application/json, text/plain, */*",
+            "Accept-Language"  : "en-US,en;q=0.5",
+            "X-Requested-With" : "XMLHttpRequest",
+            "Sec-Fetch-Site"   : "same-origin",
+            "Sec-Fetch-Mode"   : "cors",
+            "Sec-Fetch-Dest"   : "empty",
+            "Referer"          : f"{self.main_url}/"
+        }
+
+        post_resp = await self.httpx.post(search_url, headers=headers)
+
+        try:
+            resp_json     = post_resp.json()
+            response_data = resp_json.get("response")
+            raw_data      = base64.b64decode(response_data)
+            try:
+                decoded_str = raw_data.decode('utf-8')
+            except UnicodeDecodeError:
+                decoded_str = raw_data.decode('iso-8859-1')
+
+            search_data = json.loads(decoded_str)
+
+            results = []
+            for item in search_data.get("result", []):
+                # API field isimleri: object_name, used_slug, object_poster_url
+                title  = item.get("object_name") or item.get("title")
+                slug   = item.get("used_slug") or item.get("slug")
+                poster = item.get("object_poster_url") or item.get("poster")
+
+                if poster:
+                    poster = self.clean_image_url(poster)
+
+                if slug and "/seri-filmler/" not in slug:
+                    results.append(SearchResult(
+                        title  = title,
+                        url    = self.fix_url(slug),
+                        poster = poster
+                    ))
+
+            return results
+
+        except Exception:
+            return []
+
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+
+        next_data = sel.css("script#__NEXT_DATA__::text").get()
+        if not next_data: 
+             return None
+
+        data         = json.loads(next_data)
+        secure_data  = data["props"]["pageProps"]["secureData"]
+        raw_data     = base64.b64decode(secure_data.replace('"', ''))
+        try:
+            decoded_str = raw_data.decode('utf-8')
+        except UnicodeDecodeError:
+            decoded_str = raw_data.decode('iso-8859-1')
+
+        content_details = json.loads(decoded_str)
+        item            = content_details.get("contentItem", {})
+
+        title           = item.get("original_title") or item.get("originalTitle") or ""
+        poster          = self.clean_image_url(item.get("poster_url") or item.get("posterUrl"))
+        description     = item.get("description") or item.get("used_description")
+        rating          = str(item.get("imdb_point") or item.get("imdbPoint", ""))
+        year            = item.get("release_year") or item.get("releaseYear")
+        duration        = item.get("total_minutes") or item.get("totalMinutes")
+
+        series_data     = content_details.get("relatedData", {}).get("seriesData")
+        if not series_data and "RelatedResults" in content_details:
+             series_data = content_details["RelatedResults"].get("getSerieSeasonAndEpisodes", {}).get("result")
+             if series_data and isinstance(series_data, list):
+                  pass
+
+        # Dizi mi film mi kontrol et (Kotlin referansı)
+        if series_data:
+            episodes = []
+            seasons_list = []
+            if isinstance(series_data, dict):
+                seasons_list = series_data.get("seasons", [])
+            elif isinstance(series_data, list):
+                seasons_list = series_data
+
+            for season in seasons_list:
+                if not isinstance(season, dict): continue
+                s_no = season.get("season_no") or season.get("seasonNo")
+                ep_list = season.get("episodes", [])
+                for ep in ep_list:
+                    episodes.append(Episode(
+                        season  = s_no,
+                        episode = ep.get("episode_no") or ep.get("episodeNo"),
+                        title   = ep.get("ep_text") or ep.get("epText"),
+                        url     = self.fix_url(ep.get("used_slug") or ep.get("usedSlug"))
+                    ))
+            
+            return SeriesInfo(
+                title       = title,
+                url         = url,
+                poster      = poster,
+                description = description,
+                rating      = rating,
+                year        = year,
+                episodes    = episodes
+            )
+        else:
+            # Film ise MovieInfo döndür
+            return MovieInfo(
+                title       = title,
+                url         = url,
+                poster      = poster,
+                description = description,
+                rating      = rating,
+                year        = year,
+                duration    = duration
+            )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+        
+        next_data = sel.css("script#__NEXT_DATA__::text").get()
+        if not next_data:
+            return []
+
+        try:
+            data = json.loads(next_data)
+            secure_data = data["props"]["pageProps"]["secureData"]
+            raw_data = base64.b64decode(secure_data.replace('"', ''))
+            
+            try:
+                decoded_str = raw_data.decode('utf-8')
+            except UnicodeDecodeError:
+                decoded_str = raw_data.decode('iso-8859-1')
+            
+            content_details = json.loads(decoded_str)
+            related_results = content_details.get("RelatedResults", {})
+            
+            source_content = None
+            
+            # Dizi (bölüm) için
+            if "/dizi/" in url:
+                episode_sources = related_results.get("getEpisodeSources", {})
+                if episode_sources.get("state"):
+                    res = episode_sources.get("result", [])
+                    if res:
+                        source_content = res[0].get("source_content") or res[0].get("sourceContent")
+            else:
+                # Film için
+                movie_parts = related_results.get("getMoviePartsById", {})
+                if movie_parts.get("state"):
+                    parts = movie_parts.get("result", [])
+                    if parts:
+                        first_part_id = parts[0].get("id")
+                        key = f"getMoviePartSourcesById_{first_part_id}"
+                        if key in related_results:
+                            res = related_results[key].get("result", [])
+                            if res:
+                                source_content = res[0].get("source_content") or res[0].get("sourceContent")
+
+            if source_content:
+                iframe_sel = Selector(source_content)
+                iframe_src = iframe_sel.css("iframe::attr(src)").get()
+                if iframe_src:
+                    iframe_src = self.fix_url(iframe_src)
+                    # Hotlinger domain değişimi (Kotlin referansı)
+                    if "sn.dplayer74.site" in iframe_src:
+                        iframe_src = iframe_src.replace("sn.dplayer74.site", "sn.hotlinger.com")
+                    
+                    data = await self.extract(iframe_src)
+                    if data:
+                        return [data]
+            
+            return []
+
+        except Exception:
+            return []
+
+    def clean_image_url(self, url: str) -> str:
+        if not url: return None
+        url = url.replace("images-macellan-online.cdn.ampproject.org/i/s/", "")
+        url = url.replace("file.dizilla.club", "file.macellan.online")
+        url = url.replace("images.dizilla.club", "images.macellan.online")
+        url = url.replace("images.dizimia4.com", "images.macellan.online")
+        url = url.replace("file.dizimia4.com", "file.macellan.online")
+        url = url.replace("/f/f/", "/630/910/")
+        return self.fix_url(url)