KekikStream 0.7.1__py3-none-any.whl

KekikStream/Extractors/VidMoly.py

@@ -0,0 +1,85 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+# ! https://github.com/recloudstream/cloudstream/blob/master/library/src/commonMain/kotlin/com/lagradost/cloudstream3/extractors/Vidmoly.kt
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re, asyncio, contextlib, json
+
+class VidMoly(ExtractorBase):
+    name     = "VidMoly"
+    main_url = "https://vidmoly.to"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        if referer:
+            self.oturum.headers.update({"Referer": referer})
+
+        self.oturum.headers.update({
+            "User-Agent"     : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+            "Sec-Fetch-Dest" : "iframe",
+        })
+
+        # Embed URL oluştur
+        embed_url      = url.replace("/w/", "/embed-") + "-920x360.html" if "/w/" in url else url
+        script_content = None
+        attempts       = 0
+
+        # Script verisini almak için deneme yap
+        while attempts < 10 and not script_content:
+            attempts += 1
+            response = await self.oturum.get(embed_url)
+            response.raise_for_status()
+
+            script_match   = re.search(r"sources:\s*\[(.*?)\],", response.text, re.DOTALL)
+            script_content = script_match[1] if script_match else None
+            if not script_content:
+                await asyncio.sleep(0.5)
+
+        if not script_content:
+            raise ValueError("Gerekli script bulunamadı.")
+
+        # Video kaynaklarını ayrıştır
+        video_data = self._add_marks(script_content, "file")
+        try:
+            video_sources = json.loads(f"[{video_data}]")
+        except json.JSONDecodeError as hata:
+            raise ValueError("Video kaynakları ayrıştırılamadı.") from hata
+
+        # Altyazı kaynaklarını ayrıştır
+        subtitles = []
+        if subtitle_match := re.search(r"tracks:\s*\[(.*?)\]", response.text, re.DOTALL):
+            subtitle_data = self._add_marks(subtitle_match[1], "file")
+            subtitle_data = self._add_marks(subtitle_data, "label")
+            subtitle_data = self._add_marks(subtitle_data, "kind")
+
+            with contextlib.suppress(json.JSONDecodeError):
+                subtitle_sources = json.loads(f"[{subtitle_data}]")
+                subtitles = [
+                    Subtitle(
+                        name = sub.get("label"),
+                        url  = self.fix_url(sub.get("file")),
+                    )
+                        for sub in subtitle_sources
+                            if sub.get("kind") == "captions"
+                ]
+        # İlk video kaynağını al
+        video_url = None
+        for source in video_sources:
+            if file_url := source.get("file"):
+                video_url = file_url
+                break
+
+        if not video_url:
+            raise ValueError("Video URL bulunamadı.")
+
+        await self.close()
+        return ExtractResult(
+            name      = self.name,
+            url       = video_url,
+            referer   = self.main_url,
+            subtitles = subtitles
+        )
+
+    def _add_marks(self, text: str, field: str) -> str:
+        """
+        Verilen alanı çift tırnak içine alır.
+        """
+        return re.sub(rf"\"?{field}\"?", f"\"{field}\"", text)

KekikStream/Extractors/VidMoxy.py

@@ -0,0 +1,50 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from Kekik.Sifreleme  import Packer, HexCodec
+import re
+
+class VidMoxy(ExtractorBase):
+    name     = "VidMoxy"
+    main_url = "https://vidmoxy.com"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if referer:
+            self.oturum.headers.update({"Referer": referer})
+
+        istek = await self.oturum.get(url)
+        istek.raise_for_status()
+
+        subtitles        = []
+        subtitle_matches = re.findall(r'captions","file":"([^"]+)","label":"([^"]+)"', istek.text)
+        seen_subtitles   = set()
+
+        for sub_url, sub_lang in subtitle_matches:
+            if sub_url in seen_subtitles:
+                continue
+
+            seen_subtitles.add(sub_url)
+            decoded_lang = (
+                sub_lang.replace("\\u0131", "ı")
+                        .replace("\\u0130", "İ")
+                        .replace("\\u00fc", "ü")
+                        .replace("\\u00e7", "ç")
+            )
+            subtitles.append(Subtitle(name=decoded_lang, url=sub_url.replace("\\", "")))
+
+        try:
+            escaped_hex = re.findall(r'file": "(.*)",', istek.text)[0]
+        except Exception:
+            eval_jwsetup = re.compile(r'\};\s*(eval\(function[\s\S]*?)var played = \d+;').findall(istek.text)[0]
+            jwsetup      = Packer.unpack(Packer.unpack(eval_jwsetup))
+            escaped_hex  = re.findall(r'file":"(.*)","label', jwsetup)[0]
+
+        m3u_link = HexCodec.decode(escaped_hex)
+
+        await self.close()
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = self.main_url,
+            subtitles = subtitles
+        )

KekikStream/Extractors/VideoSeyred.py

@@ -0,0 +1,47 @@
+# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import json
+
+class VideoSeyred(ExtractorBase):
+    name     = "VideoSeyred"
+    main_url = "https://videoseyred.in"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if referer:
+            self.oturum.headers.update({"Referer": referer})
+
+        video_id  = url.split("embed/")[1].split("?")[0]
+        video_url = f"{self.main_url}/playlist/{video_id}.json"
+
+        response = await self.oturum.get(video_url)
+        response.raise_for_status()
+
+        try:
+            if response_list := json.loads(response.text):
+                response_data = response_list[0]
+            else:
+                raise ValueError("Empty response from VideoSeyred.")
+
+        except (json.JSONDecodeError, IndexError) as hata:
+            raise RuntimeError(f"Failed to parse response: {hata}") from hata
+
+        subtitles = [
+            Subtitle(name=track["label"], url=self.fix_url(track["file"]))
+                for track in response_data.get("tracks", [])
+                    if track.get("kind") == "captions" and track.get("label")
+        ]
+
+        if video_links := [
+            ExtractResult(
+                name      = self.name,
+                url       = self.fix_url(source["file"]),
+                referer   = self.main_url,
+                subtitles = subtitles,
+            )
+                for source in response_data.get("sources", [])
+        ]:
+            # En yüksek kaliteli videoyu döndür (varsayılan olarak ilk video)
+            return video_links[0] if len(video_links) == 1 else video_links
+        else:
+            raise ValueError("No video links found in the response.")

KekikStream/Managers/ExtractorManager.py

@@ -0,0 +1,27 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from ..Core import ExtractorLoader, ExtractorBase
+
+class ExtractorManager:
+    def __init__(self, extractor_dir="Extractors"):
+        self.extractor_loader = ExtractorLoader(extractor_dir)
+        self.extractors       = self.extractor_loader.load_all()
+
+    def find_extractor(self, link):
+        for extractor_cls in self.extractors:
+            extractor:ExtractorBase = extractor_cls()
+            if extractor.can_handle_url(link):
+                return extractor
+
+        return None
+
+    def map_links_to_extractors(self, links):
+        mapping = {}
+        for link in links:
+            for extractor_cls in self.extractors:
+                extractor:ExtractorBase = extractor_cls()
+                if extractor.can_handle_url(link):
+                    mapping[link] = f"{extractor.name:<30} » {link.replace(extractor.main_url, '')}"
+                    break
+
+        return mapping

KekikStream/Managers/MediaManager.py

@@ -0,0 +1,19 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from ..Core import MediaHandler
+
+class MediaManager:
+    def __init__(self):
+        self.media_handler = MediaHandler()
+
+    def set_title(self, title):
+        self.media_handler.title = title
+
+    def get_title(self):
+        return self.media_handler.title
+
+    def set_headers(self, headers):
+        self.media_handler.headers.update(headers)
+
+    def play_media(self, extract_data):
+        self.media_handler.play_media(extract_data)

KekikStream/Managers/PluginManager.py

@@ -0,0 +1,19 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from ..Core import PluginLoader, PluginBase
+
+class PluginManager:
+    def __init__(self, plugin_dir="Plugins"):
+        self.plugin_loader = PluginLoader(plugin_dir)
+        self.plugins       = self.plugin_loader.load_all()
+
+    def get_plugin_names(self):
+        return sorted(list(self.plugins.keys()))
+
+    def select_plugin(self, plugin_name):
+        return self.plugins.get(plugin_name)
+
+    async def close_plugins(self):
+        for plugin in self.plugins.values():
+            if isinstance(plugin, PluginBase):
+                await plugin.close()

KekikStream/Managers/UIManager.py

@@ -0,0 +1,49 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from ..CLI      import konsol
+from rich.panel import Panel
+from rich.table import Table
+from InquirerPy import inquirer
+import os
+
+class UIManager:
+    @staticmethod
+    def clear_console():
+        # return True
+        os.system("cls" if os.name == "nt" else "clear")
+
+    @staticmethod
+    async def select_from_list(message, choices):
+        return await inquirer.select(message=message, choices=choices, max_height="75%").execute_async()
+
+    @staticmethod
+    async def select_from_fuzzy(message, choices):
+        return await inquirer.fuzzy(
+            message    = message,
+            choices    = choices,
+            validate   = lambda result: result in [choice if isinstance(choice, str) else choice["value"] for choice in choices],
+            filter     = lambda result: result,
+            max_height = "75%"
+        ).execute_async()
+
+    @staticmethod
+    async def prompt_text(message):
+        return await inquirer.text(message=message).execute_async()
+
+    @staticmethod
+    def display_media_info(plugin_name, media_info):
+        table = Table(show_header=False, box=None)
+        table.add_column(justify="right", style="cyan", no_wrap=True)
+        table.add_column(style="magenta")
+
+        for key, value in media_info.dict().items():
+            if key == "episodes":
+                continue
+
+            if isinstance(value, str):
+                if '",' in value:
+                    continue
+
+                table.add_row(f"[bold cyan]{key.capitalize()}[/bold cyan]", str(value))
+
+        konsol.print(Panel(table, title=f"[bold green]{plugin_name}[/bold green]", expand=False))

KekikStream/Managers/__init__.py

@@ -0,0 +1,6 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from .PluginManager    import PluginManager
+from .ExtractorManager import ExtractorManager
+from .UIManager        import UIManager
+from .MediaManager     import MediaManager

KekikStream/Plugins/DiziBox.py

@@ -0,0 +1,143 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, SearchResult, SeriesInfo, Episode
+from Kekik.Sifreleme  import CryptoJS
+from parsel           import Selector
+import re, urllib.parse, base64, contextlib, asyncio
+
+class DiziBox(PluginBase):
+    name     = "DiziBox"
+    main_url = "https://www.dizibox.plus"
+
+    async def search(self, query: str) -> list[SearchResult]:
+        self.oturum.cookies.update({
+            "LockUser"      : "true",
+            "isTrustedUser" : "true",
+            "dbxu"          : "1722403730363"
+        })
+        istek  = await self.oturum.get(f"{self.main_url}/?s={query}")
+        secici = Selector(istek.text)
+
+        return [
+            SearchResult(
+                title  = item.css("h3 a::text").get(),
+                url    = self.fix_url(item.css("h3 a::attr(href)").get()),
+                poster = self.fix_url(item.css("img::attr(src)").get()),
+            )
+                for item in secici.css("article.detailed-article")
+        ]
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.oturum.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("div.tv-overview h1 a::text").get()
+        poster      = self.fix_url(secici.css("div.tv-overview figure img::attr(src)").get())
+        description = secici.css("div.tv-story p::text").get()
+        year        = secici.css("a[href*='/yil/']::text").re_first(r"(\d{4})")
+        tags        = secici.css("a[href*='/tur/']::text").getall()
+        rating      = secici.css("span.label-imdb b::text").re_first(r"[\d.,]+")
+        actors      = [actor.css("::text").get() for actor in secici.css("a[href*='/oyuncu/']")]
+
+        episodes = []
+        for sezon_link in secici.css("div#seasons-list a::attr(href)").getall():
+            sezon_url    = self.fix_url(sezon_link)
+            sezon_istek  = await self.oturum.get(sezon_url)
+            sezon_secici = Selector(sezon_istek.text)
+
+            for bolum in sezon_secici.css("article.grid-box"):
+                ep_secici  = bolum.css("div.post-title a::text")
+
+                ep_title   = ep_secici.get()
+                ep_href    = self.fix_url(bolum.css("div.post-title a::attr(href)").get())
+                ep_season  = ep_secici.re_first(r"(\d+)\. ?Sezon")
+                ep_episode = ep_secici.re_first(r"(\d+)\. ?Bölüm")
+
+                if ep_title and ep_href:
+                    episodes.append(Episode(
+                        season  = ep_season,
+                        episode = ep_episode,
+                        title   = ep_title.strip(),
+                        url     = ep_href,
+                    ))
+
+        return SeriesInfo(
+            url         = url,
+            poster      = poster,
+            title       = title,
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            year        = year,
+            episodes    = episodes,
+            actors      = actors,
+        )
+
+    async def _iframe_decode(self, name:str, iframe_link:str, referer:str) -> list[str]:
+        results = []
+
+        if "/player/king/king.php" in iframe_link:
+            iframe_link = iframe_link.replace("king.php?v=", "king.php?wmode=opaque&v=")
+            self.oturum.headers.update({"Referer": referer})
+
+            istek  = await self.oturum.get(iframe_link)
+            secici = Selector(istek.text)
+            iframe = secici.css("div#Player iframe::attr(src)").get()
+
+            self.oturum.headers.update({"Referer": self.main_url})
+            istek = await self.oturum.get(iframe)
+
+            crypt_data = re.search(r"CryptoJS\.AES\.decrypt\(\"(.*)\",\"", istek.text)[1]
+            crypt_pass = re.search(r"\",\"(.*)\"\);", istek.text)[1]
+
+            results.append(CryptoJS.decrypt(crypt_pass, crypt_data))
+
+        elif "/player/moly/moly.php" in iframe_link:
+            iframe_link = iframe_link.replace("moly.php?h=", "moly.php?wmode=opaque&h=")
+            self.oturum.headers.update({"Referer": referer})
+            while True:
+                await asyncio.sleep(.3)
+                with contextlib.suppress(Exception):
+                    istek  = await self.oturum.get(iframe_link)
+
+                    if atob_data := re.search(r"unescape\(\"(.*)\"\)", istek.text):
+                        decoded_atob = urllib.parse.unquote(atob_data[1])
+                        str_atob     = base64.b64decode(decoded_atob).decode("utf-8")
+
+                    if iframe := Selector(str_atob).css("div#Player iframe::attr(src)").get():
+                        results.append(iframe)
+
+                    break
+
+        elif "/player/haydi.php" in iframe_link:
+            okru_url = base64.b64decode(iframe_link.split("?v=")[-1]).decode("utf-8")
+            results.append(okru_url)
+
+        return results
+
+    async def load_links(self, url: str) -> list[str]:
+        istek  = await self.oturum.get(url)
+        secici = Selector(istek.text)
+
+        iframes = []
+        if main_iframe := secici.css("div#video-area iframe::attr(src)").get():
+            if decoded := await self._iframe_decode(self.name, main_iframe, url):
+                iframes.extend(decoded)
+
+        for alternatif in secici.css("div.video-toolbar option[value]"):
+            alt_name = alternatif.css("::text").get()
+            alt_link = alternatif.css("::attr(value)").get()
+
+            if not alt_link:
+                continue
+
+            self.oturum.headers.update({"Referer": url})
+            alt_istek = await self.oturum.get(alt_link)
+            alt_istek.raise_for_status()
+
+            alt_secici = Selector(alt_istek.text)
+            if alt_iframe := alt_secici.css("div#video-area iframe::attr(src)").get():
+                if decoded := await self._iframe_decode(alt_name, alt_iframe, url):
+                    iframes.extend(decoded)
+
+        return iframes

KekikStream/Plugins/DiziYou.py

@@ -0,0 +1,127 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, SearchResult, SeriesInfo, Episode, Subtitle, ExtractResult
+from parsel           import Selector
+import re
+
+class DiziYou(PluginBase):
+    name     = "DiziYou"
+    main_url = "https://www.diziyou.co"
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek  = await self.oturum.get(f"{self.main_url}/?s={query}")
+        secici = Selector(istek.text)
+
+        return [
+            SearchResult(
+                title  = afis.css("div#categorytitle a::text").get().strip(),
+                url    = self.fix_url(afis.css("div#categorytitle a::attr(href)").get()),
+                poster = self.fix_url(afis.css("img::attr(src)").get()),
+            )
+                for afis in secici.css("div.incontent div#list-series")
+        ]
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.oturum.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("h1::text").get().strip()
+        poster      = self.fix_url(secici.css("div.category_image img::attr(src)").get().strip())
+        year        = secici.xpath("//span[contains(., 'Yapım Yılı')]/following-sibling::text()[1]").get()
+        description = secici.css("div.diziyou_desc::text").get().strip()
+        tags        = secici.css("div.genres a::text").getall()
+        rating      = secici.xpath("//span[contains(., 'IMDB')]/following-sibling::text()[1]").get()
+        _actors     = secici.xpath("//span[contains(., 'Oyuncular')]/following-sibling::text()[1]").get()
+        actors      = [actor.strip() for actor in _actors.split(",")] if _actors else []
+
+        episodes    = []
+        for it in secici.css("div.bolumust"):
+            ep_name = it.css("div.baslik::text").get().strip()
+            ep_href = it.xpath("ancestor::a/@href").get()
+            if not ep_name or not ep_href:
+                continue
+
+            ep_name_clean = it.css("div.bolumismi::text").get().strip().replace("(", "").replace(")", "").strip() if it.css("div.bolumismi::text").get() else ep_name
+
+            ep_episode = re.search(r"(\d+)\. Bölüm", ep_name)[1]
+            ep_season  = re.search(r"(\d+)\. Sezon", ep_name)[1]
+
+            episode = Episode(
+                season  = ep_season,
+                episode = ep_episode,
+                title   = ep_name_clean,
+                url     = ep_href,
+            )
+
+            episodes.append(episode)
+
+        return SeriesInfo(
+            url         = url,
+            poster      = poster,
+            title       = title,
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            year        = year,
+            episodes    = episodes,
+            actors      = actors
+        )
+
+    async def load_links(self, url: str) -> list[str]:
+        istek  = await self.oturum.get(url)
+        secici = Selector(istek.text)
+
+        item_title = secici.css("div.title h1::text").get().strip()
+        item_id    = secici.css("iframe#diziyouPlayer::attr(src)").get().split("/")[-1].replace(".html", "")
+
+        subtitles   = []
+        stream_urls = []
+
+        for secenek in secici.css("span.diziyouOption"):
+            opt_id  = secenek.css("::attr(id)").get()
+            op_name = secenek.css("::text").get()
+
+            match opt_id:
+                case "turkceAltyazili":
+                    subtitles.append(Subtitle(
+                        name = op_name,
+                        url  = self.fix_url(f"https://storage.diziyou.co/subtitles/{item_id}/tr.vtt"),
+                    ))
+                    veri = {
+                        "dil": "Orjinal Dil",
+                        "url": f"https://storage.diziyou.co/episodes/{item_id}/play.m3u8"
+                    }
+                    if veri not in stream_urls:
+                        stream_urls.append(veri)
+                case "ingilizceAltyazili":
+                    subtitles.append(Subtitle(
+                        name = op_name,
+                        url  = self.fix_url(f"https://storage.diziyou.co/subtitles/{item_id}/en.vtt"),
+                    ))
+                    veri = {
+                        "dil": "Orjinal Dil",
+                        "url": f"https://storage.diziyou.co/episodes/{item_id}/play.m3u8"
+                    }
+                    if veri not in stream_urls:
+                        stream_urls.append(veri)
+                case "turkceDublaj":
+                    stream_urls.append({
+                        "dil": "Dublaj",
+                        "url": f"https://storage.diziyou.co/episodes/{item_id}_tr/play.m3u8"
+                    })
+
+
+        for stream in stream_urls:
+            self._data[stream.get("url")] = {
+                "name"      : f"{self.name} | {stream.get('dil')} | {item_title}",
+                "ext_name"  : f"{self.name} | {stream.get('dil')}",
+                "referer"   : url,
+                "subtitles" : subtitles
+            }
+
+        return [stream.get("url") for stream in stream_urls]
+
+    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
+        self.media_handler.play_media(extract_result)