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

KekikStream/Extractors/VidPapi.py

@@ -0,0 +1,90 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re
+
+class VidPapi(ExtractorBase):
+    name     = "VidApi"
+    main_url = "https://vidpapi.xyz"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref = referer or ""
+        
+        # URL parsing
+        if "video/" in url:
+            vid_id = url.split("video/")[-1]
+        else:
+            vid_id = url.split("?data=")[-1]
+            
+        # 1. Altyazıları çek
+        sub_url = f"{self.main_url}/player/index.php?data={vid_id}"
+        sub_headers = {
+            "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+            "X-Requested-With" : "XMLHttpRequest",
+            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0",
+            "Referer"          : ext_ref or "https://kultfilmler.pro/"
+        }
+        
+        subtitles = []
+        try:
+            sub_istek = await self.cffi.post(
+                url     = sub_url,
+                headers = sub_headers,
+                data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+            )
+            
+            subtitle_match = re.search(r'var playerjsSubtitle = "([^"]*)"', sub_istek.text, re.IGNORECASE)
+            if subtitle_match and subtitle_match.group(1):
+                raw_subs = subtitle_match.group(1)
+                
+                found_subs = re.findall(r'\[(.*?)\](.*?)(?:,|$)', raw_subs)
+                for lang, sub_link in found_subs:
+                    lang = lang.strip()
+                    if "Türkçe" in lang:
+                        lang_code = "tr"
+                        lang_name = "Turkish"
+                    elif "İngilizce" in lang:
+                        lang_code = "en"
+                        lang_name = "English"
+                    else:
+                        lang_code = lang[:2].lower()
+                        lang_name = lang
+                        
+                    subtitles.append(Subtitle(
+                        name = lang_name,
+                        url  = sub_link.strip()
+                    ))
+                    
+        except Exception as e:
+            pass
+
+        # 2. Videoyu çek
+        video_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
+        video_headers = sub_headers.copy()
+        
+        response = await self.cffi.post(
+            url     = video_url,
+            headers = video_headers,
+            data    = {"hash": vid_id, "r": "https://kultfilmler.pro/"}
+        )
+        response.raise_for_status()
+        
+        try:
+            video_data = response.json()
+        except Exception:
+            return None
+
+        stream_url = video_data.get("securedLink")
+        if not stream_url or not stream_url.strip():
+            stream_url = video_data.get("videoSource")
+            
+        if not stream_url:
+            raise ValueError("No video link found in VidPapi response")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = stream_url,
+            referer   = ext_ref or self.main_url,
+            headers   = {},
+            subtitles = subtitles
+        )

KekikStream/Extractors/VidStack.py

@@ -0,0 +1,75 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from Crypto.Cipher    import AES
+from urllib.parse     import urlparse
+import re, binascii
+
+class VidStack(ExtractorBase):
+    name             = "VidStack"
+    main_url         = "https://vidstack.io"
+    requires_referer = True
+
+    def get_base_url(self, url: str) -> str:
+        try:
+            parsed = urlparse(url)
+            return f"{parsed.scheme}://{parsed.netloc}"
+        except Exception:
+            return self.main_url
+
+    def decrypt_aes(self, encrypted_hex: str, key: str, iv: str) -> str:
+        try:
+            key_bytes = key.encode('utf-8')
+            iv_bytes  = iv.encode('utf-8')
+            cipher    = AES.new(key_bytes, AES.MODE_CBC, iv_bytes)
+            
+            encrypted_bytes = binascii.unhexlify(encrypted_hex)
+            decrypted_bytes = cipher.decrypt(encrypted_bytes)
+            
+            # Remove PKCS5 padding
+            padding_len = decrypted_bytes[-1]
+            return decrypted_bytes[:-padding_len].decode('utf-8')
+        except Exception:
+            return None
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.cffi.headers.update({
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0"
+        })
+
+        if referer:
+            self.cffi.headers.update({"Referer": referer})
+
+        video_hash = url.split("#")[-1].split("/")[-1]
+        base_url   = self.get_base_url(url)
+        
+        api_url = f"{base_url}/api/v1/video?id={video_hash}"
+        istek   = await self.cffi.get(api_url)
+        encoded = istek.text.strip()
+
+        key     = "kiemtienmua911ca"
+        iv_list = ["1234567890oiuytr", "0123456789abcdef"]
+        
+        decrypted_text = None
+        for iv in iv_list:
+            if result := self.decrypt_aes(encoded, key, iv):
+                decrypted_text = result
+                break
+        
+        if not decrypted_text:
+            raise ValueError(f"VidStack: Şifre çözülemedi. {url}")
+
+        m3u8_url = ""
+        if match := re.search(r'"source":"(.*?)"', decrypted_text):
+            m3u8_url = match.group(1).replace("\\/", "/")
+        
+        if not m3u8_url:
+             raise ValueError(f"VidStack: Source bulunamadı. {url}")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u8_url,
+            referer   = url,
+            headers   = {},
+            subtitles = []
+        )

KekikStream/Extractors/YildizKisaFilm.py

@@ -0,0 +1,42 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+
+class YildizKisaFilm(ExtractorBase):
+    name     = "YildizKisaFilm"
+    main_url = "https://yildizkisafilm.org"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref = referer or ""
+
+        if "video/" in url:
+            vid_id = url.split("video/")[-1]
+        else:
+            vid_id = url.split("?data=")[-1]
+
+        post_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
+
+        response = await self.cffi.post(
+            url     = post_url,
+            data    = {"hash": vid_id, "r": ext_ref},
+            headers = {
+                "Referer"          : ext_ref,
+                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+                "X-Requested-With" : "XMLHttpRequest"
+            }
+        )
+        response.raise_for_status()
+
+        video_data = response.json()
+        m3u_link   = video_data.get("securedLink")
+
+        if not m3u_link:
+            raise ValueError("securedLink not found in response")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = ext_ref,
+            headers   = {},
+            subtitles = []
+        )

KekikStream/Plugins/DiziPal.py

@@ -0,0 +1,246 @@
+# 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
+
+class DiziPal(PluginBase):
+    name        = "DiziPal"
+    language    = "tr"
+    main_url    = "https://dizipal1222.com"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Yabancı Dizi ve Film izle."
+
+    main_page   = {
+        f"{main_url}/diziler/son-bolumler"              : "Son Bölümler",
+        f"{main_url}/diziler"                           : "Yeni Diziler",
+        f"{main_url}/filmler"                           : "Yeni Filmler",
+        f"{main_url}/koleksiyon/netflix"                : "Netflix",
+        f"{main_url}/koleksiyon/exxen"                  : "Exxen",
+        f"{main_url}/koleksiyon/blutv"                  : "BluTV",
+        f"{main_url}/koleksiyon/disney"                 : "Disney+",
+        f"{main_url}/koleksiyon/amazon-prime"           : "Amazon Prime",
+        f"{main_url}/koleksiyon/tod-bein"               : "TOD (beIN)",
+        f"{main_url}/koleksiyon/gain"                   : "Gain",
+        f"{main_url}/tur/mubi"                          : "Mubi",
+    }
+
+    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 = []
+
+        if "/son-bolumler" in url:
+            for veri in secici.css("div.episode-item"):
+                name     = veri.css("div.name::text").get()
+                episode  = veri.css("div.episode::text").get()
+                href     = veri.css("a::attr(href)").get()
+                poster   = veri.css("img::attr(src)").get()
+
+                if name and href:
+                    ep_text = episode.strip().replace(". Sezon ", "x").replace(". Bölüm", "") if episode else ""
+                    title   = f"{name} {ep_text}"
+                    # Son bölümler linkini dizi sayfasına çevir
+                    dizi_url = href.split("/sezon")[0] if "/sezon" in href else href
+
+                    results.append(MainPageResult(
+                        category = category,
+                        title    = title,
+                        url      = self.fix_url(dizi_url),
+                        poster   = self.fix_url(poster) if poster else None,
+                    ))
+        else:
+            for veri in secici.css("article.type2 ul li"):
+                title  = veri.css("span.title::text").get()
+                href   = veri.css("a::attr(href)").get()
+                poster = veri.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) if poster else None,
+                    ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        self.cffi.headers.update({
+            "Accept"           : "application/json, text/javascript, */*; q=0.01",
+            "X-Requested-With" : "XMLHttpRequest"
+        })
+
+        istek = await self.cffi.post(
+            url  = f"{self.main_url}/api/search-autocomplete",
+            data = {"query": query}
+        )
+
+        try:
+            data = istek.json()
+        except Exception:
+            return []
+
+        results = []
+
+        # API bazen dict, bazen list döner
+        items = data.values() if isinstance(data, dict) else data
+
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+
+            title  = item.get("title")
+            url    = item.get("url")
+            poster = item.get("poster")
+
+            if title and url:
+                results.append(SearchResult(
+                    title  = title,
+                    url    = f"{self.main_url}{url}",
+                    poster = self.fix_url(poster) if poster else None,
+                ))
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        # Reset headers to get HTML response
+        self.cffi.headers.update({
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        })
+        self.cffi.headers.pop("X-Requested-With", None)
+
+        istek  = await self.cffi.get(url)
+        secici = Selector(text=istek.text, type="html")
+
+        poster      = self.fix_url(secici.css("meta[property='og:image']::attr(content)").get())
+        year        = secici.xpath("//div[text()='Yapım Yılı']//following-sibling::div/text()").get()
+        description = secici.css("div.summary p::text").get()
+        rating      = secici.xpath("//div[text()='IMDB Puanı']//following-sibling::div/text()").get()
+        tags_raw    = secici.xpath("//div[text()='Türler']//following-sibling::div/text()").get()
+        tags        = [t.strip() for t in tags_raw.split() if t.strip()] if tags_raw else None
+
+        dur_text    = secici.xpath("//div[text()='Ortalama Süre']//following-sibling::div/text()").get()
+        dur_match   = re.search(r"(\d+)", dur_text or "")
+        duration    = int(dur_match[1]) if dur_match else None
+
+        if "/dizi/" in url:
+            title = secici.css("div.cover h5::text").get()
+
+            episodes = []
+            for ep in secici.css("div.episode-item"):
+                ep_name    = ep.css("div.name::text").get()
+                ep_href    = ep.css("a::attr(href)").get()
+                ep_text    = ep.css("div.episode::text").get() or ""
+                ep_parts   = ep_text.strip().split(" ")
+
+                ep_season  = None
+                ep_episode = None
+                if len(ep_parts) >= 4:
+                    try:
+                        ep_season  = int(ep_parts[0].replace(".", ""))
+                        ep_episode = int(ep_parts[2].replace(".", ""))
+                    except ValueError:
+                        pass
+
+                if ep_name and ep_href:
+                    episodes.append(Episode(
+                        season  = ep_season,
+                        episode = ep_episode,
+                        title   = ep_name.strip(),
+                        url     = self.fix_url(ep_href),
+                    ))
+
+            return SeriesInfo(
+                url         = url,
+                poster      = poster,
+                title       = title,
+                description = description.strip() if description else None,
+                tags        = tags,
+                rating      = rating.strip() if rating else None,
+                year        = year.strip() if year else None,
+                duration    = duration,
+                episodes    = episodes if episodes else None,
+            )
+        else:
+            title = secici.xpath("//div[@class='g-title'][2]/div/text()").get()
+
+            return MovieInfo(
+                url         = url,
+                poster      = poster,
+                title       = title.strip() if title else None,
+                description = description.strip() if description else None,
+                tags        = tags,
+                rating      = rating.strip() if rating else None,
+                year        = year.strip() if year else None,
+                duration    = duration,
+            )
+
+    async def load_links(self, url: str) -> list[dict]:
+        # Reset headers to get HTML response
+        self.cffi.headers.update({
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        })
+        self.cffi.headers.pop("X-Requested-With", None)
+
+        istek  = await self.cffi.get(url)
+        secici = Selector(istek.text)
+
+        iframe = secici.css(".series-player-container iframe::attr(src)").get()
+        if not iframe:
+            iframe = secici.css("div#vast_new iframe::attr(src)").get()
+
+        if not iframe:
+            return []
+
+        results = []
+
+        self.cffi.headers.update({"Referer": f"{self.main_url}/"})
+        i_istek = await self.cffi.get(iframe)
+        i_text  = i_istek.text
+
+        # m3u link çıkar
+        m3u_match = re.search(r'file:"([^"]+)"', i_text)
+        if m3u_match:
+            m3u_link = m3u_match[1]
+
+            # Altyazıları çıkar
+            subtitles = []
+            sub_match = re.search(r'"subtitle":"([^"]+)"', i_text)
+            if sub_match:
+                sub_text = sub_match[1]
+                if "," in sub_text:
+                    for sub in sub_text.split(","):
+                        lang = sub.split("[")[1].split("]")[0] if "[" in sub else "Türkçe"
+                        sub_url = sub.replace(f"[{lang}]", "")
+                        subtitles.append(Subtitle(name=lang, url=self.fix_url(sub_url)))
+                else:
+                    lang = sub_text.split("[")[1].split("]")[0] if "[" in sub_text else "Türkçe"
+                    sub_url = sub_text.replace(f"[{lang}]", "")
+                    subtitles.append(Subtitle(name=lang, url=self.fix_url(sub_url)))
+
+            results.append({
+                "name"      : self.name,
+                "url"       : m3u_link,
+                "referer"   : f"{self.main_url}/",
+                "subtitles" : subtitles
+            })
+        else:
+            # Extractor'a yönlendir
+            extractor = self.ex_manager.find_extractor(iframe)
+            results.append({
+                "name"    : f"{extractor.name if extractor else self.name}",
+                "url"     : iframe,
+                "referer" : f"{self.main_url}/",
+            })
+
+        return results
+
+    async def play(self, name: str, url: str, referer: str, subtitles: list[Subtitle]):
+        extract_result = ExtractResult(name=name, url=url, referer=referer, subtitles=subtitles)
+        self.media_handler.title = name
+        if self.name not in self.media_handler.title:
+            self.media_handler.title = f"{self.name} | {self.media_handler.title}"
+
+        self.media_handler.play_media(extract_result)

KekikStream/Plugins/Dizilla.py

@@ -134,7 +134,11 @@ class Dizilla(PluginBase):
         bolumler = []
         sezonlar = veri.get("containsSeason") if isinstance(veri.get("containsSeason"), list) else [veri.get("containsSeason")]
         for sezon in sezonlar:
-            for bolum in sezon.get("episode"):
+            episodes = sezon.get("episode")
+            if isinstance(episodes, dict):
+                episodes = [episodes]
+            
+            for bolum in episodes:
                 bolumler.append(Episode(
                     season  = sezon.get("seasonNumber"),
                     episode = bolum.get("episodeNumber"),

KekikStream/Plugins/FilmBip.py

@@ -0,0 +1,145 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo
+from parsel import Selector
+
+class FilmBip(PluginBase):
+    name        = "FilmBip"
+    language    = "tr"
+    main_url    = "https://filmbip.com"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Film izleme sitesi."
+
+    main_page   = {
+        f"{main_url}/filmler/SAYFA"                 : "Yeni Filmler",
+        f"{main_url}/film/tur/aile/SAYFA"           : "Aile",
+        f"{main_url}/film/tur/aksiyon/SAYFA"        : "Aksiyon",
+        f"{main_url}/film/tur/belgesel/SAYFA"       : "Belgesel",
+        f"{main_url}/film/tur/bilim-kurgu/SAYFA"    : "Bilim Kurgu",
+        f"{main_url}/film/tur/dram/SAYFA"           : "Dram",
+        f"{main_url}/film/tur/fantastik/SAYFA"      : "Fantastik",
+        f"{main_url}/film/tur/gerilim/SAYFA"        : "Gerilim",
+        f"{main_url}/film/tur/gizem/SAYFA"          : "Gizem",
+        f"{main_url}/film/tur/komedi/SAYFA"         : "Komedi",
+        f"{main_url}/film/tur/korku/SAYFA"          : "Korku",
+        f"{main_url}/film/tur/macera/SAYFA"         : "Macera",
+        f"{main_url}/film/tur/muzik/SAYFA"          : "Müzik",
+        f"{main_url}/film/tur/romantik/SAYFA"       : "Romantik",
+        f"{main_url}/film/tur/savas/SAYFA"          : "Savaş",
+        f"{main_url}/film/tur/suc/SAYFA"            : "Suç",
+        f"{main_url}/film/tur/tarih/SAYFA"          : "Tarih",
+        f"{main_url}/film/tur/vahsi-bati/SAYFA"     : "Western",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        page_url = url.replace("SAYFA", "") if page == 1 else url.replace("SAYFA", str(page))
+        page_url = page_url.rstrip("/")
+
+        istek  = await self.cffi.get(page_url)
+        secici = Selector(istek.text)
+
+        results = []
+        for veri in secici.css("div.poster-long"):
+            img = veri.css("a.block img.lazy")
+            title = img.css("::attr(alt)").get()
+            href  = self.fix_url(veri.css("a.block::attr(href)").get())
+            poster = self.fix_url(img.css("::attr(data-src)").get() or img.css("::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.post(
+            url     = f"{self.main_url}/search",
+            headers = {
+                "Accept"           : "application/json, text/javascript, */*; q=0.01",
+                "X-Requested-With" : "XMLHttpRequest",
+                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+                "Origin"           : self.main_url,
+                "Referer"          : f"{self.main_url}/"
+            },
+            data    = {"query": query}
+        )
+
+        try:
+            json_data = istek.json()
+            if not json_data.get("success"):
+                return []
+
+            html_content = json_data.get("theme", "")
+        except Exception:
+            return []
+
+        secici = Selector(text=html_content)
+
+        results = []
+        for veri in secici.css("li"):
+            title  = veri.css("a.block.truncate::text").get()
+            href   = self.fix_url(veri.css("a::attr(href)").get())
+            poster = self.fix_url(veri.css("img.lazy::attr(data-src)").get())
+
+            if title and href:
+                results.append(SearchResult(
+                    title  = title.strip(),
+                    url    = href,
+                    poster = poster,
+                ))
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo:
+        istek  = await self.cffi.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("div.page-title h1::text").get()
+        poster      = self.fix_url(secici.css("meta[property='og:image']::attr(content)").get())
+        trailer     = secici.css("div.series-profile-trailer::attr(data-yt)").get()
+        description = secici.css("div.series-profile-infos-in.article p::text").get() or \
+                      secici.css("div.series-profile-summary p::text").get()
+        
+        tags = secici.css("div.series-profile-type.tv-show-profile-type a::text").getall()
+
+        # XPath ile yıl, süre ve puan
+        year     = secici.xpath("//li[span[contains(text(), 'Yapım yılı')]]/p/text()").re_first(r"(\d{4})")
+        duration = secici.xpath("//li[span[contains(text(), 'Süre')]]/p/text()").re_first(r"(\d+)")
+        rating   = secici.xpath("//li[span[contains(text(), 'IMDB Puanı')]]/p/span/text()").get()
+
+        actors = secici.css("div.series-profile-cast ul li a img::attr(alt)").getall()
+
+        return MovieInfo(
+            url         = url,
+            poster      = poster,
+            title       = self.clean_title(title) if title else "",
+            description = description.strip() if description else None,
+            tags        = tags,
+            year        = year,
+            rating      = rating,
+            duration    = int(duration) if duration else None,
+            actors      = actors,
+        )
+
+    async def load_links(self, url: str) -> list[dict]:
+        istek  = await self.cffi.get(url)
+        secici = Selector(istek.text)
+
+        results = []
+
+        for player in secici.css("div#tv-spoox2"):
+            iframe = self.fix_url(player.css("iframe::attr(src)").get())
+
+            if iframe:
+                extractor = self.ex_manager.find_extractor(iframe)
+                results.append({
+                    "name"    : extractor.name if extractor else "Player",
+                    "url"     : iframe,
+                    "referer" : f"{self.main_url}/"
+                })
+
+        return results