KekikStream 0.7.1__py3-none-any.whl

KekikStream/CLI/__init__.py

@@ -0,0 +1,4 @@
+# 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
+from .pypi_kontrol import pypi_kontrol_guncelle

KekikStream/CLI/pypi_kontrol.py

@@ -0,0 +1,30 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from .             import konsol
+from rich.panel    import Panel
+from pkg_resources import get_distribution
+from requests      import get
+from subprocess    import check_call
+import sys
+
+def pypi_kontrol_guncelle(paket_adi: str):
+    try:
+        konsol.print(f"[bold cyan] {paket_adi} Güncellemesi kontrol ediliyor...[/bold cyan]")
+        mevcut_surum = get_distribution(paket_adi).version
+        konsol.print(Panel(f"[cyan]Yüklü sürüm:[/cyan] [bold yellow]{mevcut_surum}[/bold yellow]"))
+
+        istek = get(f"https://pypi.org/pypi/{paket_adi}/json")
+        if istek.status_code == 200:
+            son_surum = istek.json()["info"]["version"]
+            konsol.print(Panel(f"[cyan]En son sürüm:[/cyan] [bold green]{son_surum}[/bold green]"))
+
+            if mevcut_surum != son_surum:
+                konsol.print(f"[bold red]{paket_adi} güncelleniyor...[/bold red]")
+                check_call([sys.executable, "-m", "pip", "install", "--upgrade", paket_adi, "--break-system-packages"])
+                konsol.print(f"[bold green]{paket_adi} güncellendi![/bold green]")
+            else:
+                konsol.print(f"[bold green]{paket_adi} zaten güncel.[/bold green]")
+        else:
+            konsol.print("[bold red]PyPI'ye erişilemiyor. Güncelleme kontrolü atlanıyor.[/bold red]")
+    except Exception as hata:
+        konsol.print(f"[bold red]Güncelleme kontrolü sırasında hata oluştu: {hata}[/bold red]")

KekikStream/Core/ExtractorBase.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 cloudscraper     import CloudScraper
+from typing           import Optional
+from .ExtractorModels import ExtractResult
+
+class ExtractorBase(ABC):
+    name     = "Extractor"
+    main_url = ""
+
+    def __init__(self):
+        self.oturum = AsyncClient(
+            headers = {
+                "User-Agent" : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5)",
+                "Accept"     : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            },
+            timeout = Timeout(10.0)
+        )
+        self.cloudscraper  = CloudScraper()
+
+    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
+
+    async def close(self):
+        await self.oturum.aclose()
+
+    def fix_url(self, url: str) -> str:
+        if not url:
+            return ""
+
+        if url.startswith("http") or url.startswith("{\""):
+            return url
+
+        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)

KekikStream/Core/ExtractorLoader.py

@@ -0,0 +1,82 @@
+# 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 os, importlib.util
+
+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.global_extractors_dir}[/red]")
+            cikis_yap(False)
+
+    def load_all(self) -> list[ExtractorBase]:
+        extractors = []
+
+        # Global Extractor'ları yükle
+        if self.global_extractors_dir.exists():
+            konsol.log(f"[green][*] Global Extractor dizininden yükleniyor: {self.global_extractors_dir}[/green]")
+            global_extractors = self._load_from_directory(self.global_extractors_dir)
+            konsol.log(f"[green]Global Extractor'lar: {[e.__name__ for e in global_extractors]}[/green]")
+            extractors.extend(global_extractors)
+
+        # Yerel Extractor'ları yükle
+        if self.local_extractors_dir.exists():
+            konsol.log(f"[green][*] Yerel Extractor dizininden yükleniyor: {self.local_extractors_dir}[/green]")
+            local_extractors = self._load_from_directory(self.local_extractors_dir)
+            konsol.log(f"[green]Yerel Extractor'lar: {[e.__name__ for e in local_extractors]}[/green]")
+            extractors.extend(local_extractors)
+
+        # Benzersizliği sağlama (modül adı + sınıf adı bazında)
+        unique_extractors = []
+        seen = set()
+        for ext in extractors:
+            identifier = f"{ext.__module__}.{ext.__name__}"
+            if identifier not in seen:
+                unique_extractors.append(ext)
+                seen.add(identifier)
+
+        konsol.log(f"[blue]Sonuç Extractor'lar: {[e.__name__ for e in unique_extractors]}[/blue]")
+
+        if not unique_extractors:
+            konsol.log("[yellow][!] Yüklenecek bir Extractor bulunamadı![/yellow]")
+
+        return unique_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]
+                konsol.log(f"[cyan]Modül yükleniyor: {module_name}[/cyan]")
+                if extractor := self._load_extractor(directory, module_name):
+                    konsol.log(f"[magenta]Extractor bulundu: {extractor.__name__}[/magenta]")
+                    extractors.append(extractor)
+
+        konsol.log(f"[yellow]{directory} dizininden yüklenen Extractor'lar: {[e.__name__ for e in extractors]}[/yellow]")
+        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)
+
+            # Yalnızca doğru modülden gelen ExtractorBase sınıflarını yükle
+            for attr in dir(module):
+                obj = getattr(module, attr)
+                if obj.__module__ == module_name and isinstance(obj, type) and issubclass(obj, ExtractorBase) and obj is not ExtractorBase:
+                    konsol.log(f"[green]Yüklenen sınıf: {module_name}.{obj.__name__} ({obj.__module__}.{obj.__name__})[/green]")
+                    return obj
+
+        except Exception as hata:
+            konsol.log(f"[red][!] Extractor yüklenirken hata oluştu: {module_name}\nHata: {hata}")
+
+        return None

KekikStream/Core/ExtractorModels.py

@@ -0,0 +1,19 @@
+# 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,142 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from ..CLI            import konsol
+from .ExtractorModels import ExtractResult
+import subprocess, os
+
+class MediaHandler:
+    def __init__(self, title: str = "KekikStream", headers: dict = None):
+        if headers is None:
+            headers = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5)"}
+
+        self.headers = headers
+        self.title   = title
+
+    def play_media(self, extract_data: ExtractResult):
+        if self.headers.get("User-Agent") == "googleusercontent":
+            return self.play_with_ytdlp(extract_data)
+
+        if subprocess.check_output(['uname', '-o']).strip() == b'Android':
+            return self.play_with_android_mxplayer(extract_data)
+
+        if "Cookie" in self.headers or extract_data.subtitles:
+            return self.play_with_mpv(extract_data)
+
+        return self.play_with_vlc(extract_data)
+
+    def play_with_vlc(self, extract_data: ExtractResult):
+        try:
+            vlc_command = ["vlc", "--quiet"]
+
+            if self.title:
+                vlc_command.extend([
+                    f"--meta-title={self.title}",
+                    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.extend(
+                f"--sub-file={subtitle.url}" for subtitle in extract_data.subtitles
+            )
+            vlc_command.append(extract_data.url)
+
+            with open(os.devnull, "w") as devnull:
+                subprocess.run(vlc_command, stdout=devnull, stderr=devnull, check=True)
+
+        except subprocess.CalledProcessError as hata:
+            konsol.print(f"[red]VLC oynatma hatası: {hata}[/red]")
+            konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+        except FileNotFoundError:
+            konsol.print("[red]VLC bulunamadı! VLC kurulu olduğundan emin olun.[/red]")
+            konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+
+    def play_with_mpv(self, extract_data: ExtractResult):
+        try:
+            mpv_command = ["mpv", "--really-quiet"]
+
+            if self.title:
+                mpv_command.append(f"--force-media-title={self.title}")
+
+            for key, value in self.headers.items():
+                mpv_command.append(f"--http-header-fields={key}: {value}")
+
+            mpv_command.extend(
+                f"--sub-file={subtitle.url}" for subtitle in extract_data.subtitles
+            )
+            mpv_command.append(extract_data.url)
+
+            with open(os.devnull, "w") as devnull:
+                subprocess.run(mpv_command, stdout=devnull, stderr=devnull, check=True)
+
+        except subprocess.CalledProcessError as hata:
+            konsol.print(f"[red]mpv oynatma hatası: {hata}[/red]")
+            konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+        except FileNotFoundError:
+            konsol.print("[red]mpv bulunamadı! mpv kurulu olduğundan emin olun.[/red]")
+            konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+
+    def play_with_ytdlp(self, extract_data: ExtractResult):
+        try:
+            ytdlp_command = ["yt-dlp", "--quiet", "--no-warnings", "--downloader", "ffmpeg", "--hls-use-mpegts"]
+
+            for key, value in self.headers.items():
+                ytdlp_command.extend(["--add-header", f"{key}: {value}"])
+
+            ytdlp_command.extend([
+                "-o", "-",
+                extract_data.url
+            ])
+
+            mpv_command = ["mpv", "--really-quiet", "-"]
+
+            if self.title:
+                mpv_command.append(f"--force-media-title={self.title}")
+
+            mpv_command.extend(
+                f"--sub-file={subtitle.url}" for subtitle in extract_data.subtitles
+            )
+
+            with subprocess.Popen(ytdlp_command, stdout=subprocess.PIPE) as ytdlp_proc:
+                subprocess.run(mpv_command, stdin=ytdlp_proc.stdout, check=True)
+
+        except subprocess.CalledProcessError as hata:
+            print(f"[red]Oynatma hatası: {hata}[/red]")
+            print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+        except FileNotFoundError:
+            print("[red]yt-dlp veya mpv bulunamadı! Kurulumlarından emin olun.[/red]")
+            print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+
+    def play_with_android_mxplayer(self, extract_data: ExtractResult):
+        paketler = [
+            "com.mxtech.videoplayer.ad/.ActivityScreen",  # Free sürüm
+            "com.mxtech.videoplayer.pro/.ActivityScreen"  # Pro sürüm
+        ]
+
+        for paket in paketler:
+            try:
+                android_command = [
+                    "am", "start",
+                    "-a", "android.intent.action.VIEW",
+                    "-d", extract_data.url,
+                    "-n", paket
+                ]
+
+                if self.title:
+                    android_command.extend(["--es", "title", self.title])
+
+                with open(os.devnull, "w") as devnull:
+                    subprocess.run(android_command, stdout=devnull, stderr=devnull, check=True)
+
+                return
+
+            except subprocess.CalledProcessError as hata:
+                konsol.print(f"[red]{paket} oynatma hatası: {hata}[/red]")
+                konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            except FileNotFoundError:
+                konsol.print(f"Paket: {paket}, Hata: MX Player kurulu değil")
+                konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})

KekikStream/Core/PluginBase.py

@@ -0,0 +1,80 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from abc           import ABC, abstractmethod
+from httpx         import AsyncClient, Timeout
+from cloudscraper  import CloudScraper
+from .PluginModels import SearchResult, MovieInfo
+from .MediaHandler import MediaHandler
+from urllib.parse  import urljoin
+import re
+
+class PluginBase(ABC):
+    name     = "Plugin"
+    main_url = "https://example.com"
+    _data    = {}
+
+    def __init__(self):
+        self.oturum = AsyncClient(
+            headers = {
+                "User-Agent" : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5)",
+                "Accept"     : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+            },
+            timeout = Timeout(10.0),
+        )
+        self.media_handler = MediaHandler()
+        self.cloudscraper  = CloudScraper()
+        self.oturum.headers.update(self.cloudscraper.headers)
+        self.oturum.cookies.update(self.cloudscraper.cookies)
+
+    @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, url: str) -> str:
+        if not url:
+            return ""
+
+        if url.startswith("http") or url.startswith("{\""):
+            return url
+
+        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+
+    @staticmethod
+    def clean_title(title: str) -> str:
+        suffixes = [
+            " izle", 
+            " full film", 
+            " filmini full",
+            " full türkçe",
+            " alt yazılı", 
+            " altyazılı", 
+            " tr dublaj",
+            " hd türkçe",
+            " türkçe dublaj",
+            " yeşilçam ",
+            " erotik fil",
+            " türkçe",
+            " yerli",
+            " tüekçe dublaj",
+        ]
+
+        cleaned_title = title.strip()
+
+        for suffix in suffixes:
+            cleaned_title = re.sub(f"{re.escape(suffix)}.*$", "", cleaned_title, flags=re.IGNORECASE).strip()
+
+        return cleaned_title

KekikStream/Core/PluginLoader.py

@@ -0,0 +1,61 @@
+# 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 os, importlib.util, 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 |= 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 |= self._load_from_directory(self.local_plugins_dir)
+
+        if not plugins:
+            konsol.print("[yellow][!] Yüklenecek bir Plugin bulunamadı![/yellow]")
+
+        return dict(sorted(plugins.items()))
+
+    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,63 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from pydantic import BaseModel, field_validator
+from typing   import List, 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
+
+    @field_validator("tags", "actors", mode="before")
+    @classmethod
+    def convert_lists(cls, value):
+        return ", ".join(value) if isinstance(value, list) else value
+
+    @field_validator("rating", "year", mode="before")
+    @classmethod
+    def ensure_string(cls, value):
+        return str(value) if value is not None else value
+
+
+class Episode(BaseModel):
+    season  : Optional[int] = None
+    episode : Optional[int] = None
+    title   : Optional[str] = None
+    url     : Optional[str] = None
+
+
+class SeriesInfo(BaseModel):
+    url          : Optional[str]           = None
+    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
+    episodes     : Optional[List[Episode]] = None
+
+    @field_validator("tags", "actors", mode="before")
+    @classmethod
+    def convert_lists(cls, value):
+        return ", ".join(value) if isinstance(value, list) else value
+
+    @field_validator("rating", "year", mode="before")
+    @classmethod
+    def ensure_string(cls, value):
+        return str(value) if value is not None 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, Episode, SeriesInfo
+from .ExtractorBase   import ExtractorBase
+from .ExtractorLoader import ExtractorLoader
+from .ExtractorModels import ExtractResult, Subtitle
+from .MediaHandler    import MediaHandler

KekikStream/Extractors/CloseLoad.py

@@ -0,0 +1,31 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from parsel           import Selector
+from base64           import b64decode
+
+class CloseLoadExtractor(ExtractorBase):
+    name     = "CloseLoad"
+    main_url = "https://closeload.filmmakinesi.de"
+
+    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()
+
+        secici = Selector(istek.text)
+        atob   = secici.re(r"aHR0[0-9a-zA-Z+/=]*")
+        if not atob:
+            raise ValueError("Base64 kodu bulunamadı.")
+
+        m3u_link = b64decode(f"{atob[0]}===").decode("utf-8")
+
+        await self.close()
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = self.main_url,
+            subtitles = []
+        )

KekikStream/Extractors/ContentX.py

@@ -0,0 +1,80 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re
+
+class ContentX(ExtractorBase):
+    name     = "ContentX"
+    main_url = "https://contentx.me"
+
+    async def extract(self, url, referer=None) -> list[ExtractResult]:
+        if referer:
+            self.oturum.headers.update({"Referer": referer})
+
+        istek = await self.oturum.get(url)
+        istek.raise_for_status()
+        i_source = istek.text
+
+        i_extract = re.search(r"window\.openPlayer\('([^']+)'", i_source)
+        if not i_extract:
+            raise ValueError("i_extract is null")
+        i_extract_value = i_extract[1]
+
+        subtitles = []
+        sub_urls  = set()
+        for match in re.finditer(r'"file":"([^"]+)","label":"([^"]+)"', i_source):
+            sub_url, sub_lang = match.groups()
+
+            if sub_url in sub_urls:
+                continue
+
+            sub_urls.add(sub_url)
+            subtitles.append(
+                Subtitle(
+                    name = sub_lang.replace("\\u0131", "ı")
+                                 .replace("\\u0130", "İ")
+                                 .replace("\\u00fc", "ü")
+                                 .replace("\\u00e7", "ç"),
+                    url  = self.fix_url(sub_url.replace("\\", ""))
+                )
+            )
+
+        vid_source_request = await self.oturum.get(f"{self.main_url}/source2.php?v={i_extract_value}", headers={"Referer": referer or self.main_url})
+        vid_source_request.raise_for_status()
+
+        vid_source  = vid_source_request.text
+        vid_extract = re.search(r'file":"([^"]+)"', vid_source)
+        if not vid_extract:
+            raise ValueError("vidExtract is null")
+
+        m3u_link = vid_extract[1].replace("\\", "")
+        results  = [
+            ExtractResult(
+                name      = self.name,
+                url       = m3u_link,
+                referer   = url,
+                subtitles = subtitles
+            )
+        ]
+
+        if i_dublaj := re.search(r',\"([^"]+)\",\"Türkçe"', i_source):
+            dublaj_value          = i_dublaj[1]
+            dublaj_source_request = await self.oturum.get(f"{self.main_url}/source2.php?v={dublaj_value}", headers={"Referer": referer or self.main_url})
+            dublaj_source_request.raise_for_status()
+
+            dublaj_source  = dublaj_source_request.text
+            dublaj_extract = re.search(r'file":"([^"]+)"', dublaj_source)
+            if not dublaj_extract:
+                raise ValueError("dublajExtract is null")
+
+            dublaj_link = dublaj_extract[1].replace("\\", "")
+            results.append(
+                ExtractResult(
+                    name      = f"{self.name} Türkçe Dublaj",
+                    url       = dublaj_link,
+                    referer   = url,
+                    subtitles = []
+                )
+            )
+
+        return results[0] if len(results) == 1 else results

KekikStream/Extractors/FourCX.py

@@ -0,0 +1,7 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Extractors.ContentX import ContentX
+
+class FourCX(ContentX):
+    name     = "FourCX"
+    main_url = "https://four.contentx.me"

KekikStream/Extractors/FourPichive.py

@@ -0,0 +1,7 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Extractors.ContentX import ContentX
+
+class FourPichive(ContentX):
+    name     = "FourPichive"
+    main_url = "https://four.pichive.online"