KekikStream 0.2.3__py3-none-any.whl → 0.5.7__py3-none-any.whl

KekikStream/CLI/__init__.py

@@ -1,4 +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 .check_update import check_and_update_package
+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

@@ -2,6 +2,7 @@
 
 from abc              import ABC, abstractmethod
 from httpx            import AsyncClient, Timeout
+from cloudscraper     import CloudScraper
 from typing           import Optional
 from .ExtractorModels import ExtractResult
 
@@ -15,8 +16,9 @@ class ExtractorBase(ABC):
                 "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),
+            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."""
@@ -28,4 +30,13 @@ class ExtractorBase(ABC):
         pass
 
     async def close(self):
-        await self.oturum.aclose()
+        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

@@ -3,41 +3,60 @@
 from ..CLI          import konsol, cikis_yap
 from .ExtractorBase import ExtractorBase
 from pathlib        import Path
-import importlib.util
-import os
+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.extractors_dir}[/red]")
+            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]")
-            extractors.extend(self._load_from_directory(self.global_extractors_dir))
+            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]")
-            extractors.extend(self._load_from_directory(self.local_extractors_dir))
+            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)
 
-        if not extractors:
-            konsol.print("[yellow][!] Yüklenecek bir Extractor bulunamadı![/yellow]")
+        # 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)
 
-        return extractors
+        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):
@@ -50,12 +69,14 @@ class ExtractorLoader:
             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 isinstance(obj, type) and issubclass(obj, ExtractorBase) and obj is not ExtractorBase:
+                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.print(f"[red][!] Extractor yüklenirken hata oluştu: {module_name}\nHata: {hata}")
+            konsol.log(f"[red][!] Extractor yüklenirken hata oluştu: {module_name}\nHata: {hata}")
 
         return None

KekikStream/Core/ExtractorModels.py

@@ -3,11 +3,13 @@
 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

KekikStream/Core/MediaHandler.py

@@ -2,24 +2,34 @@
 
 from ..CLI            import konsol
 from .ExtractorModels import ExtractResult
-import subprocess
+import subprocess, os
 
 class MediaHandler:
-    def __init__(self, title: str = "KekikStream", headers: dict = {"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5)"}):
+    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 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:
-            if "Cookie" in self.headers or extract_data.subtitles:
-                self.play_with_mpv(extract_data)
-                return
-
-            vlc_command = ["vlc"]
+            vlc_command = ["vlc", "--quiet"]
 
             if self.title:
-                vlc_command.append(f"--meta-title={self.title}")
-                vlc_command.append(f"--input-title-format={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')}")
@@ -27,13 +37,16 @@ class MediaHandler:
             if "Referer" in self.headers:
                 vlc_command.append(f"--http-referrer={self.headers.get('Referer')}")
 
-            for subtitle in extract_data.subtitles:
-                vlc_command.append(f"--sub-file={subtitle.url}")
-
+            vlc_command.extend(
+                f"--sub-file={subtitle.url}" for subtitle in extract_data.subtitles
+            )
             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]")
+
+            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]")
@@ -41,28 +54,55 @@ class MediaHandler:
 
     def play_with_mpv(self, extract_data: ExtractResult):
         try:
-            mpv_command = ["mpv"]
+            mpv_command = ["mpv", "--really-quiet"]
 
             if self.title:
-                mpv_command.append(f"--title={self.title}")
+                mpv_command.append(f"--force-media-title={self.title}")
 
-            if "User-Agent" in self.headers:
-                mpv_command.append(f"--http-header-fields=User-Agent: {self.headers.get('User-Agent')}")
+            for key, value in self.headers.items():
+                mpv_command.append(f"--http-header-fields={key}: {value}")
 
-            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.extend(
+                f"--sub-file={subtitle.url}" for subtitle in extract_data.subtitles
+            )
+            mpv_command.append(extract_data.url)
 
-            for subtitle in extract_data.subtitles:
-                mpv_command.append(f"--sub-file={subtitle.url}")
+            with open(os.devnull, "w") as devnull:
+                subprocess.run(mpv_command, stdout=devnull, stderr=devnull, check=True)
 
-            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 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_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

@@ -2,6 +2,7 @@
 
 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
@@ -21,6 +22,9 @@ class PluginBase(ABC):
             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]:
@@ -43,14 +47,11 @@ class PluginBase(ABC):
     def fix_url(self, url: str) -> str:
         if not url:
             return ""
-        
+
         if url.startswith("http") or url.startswith("{\""):
             return url
 
-        if url.startswith("//"):
-            return f"https:{url}"
-
-        return urljoin(self.main_url, url)
+        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
 
     @staticmethod
     def clean_title(title: str) -> str:

KekikStream/Core/PluginLoader.py

@@ -3,9 +3,7 @@
 from ..CLI       import konsol, cikis_yap
 from .PluginBase import PluginBase
 from pathlib     import Path
-import importlib.util
-import os
-import traceback
+import os, importlib.util, traceback
 
 class PluginLoader:
     def __init__(self, plugins_dir: str):
@@ -20,11 +18,11 @@ class PluginLoader:
 
         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))
+            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.update(self._load_from_directory(self.local_plugins_dir))
+            plugins |= self._load_from_directory(self.local_plugins_dir)
 
         if not plugins:
             konsol.print("[yellow][!] Yüklenecek bir Plugin bulunamadı![/yellow]")

KekikStream/Core/PluginModels.py

@@ -23,17 +23,12 @@ class MovieInfo(BaseModel):
     actors      : Optional[str] = None
     duration    : Optional[int] = None
 
-    @field_validator("tags", mode="before")
+    @field_validator("tags", "actors", mode="before")
     @classmethod
-    def convert_tags(cls, value):
+    def convert_lists(cls, value):
         return ", ".join(value) if isinstance(value, list) else value
 
-    @field_validator("actors", mode="before")
-    @classmethod
-    def convert_actors(cls, value):
-        return ", ".join(value) if isinstance(value, list) else value
-
-    @field_validator("rating", mode="before")
+    @field_validator("rating", "year", mode="before")
     @classmethod
     def ensure_string(cls, value):
         return str(value) if value is not None else value
@@ -57,17 +52,12 @@ class SeriesInfo(BaseModel):
     actors       : Optional[str]           = None
     episodes     : Optional[List[Episode]] = None
 
-    @field_validator("tags", mode="before")
-    @classmethod
-    def convert_tags(cls, value):
-        return ", ".join(value) if isinstance(value, list) else value
-
-    @field_validator("actors", mode="before")
+    @field_validator("tags", "actors", mode="before")
     @classmethod
-    def convert_actors(cls, value):
+    def convert_lists(cls, value):
         return ", ".join(value) if isinstance(value, list) else value
 
-    @field_validator("rating", mode="before")
+    @field_validator("rating", "year", mode="before")
     @classmethod
     def ensure_string(cls, value):
         return str(value) if value is not None else value

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"

KekikStream/Extractors/FourPlayRu.py

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

KekikStream/Extractors/HDStreamAble.py

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

KekikStream/Extractors/Hotlinger.py

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

KekikStream/Extractors/MixPlayHD.py

@@ -0,0 +1,42 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from Kekik.Sifreleme import AESManager
+import re, json
+
+class MixPlayHD(ExtractorBase):
+    name     = "MixPlayHD"
+    main_url = "https://mixplayhd.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()
+
+        be_player_match = re.search(r"bePlayer\('([^']+)',\s*'(\{[^\}]+\})'\);", istek.text)
+        if not be_player_match:
+            raise ValueError("bePlayer not found in the response.")
+
+        be_player_pass = be_player_match[1]
+        be_player_data = be_player_match[2]
+
+        try:
+            decrypted_data = AESManager.decrypt(be_player_data, be_player_pass).replace("\\", "")
+            decrypted_json = json.loads(decrypted_data)
+        except Exception as hata:
+            raise RuntimeError(f"Decryption failed: {hata}") from hata
+
+        if video_url_match := re.search(
+            pattern = r'"video_location":"([^"]+)"',
+            string  = decrypted_json.get("schedule", {}).get("client", ""),
+        ):
+            return ExtractResult(
+                name      = self.name,
+                url       = video_url_match[1],
+                referer   = self.main_url,
+                subtitles = []
+            )
+        else:
+            raise ValueError("M3U8 video URL not found in the decrypted data.")