KekikStream 0.0.1__py3-none-any.whl

KekikStream/CLI/__init__.py

@@ -0,0 +1,3 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from Kekik.cli import konsol, cikis_yap, hata_salla, log_salla, hata_yakala, bellek_temizle, temizle

KekikStream/Core/ExtractorBase.py

@@ -0,0 +1,18 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from abc              import ABC, abstractmethod
+from typing           import Optional
+from .ExtractorModels import ExtractResult
+
+class ExtractorBase(ABC):
+    name     = "Extractor"
+    main_url = ""
+
+    def can_handle_url(self, url: str) -> bool:
+        """URL'nin bu extractor tarafından işlenip işlenemeyeceğini kontrol eder."""
+        return self.main_url in url
+
+    @abstractmethod
+    async def extract(self, url: str, referer: Optional[str] = None) -> ExtractResult:
+        """Bir URL'den medya bilgilerini çıkarır."""
+        pass

KekikStream/Core/ExtractorLoader.py

@@ -0,0 +1,61 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from ..CLI          import konsol, cikis_yap
+from .ExtractorBase import ExtractorBase
+from pathlib        import Path
+import importlib.util
+import os
+
+class ExtractorLoader:
+    def __init__(self, extractors_dir: str):
+        self.local_extractors_dir  = Path(extractors_dir)
+        self.global_extractors_dir = Path(__file__).parent.parent / extractors_dir
+        if not self.local_extractors_dir.exists() and not self.global_extractors_dir.exists():
+            konsol.log(f"[red][!] Extractor dizini bulunamadı: {self.extractors_dir}[/red]")
+            cikis_yap(False)
+
+    def load_all(self) -> list[ExtractorBase]:
+        extractors = []
+
+        if self.global_extractors_dir.exists():
+            konsol.log(f"[green][*] Global Extractor dizininden yükleniyor: {self.global_extractors_dir}[/green]")
+            extractors.extend(self._load_from_directory(self.global_extractors_dir))
+
+        if self.local_extractors_dir.exists():
+            konsol.log(f"[green][*] Yerel Extractor dizininden yükleniyor: {self.local_extractors_dir}[/green]")
+            extractors.extend(self._load_from_directory(self.local_extractors_dir))
+
+        if not extractors:
+            konsol.print("[yellow][!] Yüklenecek bir Extractor bulunamadı![/yellow]")
+
+        return extractors
+
+    def _load_from_directory(self, directory: Path) -> list[ExtractorBase]:
+        extractors = []
+        for file in os.listdir(directory):
+            if file.endswith(".py") and not file.startswith("__"):
+                module_name = file[:-3]
+                if extractor := self._load_extractor(directory, module_name):
+                    extractors.append(extractor)
+
+        return extractors
+
+    def _load_extractor(self, directory: Path, module_name: str):
+        try:
+            path = directory / f"{module_name}.py"
+            spec = importlib.util.spec_from_file_location(module_name, path)
+            if not spec or not spec.loader:
+                return None
+
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            for attr in dir(module):
+                obj = getattr(module, attr)
+                if isinstance(obj, type) and issubclass(obj, ExtractorBase) and obj is not ExtractorBase:
+                    return obj
+
+        except Exception as hata:
+            konsol.print(f"[red][!] Extractor yüklenirken hata oluştu: {module_name}\nHata: {hata}")
+
+        return None

KekikStream/Core/ExtractorModels.py

@@ -0,0 +1,17 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from pydantic import BaseModel
+from typing   import List, Optional
+
+class Subtitle(BaseModel):
+    """Altyazı modeli."""
+    name : str
+    url  : str
+
+class ExtractResult(BaseModel):
+    """Extractor'ın döndürmesi gereken sonuç modeli."""
+    name      : str
+    url       : str
+    referer   : str
+    subtitles : List[Subtitle] = []
+    headers   : Optional[dict] = {}

KekikStream/Core/MediaHandler.py

@@ -0,0 +1,58 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from ..CLI            import konsol
+from .ExtractorModels import ExtractResult
+import subprocess
+
+class MediaHandler:
+    def __init__(self, title: str = "KekikStream", headers: dict = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5)"}):
+        self.headers = headers
+        self.title   = title
+
+    def play_with_vlc(self, extract_data: ExtractResult):
+        try:
+            if "Cookie" in self.headers:
+                self.play_with_mpv(extract_data)
+                return
+
+            vlc_command = ["vlc"]
+
+            if self.title:
+                vlc_command.append(f"--meta-title={self.title}")
+                vlc_command.append(f"--input-title-format={self.title}")
+
+            if "User-Agent" in self.headers:
+                vlc_command.append(f"--http-user-agent={self.headers.get('User-Agent')}")
+
+            if "Referer" in self.headers:
+                vlc_command.append(f"--http-referrer={self.headers.get('Referer')}")
+
+            vlc_command.append(extract_data.url)
+            subprocess.run(vlc_command, check=True)
+        except subprocess.CalledProcessError as e:
+            konsol.print(f"[red]VLC oynatma hatası: {e}[/red]")
+        except FileNotFoundError:
+            konsol.print("[red]VLC bulunamadı! VLC kurulu olduğundan emin olun.[/red]")
+
+    def play_with_mpv(self, extract_data: ExtractResult):
+        try:
+            mpv_command = ["mpv"]
+
+            if self.title:
+                mpv_command.append(f"--title={self.title}")
+
+            if "User-Agent" in self.headers:
+                mpv_command.append(f"--http-header-fields=User-Agent: {self.headers.get('User-Agent')}")
+
+            if "Referer" in self.headers:
+                mpv_command.append(f"--http-header-fields=Referer: {self.headers.get('Referer')}")
+
+            if "Cookie" in self.headers:
+                mpv_command.append(f"--http-header-fields=Cookie: {self.headers.get('Cookie')}")
+
+            mpv_command.append(extract_data.url)
+            subprocess.run(mpv_command, check=True)
+        except subprocess.CalledProcessError as e:
+            konsol.print(f"[red]mpv oynatma hatası: {e}[/red]")
+        except FileNotFoundError:
+            konsol.print("[red]mpv bulunamadı! mpv kurulu olduğundan emin olun.[/red]")

KekikStream/Core/PluginBase.py

@@ -0,0 +1,42 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from abc           import ABC, abstractmethod
+from httpx         import AsyncClient, Timeout
+from .PluginModels import SearchResult, MovieInfo
+
+class PluginBase(ABC):
+    name     = "Plugin"
+    main_url = "https://example.com"
+
+    def __init__(self):
+        self.oturum = AsyncClient(
+            headers = {
+                "User-Agent" : "keyiflerolsun/KekikStream",
+                "Accept"     : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            },
+            timeout = Timeout(10.0),
+        )
+
+    @abstractmethod
+    async def search(self, query: str) -> list[SearchResult]:
+        """Kullanıcı arama sorgusuna göre sonuç döndürür."""
+        pass
+
+    @abstractmethod
+    async def load_item(self, url: str) -> MovieInfo:
+        """Bir medya öğesi hakkında detaylı bilgi döndürür."""
+        pass
+
+    @abstractmethod
+    async def load_links(self, url: str) -> list[str]:
+        """Bir medya öğesi için oynatma bağlantılarını döndürür."""
+        pass
+
+    async def close(self):
+        await self.oturum.aclose()
+
+    def fix_url(self, partial_url: str):
+        if partial_url.startswith("http"):
+            return partial_url
+
+        return self.main_url.rstrip("/") + "/" + partial_url.lstrip("/")

KekikStream/Core/PluginLoader.py

@@ -0,0 +1,63 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from ..CLI       import konsol, cikis_yap
+from .PluginBase import PluginBase
+from pathlib     import Path
+import importlib.util
+import os
+import traceback
+
+class PluginLoader:
+    def __init__(self, plugins_dir: str):
+        self.local_plugins_dir  = Path(plugins_dir).resolve()
+        self.global_plugins_dir = Path(__file__).parent.parent / plugins_dir
+        if not self.local_plugins_dir.exists() and not self.global_plugins_dir.exists():
+            konsol.log(f"[red][!] Extractor dizini bulunamadı: {self.plugins_dir}[/red]")
+            cikis_yap(False)
+
+    def load_all(self) -> dict[str, PluginBase]:
+        plugins = {}
+
+        if self.global_plugins_dir.exists():
+            konsol.log(f"[green][*] Global Plugin dizininden yükleniyor: {self.global_plugins_dir}[/green]")
+            plugins.update(self._load_from_directory(self.global_plugins_dir))
+
+        if self.local_plugins_dir.exists():
+            konsol.log(f"[green][*] Yerel Plugin dizininden yükleniyor: {self.local_plugins_dir}[/green]")
+            plugins.update(self._load_from_directory(self.local_plugins_dir))
+
+        if not plugins:
+            konsol.print("[yellow][!] Yüklenecek bir Plugin bulunamadı![/yellow]")
+
+        return plugins
+
+    def _load_from_directory(self, directory: Path) -> dict[str, PluginBase]:
+        plugins = {}
+        for file in os.listdir(directory):
+            if file.endswith(".py") and not file.startswith("__"):
+                module_name = file[:-3]
+                if plugin := self._load_plugin(directory, module_name):
+                    plugins[module_name] = plugin
+
+        return plugins
+
+    def _load_plugin(self, directory: Path, module_name: str):
+        try:
+            path = directory / f"{module_name}.py"
+            spec = importlib.util.spec_from_file_location(module_name, path)
+            if not spec or not spec.loader:
+                raise ImportError(f"Spec oluşturulamadı: {module_name}")
+
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            for attr in dir(module):
+                obj = getattr(module, attr)
+                if isinstance(obj, type) and issubclass(obj, PluginBase) and obj is not PluginBase:
+                    return obj()
+
+        except Exception as hata:
+            konsol.print(f"[red][!] Plugin yüklenirken hata oluştu: {module_name}\nHata: {hata}")
+            konsol.print(f"[dim]{traceback.format_exc()}[/dim]")
+
+        return None

KekikStream/Core/PluginModels.py

@@ -0,0 +1,32 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from pydantic import BaseModel, validator
+from typing   import Optional
+
+
+class SearchResult(BaseModel):
+    """Arama sonucunda dönecek veri modeli."""
+    title  : str
+    url    : str
+    poster : Optional[str] = None
+
+
+class MovieInfo(BaseModel):
+    """Bir medya öğesinin bilgilerini tutan model."""
+    url         : str
+    poster      : Optional[str] = None
+    title       : Optional[str] = None
+    description : Optional[str] = None
+    tags        : Optional[str] = None
+    rating      : Optional[str] = None
+    year        : Optional[str] = None
+    actors      : Optional[str] = None
+    duration    : Optional[int] = None
+
+    @validator("tags", pre=True)
+    def convert_tags(cls, value):
+        return ", ".join(value) if isinstance(value, list) else value
+
+    @validator("actors", pre=True)
+    def convert_actors(cls, value):
+        return ", ".join(value) if isinstance(value, list) else value

KekikStream/Core/__init__.py

@@ -0,0 +1,9 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from .PluginBase      import PluginBase
+from .PluginLoader    import PluginLoader
+from .PluginModels    import SearchResult, MovieInfo
+from .ExtractorBase   import ExtractorBase
+from .ExtractorLoader import ExtractorLoader
+from .ExtractorModels import ExtractResult
+from .MediaHandler    import MediaHandler

KekikStream/Extractors/CloseLoad.py

@@ -0,0 +1,30 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from parsel           import Selector
+from httpx            import AsyncClient
+from base64           import b64decode
+
+class CloseLoadExtractor(ExtractorBase):
+    name     = "CloseLoad"
+    main_url = "https://closeload.filmmakinesi.de"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        """Bir URL'den medya bilgilerini çıkarır."""
+        async with AsyncClient() as client:
+            response = await client.get(url, headers={"Referer": referer} if referer else {})
+            response.raise_for_status()
+
+        selector = Selector(response.text)
+        atob     = selector.re(r"aHR0[0-9a-zA-Z+/=]*")
+        if not atob:
+            raise ValueError("Base64 kodu bulunamadı.")
+
+        m3u_link = b64decode(f"{atob[0]}===").decode("utf-8")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = self.main_url,
+            subtitles = []
+        )

KekikStream/Extractors/MailRu.py

@@ -0,0 +1,40 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from httpx            import AsyncClient
+import json
+
+class MailRuExtractor(ExtractorBase):
+    name     = "MailRu"
+    main_url = "https://my.mail.ru"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        """Mail.Ru URL'sinden medya bilgilerini çıkarır."""
+        vid_id         = url.split("video/embed/")[-1].strip()
+        video_meta_url = f"{self.main_url}/+/video/meta/{vid_id}"
+
+        async with AsyncClient() as client:
+            response = await client.get(video_meta_url, headers={"Referer": url} if referer else {})
+            response.raise_for_status()
+
+            video_key = response.cookies.get("video_key")
+            if not video_key:
+                raise ValueError("Video key bulunamadı.")
+
+            video_data = json.loads(response.text)
+            videos     = video_data.get("videos", [])
+            if not videos:
+                raise ValueError("Videolar bulunamadı.")
+
+            video     = videos[0]
+            video_url = video["url"]
+            if video_url.startswith("//"):
+                video_url = f"https:{video_url}"
+
+            return ExtractResult(
+                name      = self.name,
+                url       = video_url,
+                referer   = self.main_url,
+                subtitles = [],
+                headers   = {"Cookie": f"video_key={video_key}"}
+            )

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] = extractor.name
+                    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_with_vlc(extract_data)

KekikStream/Managers/PluginManager.py

@@ -0,0 +1,18 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from ..Core import PluginLoader
+
+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 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():
+            await plugin.close()

KekikStream/Managers/UIManager.py

@@ -0,0 +1,32 @@
+# 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():
+        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).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 value:
+                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/FilmMakinesi.py

@@ -0,0 +1,65 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, SearchResult, MovieInfo
+from parsel           import Selector
+
+class FilmMakinesi(PluginBase):
+    name     = "FilmMakinesi"
+    main_url = "https://filmmakinesi.de"
+
+    async def search(self, query: str) -> list[SearchResult]:
+        response = await self.oturum.get(f"{self.main_url}/?s={query}")
+        selector = Selector(response.text)
+
+        results = []
+        for article in selector.css("section#film_posts article"):
+            title  = article.css("h6 a::text").get()
+            href   = article.css("h6 a::attr(href)").get()
+            poster = article.css("img::attr(data-src)").get() or article.css("img::attr(src)").get()
+
+            if title and href:
+                results.append(
+                    SearchResult(
+                        title  = title.strip(),
+                        url    = self.fix_url(href.strip()),
+                        poster = self.fix_url(poster.strip()) if poster else None,
+                    )
+                )
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo:
+        response = await self.oturum.get(url)
+        selector = Selector(response.text)
+
+        title       = selector.css("h1.single_h1 a::text").get(default="").strip()
+        poster      = selector.css("[property='og:image']::attr(content)").get(default="").strip()
+        description = selector.css("section#film_single article p:last-of-type::text").get(default="").strip()
+        tags        = selector.css("dt:contains('Tür:') + dd a::text").get(default="").strip()
+        rating      = selector.css("dt:contains('IMDB Puanı:') + dd::text").get(default="").strip()
+        year        = selector.css("dt:contains('Yapım Yılı:') + dd a::text").get(default="").strip()
+        actors      = selector.css("dt:contains('Oyuncular:') + dd::text").get(default="").strip()
+        duration    = selector.css("dt:contains('Film Süresi:') + dd time::attr(datetime)").get(default="").strip()
+
+        duration_minutes = 0
+        if duration and duration.startswith("PT") and duration.endswith("M"):
+            duration_minutes = int(duration[2:-1])
+
+        return MovieInfo(
+            url         = url,
+            poster      = self.fix_url(poster),
+            title       = title,
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            year        = year,
+            actors      = actors,
+            duration    = duration_minutes
+        )
+
+    async def load_links(self, url: str) -> list[str]:
+        response = await self.oturum.get(url)
+        selector = Selector(response.text)
+
+        iframe_src = selector.css("div.player-div iframe::attr(src)").get() or selector.css("div.player-div iframe::attr(data-src)").get()
+        return [self.fix_url(iframe_src)] if iframe_src else []

KekikStream/Plugins/UgurFilm.py

@@ -0,0 +1,75 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, SearchResult, MovieInfo
+from parsel           import Selector
+
+class UgurFilm(PluginBase):
+    name     = "UgurFilm"
+    main_url = "https://ugurfilm8.com"
+
+    async def search(self, query: str) -> list[SearchResult]:
+        response = await self.oturum.get(f"{self.main_url}/?s={query}")
+        selector = Selector(response.text)
+
+        results = []
+        for article in selector.css("div.icerik div"):
+            title  = article.css("span:nth-child(1)::text").get()
+            href   = article.css("a::attr(href)").get()
+            poster = article.css("img::attr(src)").get()
+
+            if title and href:
+                results.append(
+                    SearchResult(
+                        title  = title.strip(),
+                        url    = self.fix_url(href.strip()),
+                        poster = self.fix_url(poster.strip()) if poster else None,
+                    )
+                )
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo:
+        response = await self.oturum.get(url)
+        selector = Selector(response.text)
+
+        title       = selector.css("div.bilgi h2::text").get(default="").strip()
+        poster      = selector.css("div.resim img::attr(src)").get(default="").strip()
+        description = selector.css("div.slayt-aciklama::text").get(default="").strip()
+        tags        = selector.css("p.tur a[href*='/category/']::text").getall()
+        year        = selector.css("a[href*='/yil/']::text").re_first(r"\d+")
+        actors      = [actor.css("span::text").get() for actor in selector.css("li.oyuncu-k")]
+
+        return MovieInfo(
+            url         = self.fix_url(url),
+            poster      = self.fix_url(poster),
+            title       = title,
+            description = description,
+            tags        = tags,
+            year        = year,
+            actors      = actors,
+        )
+
+    async def load_links(self, url: str) -> list[str]:
+        response = await self.oturum.get(url)
+        selector = Selector(response.text)
+        results  = []
+
+        for part_link in selector.css("li.parttab a::attr(href)").getall():
+            sub_response = await self.oturum.get(part_link)
+            sub_selector = Selector(sub_response.text)
+
+            iframe = sub_selector.css("div#vast iframe::attr(src)").get()
+            if iframe and self.main_url in iframe:
+                post_data = {
+                    "vid"         : iframe.split("vid=")[-1],
+                    "alternative" : "default",
+                    "ord"         : "1",
+                }
+                player_response = await self.oturum.post(
+                    url  = f"{self.main_url}/player/ajax_sources.php",
+                    data = post_data
+                )
+                iframe = player_response.json().get("iframe")
+                results.append(iframe)
+
+        return results