KekikStream 0.2.0__tar.gz → 0.5.3__tar.gz

{kekikstream-0.2.0 → kekikstream-0.5.3}/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-0.5.3/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-0.2.0 → kekikstream-0.5.3}/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-0.5.3/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-0.2.0 → kekikstream-0.5.3}/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-0.5.3/KekikStream/Core/MediaHandler.py

@@ -0,0 +1,108 @@
+# 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 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_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-0.2.0 → kekikstream-0.5.3}/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-0.2.0 → kekikstream-0.5.3}/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-0.2.0 → kekikstream-0.5.3}/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-0.5.3/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-0.5.3/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-0.5.3/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-0.5.3/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-0.5.3/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-0.5.3/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-0.5.3/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.")

kekikstream-0.5.3/KekikStream/Extractors/Odnoklassniki.py

@@ -0,0 +1,106 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+import re, json
+
+class Odnoklassniki(ExtractorBase):
+    name     = "Odnoklassniki"
+    main_url = "https://odnoklassniki.ru"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if referer:
+            self.oturum.headers.update({"Referer": referer})
+
+        self.oturum.headers.update({
+            "User-Agent": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Mobile Safari/537.36"
+        })
+
+        if "/video/" in url:
+            url = url.replace("/video/", "/videoembed/")
+
+        try:
+            istek = await self.fetch_with_redirects(url)
+            istek.raise_for_status()
+        except Exception as hata:
+            raise RuntimeError(f"Failed to fetch the URL: {url}, Error: {hata}") from hata
+
+        response_text = (
+            istek.text.replace("\\"", "\"")
+                      .replace("\\\\", "\\")
+                      .replace(r"\\u", "\\u")
+        )
+        response_text = re.sub(
+            r"\\u([0-9A-Fa-f]{4})", 
+            lambda match: chr(int(match[1], 16)), 
+            response_text
+        )
+
+        videos_match = re.search(r'"videos":(\[.*?\])', response_text)
+        if not videos_match:
+            raise ValueError("No video data found in the response.")
+
+        try:
+            videos = json.loads(videos_match[1])
+        except json.JSONDecodeError as hata:
+            raise ValueError("Failed to parse video data.") from hata
+
+        quality_order = {
+            "ULTRA": 6,  # 4K veya daha yüksek
+            "QUAD": 5,   # 1440p
+            "FULL": 4,   # 1080p
+            "HD": 3,     # 720p
+            "SD": 2,     # 480p
+            "LOW": 1,    # 360p
+            "MOBILE": 0  # 144p
+        }
+
+        # Kaliteye göre en iyi videoyu seçme
+        best_video = None
+        best_quality_score = -1
+
+        for video in videos:
+            video_url    = video.get("url")
+            quality_name = video.get("name", "").upper()
+
+            if not video_url or not quality_name:
+                continue
+
+            # Kalite sıralamasına göre puanla
+            quality_score = quality_order.get(quality_name, -1)
+            if quality_score > best_quality_score:
+                best_quality_score = quality_score
+                best_video         = video_url
+
+        if not best_video:
+            raise ValueError("No valid video URLs found.")
+
+        if best_video.startswith("//"):
+            best_video = f"https:{best_video}"
+
+        return ExtractResult(
+            name      = self.name,
+            url       = best_video,
+            referer   = self.main_url,
+            subtitles = []
+        )
+
+    async def fetch_with_redirects(self, url, max_redirects=5):
+        """Yönlendirmeleri takip eden bir fonksiyon"""
+        redirects = 0
+        while redirects < max_redirects:
+            istek = await self.oturum.get(url, follow_redirects=False)
+
+            if istek.status_code not in [301, 302]:
+                break  # Yönlendirme yoksa çık
+
+            redirected_url = istek.headers.get("Location")
+            if not redirected_url:
+                raise ValueError("Redirect location not found.")
+
+            url = redirected_url if redirected_url.startswith("http") else f"https://{redirected_url}"
+            redirects += 1
+
+        if redirects == max_redirects:
+            raise RuntimeError(f"Max redirects ({max_redirects}) reached.")
+
+        return istek

kekikstream-0.5.3/KekikStream/Extractors/OkRuHTTP.py

@@ -0,0 +1,7 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Extractors.Odnoklassniki import Odnoklassniki
+
+class OkRuHTTP(Odnoklassniki):
+    name     = "OkRuHTTP"
+    main_url = "http://ok.ru"