KekikStream 1.7.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

KekikStream/Plugins/JetFilmizle.py

@@ -1,14 +1,15 @@
 # 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, ExtractResult
 from parsel           import Selector
+import re
 
 class JetFilmizle(PluginBase):
     name        = "JetFilmizle"
     language    = "tr"
     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"
+    description = "Film izle, Yerli, Yabancı film izle, Türkçe dublaj, alt yazılı seçenekleriyle ödül almış filmleri Full HD kalitesiyle ve jetfilmizle hızıyla donmadan ücretsizce izleyebilirsiniz."
 
     main_page   = {
         f"{main_url}/page/"                                     : "Son Filmler",
@@ -16,12 +17,29 @@ class JetFilmizle(PluginBase):
         f"{main_url}/editorun-secimi/page/"                     : "Editörün Seçimi",
         f"{main_url}/turk-film-izle/page/"                      : "Türk Filmleri",
         f"{main_url}/cizgi-filmler-izle/page/"                  : "Çizgi Filmler",
-        f"{main_url}/kategoriler/yesilcam-filmleri-izlee/page/" : "Yeşilçam Filmleri"
+        f"{main_url}/kategoriler/yesilcam-filmleri-izlee/page/" : "Yeşilçam Filmleri",
+        f"{main_url}/film-turu/aile-filmleri-izle/page/"        : "Aile Filmleri",
+        f"{main_url}/film-turu/aksiyon-filmleri/page/"          : "Aksiyon Filmleri",
+        f"{main_url}/film-turu/animasyon-filmler-izle/page/"    : "Animasyon Filmleri",
+        f"{main_url}/film-turu/bilim-kurgu-filmler/page/"       : "Bilim Kurgu Filmleri",
+        f"{main_url}/film-turu/dram-filmleri-izle/page/"        : "Dram Filmleri",
+        f"{main_url}/film-turu/fantastik-filmleri-izle/page/"   : "Fantastik Filmler",
+        f"{main_url}/film-turu/gerilim-filmleri/page/"          : "Gerilim Filmleri",
+        f"{main_url}/film-turu/gizem-filmleri/page/"            : "Gizem Filmleri",
+        f"{main_url}/film-turu/komedi-film-full-izle/page/"     : "Komedi Filmleri",
+        f"{main_url}/film-turu/korku-filmleri-izle/page/"       : "Korku Filmleri",
+        f"{main_url}/film-turu/macera-filmleri/page/"           : "Macera Filmleri",
+        f"{main_url}/film-turu/muzikal/page/"                   : "Müzikal Filmler",
+        f"{main_url}/film-turu/polisiye/page/"                  : "Polisiye Filmler",
+        f"{main_url}/film-turu/romantik-film-izle/page/"        : "Romantik Filmler",
+        f"{main_url}/film-turu/savas-filmi-izle/page/"          : "Savaş Filmleri",
+        f"{main_url}/film-turu/spor/page/"                      : "Spor Filmleri",
+        f"{main_url}/film-turu/suc-filmleri/page/"              : "Suç Filmleri",
+        f"{main_url}/film-turu/tarihi-filmler/page/"            : "Tarihi Filmleri",
     }
 
-    #@kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
-        istek  = await self.cffi.get(f"{url}{page}", allow_redirects=True)
+        istek  = await self.httpx.get(f"{url}{page}", follow_redirects=True)
         secici = Selector(istek.text)
 
         return [
@@ -34,9 +52,8 @@ class JetFilmizle(PluginBase):
                 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.cffi.post(
+        istek  = await self.httpx.post(
             url     = f"{self.main_url}/filmara.php",
             data    = {"s": query},
             headers = {"Referer": f"{self.main_url}/"}
@@ -60,18 +77,31 @@ class JetFilmizle(PluginBase):
 
         return results
 
-    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> MovieInfo:
-        istek  = await self.cffi.get(url)
+        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,47 +115,50 @@ class JetFilmizle(PluginBase):
             actors      = actors
         )
 
-    #@kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[dict]:
-        istek  = await self.cffi.get(url)
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        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)
+                data = await self.extract(iframe_url)
+                if data:
+                    results.append(data)
+
+        # 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)
+                        data = await self.extract(iframe_url, prefix=isim)
+                        if data:
+                            results.append(data)
+            except Exception:
                 continue
 
-            part_istek  = await self.cffi.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.cffi.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)
-
-        results = []
-        for idx, iframe in enumerate(processed_iframes):
-            extractor = self.ex_manager.find_extractor(iframe)
-            results.append({
-                "url"  : iframe,
-                "name" : f"{extractor.name if extractor else f'Player {idx + 1}'}"
-            })
-
         return results

KekikStream/Plugins/KultFilmler.py

@@ -0,0 +1,217 @@
+# 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 Filmler özenle en iyi filmleri derler ve iyi bir altyazılı film izleme deneyimi sunmayı amaçlar. Reklamsız 1080P Altyazılı Film izle..."
+
+    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[ExtractResult]:
+        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(ExtractResult(
+                        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))
+
+            data = await self.extract(iframe)
+            if data:
+                # ExtractResult objesi immutable, yeni bir kopya oluştur
+                updated_data = data.model_copy(update={"subtitles": subtitles}) if subtitles else data
+                results.append(updated_data)
+
+        return results

KekikStream/Plugins/RecTV.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import kekik_cache, PluginBase, MainPageResult, SearchResult, MovieInfo, Episode, SeriesInfo, ExtractResult, Subtitle
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, Episode, SeriesInfo, ExtractResult
 from json             import dumps, loads
 import re
 
@@ -30,10 +30,9 @@ class RecTV(PluginBase):
         f"{main_url}/api/movie/by/filtres/5/created/SAYFA/{sw_key}/"  : "Romantik"
     }
 
-    #@kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
-        self.cffi.headers.update({"user-agent": "okhttp/4.12.0"})
-        istek   = await self.cffi.get(f"{url.replace('SAYFA', str(int(page) - 1))}")
+        self.httpx.headers.update({"user-agent": "okhttp/4.12.0"})
+        istek   = await self.httpx.get(f"{url.replace('SAYFA', str(int(page) - 1))}")
         veriler = istek.json()
 
         return [
@@ -46,10 +45,9 @@ class RecTV(PluginBase):
                 for veri in veriler
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
-        self.cffi.headers.update({"user-agent": "okhttp/4.12.0"})
-        istek     = await self.cffi.get(f"{self.main_url}/api/search/{query}/{self.sw_key}/")
+        self.httpx.headers.update({"user-agent": "okhttp/4.12.0"})
+        istek     = await self.httpx.get(f"{self.main_url}/api/search/{query}/{self.sw_key}/")
 
         kanallar  = istek.json().get("channels")
         icerikler = istek.json().get("posters")
@@ -67,14 +65,13 @@ class RecTV(PluginBase):
                 for veri in tum_veri
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> MovieInfo:
-        self.cffi.headers.update({"user-agent": "okhttp/4.12.0"})
+        self.httpx.headers.update({"user-agent": "okhttp/4.12.0"})
         veri = loads(url)
 
         match veri.get("type"):
             case "serie":
-                dizi_istek = await self.cffi.get(f"{self.main_url}/api/season/by/serie/{veri.get('id')}/{self.sw_key}/")
+                dizi_istek = await self.httpx.get(f"{self.main_url}/api/season/by/serie/{veri.get('id')}/{self.sw_key}/")
                 dizi_veri  = dizi_istek.json()
 
                 episodes = []
@@ -119,23 +116,21 @@ class RecTV(PluginBase):
                     actors      = []
                 )
 
-    #@kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[dict]:
-        self.media_handler.headers.update({"User-Agent": "googleusercontent"})
-
+    async def load_links(self, url: str) -> list[ExtractResult]:
         try:
             veri = loads(url)
         except Exception:
             # JSON değilse düz URL'dir (eski yapı veya hata)
-            return [{"url": url, "name": "Video"}]
+            return [ExtractResult(url=url, name="Video")]
 
         # Eğer dizi bölümü ise (bizim oluşturduğumuz yapı)
         if veri.get("is_episode"):
-            return [{
-                "url"     : veri.get("url"),
-                "name"    : veri.get("title", "Bölüm"),
-                "referer" : "https://twitter.com/"
-            }]
+            return [ExtractResult(
+                url        = veri.get("url"),
+                name       = veri.get("title", "Bölüm"),
+                user_agent = "googleusercontent",
+                referer    = "https://twitter.com/"
+            )]
 
         # Film ise (RecTV API yapısı)
         results = []
@@ -145,18 +140,11 @@ class RecTV(PluginBase):
                 if "otolinkaff" in video_link:
                     continue
 
-                results.append({
-                    "url"     : video_link,
-                    "name"    : f"{veri.get('title')} - {kaynak.get('title')}",
-                    "referer" : "https://twitter.com/"
-                })
-
-        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
-        if self.name not in self.media_handler.title:
-            self.media_handler.title = f"{self.name} | {self.media_handler.title}"
+                results.append(ExtractResult(
+                    url        = video_link,
+                    name       = f"{veri.get('title')} - {kaynak.get('title')}",
+                    user_agent = "googleusercontent",
+                    referer    = "https://twitter.com/"
+                ))
 
-        self.media_handler.play_media(extract_result)
+        return results