KekikStream 2.4.0__tar.gz → 2.4.8__tar.gz

{kekikstream-2.4.0 → kekikstream-2.4.8}/KekikStream/Core/Extractor/ExtractorBase.py

@@ -49,6 +49,7 @@ class ExtractorBase(ABC):
             return ""
 
         if url.startswith("http") or url.startswith("{\""):
-            return url
+            return url.replace("\\", "")
 
-        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        url = f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        return url.replace("\\", "")

kekikstream-2.4.8/KekikStream/Core/HTMLHelper.py

@@ -0,0 +1,205 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from __future__ import annotations
+
+import re
+from selectolax.parser import HTMLParser, Node
+
+
+class HTMLHelper:
+    """
+    Selectolax ile HTML parsing işlemlerini temiz, kısa ve okunabilir hale getiren yardımcı sınıf.
+    """
+
+    def __init__(self, html: str):
+        self.html   = html
+        self.parser = HTMLParser(html)
+
+    # ========================
+    # SELECTOR (CSS) İŞLEMLERİ
+    # ========================
+
+    def _root(self, element: Node | None) -> Node | HTMLParser:
+        """İşlem yapılacak temel elementi döndürür."""
+        return element if element is not None else self.parser
+
+    def select(self, selector: str, element: Node | None = None) -> list[Node]:
+        """CSS selector ile tüm eşleşen elementleri döndür."""
+        return self._root(element).css(selector)
+
+    def select_first(self, selector: str | None, element: Node | None = None) -> Node | None:
+        """CSS selector ile ilk eşleşen elementi döndür."""
+        if not selector:
+            return element
+        return self._root(element).css_first(selector)
+
+    def select_text(self, selector: str | None = None, element: Node | None = None) -> str | None:
+        """CSS selector ile element bul ve text içeriğini döndür."""
+        el = self.select_first(selector, element)
+        if not el:
+            return None
+        val = el.text(strip=True)
+        return val or None
+
+    def select_texts(self, selector: str, element: Node | None = None) -> list[str] | None:
+        """CSS selector ile tüm eşleşen elementlerin text içeriklerini döndür."""
+        out: list[str] = []
+        for el in self.select(selector, element):
+            txt = el.text(strip=True)
+            if txt:
+                out.append(txt)
+        return out or None
+
+    def select_attr(self, selector: str | None, attr: str, element: Node | None = None) -> str | None:
+        """CSS selector ile element bul ve attribute değerini döndür."""
+        el = self.select_first(selector, element)
+        return el.attrs.get(attr) if el else None
+
+    def select_attrs(self, selector: str, attr: str, element: Node | None = None) -> list[str]:
+        """CSS selector ile tüm eşleşen elementlerin attribute değerlerini döndür."""
+        out: list[str] = []
+        for el in self.select(selector, element):
+            val = el.attrs.get(attr)
+            if val:
+                out.append(val)
+        return out
+
+    def select_poster(self, selector: str = "img", element: Node | None = None) -> str | None:
+        """Poster URL'sini çıkar. Önce data-src, sonra src dener."""
+        el = self.select_first(selector, element)
+        if not el:
+            return None
+        return el.attrs.get("data-src") or el.attrs.get("src")
+
+    def select_direct_text(self, selector: str, element: Node | None = None) -> str | None:
+        """
+        Elementin yalnızca "kendi" düz metnini döndürür (child elementlerin text'ini katmadan).
+        """
+        el = self.select_first(selector, element)
+        if not el:
+            return None
+
+        # type: ignore[call-arg]
+        val = el.text(strip=True, deep=False)
+        return val or None
+
+    # ========================
+    # META (LABEL -> VALUE) İŞLEMLERİ
+    # ========================
+
+    def meta_value(self, label: str, container_selector: str | None = None) -> str | None:
+        """
+        Herhangi bir container içinde: LABEL metnini içeren bir elementten SONRA gelen metni döndürür.
+        label örn: "Oyuncular", "Yapım Yılı", "IMDB"
+        """
+        needle = label.casefold()
+
+        # Belirli bir container varsa içinde ara, yoksa tüm dökümanda
+        targets = self.select(container_selector) if container_selector else [self.parser.body]
+
+        for root in targets:
+            if not root: continue
+
+            # Kalın/vurgulu elementlerde (span, strong, b, label, dt) label'ı ara
+            for label_el in self.select("span, strong, b, label, dt", root):
+                txt = (label_el.text(strip=True) or "").casefold()
+                if needle not in txt:
+                    continue
+
+                # 1) Elementin kendi içindeki text'te LABEL: VALUE formatı olabilir
+                # "Oyuncular: Brad Pitt" gibi. LABEL: sonrasını al.
+                full_txt = label_el.text(strip=True)
+                if ":" in full_txt and needle in full_txt.split(":")[0].casefold():
+                    val = full_txt.split(":", 1)[1].strip()
+                    if val: return val
+
+                # 2) Label sonrası gelen ilk text node'u veya element'i al
+                curr = label_el.next
+                while curr:
+                    if curr.tag == "-text":
+                        val = curr.text(strip=True).strip(" :")
+                        if val: return val
+                    elif curr.tag != "br":
+                        val = curr.text(strip=True).strip(" :")
+                        if val: return val
+                    else: # <br> gördüysek satır bitmiştir
+                        break
+                    curr = curr.next
+
+        return None
+
+    def meta_list(self, label: str, container_selector: str | None = None, sep: str = ",") -> list[str]:
+        """meta_value(...) çıktısını veya label'ın ebeveynindeki linkleri listeye döndürür."""
+        needle = label.casefold()
+        targets = self.select(container_selector) if container_selector else [self.parser.body]
+
+        for root in targets:
+            if not root: continue
+            for label_el in self.select("span, strong, b, label, dt", root):
+                if needle in (label_el.text(strip=True) or "").casefold():
+                    # Eğer elementin ebeveyninde linkler varsa (Kutucuklu yapı), onları al
+                    links = self.select_texts("a", label_el.parent)
+                    if links: return links
+
+                    # Yoksa düz metin olarak meta_value mantığıyla al
+                    raw = self.meta_value(label, container_selector=container_selector)
+                    if not raw: return []
+                    return [x.strip() for x in raw.split(sep) if x.strip()]
+
+        return []
+
+    # ========================
+    # REGEX İŞLEMLERİ
+    # ========================
+
+    def _regex_source(self, target: str | int | None) -> str:
+        """Regex için kaynak metni döndürür."""
+        return target if isinstance(target, str) else self.html
+
+    def regex_first(self, pattern: str, target: str | int | None = None, group: int | None = 1) -> str | tuple | None:
+        """Regex ile arama yap, istenen grubu döndür (group=None ise tüm grupları tuple olarak döndür)."""
+        match = re.search(pattern, self._regex_source(target))
+        if not match:
+            return None
+            
+        if group is None:
+            return match.groups()
+            
+        last_idx = match.lastindex or 0
+        return match.group(group) if last_idx >= group else match.group(0)
+
+    def regex_all(self, pattern: str, target: str | int | None = None) -> list[str] | list[tuple]:
+        """Regex ile tüm eşleşmeleri döndür."""
+        return re.findall(pattern, self._regex_source(target))
+
+    def regex_replace(self, pattern: str, repl: str, target: str | int | None = None) -> str:
+        """Regex ile replace yap."""
+        return re.sub(pattern, repl, self._regex_source(target))
+
+    # ========================
+    # ÖZEL AYIKLAYICILAR
+    # ========================
+
+    @staticmethod
+    def extract_season_episode(text: str) -> tuple[int | None, int | None]:
+        """Metin içinden sezon ve bölüm numarasını çıkar."""
+        if m := re.search(r"[Ss](\d+)[Ee](\d+)", text):
+            return int(m.group(1)), int(m.group(2))
+
+        s = re.search(r"(\d+)\.\s*[Ss]ezon|[Ss]ezon[- ]?(\d+)|-(\d+)-sezon|S(\d+)|(\d+)\.[Ss]", text, re.I)
+        e = re.search(r"(\d+)\.\s*[Bb][öo]l[üu]m|[Bb][öo]l[üu]m[- ]?(\d+)|-(\d+)-bolum|[Ee](\d+)", text, re.I)
+
+        s_val = next((int(g) for g in s.groups() if g), None) if s else None
+        e_val = next((int(g) for g in e.groups() if g), None) if e else None
+
+        return s_val, e_val
+
+    def extract_year(self, *selectors: str, pattern: str = r"(\d{4})") -> int | None:
+        """Birden fazla selector veya regex ile yıl bilgisini çıkar."""
+        for selector in selectors:
+            if text := self.select_text(selector):
+                if m := re.search(r"(\d{4})", text):
+                    return int(m.group(1))
+
+        val = self.regex_first(pattern)
+        return int(val) if val and val.isdigit() else None

{kekikstream-2.4.0 → kekikstream-2.4.8}/KekikStream/Core/Plugin/PluginBase.py

@@ -101,11 +101,18 @@ class PluginBase(ABC):
             return ""
 
         if url.startswith("http") or url.startswith("{\""):
-            return url
-
-        return f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
-
-    async def extract(self, url: str, referer: str = None, prefix: str | None = None) -> ExtractResult | None:
+            return url.replace("\\", "")
+
+        url = f"https:{url}" if url.startswith("//") else urljoin(self.main_url, url)
+        return url.replace("\\", "")
+
+    async def extract(
+        self, 
+        url: str, 
+        referer: str = None, 
+        prefix: str | None = None, 
+        name_override: str | None = None
+    ) -> ExtractResult | list[ExtractResult] | None:
         """
         Extractor ile video URL'sini çıkarır.
 
@@ -113,6 +120,7 @@ class PluginBase(ABC):
             url: Iframe veya video URL'si
             referer: Referer header (varsayılan: plugin main_url)
             prefix: İsmin başına eklenecek opsiyonel etiket (örn: "Türkçe Dublaj")
+            name_override: İsmi tamamen değiştirecek opsiyonel etiket (Extractor adını ezer)
 
         Returns:
             ExtractResult: Extractor sonucu (name prefix ile birleştirilmiş) veya None
@@ -130,15 +138,19 @@ class PluginBase(ABC):
         try:
             data = await extractor.extract(url, referer=referer)
 
-            # Liste ise her bir öğe için prefix ekle
+            # Liste ise her bir öğe için prefix/override ekle
             if isinstance(data, list):
                 for item in data:
-                    if prefix and item.name:
+                    if name_override:
+                        item.name = name_override
+                    elif prefix and item.name:
                         item.name = f"{prefix} | {item.name}"
                 return data
 
             # Tekil öğe ise
-            if prefix and data.name:
+            if name_override:
+                data.name = name_override
+            elif prefix and data.name:
                 data.name = f"{prefix} | {data.name}"
 
             return data

kekikstream-2.4.8/KekikStream/Extractors/CloseLoad.py

@@ -0,0 +1,52 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core  import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+from Kekik.Sifreleme   import Packer, StreamDecoder
+import json, contextlib
+
+class CloseLoad(ExtractorBase):
+    name     = "CloseLoad"
+    main_url = "https://closeload.filmmakinesi.to"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({
+            "Referer" : referer or self.main_url,
+            "Origin"  : self.main_url
+        })
+
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+
+        # 1. JSON-LD'den Dene
+        m3u8_url = None
+        for script in sel.select("script[type='application/ld+json']"):
+            with contextlib.suppress(Exception):
+                data = json.loads(script.text(strip=True))
+                if content_url := data.get("contentUrl"):
+                    if content_url.startswith("http"):
+                        m3u8_url = content_url
+                        break
+        
+        # 2. Packed Script Fallback
+        if not m3u8_url:
+            if packed := sel.regex_first(r"(eval\(function\(p,a,c,k,e,d\).+?)\s*</script>"):
+                m3u8_url = StreamDecoder.extract_stream_url(Packer.unpack(packed))
+
+        if not m3u8_url:
+            raise ValueError(f"CloseLoad: Video URL bulunamadı. {url}")
+
+        subtitles = []
+        for track in sel.select("track"):
+            src = track.attrs.get("src")
+            if src:
+                subtitles.append(Subtitle(
+                    name = track.attrs.get("label") or track.attrs.get("srclang") or "Altyazı",
+                    url  = self.fix_url(src)
+                ))
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u8_url,
+            referer   = self.main_url,
+            subtitles = subtitles
+        )

kekikstream-2.4.8/KekikStream/Extractors/ContentX.py

@@ -0,0 +1,54 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+
+class ContentX(ExtractorBase):
+    name     = "ContentX"
+    main_url = "https://contentx.me"
+
+    # Birden fazla domain destekle
+    supported_domains = [
+        "contentx.me", "four.contentx.me",
+        "dplayer82.site", "sn.dplayer82.site", "four.dplayer82.site", "org.dplayer82.site",
+        "dplayer74.site", "sn.dplayer74.site",
+        "hotlinger.com", "sn.hotlinger.com",
+        "playru.net", "four.playru.net",
+        "pichive.online", "four.pichive.online", "pichive.me", "four.pichive.me"
+    ]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
+    async def extract(self, url: str, referer: str = None) -> list[ExtractResult] | ExtractResult:
+        ref = referer or self.get_base_url(url)
+        self.httpx.headers.update({"Referer": ref})
+
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+
+        v_id = sel.regex_first(r"window\.openPlayer\('([^']+)'")
+        if not v_id:
+            raise ValueError(f"ContentX: ID bulunamadı. {url}")
+
+        subtitles = []
+        for s_url, s_lang in sel.regex_all(r'"file":"([^\"]+)","label":"([^\"]+)"'):
+            decoded_lang = s_lang.encode().decode('unicode_escape')
+            subtitles.append(Subtitle(name=decoded_lang, url=self.fix_url(s_url.replace("\\", ""))))
+
+        results = []
+        # Base m3u8
+        vid_resp = await self.httpx.get(f"{self.get_base_url(url)}/source2.php?v={v_id}", headers={"Referer": url})
+        if m3u8_link := HTMLHelper(vid_resp.text).regex_first(r'file":"([^\"]+)"'):
+            m3u8_link = m3u8_link.replace("\\", "").replace("/m.php", "/master.m3u8")
+            results.append(ExtractResult(name=self.name, url=m3u8_link, referer=url, subtitles=subtitles))
+
+        # Dublaj Kontrolü
+        if dub_id := sel.regex_first(r'["\']([^"\']+)["\'],["\']Türkçe["\']'):
+            dub_resp = await self.httpx.get(f"{self.get_base_url(url)}/source2.php?v={dub_id}", headers={"Referer": url})
+            if dub_link := HTMLHelper(dub_resp.text).regex_first(r'file":"([^\"]+)"'):
+                results.append(ExtractResult(name=f"{self.name} Türkçe Dublaj", url=dub_link.replace("\\", ""), referer=url))
+
+        if not results:
+            raise ValueError(f"ContentX: Video linki bulunamadı. {url}")
+
+        return results[0] if len(results) == 1 else results

kekikstream-2.4.8/KekikStream/Extractors/DonilasPlay.py

@@ -0,0 +1,42 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle, HTMLHelper
+from Kekik.Sifreleme   import AESManager
+import json, contextlib
+
+class DonilasPlay(ExtractorBase):
+    name     = "DonilasPlay"
+    main_url = "https://donilasplay.com"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
+
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+
+        m3u8_url  = None
+        subtitles = []
+
+        # 1. bePlayer (AES)
+        if be_match := sel.regex_first(r"bePlayer\('([^']+)',\s*'(\{[^}]+\})'\);", group=None):
+            pass_val, data_val = be_match
+            with contextlib.suppress(Exception):
+                data = json.loads(AESManager.decrypt(data_val, pass_val))
+                m3u8_url = data.get("video_location")
+                for sub in data.get("strSubtitles", []):
+                    if "Forced" not in sub.get("label", ""):
+                        subtitles.append(Subtitle(name=sub.get("label"), url=self.fix_url(sub.get("file"))))
+
+        # 2. Fallback
+        if not m3u8_url:
+            m3u8_url = sel.regex_first(r'file:"([^"]+)"')
+            if tracks_match := sel.regex_first(r'tracks:\[([^\]]+)'):
+                with contextlib.suppress(Exception):
+                    for track in json.loads(f"[{tracks_match}]"):
+                        if "Forced" not in track.get("label", ""):
+                            subtitles.append(Subtitle(name=track.get("label"), url=self.fix_url(track.get("file"))))
+
+        if not m3u8_url:
+            raise ValueError(f"DonilasPlay: Video linki bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=url, subtitles=subtitles)

kekikstream-2.4.8/KekikStream/Extractors/DzenRu.py

@@ -0,0 +1,24 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+
+class DzenRu(ExtractorBase):
+    name     = "DzenRu"
+    main_url = "https://dzen.ru"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        video_key = url.split("/")[-1]
+        v_url     = f"{self.main_url}/embed/{video_key}"
+
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        resp = await self.httpx.get(v_url)
+        sel  = HTMLHelper(resp.text)
+        
+        # Benzersiz okcdn.ru linklerini bul ve en yüksek kaliteyi (genelde sonuncu) seç
+        links = sel.regex_all(r'https://vd\d+\.okcdn\.ru/\?[^"\'\\\s]+')
+        if not links:
+            raise ValueError(f"DzenRu: Video linki bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=list(set(links))[-1], referer=self.main_url)

kekikstream-2.4.8/KekikStream/Extractors/ExPlay.py

@@ -0,0 +1,35 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+from urllib.parse import urlparse, parse_qs
+
+class ExPlay(ExtractorBase):
+    name     = "ExPlay"
+    main_url = "https://explay.store"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
+        
+        # Clean URL from partKey for initial request
+        clean_url = url.split("?")[0]
+        resp = await self.httpx.get(clean_url)
+        sel  = HTMLHelper(resp.text)
+
+        v_url = sel.regex_first(r'videoUrl":"([^",]+)"')
+        v_srv = sel.regex_first(r'videoServer":"([^",]+)"')
+        if not v_url or not v_srv:
+            raise ValueError(f"ExPlay: Video url/server bulunamadı. {url}")
+
+        params   = parse_qs(urlparse(url).query)
+        part_key = params.get("partKey", [""])[0]
+        
+        suffix = part_key or "Bilinmiyor"
+        if not part_key:
+            title = sel.regex_first(r'title":"([^",]+)"')
+            if title: suffix = title.split(".")[-1]
+
+        return ExtractResult(
+            name    = f"{self.name} - {suffix}",
+            url     = f"{self.main_url}{v_url.replace('\\', '')}?s={v_srv}",
+            referer = clean_url
+        )

kekikstream-2.4.8/KekikStream/Extractors/Filemoon.py

@@ -0,0 +1,63 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core  import ExtractorBase, ExtractResult, HTMLHelper
+from Kekik.Sifreleme   import Packer
+
+class Filemoon(ExtractorBase):
+    name     = "Filemoon"
+    main_url = "https://filemoon.to"
+
+    # Filemoon'un farklı domainlerini destekle
+    supported_domains = [
+        "filemoon.to",
+        "filemoon.in",
+        "filemoon.sx",
+        "filemoon.nl",
+        "filemoon.com"
+    ]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        default_headers = {
+            "Referer"         : url,
+            "Sec-Fetch-Dest"  : "iframe",
+            "Sec-Fetch-Mode"  : "navigate",
+            "Sec-Fetch-Site"  : "cross-site",
+            "User-Agent"      : "Mozilla/5.0 (X11; Linux x86_64; rv:137.0) Gecko/20100101 Firefox/137.0"
+        }
+        self.httpx.headers.update(default_headers)
+
+        # İlk sayfayı al
+        istek  = await self.httpx.get(url)
+        secici = HTMLHelper(istek.text)
+
+        # Eğer iframe varsa, iframe'e git
+        iframe_src = secici.select_attr("iframe", "src")
+        m3u8_url   = None
+        
+        if iframe_src:
+            url    = self.fix_url(iframe_src)
+            istek  = await self.httpx.get(url)
+            secici = HTMLHelper(istek.text)
+
+        # script p,a,c,k,e,d içinde ara
+        script_data = secici.regex_first(r"(eval\(function\(p,a,c,k,e,d\).+?)\s*</script>")
+        if script_data:
+            unpacked = Packer.unpack(script_data)
+            m3u8_url = HTMLHelper(unpacked).regex_first(r'sources:\[\{file:"(.*?)"')
+
+        if not m3u8_url:
+            # Fallback
+            m3u8_url = secici.regex_first(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"') or secici.regex_first(r'file:\s*"([^\"]*?\.m3u8[^"]*)"')
+
+        if not m3u8_url:
+            raise ValueError(f"Filemoon: Video URL bulunamadı. {url}")
+
+        return ExtractResult(
+            name       = self.name,
+            url        = self.fix_url(m3u8_url),
+            referer    = f"{self.get_base_url(url)}/",
+            user_agent = default_headers["User-Agent"]
+        )

kekikstream-2.4.8/KekikStream/Extractors/HDMomPlayer.py

@@ -0,0 +1,30 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core  import ExtractorBase, ExtractResult, HTMLHelper
+from Kekik.Sifreleme import AESManager
+import contextlib, json
+
+class HDMomPlayer(ExtractorBase):
+    name     = "HDMomPlayer"
+    main_url = "https://hdmomplayer.com"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
+
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+
+        m3u8_url = None
+        if match := sel.regex_first(r"bePlayer\('([^']+)',\s*'(\{[^\}]+\})'\);", group=None):
+            pass_val, data_val = match
+            with contextlib.suppress(Exception):
+                decrypted = AESManager.decrypt(data_val, pass_val)
+                m3u8_url  = HTMLHelper(decrypted).regex_first(r'video_location":"([^"]+)"')
+
+        if not m3u8_url:
+            m3u8_url = sel.regex_first(r'file:"([^"]+)"')
+
+        if not m3u8_url:
+            raise ValueError(f"HDMomPlayer: Video linki bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=self.fix_url(m3u8_url), referer=url)

kekikstream-2.4.8/KekikStream/Extractors/HDPlayerSystem.py

@@ -0,0 +1,23 @@
+# 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: str, referer: str = None) -> ExtractResult:
+        ref = referer or self.main_url
+        v_id = url.split("video/")[-1] if "video/" in url else url.split("?data=")[-1]
+
+        resp = await self.httpx.post(
+            f"{self.main_url}/player/index.php?data={v_id}&do=getVideo",
+            data    = {"hash": v_id, "r": ref},
+            headers = {"Referer": ref, "X-Requested-With": "XMLHttpRequest"}
+        )
+        
+        m3u8_url = resp.json().get("securedLink")
+        if not m3u8_url:
+            raise ValueError(f"HDPlayerSystem: Video URL bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=m3u8_url, referer=url)

kekikstream-2.4.8/KekikStream/Extractors/HotStream.py

@@ -0,0 +1,27 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, HTMLHelper
+from Kekik.Sifreleme import AESManager
+import contextlib
+
+class HotStream(ExtractorBase):
+    name     = "HotStream"
+    main_url = "https://hotstream.club"
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        self.httpx.headers.update({"Referer": referer or url})
+
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+
+        m3u8_url = None
+        if match := sel.regex_first(r"bePlayer\('([^']+)',\s*'(\{[^']+\})'\)", group=None):
+            pass_val, data_val = match
+            with contextlib.suppress(Exception):
+                decrypted = AESManager.decrypt(data_val, pass_val)
+                m3u8_url  = HTMLHelper(decrypted).regex_first(r'"video_location":"([^"]+)"')
+
+        if not m3u8_url:
+            raise ValueError(f"HotStream: Video linki bulunamadı. {url}")
+
+        return ExtractResult(name=self.name, url=self.fix_url(m3u8_url), referer=url)

kekikstream-2.4.8/KekikStream/Extractors/JFVid.py

@@ -0,0 +1,19 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+
+class JFVid(ExtractorBase):
+    name     = "JFVid"
+    main_url = "https://jfvid.com"
+
+    # Birden fazla domain destekle
+    supported_domains = ["jfvid.com"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
+    async def extract(self, url: str, referer: str = None) -> ExtractResult:
+        base_url = self.get_base_url(url)
+        v_id     = url.split("/play/")[-1] if "/play/" in url else url.split("/stream/")[-1]
+        
+        return ExtractResult(name=self.name, url=f"{base_url}/stream/{v_id}", referer=referer or base_url)