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

KekikStream/Plugins/HDFilmCehennemi.py

@@ -1,16 +1,18 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core           import kekik_cache, PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, Subtitle
-from parsel                     import Selector
-from KekikStream.Helpers.Unpack import unpack
-import random, string, re, base64
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, Subtitle
+from parsel           import Selector
+from Kekik.Sifreleme  import Packer, StreamDecoder
+import random, string, re
 
 class HDFilmCehennemi(PluginBase):
     name        = "HDFilmCehennemi"
     language    = "tr"
-    main_url    = "https://www.hdfilmcehennemi.nl"
+    main_url    = "https://www.hdfilmcehennemi.ws"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "Türkiye'nin en hızlı hd film izleme sitesi"
+    
+
 
     main_page   = {
         f"{main_url}"                                      : "Yeni Eklenen Filmler",
@@ -29,9 +31,8 @@ class HDFilmCehennemi(PluginBase):
         f"{main_url}/tur/romantik-filmleri-izle-1"         : "Romantik Filmleri"
     }
 
-    @kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
-        istek  = await self.httpx.get(f"{url}")
+        istek  = await self.httpx.get(f"{url}", follow_redirects=True)
         secici = Selector(istek.text)
 
         return [
@@ -44,10 +45,9 @@ class HDFilmCehennemi(PluginBase):
                 for veri in secici.css("div.section-content a.poster")
         ]
 
-    @kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
         istek = await self.httpx.get(
-            url     = f"{self.main_url}/search?q={query}",
+            url     = f"{self.main_url}/search/?q={query}",
             headers = {
                 "Referer"          : f"{self.main_url}/",
                 "X-Requested-With" : "fetch",
@@ -73,7 +73,6 @@ class HDFilmCehennemi(PluginBase):
             
         return results
 
-    @kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> MovieInfo:
         istek  = await self.httpx.get(url, headers = {"Referer": f"{self.main_url}/"})
         secici = Selector(istek.text)
@@ -96,7 +95,7 @@ class HDFilmCehennemi(PluginBase):
         return MovieInfo(
             url         = url,
             poster      = self.fix_url(poster),
-            title       = title,
+            title       = self.clean_title(title),
             description = description,
             tags        = tags,
             rating      = rating,
@@ -108,8 +107,9 @@ class HDFilmCehennemi(PluginBase):
     def generate_random_cookie(self):
         return "".join(random.choices(string.ascii_letters + string.digits, k=16))
 
-    @kekik_cache(ttl=15*60)
-    async def cehennempass(self, video_id: str):
+    async def cehennempass(self, video_id: str) -> list[dict]:
+        results = []
+        
         istek = await self.httpx.post(
             url     = "https://cehennempass.pw/process_quality_selection.php",
             headers = {
@@ -120,15 +120,12 @@ class HDFilmCehennemi(PluginBase):
             },
             data    = {"video_id": video_id, "selected_quality": "low"},
         )
-
-        video_url = istek.json().get("download_link")
-
-        self._data[self.fix_url(video_url)] = {
-            "ext_name"  : f"{self.name} | Düşük Kalite",
-            "name"      : "Düşük Kalite",
-            "referer"   : f"https://cehennempass.pw/download/{video_id}",
-            "subtitles" : []
-        }
+        if video_url := istek.json().get("download_link"):
+            results.append({
+                "url"     : self.fix_url(video_url),
+                "name"    : "Düşük Kalite",
+                "referer" : f"https://cehennempass.pw/download/{video_id}"
+            })
 
         istek = await self.httpx.post(
             url     = "https://cehennempass.pw/process_quality_selection.php",
@@ -140,19 +137,15 @@ class HDFilmCehennemi(PluginBase):
             },
             data    = {"video_id": video_id, "selected_quality": "high"},
         )
+        if video_url := istek.json().get("download_link"):
+            results.append({
+                "url"     : self.fix_url(video_url),
+                "name"    : "Yüksek Kalite",
+                "referer" : f"https://cehennempass.pw/download/{video_id}"
+            })
 
-        video_url = istek.json().get("download_link")
-
-        self._data[self.fix_url(video_url)] = {
-            "ext_name"  : f"{self.name} | Yüksek Kalite",
-            "name"      : "Yüksek Kalite",
-            "referer"   : f"https://cehennempass.pw/download/{video_id}",
-            "subtitles" : []
-        }
-
-        return None
+        return results
 
-    @kekik_cache(ttl=15*60)
     async def invoke_local_source(self, iframe: str, source: str, url: str):
         self.httpx.headers.update({"Referer": f"{self.main_url}/"})
         istek = await self.httpx.get(iframe)
@@ -160,12 +153,10 @@ class HDFilmCehennemi(PluginBase):
         try:
             eval_func = re.compile(r'\s*(eval\(function[\s\S].*)\s*').findall(istek.text)[0]
         except Exception:
-            await self.cehennempass(iframe.split("/")[-1])
-            return None, None
+            return await self.cehennempass(iframe.split("/")[-1])
 
-        unpacked  = unpack(eval_func)
-        b64_url   = re.search(r'file_link=\"(.*)\"\;', unpacked)[1]
-        video_url = base64.b64decode(b64_url).decode("utf-8")
+        unpacked  = Packer.unpack(eval_func)
+        video_url = StreamDecoder.extract_stream_url(unpacked)
 
         subtitles = []
         try:
@@ -178,20 +169,18 @@ class HDFilmCehennemi(PluginBase):
         except Exception:
             pass
 
-        data = {
-            "ext_name"  : f"{self.name} | {source}",
-            "name"      : f"{self.name} | {source}",
+        return [{
+            "url"       : video_url,
+            "name"      : source,
             "referer"   : url,
             "subtitles" : subtitles
-        }
-
-        return video_url, data
+        }]
 
-    @kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[str]:
+    async def load_links(self, url: str) -> list[dict]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
+        results = []
         for alternatif in secici.css("div.alternative-links"):
             lang_code = alternatif.css("::attr(data-lang)").get().upper()
 
@@ -208,23 +197,24 @@ class HDFilmCehennemi(PluginBase):
                     },
                 )
 
-                match  = re.search(r'data-src=\\"([^"]+)', api_get.text)
+                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]}"
 
-                video_url, data = await self.invoke_local_source(iframe, source, url)
-                if not video_url:
+                video_data_list = await self.invoke_local_source(iframe, source, url)
+                if not video_data_list:
                     continue
 
-                self._data[video_url] = data
+                for video_data in video_data_list:
+                    results.append(video_data)
 
-        return list(self._data.keys())
+        return results
 
-    async def play(self, name: str, url: str, referer: str, subtitles: list[Subtitle]):
-        extract_result = ExtractResult(name=name, url=url, referer=referer, subtitles=subtitles)
-        self.media_handler.title = name
+    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}"
 

KekikStream/Plugins/JetFilmizle.py

@@ -1,12 +1,12 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import kekik_cache, PluginBase, MainPageResult, SearchResult, MovieInfo
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo
 from parsel           import Selector
 
 class JetFilmizle(PluginBase):
     name        = "JetFilmizle"
     language    = "tr"
-    main_url    = "https://jetfilmizle.io"
+    main_url    = "https://jetfilmizle.website"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "Binlerce Film İzleme Seçeneğiyle En İyi Film İzleme Sitesi"
 
@@ -19,9 +19,8 @@ class JetFilmizle(PluginBase):
         f"{main_url}/kategoriler/yesilcam-filmleri-izlee/page/" : "Yeşilçam Filmleri"
     }
 
-    @kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
-        istek  = await self.httpx.get(f"{url}{page}")
+        istek  = await self.httpx.get(f"{url}{page}", follow_redirects=True)
         secici = Selector(istek.text)
 
         return [
@@ -31,10 +30,9 @@ class JetFilmizle(PluginBase):
                 url      = self.fix_url(veri.css("a::attr(href)").get()),
                 poster   = self.fix_url(veri.css("img::attr(data-src)").get() or veri.css("img::attr(src)").get()),
             )
-                for veri in secici.css("article.movie")
+                for veri in secici.css("article.movie") if veri.css("h2 a::text, h3 a::text, h4 a::text, h5 a::text, h6 a::text").get()
         ]
 
-    @kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
         istek  = await self.httpx.post(
             url     = f"{self.main_url}/filmara.php",
@@ -60,18 +58,31 @@ class JetFilmizle(PluginBase):
 
         return results
 
-    @kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> MovieInfo:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
         title       = self.clean_title(secici.css("div.movie-exp-title::text").get())
-        poster      = secici.css("section.movie-exp img::attr(data-src), section.movie-exp img::attr(src)").get().strip()
-        description = secici.css("section.movie-exp p.aciklama::text").get().strip()
+        poster_raw  = secici.css("section.movie-exp img::attr(data-src), section.movie-exp img::attr(src)").get()
+        poster      = poster_raw.strip() if poster_raw else None
+        
+        desc_raw    = secici.css("section.movie-exp p.aciklama::text").get()
+        description = desc_raw.strip() if desc_raw else None
+        
         tags        = secici.css("section.movie-exp div.catss a::text").getall()
-        rating      = secici.css("section.movie-exp div.imdb_puan span::text").get().strip()
-        year        = secici.xpath("//div[@class='yap' and (contains(., 'Vizyon') or contains(., 'Yapım'))]/text()").get()
-        year        = year.strip() if year else None
+        
+        rating_raw  = secici.css("section.movie-exp div.imdb_puan span::text").get()
+        rating      = rating_raw.strip() if rating_raw else None
+        
+        
+        # Year - div.yap içinde 4 haneli sayı ara
+        year_div = secici.xpath("//div[@class='yap' and (contains(., 'Vizyon') or contains(., 'Yapım'))]/text()").get()
+        year = None
+        if year_div:
+            year_match = re.search(r'(\d{4})', year_div.strip())
+            if year_match:
+                year = year_match.group(1)
+        
         actors      = secici.css("div[itemprop='actor'] a span::text").getall()
 
         return MovieInfo(
@@ -85,39 +96,54 @@ class JetFilmizle(PluginBase):
             actors      = actors
         )
 
-    @kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[str]:
+    async def load_links(self, url: str) -> list[dict]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
-        iframes = []
-        if main_iframe := secici.css("div#movie iframe::attr(data-src), div#movie iframe::attr(data), div#movie iframe::attr(src)").get():
-            iframes.append(self.fix_url(main_iframe))
+        results = []
 
-        for part in secici.css("div.film_part a"):
-            part_href = part.attrib.get("href")
-            if not part_href:
+        # 1) Ana iframe'leri kontrol et
+        for iframe in secici.css("iframe"):
+            src = (iframe.css("::attr(src)").get() or 
+                   iframe.css("::attr(data-src)").get() or
+                   iframe.css("::attr(data-lazy-src)").get())
+            
+            if src and src != "about:blank":
+                iframe_url = self.fix_url(src)
+                extractor = self.ex_manager.find_extractor(iframe_url)
+                results.append({
+                    "url": iframe_url,
+                    "name": extractor.name if extractor else "Ana Player"
+                })
+
+        # 2) Sayfa numaralarından linkleri topla (Fragman hariç)
+        page_links = []
+        for link in secici.css("a.post-page-numbers"):
+            isim = link.css("span::text").get() or ""
+            if isim != "Fragman":
+                href = link.css("::attr(href)").get()
+                if href:
+                    page_links.append((self.fix_url(href), isim))
+
+        # 3) Her sayfa linkindeki iframe'leri bul
+        for page_url, isim in page_links:
+            try:
+                page_resp = await self.httpx.get(page_url)
+                page_sel = Selector(page_resp.text)
+                
+                for iframe in page_sel.css("div#movie iframe"):
+                    src = (iframe.css("::attr(src)").get() or 
+                           iframe.css("::attr(data-src)").get() or
+                           iframe.css("::attr(data-lazy-src)").get())
+                    
+                    if src and src != "about:blank":
+                        iframe_url = self.fix_url(src)
+                        extractor = self.ex_manager.find_extractor(iframe_url)
+                        results.append({
+                            "url": iframe_url,
+                            "name": f"{extractor.name if extractor else 'Player'} | {isim}"
+                        })
+            except Exception:
                 continue
 
-            part_istek  = await self.httpx.get(part_href)
-            part_secici = Selector(part_istek.text)
-
-            if iframe := part_secici.css("div#movie iframe::attr(data-src), div#movie iframe::attr(data), div#movie iframe::attr(src)").get():
-                iframes.append(self.fix_url(iframe))
-            else:
-                for link in part_secici.css("div#movie p a"):
-                    if download_link := link.attrib.get("href"):
-                        iframes.append(self.fix_url(download_link))
-
-        processed_iframes = []
-        for iframe in iframes:
-            if "jetv.xyz" in iframe:
-                jetv_istek  = await self.httpx.get(iframe)
-                jetv_secici = Selector(jetv_istek.text)
-
-                if jetv_iframe := jetv_secici.css("iframe::attr(src)").get():
-                    processed_iframes.append(self.fix_url(jetv_iframe))
-            else:
-                processed_iframes.append(iframe)
-
-        return processed_iframes
+        return results

KekikStream/Plugins/KultFilmler.py

@@ -0,0 +1,219 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, Subtitle
+from parsel import Selector
+import re, base64
+
+class KultFilmler(PluginBase):
+    name        = "KultFilmler"
+    language    = "tr"
+    main_url    = "https://kultfilmler.net"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Kült film ve dizi izleme sitesi."
+
+    main_page   = {
+        f"{main_url}/category/aile-filmleri-izle"       : "Aile",
+        f"{main_url}/category/aksiyon-filmleri-izle"    : "Aksiyon",
+        f"{main_url}/category/animasyon-filmleri-izle"  : "Animasyon",
+        f"{main_url}/category/belgesel-izle"            : "Belgesel",
+        f"{main_url}/category/bilim-kurgu-filmleri-izle": "Bilim Kurgu",
+        f"{main_url}/category/biyografi-filmleri-izle"  : "Biyografi",
+        f"{main_url}/category/dram-filmleri-izle"       : "Dram",
+        f"{main_url}/category/fantastik-filmleri-izle"  : "Fantastik",
+        f"{main_url}/category/gerilim-filmleri-izle"    : "Gerilim",
+        f"{main_url}/category/gizem-filmleri-izle"      : "Gizem",
+        f"{main_url}/category/kara-filmleri-izle"       : "Kara Film",
+        f"{main_url}/category/kisa-film-izle"           : "Kısa Metraj",
+        f"{main_url}/category/komedi-filmleri-izle"     : "Komedi",
+        f"{main_url}/category/korku-filmleri-izle"      : "Korku",
+        f"{main_url}/category/macera-filmleri-izle"     : "Macera",
+        f"{main_url}/category/muzik-filmleri-izle"      : "Müzik",
+        f"{main_url}/category/polisiye-filmleri-izle"   : "Polisiye",
+        f"{main_url}/category/romantik-filmleri-izle"   : "Romantik",
+        f"{main_url}/category/savas-filmleri-izle"      : "Savaş",
+        f"{main_url}/category/suc-filmleri-izle"        : "Suç",
+        f"{main_url}/category/tarih-filmleri-izle"      : "Tarih",
+        f"{main_url}/category/yerli-filmleri-izle"      : "Yerli",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        results = []
+        for veri in secici.css("div.col-md-12 div.movie-box"):
+            title  = veri.css("div.img img::attr(alt)").get()
+            href   = self.fix_url(veri.css("a::attr(href)").get())
+            poster = self.fix_url(veri.css("div.img img::attr(src)").get())
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = title,
+                    url      = href,
+                    poster   = poster,
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek  = await self.httpx.get(f"{self.main_url}?s={query}")
+        secici = Selector(istek.text)
+
+        results = []
+        for veri in secici.css("div.movie-box"):
+            title  = veri.css("div.img img::attr(alt)").get()
+            href   = self.fix_url(veri.css("a::attr(href)").get())
+            poster = self.fix_url(veri.css("div.img img::attr(src)").get())
+
+            if title and href:
+                results.append(SearchResult(
+                    title  = title,
+                    url    = href,
+                    poster = poster,
+                ))
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("div.film-bilgileri img::attr(alt)").get() or secici.css("[property='og:title']::attr(content)").get()
+        poster      = self.fix_url(secici.css("[property='og:image']::attr(content)").get())
+        description = secici.css("div.description::text").get()
+        tags        = secici.css("ul.post-categories a::text").getall()
+        # HTML analizine göre güncellenen alanlar
+        year        = secici.css("li.release span a::text").get()
+        duration    = secici.css("li.time span::text").re_first(r"(\d+)")
+        rating      = secici.css("div.imdb-count::text").get()
+        actors      = secici.css("div.actors a::text").getall()
+        if rating:
+            rating = rating.strip()
+
+        # Dizi mi kontrol et
+        if "/dizi/" in url:
+            episodes = []
+            for bolum in secici.css("div.episode-box"):
+                ep_href   = self.fix_url(bolum.css("div.name a::attr(href)").get())
+                ssn_detail = bolum.css("span.episodetitle::text").get() or ""
+                ep_detail  = bolum.css("span.episodetitle b::text").get() or ""
+                ep_name    = f"{ssn_detail} - {ep_detail}"
+
+                if ep_href:
+                    ep_season  = re.search(r"(\d+)\.", ssn_detail)
+                    ep_episode = re.search(r"(\d+)\.", ep_detail)
+
+                    episodes.append(Episode(
+                        season  = int(ep_season[1]) if ep_season else 1,
+                        episode = int(ep_episode[1]) if ep_episode else 1,
+                        title   = ep_name.strip(" -"),
+                        url     = ep_href,
+                    ))
+
+            return SeriesInfo(
+                url         = url,
+                poster      = poster,
+                title       = self.clean_title(title) if title else "",
+                description = description,
+                tags        = tags,
+                year        = year,
+                actors      = actors,
+                rating      = rating,
+                episodes    = episodes,
+            )
+
+        return MovieInfo(
+            url         = url,
+            poster      = poster,
+            title       = self.clean_title(title) if title else "",
+            description = description,
+            tags        = tags,
+            year        = year,
+            rating      = rating,
+            actors      = actors,
+            duration    = int(duration) if duration else None,
+        )
+
+    def _get_iframe(self, source_code: str) -> str:
+        """Base64 kodlu iframe'i çözümle"""
+        atob_match = re.search(r"PHA\+[0-9a-zA-Z+/=]*", source_code)
+        if not atob_match:
+            return ""
+
+        atob = atob_match.group()
+
+        # Padding düzelt
+        padding = 4 - len(atob) % 4
+        if padding < 4:
+            atob = atob + "=" * padding
+
+        try:
+            decoded = base64.b64decode(atob).decode("utf-8")
+            secici  = Selector(text=decoded)
+            return self.fix_url(secici.css("iframe::attr(src)").get()) or ""
+        except Exception:
+            return ""
+
+    def _extract_subtitle_url(self, source_code: str) -> str | None:
+        """Altyazı URL'sini çıkar"""
+        match = re.search(r"(https?://[^\s\"]+\.srt)", source_code)
+        return match[1] if match else None
+
+    async def load_links(self, url: str) -> list[dict]:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        iframes = set()
+
+        # Ana iframe
+        main_frame = self._get_iframe(istek.text)
+        if main_frame:
+            iframes.add(main_frame)
+
+        # Alternatif player'lar
+        for player in secici.css("div.container#player"):
+            alt_iframe = self.fix_url(player.css("iframe::attr(src)").get())
+            if alt_iframe:
+                alt_istek = await self.httpx.get(alt_iframe)
+                alt_frame = self._get_iframe(alt_istek.text)
+                if alt_frame:
+                    iframes.add(alt_frame)
+
+        results = []
+
+        for iframe in iframes:
+            subtitles = []
+
+            # VidMoly özel işleme
+            if "vidmoly" in iframe:
+                headers = {
+                    "User-Agent"     : "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36",
+                    "Sec-Fetch-Dest" : "iframe"
+                }
+                iframe_istek = await self.httpx.get(iframe, headers=headers)
+                m3u_match    = re.search(r'file:"([^"]+)"', iframe_istek.text)
+
+                if m3u_match:
+                    results.append({
+                        "name"      : "VidMoly",
+                        "url"       : m3u_match[1],
+                        "referer"   : self.main_url,
+                        "subtitles" : []
+                    })
+                    continue
+
+            # Altyazı çıkar
+            subtitle_url = self._extract_subtitle_url(url)
+            if subtitle_url:
+                subtitles.append(Subtitle(name="Türkçe", url=subtitle_url))
+
+            extractor = self.ex_manager.find_extractor(iframe)
+            results.append({
+                "name"      : extractor.name if extractor else "Player",
+                "url"       : iframe,
+                "referer"   : f"{self.main_url}/",
+                "subtitles" : subtitles
+            })
+
+        return results