KekikStream 2.2.9__py3-none-any.whl → 2.3.9__py3-none-any.whl

KekikStream/Plugins/KultFilmler.py

@@ -1,8 +1,7 @@
 # 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 selectolax.parser import HTMLParser
-import re, base64
+from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, Subtitle, HTMLHelper
+import base64
 
 class KultFilmler(PluginBase):
     name        = "KultFilmler"
@@ -38,16 +37,13 @@ class KultFilmler(PluginBase):
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("div.col-md-12 div.movie-box"):
-            img_el  = veri.css_first("div.img img")
-            link_el = veri.css_first("a")
-
-            title  = img_el.attrs.get("alt") if img_el else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = img_el.attrs.get("src") if img_el else None
+        for veri in secici.select("div.col-md-12 div.movie-box"):
+            title  = secici.select_attr("div.img img", "alt", veri)
+            href   = secici.select_attr("a", "href", veri)
+            poster = secici.select_attr("div.img img", "src", veri)
 
             if title and href:
                 results.append(MainPageResult(
@@ -61,16 +57,13 @@ class KultFilmler(PluginBase):
 
     async def search(self, query: str) -> list[SearchResult]:
         istek  = await self.httpx.get(f"{self.main_url}?s={query}")
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("div.movie-box"):
-            img_el  = veri.css_first("div.img img")
-            link_el = veri.css_first("a")
-
-            title  = img_el.attrs.get("alt") if img_el else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = img_el.attrs.get("src") if img_el else None
+        for veri in secici.select("div.movie-box"):
+            title  = secici.select_attr("div.img img", "alt", veri)
+            href   = secici.select_attr("a", "href", veri)
+            poster = secici.select_attr("div.img img", "src", veri)
 
             if title and href:
                 results.append(SearchResult(
@@ -83,58 +76,44 @@ class KultFilmler(PluginBase):
 
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
-
-        film_img = secici.css_first("div.film-bilgileri img")
-        og_title = secici.css_first("[property='og:title']")
-        og_image = secici.css_first("[property='og:image']")
+        secici = HTMLHelper(istek.text)
 
-        title       = (film_img.attrs.get("alt") if film_img else None) or (og_title.attrs.get("content") if og_title else None)
-        poster      = self.fix_url(og_image.attrs.get("content")) if og_image else None
+        title       = secici.select_attr("div.film-bilgileri img", "alt") or secici.select_attr("[property='og:title']", "content")
+        poster      = self.fix_url(secici.select_attr("[property='og:image']", "content")) if secici.select_attr("[property='og:image']", "content") else None
 
-        desc_el     = secici.css_first("div.description")
-        description = desc_el.text(strip=True) if desc_el else None
+        description = secici.select_text("div.description")
 
-        tags = [a.text(strip=True) for a in secici.css("ul.post-categories a") if a.text(strip=True)]
+        tags = [a.text(strip=True) for a in secici.select("ul.post-categories a") if a.text(strip=True)]
 
         # HTML analizine göre güncellenen alanlar
-        year_el = secici.css_first("li.release span a")
-        year    = year_el.text(strip=True) if year_el else None
+        year    = secici.select_text("li.release span a")
 
-        time_el = secici.css_first("li.time span")
-        duration = None
-        if time_el:
-            time_text = time_el.text(strip=True)
-            dur_match = re.search(r"(\d+)", time_text)
-            duration  = dur_match.group(1) if dur_match else None
+        time_text = secici.select_text("li.time span")
+        duration = secici.regex_first(r"(\d+)", time_text) if time_text else None
 
-        rating_el = secici.css_first("div.imdb-count")
-        rating    = rating_el.text(strip=True) if rating_el else None
+        rating_text = secici.select_text("div.imdb-count")
+        rating = secici.regex_first(r"(\d+\.\d+|\d+)", rating_text) if rating_text else None
 
-        actors = [a.text(strip=True) for a in secici.css("div.actors a") if a.text(strip=True)]
+        actors = [a.text(strip=True) for a in secici.select("div.actors a") if a.text(strip=True)]
 
         # Dizi mi kontrol et
         if "/dizi/" in url:
             episodes = []
-            for bolum in secici.css("div.episode-box"):
-                name_link = bolum.css_first("div.name a")
-                ep_href   = name_link.attrs.get("href") if name_link else None
+            for bolum in secici.select("div.episode-box"):
+                ep_href   = secici.select_attr("div.name a", "href", bolum)
 
-                ssn_el = bolum.css_first("span.episodetitle")
-                ssn_detail = ssn_el.text(strip=True) if ssn_el else ""
-
-                ep_b_el = bolum.css_first("span.episodetitle b")
-                ep_detail = ep_b_el.text(strip=True) if ep_b_el else ""
+                ssn_detail = secici.select_text("span.episodetitle", bolum) or ""
+                ep_detail  = secici.select_text("span.episodetitle b", bolum) 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)
+                    ep_season  = secici.regex_first(r"(\d+)\.", ssn_detail)
+                    ep_episode = secici.regex_first(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,
+                        season  = int(ep_season) if ep_season else 1,
+                        episode = int(ep_episode) if ep_episode else 1,
                         title   = ep_name.strip(" -"),
                         url     = self.fix_url(ep_href),
                     ))
@@ -165,12 +144,10 @@ class KultFilmler(PluginBase):
 
     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:
+        atob = HTMLHelper(source_code).regex_first(r"PHA\+[0-9a-zA-Z+/=]*")
+        if not atob:
             return ""
 
-        atob = atob_match.group()
-
         # Padding düzelt
         padding = 4 - len(atob) % 4
         if padding < 4:
@@ -178,20 +155,19 @@ class KultFilmler(PluginBase):
 
         try:
             decoded = base64.b64decode(atob).decode("utf-8")
-            secici  = HTMLParser(decoded)
-            iframe_el = secici.css_first("iframe")
-            return self.fix_url(iframe_el.attrs.get("src")) if iframe_el else ""
+            secici  = HTMLHelper(decoded)
+            iframe_src = secici.select_attr("iframe", "src")
+            return self.fix_url(iframe_src) if iframe_src else ""
         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
+        return HTMLHelper(source_code).regex_first(r"(https?://[^\s\"]+\.srt)")
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         iframes = set()
 
@@ -201,9 +177,9 @@ class KultFilmler(PluginBase):
             iframes.add(main_frame)
 
         # Alternatif player'lar
-        for player in secici.css("div.container#player"):
-            iframe_el = player.css_first("iframe")
-            alt_iframe = self.fix_url(iframe_el.attrs.get("src")) if iframe_el else None
+        for player in secici.select("div.container#player"):
+            iframe_src = secici.select_attr("iframe", "src", player)
+            alt_iframe = self.fix_url(iframe_src) if iframe_src else None
             if alt_iframe:
                 alt_istek = await self.httpx.get(alt_iframe)
                 alt_frame = self._get_iframe(alt_istek.text)
@@ -222,12 +198,12 @@ class KultFilmler(PluginBase):
                     "Sec-Fetch-Dest" : "iframe"
                 }
                 iframe_istek = await self.httpx.get(iframe, headers=headers)
-                m3u_match    = re.search(r'file:"([^"]+)"', iframe_istek.text)
+                m3u_match    = HTMLHelper(iframe_istek.text).regex_first(r'file:"([^"]+)"')
 
                 if m3u_match:
                     results.append(ExtractResult(
                         name      = "VidMoly",
-                        url       = m3u_match[1],
+                        url       = m3u_match,
                         referer   = self.main_url,
                         subtitles = []
                     ))

KekikStream/Plugins/RecTV.py

@@ -1,8 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, Episode, SeriesInfo, ExtractResult
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, Episode, SeriesInfo, ExtractResult, HTMLHelper
 from json             import dumps, loads
-import re
 
 class RecTV(PluginBase):
     name        = "RecTV"
@@ -84,36 +83,62 @@ class RecTV(PluginBase):
                             "is_episode" : True
                         }
                         
+                        # Extract season/episode numbers using helper
+                        s1, _ = HTMLHelper.extract_season_episode(season.get("title") or "")
+                        _, e2 = HTMLHelper.extract_season_episode(episode.get("title") or "")
+
                         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,
+                            season  = s1 or 1,
+                            episode = e2 or 1,
                             title   = episode.get("title"),
                             url     = dumps(ep_data),
                         )
 
                         episodes.append(ep_model)
 
+                # Süreyi dakikaya çevir (Örn: "1h 59min")
+                duration_raw = veri.get("duration")
+                duration = None
+                if duration_raw:
+                    try:
+                        h = int(HTMLHelper(duration_raw).regex_first(r"(\d+)h") or 0)
+                        m = int(HTMLHelper(duration_raw).regex_first(r"(\d+)min") or 0)
+                        duration = h * 60 + m
+                    except: pass
+
                 return SeriesInfo(
                     url         = url,
                     poster      = self.fix_url(veri.get("image")),
                     title       = veri.get("title"),
                     description = veri.get("description"),
                     tags        = [genre.get("title") for genre in veri.get("genres")] if veri.get("genres") else [],
-                    rating      = veri.get("imdb") or veri.get("rating"),
-                    year        = veri.get("year"),
+                    rating      = str(veri.get("imdb") or veri.get("rating") or ""),
+                    year        = str(veri.get("year") or ""),
                     actors      = [],
+                    duration    = duration,
                     episodes    = episodes
                 )
             case _:
+                # Süreyi dakikaya çevir
+                duration_raw = veri.get("duration")
+                duration = None
+                if duration_raw:
+                    try:
+                        h = int(HTMLHelper(duration_raw).regex_first(r"(\d+)h") or 0)
+                        m = int(HTMLHelper(duration_raw).regex_first(r"(\d+)min") or 0)
+                        duration = h * 60 + m
+                    except: pass
+
                 return MovieInfo(
                     url         = url,
                     poster      = self.fix_url(veri.get("image")),
                     title       = veri.get("title"),
                     description = veri.get("description"),
                     tags        = [genre.get("title") for genre in veri.get("genres")] if veri.get("genres") else [],
-                    rating      = veri.get("imdb") or veri.get("rating"),
-                    year        = veri.get("year"),
-                    actors      = []
+                    rating      = str(veri.get("imdb") or veri.get("rating") or ""),
+                    year        = str(veri.get("year") or ""),
+                    actors      = [],
+                    duration    = duration
                 )
 
     async def load_links(self, url: str) -> list[ExtractResult]:

KekikStream/Plugins/RoketDizi.py

@@ -1,8 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, MovieInfo
-from selectolax.parser import HTMLParser
-import re, base64, json
+from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, MovieInfo, HTMLHelper
+import base64, json
 
 class RoketDizi(PluginBase):
     name        = "RoketDizi"
@@ -24,19 +23,15 @@ class RoketDizi(PluginBase):
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(f"{url}?&page={page}")
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
 
         # Use div.new-added-list to find the container, then get items
-        for item in secici.css("div.new-added-list > span"):
-            title_el = item.css_first("span.line-clamp-1")
-            link_el  = item.css_first("a")
-            img_el   = item.css_first("img")
-
-            title  = title_el.text(strip=True) if title_el else None
-            href   = link_el.attrs.get("href") if link_el else None
-            poster = img_el.attrs.get("src") if img_el else None
+        for item in secici.select("div.new-added-list > span"):
+            title  = secici.select_text("span.line-clamp-1", item)
+            href   = secici.select_attr("a", "href", item)
+            poster = secici.select_attr("img", "src", item)
 
             if title and href:
                 results.append(MainPageResult(
@@ -89,108 +84,93 @@ class RoketDizi(PluginBase):
         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
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         resp = await self.httpx.get(url)
-        sel  = HTMLParser(resp.text)
-        html_text = resp.text
-
-        title_el = sel.css_first("h1.text-white")
-        title    = title_el.text(strip=True) if title_el else None
-
-        poster_el = sel.css_first("div.w-full.page-top img")
-        poster    = poster_el.attrs.get("src") if poster_el else None
-
-        desc_el     = sel.css_first("div.mt-2.text-sm")
-        description = desc_el.text(strip=True) if desc_el else None
-
-        # Tags - genre bilgileri (Detaylar bölümünde)
-        tags = []
-        genre_el = sel.css_first("h3.text-white.opacity-90")
-        if genre_el:
-            genre_text = genre_el.text(strip=True)
-            if genre_text:
-                tags = [t.strip() for t in genre_text.split(",")]
-
-        # Rating
-        rating_el = sel.css_first("span.text-white.text-sm.font-bold")
-        rating    = rating_el.text(strip=True) if rating_el else None
-
-        # 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_el = item.css_first("span.text-base")
-            value_el = item.css_first("span.text-sm.opacity-90")
+        sel  = HTMLHelper(resp.text)
+        
+        next_data_text = sel.select_text("script#__NEXT_DATA__")
+        if not next_data_text:
+            return SeriesInfo(url=url, title=sel.select_text("h1") or "Bilinmeyen")
+
+        try:
+            next_data = json.loads(next_data_text)
+            secure_data_raw = next_data["props"]["pageProps"]["secureData"]
+            secure_data = json.loads(base64.b64decode(secure_data_raw).decode('utf-8'))
             
-            label = label_el.text(strip=True) if label_el else None
-            value = value_el.text(strip=True) if value_el else None
+            content_item = secure_data.get("contentItem", {})
+            content      = secure_data.get("content", {}).get("result", {})
             
-            if label and value:
-                # 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":"([^"]*)"', html_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) if poster else None,
-            description = description,
-            tags        = tags,
-            rating      = rating,
-            actors      = actors,
-            episodes    = episodes,
-            year        = year
-        )
+            title       = content_item.get("original_title") or content_item.get("culture_title")
+            poster      = content_item.get("poster_url") or content_item.get("face_url")
+            description = content_item.get("description")
+            rating      = str(content_item.get("imdb_point") or "")
+            year        = str(content_item.get("release_year") or "")
+            tags        = content_item.get("categories", "").split(",")
+            
+            # Actors extraction from getSerieCastsById or getMovieCastsById
+            actors = []
+            casts_data = content.get("getSerieCastsById") or content.get("getMovieCastsById")
+            if casts_data and casts_data.get("result"):
+                actors = [cast.get("name") for cast in casts_data["result"] if cast.get("name")]
+
+            # Episodes extraction
+            episodes = []
+            if "Series" in str(content.get("FindedType")):
+                # Check for episodes in SecureData -> RelatedResults -> getEpisodeSources (this might be for the current episode)
+                # Usually full episode list isn't in secureData, but we can get it from HTML or another API
+                # However, many times Next.js pages have them in props
+                # Let's fallback to the previous regex method for episodes if not in JSON
+                all_urls = HTMLHelper(resp.text).regex_all(r'"url":"([^"]*)"')
+                episodes_dict = {}
+                for u in all_urls:
+                    if "bolum" in u and u not in episodes_dict:
+                        s_match = HTMLHelper(u).regex_first(r'/sezon-(\d+)')
+                        e_match = HTMLHelper(u).regex_first(r'/bolum-(\d+)')
+                        s_val = int(s_match) if s_match else 1
+                        e_val = int(e_match) if e_match else 1
+                        episodes_dict[(s_val, e_val)] = Episode(
+                            season  = s_val,
+                            episode = e_val,
+                            title   = f"{s_val}. Sezon {e_val}. Bölüm",
+                            url     = self.fix_url(u)
+                        )
+                episodes = [episodes_dict[key] for key in sorted(episodes_dict.keys())]
+
+                return SeriesInfo(
+                    url         = url,
+                    poster      = self.fix_url(poster) if poster else None,
+                    title       = self.clean_title(title),
+                    description = description,
+                    tags        = tags,
+                    rating      = rating,
+                    year        = year,
+                    actors      = actors,
+                    episodes    = episodes
+                )
+            else:
+                return MovieInfo(
+                    url         = url,
+                    poster      = self.fix_url(poster) if poster else None,
+                    title       = self.clean_title(title),
+                    description = description,
+                    tags        = tags,
+                    rating      = rating,
+                    year        = year,
+                    actors      = actors
+                )
+
+        except Exception:
+            # Fallback to simple extraction if JSON parsing fails
+            return SeriesInfo(
+                url   = url,
+                title = self.clean_title(sel.select_text("h1")) or "Bilinmeyen"
+            )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         resp = await self.httpx.get(url)
-        sel  = HTMLParser(resp.text)
+        sel  = HTMLHelper(resp.text)
         
-        next_data_el = sel.css_first("script#__NEXT_DATA__")
-        if not next_data_el:
-            return []
-
-        next_data = next_data_el.text(strip=True)
+        next_data = sel.select_text("script#__NEXT_DATA__")
         if not next_data:
             return []
 
@@ -208,11 +188,9 @@ class RoketDizi(PluginBase):
                 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:
+                iframe_url = HTMLHelper(source_content).regex_first(r'<iframe[^>]*src=["\']([^"\']*)["\']')
+                if not iframe_url:
                     continue
-
-                iframe_url = iframe_match.group(1)
                 
                 # Fix URL protocol
                 if not iframe_url.startswith("http"):