KekikStream 1.7.2__py3-none-any.whl → 1.7.3__py3-none-any.whl

KekikStream/Plugins/KultFilmler.py

@@ -0,0 +1,219 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, Subtitle
+from parsel import Selector
+import re, base64
+
+class KultFilmler(PluginBase):
+    name        = "KultFilmler"
+    language    = "tr"
+    main_url    = "https://kultfilmler.net"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Kült film ve dizi izleme sitesi."
+
+    main_page   = {
+        f"{main_url}/category/aile-filmleri-izle"       : "Aile",
+        f"{main_url}/category/aksiyon-filmleri-izle"    : "Aksiyon",
+        f"{main_url}/category/animasyon-filmleri-izle"  : "Animasyon",
+        f"{main_url}/category/belgesel-izle"            : "Belgesel",
+        f"{main_url}/category/bilim-kurgu-filmleri-izle": "Bilim Kurgu",
+        f"{main_url}/category/biyografi-filmleri-izle"  : "Biyografi",
+        f"{main_url}/category/dram-filmleri-izle"       : "Dram",
+        f"{main_url}/category/fantastik-filmleri-izle"  : "Fantastik",
+        f"{main_url}/category/gerilim-filmleri-izle"    : "Gerilim",
+        f"{main_url}/category/gizem-filmleri-izle"      : "Gizem",
+        f"{main_url}/category/kara-filmleri-izle"       : "Kara Film",
+        f"{main_url}/category/kisa-film-izle"           : "Kısa Metraj",
+        f"{main_url}/category/komedi-filmleri-izle"     : "Komedi",
+        f"{main_url}/category/korku-filmleri-izle"      : "Korku",
+        f"{main_url}/category/macera-filmleri-izle"     : "Macera",
+        f"{main_url}/category/muzik-filmleri-izle"      : "Müzik",
+        f"{main_url}/category/polisiye-filmleri-izle"   : "Polisiye",
+        f"{main_url}/category/romantik-filmleri-izle"   : "Romantik",
+        f"{main_url}/category/savas-filmleri-izle"      : "Savaş",
+        f"{main_url}/category/suc-filmleri-izle"        : "Suç",
+        f"{main_url}/category/tarih-filmleri-izle"      : "Tarih",
+        f"{main_url}/category/yerli-filmleri-izle"      : "Yerli",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = await self.cffi.get(url)
+        secici = Selector(istek.text)
+
+        results = []
+        for veri in secici.css("div.col-md-12 div.movie-box"):
+            title  = veri.css("div.img img::attr(alt)").get()
+            href   = self.fix_url(veri.css("a::attr(href)").get())
+            poster = self.fix_url(veri.css("div.img img::attr(src)").get())
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = title,
+                    url      = href,
+                    poster   = poster,
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek  = await self.cffi.get(f"{self.main_url}?s={query}")
+        secici = Selector(istek.text)
+
+        results = []
+        for veri in secici.css("div.movie-box"):
+            title  = veri.css("div.img img::attr(alt)").get()
+            href   = self.fix_url(veri.css("a::attr(href)").get())
+            poster = self.fix_url(veri.css("div.img img::attr(src)").get())
+
+            if title and href:
+                results.append(SearchResult(
+                    title  = title,
+                    url    = href,
+                    poster = poster,
+                ))
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        istek  = await self.cffi.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("div.film-bilgileri img::attr(alt)").get() or secici.css("[property='og:title']::attr(content)").get()
+        poster      = self.fix_url(secici.css("[property='og:image']::attr(content)").get())
+        description = secici.css("div.description::text").get()
+        tags        = secici.css("ul.post-categories a::text").getall()
+        # HTML analizine göre güncellenen alanlar
+        year        = secici.css("li.release span a::text").get()
+        duration    = secici.css("li.time span::text").re_first(r"(\d+)")
+        rating      = secici.css("div.imdb-count::text").get()
+        actors      = secici.css("div.actors a::text").getall()
+        if rating:
+            rating = rating.strip()
+
+        # Dizi mi kontrol et
+        if "/dizi/" in url:
+            episodes = []
+            for bolum in secici.css("div.episode-box"):
+                ep_href   = self.fix_url(bolum.css("div.name a::attr(href)").get())
+                ssn_detail = bolum.css("span.episodetitle::text").get() or ""
+                ep_detail  = bolum.css("span.episodetitle b::text").get() or ""
+                ep_name    = f"{ssn_detail} - {ep_detail}"
+
+                if ep_href:
+                    ep_season  = re.search(r"(\d+)\.", ssn_detail)
+                    ep_episode = re.search(r"(\d+)\.", ep_detail)
+
+                    episodes.append(Episode(
+                        season  = int(ep_season[1]) if ep_season else 1,
+                        episode = int(ep_episode[1]) if ep_episode else 1,
+                        title   = ep_name.strip(" -"),
+                        url     = ep_href,
+                    ))
+
+            return SeriesInfo(
+                url         = url,
+                poster      = poster,
+                title       = self.clean_title(title) if title else "",
+                description = description,
+                tags        = tags,
+                year        = year,
+                actors      = actors,
+                rating      = rating,
+                episodes    = episodes,
+            )
+
+        return MovieInfo(
+            url         = url,
+            poster      = poster,
+            title       = self.clean_title(title) if title else "",
+            description = description,
+            tags        = tags,
+            year        = year,
+            rating      = rating,
+            actors      = actors,
+            duration    = int(duration) if duration else None,
+        )
+
+    def _get_iframe(self, source_code: str) -> str:
+        """Base64 kodlu iframe'i çözümle"""
+        atob_match = re.search(r"PHA\+[0-9a-zA-Z+/=]*", source_code)
+        if not atob_match:
+            return ""
+
+        atob = atob_match.group()
+
+        # Padding düzelt
+        padding = 4 - len(atob) % 4
+        if padding < 4:
+            atob = atob + "=" * padding
+
+        try:
+            decoded = base64.b64decode(atob).decode("utf-8")
+            secici  = Selector(text=decoded)
+            return self.fix_url(secici.css("iframe::attr(src)").get()) or ""
+        except Exception:
+            return ""
+
+    def _extract_subtitle_url(self, source_code: str) -> str | None:
+        """Altyazı URL'sini çıkar"""
+        match = re.search(r"(https?://[^\s\"]+\.srt)", source_code)
+        return match[1] if match else None
+
+    async def load_links(self, url: str) -> list[dict]:
+        istek  = await self.cffi.get(url)
+        secici = Selector(istek.text)
+
+        iframes = set()
+
+        # Ana iframe
+        main_frame = self._get_iframe(istek.text)
+        if main_frame:
+            iframes.add(main_frame)
+
+        # Alternatif player'lar
+        for player in secici.css("div.container#player"):
+            alt_iframe = self.fix_url(player.css("iframe::attr(src)").get())
+            if alt_iframe:
+                alt_istek = await self.cffi.get(alt_iframe)
+                alt_frame = self._get_iframe(alt_istek.text)
+                if alt_frame:
+                    iframes.add(alt_frame)
+
+        results = []
+
+        for iframe in iframes:
+            subtitles = []
+
+            # VidMoly özel işleme
+            if "vidmoly" in iframe:
+                headers = {
+                    "User-Agent"     : "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36",
+                    "Sec-Fetch-Dest" : "iframe"
+                }
+                iframe_istek = await self.cffi.get(iframe, headers=headers)
+                m3u_match    = re.search(r'file:"([^"]+)"', iframe_istek.text)
+
+                if m3u_match:
+                    results.append({
+                        "name"      : "VidMoly",
+                        "url"       : m3u_match[1],
+                        "referer"   : self.main_url,
+                        "subtitles" : []
+                    })
+                    continue
+
+            # Altyazı çıkar
+            subtitle_url = self._extract_subtitle_url(url)
+            if subtitle_url:
+                subtitles.append(Subtitle(name="Türkçe", url=subtitle_url))
+
+            extractor = self.ex_manager.find_extractor(iframe)
+            results.append({
+                "name"      : extractor.name if extractor else "Player",
+                "url"       : iframe,
+                "referer"   : f"{self.main_url}/",
+                "subtitles" : subtitles
+            })
+
+        return results

KekikStream/Plugins/RoketDizi.py

@@ -0,0 +1,204 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, MovieInfo
+from parsel           import Selector
+import re, base64, json, urllib.parse
+
+class RoketDizi(PluginBase):
+    name        = "RoketDizi"
+    lang        = "tr"
+    main_url    = "https://flatscher.net"
+    
+    main_page = {
+       "dizi/tur/aksiyon"     : "Aksiyon",
+       "dizi/tur/bilim-kurgu" : "Bilim Kurgu",
+       "dizi/tur/gerilim"     : "Gerilim",
+       "dizi/tur/fantastik"   : "Fantastik",
+       "dizi/tur/komedi"      : "Komedi",
+       "dizi/tur/korku"       : "Korku",
+       "dizi/tur/macera"      : "Macera",
+       "dizi/tur/suc"         : "Suç"
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        full_url = f"{self.main_url}/{url}?&page={page}"
+        resp = await self.cffi.get(full_url)
+        sel = Selector(resp.text)
+        
+        results = []
+        
+        for item in sel.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=title,
+                     url=self.fix_url(href),
+                     poster=self.fix_url(poster)
+                 ))
+        return results
+
+    async def get_domain(self):
+        try:
+            domain_list = await self.cffi.get("https://raw.githubusercontent.com/Kraptor123/domainListesi/refs/heads/main/eklenti_domainleri.txt")
+            if domain_list.status_code == 200:
+                for line in domain_list.text.split("|"):
+                    if line.strip().startswith("RoketDizi"):
+                        domain = line.split(":")[-1].strip()
+                        if "http" not in domain:
+                            domain = f"https://{domain}"
+                        return domain
+        except Exception:
+            pass
+        return self.main_url
+
+    async def search(self, query: str) -> list[SearchResult]:
+        current_domain = await self.get_domain()
+        
+        # Get Cookies and Keys
+        main_req = await self.cffi.get(current_domain)
+        sel = Selector(main_req.text)
+        
+        c_key   = sel.css("input[name='cKey']::attr(value)").get()
+        c_value = sel.css("input[name='cValue']::attr(value)").get()
+        
+        post_url = f"{current_domain}/api/bg/searchContent?searchterm={query}"
+        
+        headers = {
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": f"{current_domain}/",
+            "CNT": "vakTR"
+        }
+
+        data = {}
+        if c_key and c_value:
+            data = {"cKey": c_key, "cValue": c_value}
+        
+        search_req = await self.cffi.post(post_url, data=data, headers=headers)
+        
+        try:
+            resp_json = search_req.json()
+            if not resp_json.get("state"):
+                return []
+            
+            html_content = resp_json.get("html", "").strip()
+            sel_results = Selector(html_content)
+
+            results = []
+            items = re.findall(r'<a href="([^"]+)".*?data-srcset="([^"]+).*?<span class="text-white">([^<]+)', html_content, re.DOTALL)
+            
+            for href, poster, title in items:
+                 results.append(SearchResult(
+                     title=title.strip(),
+                     url=self.fix_url(href.strip(), current_domain),
+                     poster=self.fix_url(poster.strip(), current_domain)
+                 ))
+            
+            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.cffi.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()
+        
+        year = None # Implement if critical
+        
+        tags = sel.css("h3.text-white.opacity-60::text").get()
+        if tags:
+            tags = [t.strip() for t in tags.split(",")]
+            
+        rating = sel.css("div.flex.items-center span.text-white.text-sm::text").get()
+        actors = sel.css("div.global-box h5::text").getall()
+
+        # 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:
+            seen_eps = set()
+            for u in all_urls:
+                if "bolum" in u and u not in seen_eps:
+                    seen_eps.add(u)
+                    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
+                    
+                    episodes.append(Episode(
+                        season=season,
+                        episode=episode_num,
+                        title=f"{season}. Sezon {episode_num}. Bölüm", # Placeholder title
+                        url=self.fix_url(u, self.get_domain_sync(url))
+                    ))
+        
+        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[dict]:
+        resp = await self.cffi.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 = base64.b64decode(secure_data).decode('utf-8')
+            
+            results = []
+            matches = re.findall(r'iframe src=\\"([^"]*)\\"', decoded)
+            for m in matches:
+                iframe_url = m.replace('\\', '')
+                if "http" not in iframe_url:
+                     if iframe_url.startswith("//"):
+                         iframe_url = "https:" + iframe_url
+                     else:
+                         iframe_url = "https://" + iframe_url # fallback
+                
+                # Check extractor
+                extractor = self.ex_manager.find_extractor(iframe_url)
+                name = extractor.name if extractor else "Iframe"
+                
+                results.append({
+                    "url": iframe_url,
+                    "name": name
+                })
+            
+            return results
+
+        except Exception:
+            return []
+
+    def fix_url(self, url: str, domain:str=None) -> str:
+        if not url: return ""
+        if url.startswith("http"): return url
+        base = domain or self.main_url
+        return f"https:{url}" if url.startswith("//") else urllib.parse.urljoin(base, url)
+
+    def get_domain_sync(self, url:str):
+        parsed = urllib.parse.urlparse(url)
+        return f"{parsed.scheme}://{parsed.netloc}"

KekikStream/Plugins/SelcukFlix.py

@@ -0,0 +1,216 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
+from parsel           import Selector
+import re, base64, json, urllib.parse
+
+class SelcukFlix(PluginBase):
+    name     = "SelcukFlix"
+    main_url = "https://selcukflix.net"
+    lang     = "tr"
+    
+    main_page = {
+       "tum-bolumler" : "Yeni Eklenen Bölümler"
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        full_url = f"{self.main_url}/{url}"
+        resp = await self.cffi.get(full_url)
+        sel = Selector(resp.text)
+        
+        results = []
+        if "tum-bolumler" in url:
+            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)
+                    ))
+        
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        search_url = f"{self.main_url}/api/bg/searchcontent?searchterm={query}"
+        
+        headers = {
+            "Accept": "application/json, text/plain, */*",
+            "X-Requested-With": "XMLHttpRequest",
+            "Referer": f"{self.main_url}/"
+        }
+        
+        post_resp = await self.cffi.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').encode('utf-8').decode('utf-8')
+                
+            search_data = json.loads(decoded_str)
+            
+            results = []
+            for item in search_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 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) -> SeriesInfo:
+        resp = await self.cffi.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') # .encode('utf-8').decode('utf-8') implied
+        
+        content_details = json.loads(decoded_str)
+        item = content_details.get("contentItem", {})
+            
+        title = item.get("original_title") or item.get("originalTitle")
+        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", ""))
+        
+        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
+
+        episodes = []
+        if series_data:
+             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") # Try snake_case too
+                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,
+            episodes=episodes
+        )
+
+    async def load_links(self, url: str) -> list[dict]:
+        resp = await self.cffi.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_data = content_details.get("relatedData", {})
+             
+             source_content = None
+             
+             # Check if Series (episode) or Movie
+             if "/dizi/" in url:
+                 if related_data.get("episodeSources", {}).get("state"):
+                      res = related_data["episodeSources"].get("result", [])
+                      if res:
+                          source_content = res[0].get("sourceContent")
+             else:
+                 # Movie
+                 if related_data.get("movieParts", {}).get("state"):
+                      # Looking for first part source
+                      movie_parts = related_data["movieParts"].get("result", [])
+                      if movie_parts:
+                          first_part_id = movie_parts[0].get("id")
+                          # RelatedResults -> getMoviePartSourcesById_ID
+                          rr = content_details.get("RelatedResults", {})
+                          key = f"getMoviePartSourcesById_{first_part_id}"
+                          if key in rr:
+                              res = rr[key].get("result", [])
+                              if res:
+                                  source_content = res[0].get("source_content")
+
+             results = []
+             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)
+                     # Domain replace
+                     if "sn.dplayer74.site" in iframe_src:
+                         iframe_src = iframe_src.replace("sn.dplayer74.site", "sn.hotlinger.com")
+                     
+                     extractor = self.ex_manager.find_extractor(iframe_src)
+                     results.append({
+                         "url": iframe_src,
+                         "name": extractor.name if extractor else "Iframe"
+                     })
+             
+             return results
+
+        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)

KekikStream/Plugins/SezonlukDizi.py

@@ -134,6 +134,9 @@ class SezonlukDizi(PluginBase):
                     secici = Selector(veri_response.text)
 
                     if iframe := secici.css("iframe::attr(src)").get():
+                        if "link.asp" in iframe:
+                            continue
+                            
                         extractor = self.ex_manager.find_extractor(self.fix_url(iframe))
                         results.append({
                             "url"  : self.fix_url(iframe),