KekikStream 1.4.4__py3-none-any.whl → 2.0.2__py3-none-any.whl

KekikStream/Core/Plugin/PluginModels.py

@@ -1,34 +1,33 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from pydantic import BaseModel, field_validator, model_validator
-from typing   import List, Optional
 
 class MainPageResult(BaseModel):
     """Ana sayfa sonucunda dönecek veri modeli."""
     category : str
     title    : str
     url      : str
-    poster   : Optional[str] = None
+    poster   : str | None = None
 
 
 class SearchResult(BaseModel):
     """Arama sonucunda dönecek veri modeli."""
     title  : str
     url    : str
-    poster : Optional[str] = None
+    poster : str | None = 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
+    poster      : str | None = None
+    title       : str | None = None
+    description : str | None = None
+    tags        : str | None = None
+    rating      : str | None = None
+    year        : str | None = None
+    actors      : str | None = None
+    duration    : int | None = None
 
     @field_validator("tags", "actors", mode="before")
     @classmethod
@@ -42,10 +41,10 @@ class MovieInfo(BaseModel):
 
 
 class Episode(BaseModel):
-    season  : Optional[int] = None
-    episode : Optional[int] = None
-    title   : Optional[str] = None
-    url     : Optional[str] = None
+    season  : int | None = None
+    episode : int | None = None
+    title   : str | None = None
+    url     : str | None = None
 
     @model_validator(mode="after")
     def check_title(self) -> "Episode":
@@ -58,15 +57,16 @@ class Episode(BaseModel):
         return self
 
 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
+    url          : str | None           = None
+    poster       : str | None           = None
+    title        : str | None           = None
+    description  : str | None           = None
+    tags         : str | None           = None
+    rating       : str | None           = None
+    year         : str | None           = None
+    actors       : str | None           = None
+    duration     : int | None           = None
+    episodes     : list[Episode] | None = None
 
     @field_validator("tags", "actors", mode="before")
     @classmethod
@@ -76,4 +76,4 @@ class SeriesInfo(BaseModel):
     @field_validator("rating", "year", mode="before")
     @classmethod
     def ensure_string(cls, value):
-        return str(value) if value is not None else value
+        return str(value) if value is not None else value

KekikStream/Core/__init__.py

@@ -13,6 +13,7 @@ from .Extractor.ExtractorManager import ExtractorManager
 from .Extractor.ExtractorBase    import ExtractorBase
 from .Extractor.ExtractorLoader  import ExtractorLoader
 from .Extractor.ExtractorModels  import ExtractResult, Subtitle
+from .Extractor.YTDLPCache       import get_ytdlp_extractors
 
 from .Media.MediaManager import MediaManager
 from .Media.MediaHandler import MediaHandler

KekikStream/Extractors/CloseLoad.py

@@ -1,31 +1,12 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core           import ExtractorBase, ExtractResult
-from KekikStream.Helpers.Unpack import unpack
-import re, base64
-
-def get_m3u_link(data: str) -> str:
-    first = base64.b64decode(data)
-    first_reversed = first[::-1]
-    
-    second = base64.b64decode(first_reversed)
-    
-    parts = second.decode('utf-8').split("|")
-    if len(parts) < 2:
-        raise ValueError("Decoded data has an unexpected format.")
-    
-    return parts[1]
-
-def extract_data(raw_script: str) -> str:
-    pattern = re.compile(r'return result\}var .*?=.*?\("(.*?)"\)')
-    if match := pattern.search(raw_script):
-        return match[1]
-    else:
-        raise Exception("data not found")
+from KekikStream.Core import ExtractorBase, ExtractResult
+from Kekik.Sifreleme  import Packer, StreamDecoder
+import re
 
 class CloseLoadExtractor(ExtractorBase):
     name     = "CloseLoad"
-    main_url = "https://closeload.filmmakinesi.de"
+    main_url = "https://closeload.filmmakinesi.to"
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
@@ -35,12 +16,11 @@ class CloseLoadExtractor(ExtractorBase):
         istek.raise_for_status()
 
         eval_func = re.compile(r'\s*(eval\(function[\s\S].*)\s*').findall(istek.text)[0]
-        m3u_link  = get_m3u_link(extract_data(unpack(eval_func)))
+        m3u_link  = StreamDecoder.extract_stream_url(Packer.unpack(eval_func))
 
-        await self.close()
         return ExtractResult(
             name      = self.name,
             url       = m3u_link,
             referer   = self.main_url,
             subtitles = []
-        )
+        )

KekikStream/Extractors/ContentX_.py

@@ -0,0 +1,40 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Extractors.ContentX import ContentX
+
+# DPlayer82 Family - https://dplayer82.site subdomains
+class SNDPlayer(ContentX):
+    name     = "SNDPlayer"
+    main_url = "https://sn.dplayer82.site"
+
+class FourDPlayer(ContentX):
+    name     = "FourDPlayer"
+    main_url = "https://four.dplayer82.site"
+
+class ORGDPlayer(ContentX):
+    name     = "ORGDPlayer"
+    main_url = "https://org.dplayer82.site"
+
+# Hotlinger
+class Hotlinger(ContentX):
+    name     = "Hotlinger"
+    main_url = "https://hotlinger.com"
+
+# Pichive Family
+class Pichive(ContentX):
+    name     = "Pichive"
+    main_url = "https://pichive.me"
+
+class FourPichive(ContentX):
+    name     = "FourPichive"
+    main_url = "https://four.pichive.me"
+
+# PlayRu Family
+class FourPlayRu(ContentX):
+    name     = "FourPlayRu"
+    main_url = "https://four.playru.net"
+
+# CX Family
+class FourCX(ContentX):
+    name     = "FourCX"
+    main_url = "https://four.contentx.me"

KekikStream/Extractors/DzenRu.py

@@ -0,0 +1,38 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+import re
+
+class DzenRu(ExtractorBase):
+    name     = "DzenRu"
+    main_url = "https://dzen.ru"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        video_key = url.split("/")[-1]
+        video_url = f"{self.main_url}/embed/{video_key}"
+
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        istek = await self.httpx.get(video_url)
+        istek.raise_for_status()
+
+        # okcdn.ru linklerini bul
+        matches = re.findall(r'https://vd\d+\.okcdn\.ru/\?[^"\'\\\s]+', istek.text)
+
+        if not matches:
+            raise ValueError("DzenRu video link not found")
+
+        # Benzersiz linkleri al, son kaliteyi kullan
+        unique_links = list(set(matches))
+        best_link    = unique_links[-1] if unique_links else None
+
+        if not best_link:
+            raise ValueError("No valid video URL found")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = best_link,
+            referer   = self.main_url,
+            subtitles = []
+        )

KekikStream/Extractors/ExPlay.py

@@ -0,0 +1,53 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re
+from urllib.parse import urlparse, parse_qs
+
+class ExPlay(ExtractorBase):
+    name     = "ExPlay"
+    main_url = "https://explay.store"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref = referer or ""
+        
+        # URL parsing for partKey
+        parsed = urlparse(url)
+        params = parse_qs(parsed.query)
+        part_key = params.get("partKey", [""])[0]
+        clean_url = url.split("?partKey=")[0]
+
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        istek = await self.httpx.get(clean_url)
+        istek.raise_for_status()
+
+        # videoUrl çıkar
+        video_url_match = re.search(r'videoUrl":"([^",]+)"', istek.text)
+        if not video_url_match:
+            raise ValueError("videoUrl not found")
+        video_url = video_url_match[1].replace("\\", "")
+
+        # videoServer çıkar
+        video_server_match = re.search(r'videoServer":"([^",]+)"', istek.text)
+        if not video_server_match:
+            raise ValueError("videoServer not found")
+        video_server = video_server_match[1]
+
+        # title çıkar
+        title_match = re.search(r'title":"([^",]+)"', istek.text)
+        title = title_match[1].split(".")[-1] if title_match else "Unknown"
+        
+        if part_key and "turkce" in part_key.lower():
+             title = part_key # Or nicer formatting like SetPlay
+
+        # M3U8 link oluştur
+        m3u_link = f"{self.main_url}{video_url}?s={video_server}"
+
+        return ExtractResult(
+            name      = f"{self.name} - {title}",
+            url       = m3u_link,
+            referer   = clean_url, 
+            subtitles = []
+        )

KekikStream/Extractors/FirePlayer.py

@@ -0,0 +1,60 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from Kekik.Sifreleme  import Packer
+import re
+
+class FirePlayer(ExtractorBase):
+    name     = "FirePlayer"
+    main_url = "https://Player.filmizle.in"
+
+    def can_handle_url(self, url: str) -> bool:
+        return "filmizle.in" in url or "fireplayer" in url.lower()
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        if not referer:
+            referer = "https://sinezy.site/"
+            
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "Referer": referer
+        }
+
+        istek  = await self.httpx.get(url, headers=headers)
+        
+        # Unpack usage similar to VidMoxy / suggestion
+        # Find the packed code block
+        match = re.search(r'(eval\(function\(p,a,c,k,e,d\)[\s\S]+?)\s*</script>', istek.text)
+        if match:
+            packed_code = match.group(1)
+            unpacked    = Packer.unpack(packed_code)
+        else:
+            unpacked = istek.text
+
+        # Normalize escaped slashes
+        unpacked = unpacked.replace(r"\/", "/")
+        
+        video_url = None
+        
+        # Look for .mp4 or .m3u8 urls directly first
+        url_match = re.search(r'(https?://[^"\'\s]+\.(?:mp4|m3u8))', unpacked)
+        if url_match:
+             video_url = url_match.group(1)
+        
+        if not video_url:
+             # Fallback: find all 'file': '...' and pick best
+             files = re.findall(r'file\s*:\s*["\']([^"\']+)["\']', unpacked)
+             for f in files:
+                 if f.strip() and not f.endswith(".jpg") and not f.endswith(".png") and not f.endswith(".vtt"):
+                     video_url = f
+                     break
+
+        if not video_url:
+             raise ValueError("Could not find video URL in unpacked content")
+
+        return ExtractResult(
+            name       = self.name,
+            url        = video_url,
+            referer    = url,
+            user_agent = headers.get("User-Agent", "")
+        )

KekikStream/Extractors/HDPlayerSystem.py

@@ -0,0 +1,41 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+
+class HDPlayerSystem(ExtractorBase):
+    name     = "HDPlayerSystem"
+    main_url = "https://hdplayersystem.com"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref = referer or ""
+
+        if "video/" in url:
+            vid_id = url.split("video/")[-1]
+        else:
+            vid_id = url.split("?data=")[-1]
+
+        post_url = f"{self.main_url}/player/index.php?data={vid_id}&do=getVideo"
+
+        response = await self.httpx.post(
+            url     = post_url,
+            data    = {"hash": vid_id, "r": ext_ref},
+            headers = {
+                "Referer"          : ext_ref,
+                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+                "X-Requested-With" : "XMLHttpRequest"
+            }
+        )
+        response.raise_for_status()
+
+        video_data = response.json()
+        m3u_link   = video_data.get("securedLink")
+
+        if not m3u_link:
+            raise ValueError("securedLink not found in response")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = url,
+            subtitles = []
+        )

KekikStream/Extractors/JetTv.py

@@ -0,0 +1,45 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+import re, json
+
+class JetTv(ExtractorBase):
+    name     = "JetTv"
+    main_url = "https://jetv.xyz"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        istek    = await self.httpx.get(url)
+        document = istek.text
+
+        # 1. Yöntem: API üzerinden alma
+        master_url = ""
+        final_ref  = f"{self.main_url}/"
+
+        if "id=" in url:
+            vid_id = url.split("id=")[-1]
+            api_url = f"https://jetv.xyz/apollo/get_video.php?id={vid_id}"
+            try:
+                # Referer olarak video sayfasının kendisi gönderilmeli
+                api_resp = await self.httpx.get(api_url, headers={"Referer": url})
+                api_json = api_resp.json()
+                
+                if api_json.get("success"):
+                     master_url = api_json.get("masterUrl", "")
+                     final_ref  = api_json.get("referrerUrl") or final_ref
+            except Exception:
+                pass
+
+        # 2. Yöntem: Regex Fallback
+        if not master_url:
+             if match := re.search(r"file: '([^']*)'", document, re.IGNORECASE):
+                 master_url = match.group(1)
+        
+        if not master_url:
+            raise ValueError(f"JetTv: Video kaynağı bulunamadı. {url}")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = master_url,
+            referer   = final_ref,
+            subtitles = []
+        )

KekikStream/Extractors/MailRu.py

@@ -30,11 +30,9 @@ class MailRuExtractor(ExtractorBase):
         if video_url.startswith("//"):
             video_url = f"https:{video_url}"
 
-        await self.close()
         return ExtractResult(
             name      = self.name,
             url       = video_url,
             referer   = self.main_url,
-            subtitles = [],
-            headers   = {"Cookie": f"video_key={video_key}"}
-        )
+            subtitles = []
+        )

KekikStream/Extractors/MixTiger.py

@@ -0,0 +1,57 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+
+class MixTiger(ExtractorBase):
+    name     = "MixTiger"
+    main_url = "https://www.mixtiger.com"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        ext_ref  = referer or ""
+        post_url = f"{url}?do=getVideo"
+        vid_id   = url.split("video/")[-1] if "video/" in url else ""
+
+        response = await self.httpx.post(
+            url     = post_url,
+            data    = {"hash": vid_id, "r": ext_ref, "s": ""},
+            headers = {
+                "Referer"          : ext_ref,
+                "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8",
+                "X-Requested-With" : "XMLHttpRequest"
+            }
+        )
+        response.raise_for_status()
+
+        video_data = response.json()
+
+        # videoSrc varsa doğrudan kullan
+        if video_data.get("videoSrc"):
+            m3u_link = video_data["videoSrc"]
+        # videoSources listesi varsa son elemanı al
+        elif video_data.get("videoSources"):
+            sources  = video_data["videoSources"]
+            m3u_link = sources[-1].get("file") if sources else None
+        else:
+            m3u_link = None
+
+        if not m3u_link:
+            raise ValueError("Video URL not found in response")
+
+        # Recursive extraction check
+        try:
+            from KekikStream.Core.Extractor.ExtractorManager import ExtractorManager
+            # Import inside method to avoid circular dependency
+            manager = ExtractorManager()
+            if nested_extractor := manager.find_extractor(m3u_link):
+                # Use recursive extraction
+                return await nested_extractor.extract(m3u_link, referer=final_referer)
+        except Exception:
+            # If recursion fails, fallback to standard result
+            pass
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = None if "disk.yandex" in m3u_link else ext_ref,
+            subtitles = []
+        )

KekikStream/Extractors/MolyStream.py

@@ -1,16 +1,34 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import ExtractorBase, ExtractResult
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from parsel           import Selector
+import re
 
 class MolyStream(ExtractorBase):
     name     = "MolyStream"
     main_url = "https://dbx.molystream.org"
 
     async def extract(self, url, referer=None) -> ExtractResult:
+        if "doctype html" in url:
+            secici = Selector(url)
+            video  = secici.css("video#sheplayer source::attr(src)").get()
+        else:
+            video = url
+
+        matches = re.findall(
+            pattern = r"addSrtFile\(['\"]([^'\"]+\.srt)['\"]\s*,\s*['\"][a-z]{2}['\"]\s*,\s*['\"]([^'\"]+)['\"]",
+            string  = url
+        )
+
+        subtitles = [
+            Subtitle(name = name, url = self.fix_url(url))
+                for url, name in matches
+        ]
+
         return ExtractResult(
-            name      = self.name,
-            url       = url,
-            referer   = url.replace("/sheila", ""),
-            headers   = {"User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0"},
-            subtitles = []
-        )
+            name       = self.name,
+            url        = video,
+            referer    = video.replace("/sheila", ""),
+            user_agent = "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0",
+            subtitles  = subtitles
+        )

KekikStream/Extractors/Odnoklassniki.py

@@ -8,16 +8,20 @@ class Odnoklassniki(ExtractorBase):
     main_url = "https://odnoklassniki.ru"
 
     async def extract(self, url, referer=None) -> ExtractResult:
-        if referer:
-            self.httpx.headers.update({"Referer": referer})
-
-        self.httpx.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/")
 
+        headers = {
+            "Accept"         : "*/*",
+            "Connection"     : "keep-alive",
+            "Sec-Fetch-Dest" : "empty",
+            "Sec-Fetch-Mode" : "cors",
+            "Sec-Fetch-Site" : "cross-site",
+            "Origin"         : self.main_url,
+            "User-Agent"     : "Mozilla/5.0 (X11; Linux x86_64; rv:101.0) Gecko/20100101 Firefox/101.0",
+        }
+        self.httpx.headers.update(headers)
+
         try:
             istek = await self.fetch_with_redirects(url)
             istek.raise_for_status()
@@ -78,10 +82,11 @@ class Odnoklassniki(ExtractorBase):
             best_video = f"https:{best_video}"
 
         return ExtractResult(
-            name      = self.name,
-            url       = best_video,
-            referer   = self.main_url,
-            subtitles = []
+            name       = self.name,
+            url        = best_video,
+            referer    = referer,
+            user_agent = headers.get("User-Agent", None),
+            subtitles  = []
         )
 
     async def fetch_with_redirects(self, url, max_redirects=5):

KekikStream/Extractors/{OkRuHTTP.py → Odnoklassniki_.py}

@@ -4,4 +4,8 @@ from KekikStream.Extractors.Odnoklassniki import Odnoklassniki
 
 class OkRuHTTP(Odnoklassniki):
     name     = "OkRuHTTP"
-    main_url = "http://ok.ru"
+    main_url = "http://ok.ru"
+
+class OkRuSSL(Odnoklassniki):
+    name     = "OkRuSSL"
+    main_url = "https://ok.ru"

KekikStream/Extractors/{HDStreamAble.py → PeaceMakerst_.py}

@@ -4,4 +4,4 @@ from KekikStream.Extractors.PeaceMakerst import PeaceMakerst
 
 class HDStreamAble(PeaceMakerst):
     name     = "HDStreamAble"
-    main_url = "https://hdstreamable.com"
+    main_url = "https://hdstreamable.com"

KekikStream/Extractors/PixelDrain.py

@@ -19,7 +19,6 @@ class PixelDrain(ExtractorBase):
         download_link = f"{self.main_url}/api/file/{pixel_id}?download"
         referer_link  = f"{self.main_url}/u/{pixel_id}?download"
 
-        await self.close()
         return ExtractResult(
             name      = f"{self.name} - {pixel_id}",
             url       = download_link,