KekikStream 2.4.2__py3-none-any.whl → 2.4.3__py3-none-any.whl

KekikStream/Plugins/Dizilla.py

@@ -62,7 +62,7 @@ class Dizilla(PluginBase):
                 # Detay sayfasından poster vb. bilgileri al
                 ep_req = await self.httpx.get(self.fix_url(href))
                 ep_secici = HTMLHelper(ep_req.text)
-                poster = ep_secici.select_attr('img.imgt', 'src') or ep_secici.select_attr('img', 'src')
+                poster = ep_secici.select_poster('img.imgt') or ep_secici.select_poster('img')
 
                 ana_sayfa.append(MainPageResult(
                     category = category,
@@ -138,65 +138,39 @@ class Dizilla(PluginBase):
         secici = HTMLHelper(istek.text)
 
         next_data_text = secici.select_text("script#__NEXT_DATA__")
-        if not next_data_text:
-            return None
+        if not next_data_text: return None
 
         next_data   = loads(next_data_text)
         secure_data = next_data.get("props", {}).get("pageProps", {}).get("secureData")
-        if not secure_data:
-            return None
+        if not secure_data: return None
 
         decrypted = await self.decrypt_response(secure_data)
         content   = decrypted.get("contentItem", {})
-        if not content:
-            return None
+        if not content: return None
 
         title       = content.get("original_title") or content.get("used_title")
         description = content.get("description") or content.get("used_description")
         rating      = content.get("imdb_point") or content.get("local_vote_avg")
         year        = content.get("release_year")
-        
-        # Poster and Backdrop - prefer backdrop if available for SeriesInfo
-        poster = self.fix_poster_url(self.fix_url(content.get("back_url") or content.get("poster_url")))
-
-        # Tags
-        tags = []
-        categories = decrypted.get("RelatedResults", {}).get("getSerieCategoriesById", {}).get("result", [])
-        for cat in categories:
-            tags.append(cat.get("name"))
-
-        # Actors
-        actors = []
-        casts = decrypted.get("RelatedResults", {}).get("getSerieCastsById", {}).get("result", [])
-        for cast in casts:
-            actors.append(cast.get("name"))
-
-        # Episodes
-        episodes = []
-        seasons_data = decrypted.get("RelatedResults", {}).get("getSerieSeasonAndEpisodes", {}).get("result", [])
-        for season_item in seasons_data:
-            season_num = season_item.get("season_no")
-            for ep_item in season_item.get("episodes", []):
-                ep_num = ep_item.get("episode_no")
-                ep_slug = ep_item.get("used_slug")
-                ep_name = ep_item.get("episode_text") or ""
-                
-                # Filter out duplicate language entries if any (we just need one link per episode)
-                # Usually they share the same slug for the episode page
-                if any(e.season == season_num and e.episode == ep_num for e in episodes):
-                    continue
+        poster      = self.fix_poster_url(self.fix_url(content.get("back_url") or content.get("poster_url")))
 
-                episodes.append(Episode(
-                    season  = season_num,
-                    episode = ep_num,
-                    title   = ep_name,
-                    url     = self.fix_url(f"{self.main_url}/{ep_slug}")
-                ))
+        tags   = [cat.get("name") for cat in decrypted.get("RelatedResults", {}).get("getSerieCategoriesById", {}).get("result", [])]
+        actors = [cast.get("name") for cast in decrypted.get("RelatedResults", {}).get("getSerieCastsById", {}).get("result", [])]
+
+        episodes = []
+        for season in decrypted.get("RelatedResults", {}).get("getSerieSeasonAndEpisodes", {}).get("result", []):
+            s_no = season.get("season_no")
+            for ep in season.get("episodes", []):
+                e_no = ep.get("episode_no")
+                slug = ep.get("used_slug")
+                name = ep.get("episode_text") or ""
+                if not any(e.season == s_no and e.episode == e_no for e in episodes):
+                    episodes.append(Episode(season=s_no, episode=e_no, title=name, url=self.fix_url(f"{self.main_url}/{slug}")))
 
         return SeriesInfo(
             url         = url,
             poster      = poster,
-            title       = title,
+            title       = title or "Bilinmiyor",
             description = description,
             tags        = tags,
             rating      = str(rating) if rating else None,

KekikStream/Plugins/FilmBip.py

@@ -95,38 +95,24 @@ class FilmBip(PluginBase):
     async def load_item(self, url: str) -> MovieInfo:
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
-        html_text = istek.text
-
-        title = secici.select_text("div.page-title h1") or ""
-
-        poster = secici.select_attr("meta[property='og:image']", "content")
-
-        trailer = secici.select_attr("div.series-profile-trailer", "data-yt")
 
+        title       = self.clean_title(secici.select_direct_text("div.page-title h1"))
+        poster      = secici.select_poster("div.series-profile-image a img")
         description = secici.select_text("div.series-profile-infos-in.article p") or secici.select_text("div.series-profile-summary p")
-        
-        tags = secici.select_all_text("div.series-profile-type.tv-show-profile-type a")
-
-        # XPath yerine regex kullanarak yıl, süre vs. çıkarma
-        year = secici.regex_first(r"(?is)Yap\u0131m y\u0131l\u0131.*?<p[^>]*>(.*?)<\/p>")
-        if not year:
-            # Fallback: Başlığın sonundaki parantezli yılı yakala
-            year = secici.regex_first(r"\((\d{4})\)", title)
-
-        duration_raw = secici.regex_first(r"(?is)S\u00fcre.*?<p[^>]*>(.*?)<\/p>")
-        duration = secici.regex_first(r"(\d+)", duration_raw) if duration_raw else None
-
-        rating = secici.regex_first(r"(?is)IMDB Puan\u0131.*?<span[^>]*>(.*?)<\/span>")
-
-        actors = [img.attrs.get("alt") for img in secici.select("div.series-profile-cast ul li a img") if img.attrs.get("alt")]
+        tags        = secici.select_texts("div.series-profile-type.tv-show-profile-type a")
+        year        = secici.extract_year("div.series-profile-infos-in") or secici.regex_first(r"\((\d{4})\)", title)
+        duration    = secici.regex_first(r"(\d+)", secici.meta_value("Süre", container_selector="div.series-profile-infos"))
+        rating      = secici.meta_value("IMDB Puanı", container_selector="div.series-profile-infos")
+        rating      = rating.split("(")[0] if rating else None
+        actors      = secici.select_attrs("div.series-profile-cast ul li a img", "alt")
 
         return MovieInfo(
             url         = url,
             poster      = self.fix_url(poster) if poster else None,
-            title       = HTMLHelper(title).regex_replace(r"\(\d{4}\)", "").strip() if title else "",
+            title       = title or "",
             description = description,
             tags        = tags,
-            year        = year,
+            year        = str(year) if year else None,
             rating      = rating,
             duration    = int(duration) if duration else None,
             actors      = actors,

KekikStream/Plugins/FilmEkseni.py

@@ -70,45 +70,25 @@ class FilmEkseni(PluginBase):
         istek  = await self.httpx.get(url)
         helper = HTMLHelper(istek.text)
 
-        raw_title = helper.select_text("div.page-title h1")
-        title = raw_title.replace(" izle", "").strip() if raw_title else "Bilinmiyor"
-        
-        poster = helper.select_attr("picture.poster-auto > source:nth-child(2)", "data-srcset")
-        description = helper.select_text("article.text-white")
-        year = helper.select_text("strong a")
-        
-        tags_raw = helper.select_all_text("div.pb-2")
-        tags = []
-        for tag_str in tags_raw:
-            if tag_str.startswith("Tür:"):
-                tags.extend([t.strip() for t in tag_str.replace("Tür:", "").split(",")])
+        title       = self.clean_title(helper.select_text("div.page-title h1"))
+        poster      = helper.select_poster("picture.poster-auto img")
+        description = helper.select_direct_text("article.text-white p")
+        year        = helper.extract_year("div.page-title", "strong a")
+        tags        = helper.select_texts("div.pb-2 a[href*='/tur/']")
+        rating      = helper.select_text("div.rate")
+        duration    = helper.regex_first(r"(\d+)", helper.select_text("div.d-flex.flex-column.text-nowrap"))
+        actors      = helper.select_texts("div.card-body.p-0.pt-2 .story-item .story-item-title")
 
-        rating = helper.select_text("div.rate")
-        
-        duration = None
-        duration_text = helper.select_text("div.d-flex.flex-column.text-nowrap")
-        if duration_text:
-            m = re.search(r"(\d+)", duration_text)
-            if m:
-                duration = int(m.group(1))
-
-        actors_raw = helper.select("div.card-body.p-0.pt-2 .story-item")
-        actors = []
-        for actor in actors_raw:
-            name = helper.select_text(".story-item-title", actor)
-            if name:
-                actors.append(name)
-        
         return MovieInfo(
             url         = url,
-            poster      = self.fix_url(poster),
-            title       = title,
+            poster      = self.fix_url(poster) if poster else None,
+            title       = title or "Bilinmiyor",
             description = description,
             tags        = tags,
             rating      = rating,
-            year        = year,
+            year        = str(year) if year else None,
             actors      = actors if actors else None,
-            duration    = duration
+            duration    = int(duration) if duration else None
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:

KekikStream/Plugins/FilmMakinesi.py

@@ -76,94 +76,41 @@ class FilmMakinesi(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        title = secici.select_text("h1.title") or ""
+        title       = self.clean_title(secici.select_text("h1.title"))
+        poster      = secici.select_poster("img.cover-img")
+        description = secici.select_text("div.info-description p")
+        rating      = secici.regex_first(r"(\d+[\d.]*)", secici.select_text("div.score"))
+        year        = secici.select_text("span.date a")
+        actors      = secici.select_texts("div.cast-name")
+        tags        = secici.select_texts("div.type a[href*='/tur/']")
+        duration    = secici.regex_first(r"(\d+)", secici.select_text("div.time"))
 
-        poster = secici.select_attr("img.cover-img", "src") or ""
-        poster = poster.strip()
-
-        description = secici.select_text("div.info-description p") or ""
-
-        rating_text = secici.select_text("div.score") or ""
-        rating = None
-        if rating_text:
-            rating = rating_text.split()[0]
-
-        year = secici.select_text("span.date a") or ""
-
-        actors = secici.select_all_text("div.cast-name")
-        tags = [a.text(strip=True) for a in secici.select("div.type a") if "/tur/" in (a.attrs.get("href") or "")]
-
-        duration = None
-        duration_text = secici.select_text("div.time") or None
-        if duration_text:
-            parts = duration_text.split()
-            if len(parts) > 1:
-                duration = parts[1].strip()
-
-        # Dizi mi kontrol et - sezon/bölüm linkleri var mı?
         episodes = []
-        all_links = secici.select("a[href]")
-        for link in all_links:
+        for link in secici.select("a[href]"):
             href = link.attrs.get("href", "")
-            pairs = HTMLHelper(href).regex_all(r"/sezon-(\d+)/bolum-(\d+)")
-            if pairs:
-                season_no = int(pairs[0][0])
-                ep_no = int(pairs[0][1])
-
-                # Bölüm başlığını çıkar - text'ten gerçek ismi al
-                # Format: "22 Eylül 2014 / 44 dk /1. Sezon / 1. BölümPilot"
-                full_text = link.text(strip=True)
-                # "Bölüm" kelimesinden sonraki kısmı al
-                ep_title = ""
-                if "Bölüm" in full_text:
-                    parts = full_text.split("Bölüm")
-                    if len(parts) > 1:
-                        ep_title = parts[-1].strip()
-                
-                episodes.append(Episode(
-                    season  = season_no,
-                    episode = ep_no,
-                    title   = ep_title,
-                    url     = self.fix_url(href)
-                ))
+            s, e = secici.extract_season_episode(href)
+            if s and e:
+                name = link.text(strip=True).split("Bölüm")[-1].strip() if "Bölüm" in link.text() else ""
+                episodes.append(Episode(season=s, episode=e, title=name, url=self.fix_url(href)))
         
-        # Bölümler varsa SeriesInfo döndür
+        # Tekrar edenleri temizle ve sırala
         if episodes:
-            # Tekrar eden bölümleri kaldır
             seen = set()
-            unique_episodes = []
+            unique = []
             for ep in episodes:
-                key = (ep.season, ep.episode)
-                if key not in seen:
-                    seen.add(key)
-                    unique_episodes.append(ep)
-            
-            # Sırala
-            unique_episodes.sort(key=lambda x: (x.season or 0, x.episode or 0))
-            
+                if (ep.season, ep.episode) not in seen:
+                    seen.add((ep.season, ep.episode))
+                    unique.append(ep)
+            unique.sort(key=lambda x: (x.season or 0, x.episode or 0))
+
             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,
-                duration    = duration,
-                episodes    = unique_episodes
+                url=url, poster=self.fix_url(poster) if poster else None, title=title, description=description,
+                tags=tags, rating=rating, year=year, actors=actors, duration=duration, episodes=unique
             )
 
         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,
-            duration    = duration
+            url=url, poster=self.fix_url(poster) if poster else None, title=title, description=description,
+            tags=tags, rating=rating, year=year, actors=actors, duration=duration
         )
 
     async def load_links(self, url: str) -> list[ExtractResult]:

KekikStream/Plugins/FilmModu.py

@@ -81,23 +81,15 @@ class FilmModu(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLHelper(istek.text)
 
-        org_title = secici.select_text("div.titles h1") or ""
-        alt_title = secici.select_text("div.titles h2") or ""
-        title     = f"{org_title} - {alt_title}" if alt_title else org_title
-
-        poster = secici.select_attr("img.img-responsive", "src") if secici.select_attr("img.img-responsive", "src") else None
-
-        description = secici.select_text("p[itemprop='description']") or None
-
-        tags = secici.select_all_text("a[href*='film-tur/']")
-
-        year = secici.select_text("span[itemprop='dateCreated']") or None
-
-        actors = []
-        for a in secici.select("a[itemprop='actor']"):
-            name = secici.select_text("span", a)
-            if name:
-                actors.append(name)
+        org_title   = secici.select_text("div.titles h1")
+        alt_title   = secici.select_text("div.titles h2")
+        title       = f"{org_title} - {alt_title}" if alt_title else (org_title or "")
+        poster      = secici.select_poster("img.img-responsive")
+        description = secici.select_text("p[itemprop='description']")
+        tags        = secici.select_texts("a[href*='film-tur/']")
+        rating      = secici.meta_value("IMDB")
+        year        = secici.extract_year("span[itemprop='dateCreated']")
+        actors      = secici.select_texts("a[itemprop='actor'] span")
 
         return MovieInfo(
             url         = url,
@@ -105,7 +97,8 @@ class FilmModu(PluginBase):
             title       = title,
             description = description,
             tags        = tags,
-            year        = year,
+            rating      = rating,
+            year        = str(year) if year else None,
             actors      = actors,
         )
 

KekikStream/Plugins/Filmatek.py

@@ -81,52 +81,26 @@ class Filmatek(PluginBase):
         return results
 
     async def load_item(self, url: str) -> MovieInfo:
-        istek = await self.httpx.get(url)
+        istek  = await self.httpx.get(url)
         helper = HTMLHelper(istek.text)
 
-        title = helper.select_text("div.data h1, h1") or "Bilinmiyor"
-        
-        poster_el = helper.select_first("div.poster img")
-        poster = self.fix_url(poster_el.attrs.get("src")) if poster_el else None
-        if not poster:
-            poster = helper.select_attr("meta[property='og:image']", "content")
-
-        description = helper.select_text("div.wp-content p")
-        if not description:
-            description = helper.select_attr("meta[property='og:description']", "content")
-        
-        year_text = helper.select_text("span.date")
-        year = year_text.strip()[-4:] if year_text else None
-        
-        # Rating extraction updated
-        rating = helper.select_text("span.dt_rating_vgs") or helper.select_text("span.dt_rating_vmanual")
-        
-        # Duration extraction
-        duration = None
-        duration_text = helper.select_text("span.runtime")
-        if duration_text:
-            # "80 Dak." -> "80"
-            duration = duration_text.split()[0]
-
-        tags = helper.select_all_text("div.sgeneros a")
-
-        # Actors
-        actors_list = []
-        actor_els = helper.select("div.person")
-        for el in actor_els:
-            name = helper.select_text("div.name a", el)
-            if name:
-                actors_list.append(name.strip())
-        actors = ", ".join(actors_list) if actors_list else None
+        title       = self.clean_title(helper.select_text("div.data h1, h1"))
+        poster      = helper.select_poster("div.poster img") or helper.select_attr("meta[property='og:image']", "content")
+        description = helper.select_text("div.wp-content p") or helper.select_attr("meta[property='og:description']", "content")
+        year        = helper.extract_year("span.date")
+        rating      = helper.select_text("span.dt_rating_vgs") or helper.select_text("span.dt_rating_vmanual")
+        duration    = helper.regex_first(r"(\d+)", helper.select_text("span.runtime"))
+        tags        = helper.select_texts("div.sgeneros a")
+        actors      = helper.select_texts("div.person div.name a")
 
         return MovieInfo(
             url         = url,
-            title       = title,
+            title       = title or "Bilinmiyor",
             description = description,
-            poster      = poster,
-            year        = year,
+            poster      = self.fix_url(poster) if poster else None,
+            year        = str(year) if year else None,
             rating      = rating,
-            duration    = duration,
+            duration    = int(duration) if duration else None,
             tags        = tags,
             actors      = actors
         )

KekikStream/Plugins/Full4kizle.py

@@ -98,151 +98,51 @@ class Full4kizle(PluginBase):
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         istek = await self.httpx.get(url)
         helper = HTMLHelper(istek.text)
-        
-        title_raw = helper.select_text("h1") or "Bilinmiyor"
-        title = re.sub(r"(?i)izle", "", title_raw).strip()
-        
-        poster_el = helper.select_first(".poster img")
-        poster = self.fix_url(poster_el.attrs.get("src")) if poster_el else None
-        
-        description = helper.select_text(".excerpt p")
-        
-        # Robust metadata extraction using Regex
-        
-        # Initialize year first
-        year = None
-        
-        # Try .release first (legacy) or directly regex
-        rel_text = helper.select_text(".release")
-        if rel_text:
-             m_y = re.search(r"(\d{4})", rel_text)
-             if m_y: year = m_y.group(1)
-             
-        # Year fallbacks
-        if not year:
-            # Try finding year in text like "Yapım: 2024" or just isolated year in release date
-            m_year = helper.regex_first(r"Yapım:\s*(\d{4})") or helper.regex_first(r"Yıl:\s*(\d{4})")
-            if m_year:
-                year = m_year
-
-        # Rating
-        rating_text = helper.select_text(".imdb-rating")
-        if rating_text:
-            rating = rating_text.replace("IMDB Puanı", "").strip()
-        else:
-            rating = helper.regex_first(r"IMDB\s*:\s*([\d\.]+)")
-
-        # Duration
-        duration = None
-        duration_val = helper.regex_first(r"Süre:\s*(\d+)")
-        if duration_val:
-            duration = int(duration_val)
 
-        # Actors - Extract from actor links
-        actors = None
-        actors_list = []
-        
-        # Site uses: <a href=".../oyuncular/...">Actor Name</a>
-        actor_els = helper.select("a[href*='/oyuncular/']")
-        if actor_els:
-            actors_list = [el.text(strip=True) for el in actor_els if el.text(strip=True)]
-        
-        # Fallback: Try .cast-list selector
-        if not actors_list:
-            actor_els = helper.select(".cast-list .actor-name, .cast-list a")
-            if actor_els:
-                actors_list = [el.text(strip=True) for el in actor_els if el.text(strip=True)]
-        
-        if actors_list:
-            actors = ", ".join(actors_list)
-
-
-        # Tags (Genres) - Extract from genre links
-        tags = None
-        tags_list = []
-        
-        # Site uses: <a href=".../tur/...">Genre Name</a> or <a href=".../Kategori/tur/...">
-        tag_els = helper.select("a[href*='/tur/'], a[href*='/Kategori/tur/']")
-        if tag_els:
-            tags_list = [el.text(strip=True) for el in tag_els if el.text(strip=True)]
-        
-        # Fallback: Try .genres selector
-        if not tags_list:
-            tag_els = helper.select(".genres a, .genre a")
-            if tag_els:
-                tags_list = [el.text(strip=True) for el in tag_els if el.text(strip=True)]
-        
-        # Remove duplicates while preserving order
-        if tags_list:
-            seen = set()
-            unique_tags = []
-            for tag in tags_list:
-                if tag not in seen:
-                    seen.add(tag)
-                    unique_tags.append(tag)
-            tags = unique_tags if unique_tags else None
+        title       = self.clean_title(helper.select_text("h1"))
+        poster      = helper.select_poster(".poster img")
+        description = helper.select_text(".excerpt p")
+        year        = helper.extract_year(".release", ".movie-info")
+        rating      = helper.regex_first(r"([\d\.]+)", helper.select_text(".imdb-rating"))
+        duration    = int(helper.regex_first(r"(\d+)", helper.select_text(".movie-info")) or 0)
+        tags        = helper.select_texts("a[href*='/tur/'], a[href*='/Kategori/tur/']")
+        actors      = helper.select_texts("a[href*='/oyuncular/']") or helper.select_texts(".cast-list .actor-name, .cast-list a")
 
-            
-        # Check for Episodes to decide if Series or Movie
+        # Bölüm linklerini kontrol et
         ep_elements = helper.select(".parts-middle a, .parts-middle .part.active")
-        
+
         if not ep_elements:
-            # Movie
             return MovieInfo(
                 url         = url,
-                title       = title,
+                title       = title or "Bilinmiyor",
                 description = description,
-                poster      = poster,
-                year        = year,
+                poster      = self.fix_url(poster) if poster else None,
+                year        = str(year) if year else None,
                 rating      = rating,
                 duration    = duration,
                 tags        = tags,
                 actors      = actors
             )
-        else:
-            # Series
-            episodes = []
-            for i, el in enumerate(ep_elements):
-                ep_name = helper.select_text(".part-name", el) or f"Bölüm {i+1}"
-                ep_href = el.attrs.get("href")
-                if not ep_href:
-                    ep_href = url # Current page if href is empty/active?
-                ep_href = self.fix_url(ep_href)
-                
-                # Parse season/episode from name if possible
-                # Kotlin: find digit for season, substringAfter("Sezon") digit for episode
-                season = 1
-                episode = i + 1
-                
-                # Simple heuristic similar to Kotlin
-                # "1. Sezon 5. Bölüm"
-                s_match = re.search(r"(\d+)\.\s*Sezon", ep_name)
-                e_match = re.search(r"(\d+)\.\s*Bölüm", ep_name)
-                
-                if s_match:
-                    season = int(s_match.group(1))
-                if e_match:
-                    episode = int(e_match.group(1))
-                    
-                episodes.append(Episode(
-                    season  = season,
-                    episode = episode,
-                    title   = ep_name,
-                    url     = ep_href
-                ))
-                
-            return SeriesInfo(
-                url         = url,
-                title       = title,
-                description = description,
-                poster      = poster,
-                year        = year,
-                rating      = rating,
-                duration    = duration,
-                tags        = tags,
-                actors      = actors,
-                episodes    = episodes
-            )
+        
+        episodes = []
+        for i, el in enumerate(ep_elements):
+            name = helper.select_text(".part-name", el) or f"Bölüm {i+1}"
+            href = el.attrs.get("href") or url
+            s, e = helper.extract_season_episode(name)
+            episodes.append(Episode(season=s or 1, episode=e or (i + 1), title=name, url=self.fix_url(href)))
+
+        return SeriesInfo(
+            url         = url,
+            title       = title or "Bilinmiyor",
+            description = description,
+            poster      = self.fix_url(poster) if poster else None,
+            year        = str(year) if year else None,
+            rating      = rating,
+            duration    = duration,
+            tags        = tags,
+            actors      = actors,
+            episodes    = episodes
+        )
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek = await self.httpx.get(url)