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

KekikStream/Plugins/RecTV.py

@@ -1,20 +1,17 @@
 # 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 httpx            import AsyncClient
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, Episode, SeriesInfo, ExtractResult, Subtitle
 from json             import dumps, loads
 import re
 
 class RecTV(PluginBase):
     name        = "RecTV"
     language    = "tr"
-    main_url    = "https://m.prectv37.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."
 
-    sw_key  = "4F5A9C3D9A86FA54EACEDDD635185/c3c5bd17-e37b-4b94-a944-8a3688a30452"
-    http2   = AsyncClient(http2=True)
-    http2.headers.update({"user-agent": "okhttp/4.12.0"})
+    sw_key = "4F5A9C3D9A86FA54EACEDDD635185/c3c5bd17-e37b-4b94-a944-8a3688a30452"
 
     main_page   = {
         f"{main_url}/api/channel/by/filtres/0/0/SAYFA/{sw_key}/"      : "Canlı",
@@ -33,8 +30,8 @@ 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.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()
 
@@ -48,11 +45,9 @@ class RecTV(PluginBase):
                 for veri in veriler
         ]
 
-    @kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
-        self.media_handler.headers.update({"User-Agent": "googleusercontent"})
-
-        istek     = await self.http2.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")
@@ -70,34 +65,34 @@ class RecTV(PluginBase):
                 for veri in tum_veri
         ]
 
-    @kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> MovieInfo:
+        self.httpx.headers.update({"user-agent": "okhttp/4.12.0"})
         veri = loads(url)
 
         match veri.get("type"):
             case "serie":
-                dizi_istek = await self.http2.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 = []
                 for season in dizi_veri:
                     for episode in season.get("episodes"):
+                        # Bölüm için gerekli bilgileri JSON olarak sakla
+                        ep_data = {
+                            "url"        : self.fix_url(episode.get("sources")[0].get("url")),
+                            "title"      : f"{veri.get('title')} | {season.get('title', '1. Sezon')} {episode.get('title', '1. Bölüm')}",
+                            "is_episode" : True
+                        }
+                        
                         ep_model = Episode(
                             season  = int(re.search(r"(\d+)\.S", season.get("title")).group(1)) if re.search(r"(\d+)\.S", season.get("title")) else 1,
                             episode = int(re.search(r"Bölüm (\d+)", episode.get("title")).group(1)) if re.search(r"Bölüm (\d+)", episode.get("title")) else 1,
                             title   = episode.get("title"),
-                            url     = self.fix_url(episode.get("sources")[0].get("url")),
+                            url     = dumps(ep_data),
                         )
 
                         episodes.append(ep_model)
 
-                        self._data[ep_model.url] = {
-                            "ext_name"  : self.name,
-                            "name"      : f"{veri.get('title')} | {ep_model.season}. Sezon {ep_model.episode}. Bölüm",
-                            "referer"   : "https://twitter.com/",
-                            "subtitles" : []
-                        }
-
                 return SeriesInfo(
                     url         = url,
                     poster      = self.fix_url(veri.get("image")),
@@ -121,33 +116,42 @@ class RecTV(PluginBase):
                     actors      = []
                 )
 
-    @kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[str]:
+    async def load_links(self, url: str) -> list[dict]:
         try:
             veri = loads(url)
         except Exception:
-            return [url]
-
-        videolar = []
+            # JSON değilse düz URL'dir (eski yapı veya hata)
+            return [{"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"),
+                "user_agent" : "googleusercontent",
+                "referer"    : "https://twitter.com/"
+            }]
+
+        # Film ise (RecTV API yapısı)
+        results = []
         if veri.get("sources"):
             for kaynak in veri.get("sources"):
                 video_link = kaynak.get("url")
                 if "otolinkaff" in video_link:
                     continue
 
-                self._data[video_link] = {
-                    "ext_name"  : self.name,
-                    "name"      : veri.get("title"),
-                    "referer"   : "https://twitter.com/",
-                    "subtitles" : []
-                }
-                videolar.append(video_link)
+                results.append({
+                    "url"        : video_link,
+                    "name"       : f"{veri.get('title')} - {kaynak.get('title')}",
+                    "user_agent" : "googleusercontent",
+                    "referer"    : "https://twitter.com/"
+                })
 
-        return videolar
+        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/RoketDizi.py

@@ -0,0 +1,232 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, MovieInfo
+from parsel           import Selector
+import re, base64, json
+
+class RoketDizi(PluginBase):
+    name        = "RoketDizi"
+    lang        = "tr"
+    main_url    = "https://roketdizi.to"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Türkiye'nin en tatlış yabancı dizi izleme sitesi. Türkçe dublaj, altyazılı, eski ve yeni yabancı dizilerin yanı sıra kore (asya) dizileri izleyebilirsiniz."
+
+    main_page = {
+       f"{main_url}/dizi/tur/aksiyon"     : "Aksiyon",
+       f"{main_url}/dizi/tur/bilim-kurgu" : "Bilim Kurgu",
+       f"{main_url}/dizi/tur/gerilim"     : "Gerilim",
+       f"{main_url}/dizi/tur/fantastik"   : "Fantastik",
+       f"{main_url}/dizi/tur/komedi"      : "Komedi",
+       f"{main_url}/dizi/tur/korku"       : "Korku",
+       f"{main_url}/dizi/tur/macera"      : "Macera",
+       f"{main_url}/dizi/tur/suc"         : "Suç"
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = await self.httpx.get(f"{url}?&page={page}")
+        secici = Selector(istek.text)
+
+        results = []
+
+        for item in secici.css("div.w-full.p-4 span.bg-\\[\\#232323\\]"):
+            title  = item.css("span.font-normal.line-clamp-1::text").get()
+            href   = item.css("a::attr(href)").get()
+            poster = item.css("img::attr(src)").get()
+
+            if title and href:
+                results.append(MainPageResult(
+                    category = category,
+                    title    = self.clean_title(title),
+                    url      = self.fix_url(href),
+                    poster   = self.fix_url(poster)
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek = await self.httpx.post(
+            url     = f"{self.main_url}/api/bg/searchContent?searchterm={query}",
+            headers = {
+                "Accept"           : "application/json, text/javascript, */*; q=0.01",
+                "X-Requested-With" : "XMLHttpRequest",
+                "Referer"          : f"{self.main_url}/",
+            }
+        )
+        
+        try:
+            veri    = istek.json()
+            encoded = veri.get("response", "")
+            if not encoded:
+                return []
+
+            decoded = base64.b64decode(encoded).decode("utf-8")
+            veri    = json.loads(decoded)
+
+            if not veri.get("state"):
+                return []
+
+            results = []
+
+            for item in veri.get("result", []):
+                title  = item.get("object_name", "")
+                slug   = item.get("used_slug", "")
+                poster = item.get("object_poster_url", "")
+
+                if title and slug:
+                    results.append(SearchResult(
+                        title  = self.clean_title(title.strip()),
+                        url    = self.fix_url(f"{self.main_url}/{slug}"),
+                        poster = self.fix_url(poster) if poster else None
+                    ))
+
+            return results
+
+        except Exception:
+            return []
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        # Note: Handling both Movie and Series logic in one, returning SeriesInfo generally or MovieInfo
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+
+        title       = sel.css("h1.text-white::text").get()
+        poster      = sel.css("div.w-full.page-top img::attr(src)").get()
+        description = sel.css("div.mt-2.text-sm::text").get()
+
+        # Tags - genre bilgileri (Detaylar bölümünde)
+        tags = []
+        genre_text = sel.css("h3.text-white.opacity-90::text").get()
+        if genre_text:
+            tags = [t.strip() for t in genre_text.split(",")]
+
+        # Rating
+        rating = sel.css("span.text-white.text-sm.font-bold::text").get()
+
+        # Year ve Actors - Detaylar (Details) bölümünden
+        year = None
+        actors = []
+
+        # Detaylar bölümündeki tüm flex-col div'leri al
+        detail_items = sel.css("div.flex.flex-col")
+        for item in detail_items:
+            # Label ve value yapısı: span.text-base ve span.text-sm.opacity-90
+            label = item.css("span.text-base::text").get()
+            value = item.css("span.text-sm.opacity-90::text").get()
+            
+            if label and value:
+                label = label.strip()
+                value = value.strip()
+                
+                # Yayın tarihi (yıl)
+                if label == "Yayın tarihi":
+                    # "16 Ekim 2018" formatından yılı çıkar
+                    year_match = re.search(r'\d{4}', value)
+                    if year_match:
+                        year = year_match.group()
+                
+                # Yaratıcılar veya Oyuncular
+                elif label in ["Yaratıcılar", "Oyuncular"]:
+                    if value:
+                        actors.append(value)
+
+        # Check urls for episodes
+        all_urls = re.findall(r'"url":"([^"]*)"', resp.text)
+        is_series = any("bolum-" in u for u in all_urls)
+
+        episodes = []
+        if is_series:
+            # Dict kullanarak duplicate'leri önle ama sıralı tut
+            episodes_dict = {}
+            for u in all_urls:
+                if "bolum" in u and u not in episodes_dict:
+                    season_match = re.search(r'/sezon-(\d+)', u)
+                    ep_match     = re.search(r'/bolum-(\d+)', u)
+
+                    season = int(season_match.group(1)) if season_match else 1
+                    episode_num = int(ep_match.group(1)) if ep_match else 1
+
+                    # Key olarak (season, episode) tuple kullan
+                    key = (season, episode_num)
+                    episodes_dict[key] = Episode(
+                        season  = season,
+                        episode = episode_num,
+                        title   = f"{season}. Sezon {episode_num}. Bölüm",
+                        url     = self.fix_url(u)
+                    )
+
+            # Sıralı liste oluştur
+            episodes = [episodes_dict[key] for key in sorted(episodes_dict.keys())]
+
+        return SeriesInfo(
+            title       = title,
+            url         = url,
+            poster      = self.fix_url(poster),
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            actors      = actors,
+            episodes    = episodes,
+            year        = year
+        )
+
+    async def load_links(self, url: str) -> list[dict]:
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+        
+        next_data = sel.css("script#__NEXT_DATA__::text").get()
+        if not next_data:
+            return []
+
+        try:
+            data = json.loads(next_data)
+            secure_data = data["props"]["pageProps"]["secureData"]
+            decoded_json = json.loads(base64.b64decode(secure_data).decode('utf-8'))
+
+            # secureData içindeki RelatedResults -> getEpisodeSources -> result dizisini al
+            sources = decoded_json.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
+
+            results = []
+            for source in sources:
+                source_content = source.get("source_content", "")
+
+                # iframe URL'ini source_content'ten çıkar
+                iframe_match = re.search(r'<iframe[^>]*src=["\']([^"\']*)["\']', source_content)
+                if not iframe_match:
+                    continue
+
+                iframe_url = iframe_match.group(1)
+                if "http" not in iframe_url:
+                     if iframe_url.startswith("//"):
+                         iframe_url = "https:" + iframe_url
+                     else:
+                         iframe_url = "https://" + iframe_url
+
+                # Check extractor
+                extractor = self.ex_manager.find_extractor(iframe_url)
+                ext_name  = extractor.name if extractor else ""
+
+                # Metadata'dan bilgileri al
+                source_name   = source.get("source_name", "")
+                language_name = source.get("language_name", "")
+                quality_name  = source.get("quality_name", "")
+
+                # İsmi oluştur
+                name_parts = []
+                if source_name:
+                    name_parts.append(source_name)
+                if ext_name:
+                    name_parts.append(ext_name)
+                if language_name:
+                    name_parts.append(language_name)
+                if quality_name:
+                    name_parts.append(quality_name)
+
+                results.append({
+                    "url"  : iframe_url,
+                    "name" : " | ".join(name_parts)
+                })
+
+            return results
+
+        except Exception:
+            return []