KekikStream 2.0.4__tar.gz → 2.0.6__tar.gz

{kekikstream-2.0.4 → kekikstream-2.0.6}/KekikStream/Extractors/ContentX.py

@@ -7,6 +7,19 @@ 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, referer=None) -> list[ExtractResult]:
         if referer:
             self.httpx.headers.update({"Referer": referer})

kekikstream-2.0.6/KekikStream/Extractors/DonilasPlay.py

@@ -0,0 +1,86 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult, Subtitle
+from Kekik.Sifreleme   import AESManager
+import re, json
+
+class DonilasPlay(ExtractorBase):
+    name     = "DonilasPlay"
+    main_url = "https://donilasplay.com"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        istek = await self.httpx.get(url)
+        istek.raise_for_status()
+        i_source = istek.text
+
+        m3u_link   = None
+        subtitles  = []
+
+        # bePlayer pattern
+        be_player_match = re.search(r"bePlayer\('([^']+)',\s*'(\{[^}]+\})'\);", i_source)
+        if be_player_match:
+            be_player_pass = be_player_match.group(1)
+            be_player_data = be_player_match.group(2)
+
+            try:
+                # AES decrypt
+                decrypted = AESManager.decrypt(be_player_data, be_player_pass)
+                data      = json.loads(decrypted)
+
+                m3u_link = data.get("video_location")
+
+                # Altyazıları işle
+                str_subtitles = data.get("strSubtitles", [])
+                if str_subtitles:
+                    for sub in str_subtitles:
+                        label = sub.get("label", "")
+                        file  = sub.get("file", "")
+                        # Forced altyazıları hariç tut
+                        if "Forced" in label:
+                            continue
+                        if file:
+                            # Türkçe kontrolü
+                            keywords = ["tur", "tr", "türkçe", "turkce"]
+                            language = "Turkish" if any(k in label.lower() for k in keywords) else label
+                            subtitles.append(Subtitle(
+                                name = language,
+                                url  = self.fix_url(file)
+                            ))
+            except Exception:
+                pass
+
+        # Fallback: file pattern
+        if not m3u_link:
+            file_match = re.search(r'file:"([^"]+)"', i_source)
+            if file_match:
+                m3u_link = file_match.group(1)
+
+            # tracks pattern for subtitles
+            tracks_match = re.search(r'tracks:\[([^\]]+)', i_source)
+            if tracks_match:
+                try:
+                    tracks_str = f"[{tracks_match.group(1)}]"
+                    tracks = json.loads(tracks_str)
+                    for track in tracks:
+                        file_url = track.get("file")
+                        label    = track.get("label", "")
+                        if file_url and "Forced" not in label:
+                            subtitles.append(Subtitle(
+                                name = label,
+                                url  = self.fix_url(file_url)
+                            ))
+                except Exception:
+                    pass
+
+        if not m3u_link:
+            raise ValueError("m3u link not found")
+
+        return ExtractResult(
+            name      = self.name,
+            url       = m3u_link,
+            referer   = url,
+            subtitles = subtitles
+        )

{kekikstream-2.0.4 → kekikstream-2.0.6}/KekikStream/Extractors/Odnoklassniki.py

@@ -7,6 +7,12 @@ class Odnoklassniki(ExtractorBase):
     name     = "Odnoklassniki"
     main_url = "https://odnoklassniki.ru"
 
+    # Birden fazla domain destekle
+    supported_domains = ["odnoklassniki.ru", "ok.ru"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     async def extract(self, url, referer=None) -> ExtractResult:
         if "/video/" in url:
             url = url.replace("/video/", "/videoembed/")

{kekikstream-2.0.4 → kekikstream-2.0.6}/KekikStream/Extractors/PeaceMakerst.py

@@ -7,6 +7,12 @@ class PeaceMakerst(ExtractorBase):
     name     = "PeaceMakerst"
     main_url = "https://peacemakerst.com"
 
+    # Birden fazla domain destekle
+    supported_domains = ["peacemakerst.com", "hdstreamable.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, referer=None) -> ExtractResult:
         if referer:
             self.httpx.headers.update({"Referer": referer})

{kekikstream-2.0.4 → kekikstream-2.0.6}/KekikStream/Extractors/RapidVid.py

@@ -8,6 +8,12 @@ class RapidVid(ExtractorBase):
     name     = "RapidVid"
     main_url = "https://rapidvid.net"
 
+    # Birden fazla domain destekle
+    supported_domains = ["rapidvid.net", "rapid.filmmakinesi.to"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
+
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
             self.httpx.headers.update({"Referer": referer})

{kekikstream-2.0.4 → kekikstream-2.0.6}/KekikStream/Extractors/SetPlay.py

@@ -5,7 +5,13 @@ import re
 
 class SetPlay(ExtractorBase):
     name     = "SetPlay"
-    main_url = "https://setplay.cfd"
+    main_url = "https://setplay.shop"
+
+    # Birden fazla domain destekle
+    supported_domains = ["setplay.cfd", "setplay.shop", "setplay.site"]
+
+    def can_handle_url(self, url: str) -> bool:
+        return any(domain in url for domain in self.supported_domains)
 
     async def extract(self, url, referer=None) -> ExtractResult:
         ext_ref = referer or ""

kekikstream-2.0.6/KekikStream/Extractors/VCTPlay.py

@@ -0,0 +1,41 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import ExtractorBase, ExtractResult
+from urllib.parse     import urlparse, parse_qs
+
+class VCTPlay(ExtractorBase):
+    name     = "VCTPlay"
+    main_url = "https://vctplay.site"
+
+    async def extract(self, url, referer=None) -> ExtractResult:
+        if referer:
+            self.httpx.headers.update({"Referer": referer})
+
+        # URL'den video ID'sini çıkar
+        # https://vctplay.site/video/2hjDGco5exdv -> 2hjDGco5exdv
+        video_id = url.split("/")[-1]
+        if "?" in video_id:
+            video_id = video_id.split("?")[0]
+
+        # Manifests URL oluştur
+        master_url = f"{self.main_url}/manifests/{video_id}/master.txt"
+
+        # partKey'den isim belirle
+        parsed   = urlparse(url)
+        params   = parse_qs(parsed.query)
+        part_key = params.get("partKey", [""])[0]
+
+        name_suffix = ""
+        if "turkcedublaj" in part_key.lower():
+            name_suffix = "Dublaj"
+        elif "turkcealtyazi" in part_key.lower():
+            name_suffix = "Altyazı"
+
+        display_name = f"{self.name} - {name_suffix}" if name_suffix else self.name
+
+        return ExtractResult(
+            name      = display_name,
+            url       = master_url,
+            referer   = f"{self.main_url}/",
+            subtitles = []
+        )

{kekikstream-2.0.4 → kekikstream-2.0.6}/KekikStream/Extractors/VidMoly.py

@@ -9,6 +9,12 @@ class VidMoly(ExtractorBase):
     name     = "VidMoly"
     main_url = "https://vidmoly.to"
 
+    # Birden fazla domain destekle
+    supported_domains = ["vidmoly.to", "vidmoly.me", "vidmoly.net"]
+
+    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:
         if referer:
             self.httpx.headers.update({"Referer": referer})

kekikstream-2.0.6/KekikStream/Plugins/BelgeselX.py

@@ -0,0 +1,204 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode
+from parsel           import Selector
+import re
+
+class BelgeselX(PluginBase):
+    name        = "BelgeselX"
+    language    = "tr"
+    main_url    = "https://belgeselx.com"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "2022 yılında son çıkan belgeselleri belgeselx.com'da izle. En yeni belgeseller, türkçe altyazılı yada dublaj olarak 1080p kalitesinde hd belgesel izle."
+
+    main_page   = {
+        f"{main_url}/konu/turk-tarihi-belgeselleri&page=" : "Türk Tarihi",
+        f"{main_url}/konu/tarih-belgeselleri&page="       : "Tarih",
+        f"{main_url}/konu/seyehat-belgeselleri&page="     : "Seyahat",
+        f"{main_url}/konu/seri-belgeseller&page="         : "Seri",
+        f"{main_url}/konu/savas-belgeselleri&page="       : "Savaş",
+        f"{main_url}/konu/sanat-belgeselleri&page="       : "Sanat",
+        f"{main_url}/konu/psikoloji-belgeselleri&page="   : "Psikoloji",
+        f"{main_url}/konu/polisiye-belgeselleri&page="    : "Polisiye",
+        f"{main_url}/konu/otomobil-belgeselleri&page="    : "Otomobil",
+        f"{main_url}/konu/nazi-belgeselleri&page="        : "Nazi",
+        f"{main_url}/konu/muhendislik-belgeselleri&page=" : "Mühendislik",
+        f"{main_url}/konu/kultur-din-belgeselleri&page="  : "Kültür Din",
+        f"{main_url}/konu/kozmik-belgeseller&page="       : "Kozmik",
+        f"{main_url}/konu/hayvan-belgeselleri&page="      : "Hayvan",
+        f"{main_url}/konu/eski-tarih-belgeselleri&page="  : "Eski Tarih",
+        f"{main_url}/konu/egitim-belgeselleri&page="      : "Eğitim",
+        f"{main_url}/konu/dunya-belgeselleri&page="       : "Dünya",
+        f"{main_url}/konu/doga-belgeselleri&page="        : "Doğa",
+        f"{main_url}/konu/bilim-belgeselleri&page="       : "Bilim"
+    }
+
+    @staticmethod
+    def _to_title_case(text: str) -> str:
+        """Türkçe için title case dönüşümü."""
+        return " ".join(
+            word.lower().replace("i", "İ").capitalize() if word.lower().startswith("i") else word.capitalize()
+            for word in text.split()
+        )
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = self.cloudscraper.get(f"{url}{page}")
+        secici = Selector(istek.text)
+
+        results = []
+        for item in secici.css("div.gen-movie-contain > div.gen-info-contain > div.gen-movie-info"):
+            title  = item.css("div.gen-movie-info > h3 a::text").get()
+            href   = item.css("div.gen-movie-info > h3 a::attr(href)").get()
+            parent = item.xpath("../../..")
+            poster = parent.css("div.gen-movie-img > img::attr(src)").get()
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = self._to_title_case(title.strip()),
+                    url      = self.fix_url(href),
+                    poster   = self.fix_url(poster) if poster else None
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        # Google Custom Search API kullanıyor
+        cx = "016376594590146270301:iwmy65ijgrm"
+
+        token_resp = self.cloudscraper.get(f"https://cse.google.com/cse.js?cx={cx}")
+        token_text = token_resp.text
+
+        cse_lib_match = re.search(r'cselibVersion": "(.*)"', token_text)
+        cse_tok_match = re.search(r'cse_token": "(.*)"', token_text)
+
+        if not cse_lib_match or not cse_tok_match:
+            return []
+
+        cse_lib = cse_lib_match.group(1)
+        cse_tok = cse_tok_match.group(1)
+
+        search_url = (
+            f"https://cse.google.com/cse/element/v1?"
+            f"rsz=filtered_cse&num=100&hl=tr&source=gcsc&cselibv={cse_lib}&cx={cx}"
+            f"&q={query}&safe=off&cse_tok={cse_tok}&sort=&exp=cc%2Capo&oq={query}"
+            f"&callback=google.search.cse.api9969&rurl=https%3A%2F%2Fbelgeselx.com%2F"
+        )
+
+        resp = self.cloudscraper.get(search_url)
+        resp_text = resp.text
+
+        titles = re.findall(r'"titleNoFormatting": "(.*?)"', resp_text)
+        urls   = re.findall(r'"url": "(.*?)"', resp_text)
+        images = re.findall(r'"ogImage": "(.*?)"', resp_text)
+
+        results = []
+        for i, title in enumerate(titles):
+            url_val = urls[i] if i < len(urls) else None
+            poster  = images[i] if i < len(images) else None
+
+            if not url_val or "diziresimleri" not in url_val:
+                # URL'den belgesel linkini oluştur
+                if poster and "diziresimleri" in poster:
+                    file_name = poster.rsplit("/", 1)[-1]
+                    file_name = re.sub(r"\.(jpe?g|png|webp)$", "", file_name)
+                    url_val = f"{self.main_url}/belgeseldizi/{file_name}"
+                else:
+                    continue
+
+            clean_title = title.split("İzle")[0].strip()
+            results.append(SearchResult(
+                title  = self._to_title_case(clean_title),
+                url    = url_val,
+                poster = poster
+            ))
+
+        return results
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("h2.gen-title::text").get()
+        poster      = secici.css("div.gen-tv-show-top img::attr(src)").get()
+        description = secici.css("div.gen-single-tv-show-info p::text").get()
+
+        tags = []
+        for tag_link in secici.css("div.gen-socail-share a[href*='belgeselkanali']"):
+            tag_href = tag_link.css("::attr(href)").get()
+            if tag_href:
+                tag_name = tag_href.rsplit("/", 1)[-1].replace("-", " ")
+                tags.append(self._to_title_case(tag_name))
+
+        episodes = []
+        counter  = 0
+        for ep_item in secici.css("div.gen-movie-contain"):
+            ep_name = ep_item.css("div.gen-movie-info h3 a::text").get()
+            ep_href = ep_item.css("div.gen-movie-info h3 a::attr(href)").get()
+
+            if not ep_name or not ep_href:
+                continue
+
+            season_text   = ep_item.css("div.gen-single-meta-holder ul li::text").get() or ""
+            episode_match = re.search(r"Bölüm (\d+)", season_text)
+            season_match  = re.search(r"Sezon (\d+)", season_text)
+
+            ep_episode = int(episode_match.group(1)) if episode_match else counter
+            ep_season  = int(season_match.group(1)) if season_match else 1
+
+            counter += 1
+
+            episodes.append(Episode(
+                season  = ep_season,
+                episode = ep_episode,
+                title   = ep_name.strip(),
+                url     = self.fix_url(ep_href)
+            ))
+
+        return SeriesInfo(
+            url         = url,
+            poster      = self.fix_url(poster) if poster else None,
+            title       = self._to_title_case(title.strip()) if title else None,
+            description = description.strip() if description else None,
+            tags        = tags,
+            episodes    = episodes
+        )
+
+    async def load_links(self, url: str) -> list[dict]:
+        istek = await self.httpx.get(url)
+        text  = istek.text
+
+        # fnc_addWatch div'inden data-episode ID'sini al
+        ep_match = re.search(r'<div[^>]*class=["\'][^"\']*fnc_addWatch[^"\']*["\'][^>]*data-episode=["\'](\d+)["\']', text)
+        if not ep_match:
+            return []
+
+        episode_id  = ep_match.group(1)
+        iframe_url  = f"{self.main_url}/video/data/new4.php?id={episode_id}"
+
+        iframe_resp = await self.httpx.get(iframe_url, headers={"Referer": url})
+        iframe_text = iframe_resp.text
+
+        links = []
+        for match in re.finditer(r'file:"([^"]+)", label: "([^"]+)"', iframe_text):
+            video_url = match.group(1)
+            quality   = match.group(2)
+
+            source_name = "Google" if quality == "FULL" else self.name
+            quality_str = "1080p" if quality == "FULL" else quality
+
+            links.append({
+                "url"     : video_url,
+                "name"    : f"{source_name} | {quality_str}",
+                "referer" : url
+            })
+
+        return links
+
+    async def play(self, **kwargs):
+        extract_result = ExtractResult(**kwargs)
+        self.media_handler.title = kwargs.get("name")
+        if self.name not in self.media_handler.title:
+            self.media_handler.title = f"{self.name} | {self.media_handler.title}"
+
+        self.media_handler.play_media(extract_result)

{kekikstream-2.0.4 → kekikstream-2.0.6}/KekikStream/Plugins/HDFilmCehennemi.py

@@ -3,7 +3,7 @@
 from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, Subtitle
 from parsel           import Selector
 from Kekik.Sifreleme  import Packer, StreamDecoder
-import random, string, re
+import random, string, re, base64
 
 class HDFilmCehennemi(PluginBase):
     name        = "HDFilmCehennemi"
@@ -146,17 +146,85 @@ class HDFilmCehennemi(PluginBase):
 
         return results
 
+    def hdch_decode(self, value_parts: list[str]) -> str:
+        """
+        HDFilmCehennemi için özel decoder.
+        JavaScript sırası: join -> reverse -> atob -> atob -> shift_back
+        """
+        try:
+            # 1. Parçaları birleştir
+            joined = ''.join(value_parts)
+            
+            # 2. Ters çevir (REV)
+            result = StreamDecoder._reverse(joined)
+            
+            # 3. İlk base64 decode (B64D)
+            result = StreamDecoder._base64_decode(result)
+            if result is None:
+                return ""
+            
+            # 4. İkinci base64 decode (B64D) - JavaScript'te iki kez atob yapılıyor!
+            result = StreamDecoder._base64_decode(result)
+            if result is None:
+                return ""
+            
+            # 5. Shift back (SHF)
+            result = StreamDecoder._shift_back(result)
+            
+            return result
+        except Exception:
+            return ""
+
+    def extract_hdch_url(self, unpacked: str) -> str:
+        """HDFilmCehennemi unpacked script'ten video URL'sini çıkar"""
+        # 1) Decode fonksiyonunun adını bul: function <NAME>(value_parts)
+        match_fn = re.search(r'function\s+(\w+)\s*\(\s*value_parts\s*\)', unpacked)
+        if not match_fn:
+            return ""
+        
+        fn_name = match_fn.group(1)
+        
+        # 2) Bu fonksiyonun array ile çağrıldığı yeri bul: <NAME>([ ... ])
+        array_call_regex = re.compile(rf'{re.escape(fn_name)}\(\s*\[(.*?)\]\s*\)', re.DOTALL)
+        match_call = array_call_regex.search(unpacked)
+        if not match_call:
+            return ""
+        
+        array_body = match_call.group(1)
+        
+        # 3) Array içindeki string parçalarını topla
+        parts = re.findall(r'["\']([^"\']+)["\']', array_body)
+        if not parts:
+            return ""
+        
+        # 4) Özel decoder ile çöz
+        return self.hdch_decode(parts)
+
     async def invoke_local_source(self, iframe: str, source: str, url: str):
-        self.httpx.headers.update({"Referer": f"{self.main_url}/"})
+        self.httpx.headers.update({
+            "Referer": f"{self.main_url}/",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0"
+        })
         istek = await self.httpx.get(iframe)
 
+        if not istek.text:
+            return await self.cehennempass(iframe.split("/")[-1])
+
+        # eval(function...) içeren packed script bul
+        eval_match = re.search(r'(eval\(function[\s\S]+)', istek.text)
+        if not eval_match:
+            return await self.cehennempass(iframe.split("/")[-1])
+
         try:
-            eval_func = re.compile(r'\s*(eval\(function[\s\S].*)\s*').findall(istek.text)[0]
+            unpacked = Packer.unpack(eval_match.group(1))
         except Exception:
             return await self.cehennempass(iframe.split("/")[-1])
 
-        unpacked  = Packer.unpack(eval_func)
-        video_url = StreamDecoder.extract_stream_url(unpacked)
+        # HDFilmCehennemi özel decoder ile video URL'sini çıkar
+        video_url = self.extract_hdch_url(unpacked)
+        
+        if not video_url:
+            return await self.cehennempass(iframe.split("/")[-1])
 
         subtitles = []
         try:
@@ -200,8 +268,15 @@ class HDFilmCehennemi(PluginBase):
                 match  = re.search(r'data-src=\\\"([^"]+)', api_get.text)
                 iframe = match[1].replace("\\", "") if match else None
 
-                if iframe and "?rapidrame_id=" in iframe:
-                    iframe = f"{self.main_url}/playerr/{iframe.split('?rapidrame_id=')[1]}"
+                if not iframe:
+                    continue
+
+                # mobi URL'si varsa direkt kullan (query string'i kaldır)
+                if "mobi" in iframe:
+                    iframe = iframe.split("?")[0]  # rapidrame_id query param'ı kaldır
+                # mobi değilse ve rapidrame varsa rplayer kullan
+                elif "rapidrame" in iframe and "?rapidrame_id=" in iframe:
+                    iframe = f"{self.main_url}/rplayer/{iframe.split('?rapidrame_id=')[1]}"
 
                 video_data_list = await self.invoke_local_source(iframe, source, url)
                 if not video_data_list:

{kekikstream-2.0.4 → kekikstream-2.0.6}/KekikStream/Plugins/RecTV.py

@@ -7,7 +7,7 @@ import re
 class RecTV(PluginBase):
     name        = "RecTV"
     language    = "tr"
-    main_url    = "https://m.prectv50.sbs"
+    main_url    = "https://m.prectv60.lol"
     favicon     = "https://rectvapk.cc/wp-content/uploads/2023/02/Rec-TV.webp"
     description = "RecTv APK, Türkiye’deki en popüler Çevrimiçi Medya Akış platformlarından biridir. Filmlerin, Canlı Sporların, Web Dizilerinin ve çok daha fazlasının keyfini ücretsiz çıkarın."