KekikStream 2.2.8__tar.gz → 2.3.0__tar.gz

{kekikstream-2.2.8 → kekikstream-2.3.0}/KekikStream/Extractors/Filemoon.py

@@ -22,13 +22,14 @@ class Filemoon(ExtractorBase):
         return any(domain in url for domain in self.supported_domains)
 
     async def extract(self, url: str, referer: str = None) -> ExtractResult:
-        headers = {
-            "Referer"        : url,
-            "Sec-Fetch-Dest" : "iframe",
-            "Sec-Fetch-Mode" : "navigate",
-            "Sec-Fetch-Site" : "cross-site",
+        default_headers = {
+            "Referer"         : url,
+            "Sec-Fetch-Dest"  : "iframe",
+            "Sec-Fetch-Mode"  : "navigate",
+            "Sec-Fetch-Site"  : "cross-site",
+            "User-Agent"      : "Mozilla/5.0 (X11; Linux x86_64; rv:137.0) Gecko/20100101 Firefox/137.0"
         }
-        self.httpx.headers.update(headers)
+        self.httpx.headers.update(default_headers)
 
         # İlk sayfayı al
         istek    = await self.httpx.get(url)
@@ -38,31 +39,44 @@ class Filemoon(ExtractorBase):
         # Eğer iframe varsa, iframe'e git
         iframe_el = secici.css_first("iframe")
         iframe_src = iframe_el.attrs.get("src") if iframe_el else None
-        if iframe_src:
-            iframe_url = self.fix_url(iframe_src)
-            self.httpx.headers.update({
-                "Accept-Language" : "en-US,en;q=0.5",
-                "Sec-Fetch-Dest"  : "iframe"
-            })
-            istek    = await self.httpx.get(iframe_url)
-            response = istek.text
-
-        # Packed script'i bul ve unpack et
+        
         m3u8_url = None
-
-        if Packer.detect_packed(response):
-            try:
-                unpacked = Packer.unpack(response)
-                # sources:[{file:"...» pattern'ını ara
-                if match := re.search(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"', unpacked):
+        
+        if not iframe_src:
+            # Fallback: Script içinde ara (Kotlin: selectFirst("script:containsData(function(p,a,c,k,e,d))"))
+            script_data = ""
+            for script in secici.css("script"):
+                if "function(p,a,c,k,e,d)" in script.text():
+                    script_data = script.text()
+                    break
+            
+            if script_data:
+                unpacked = Packer.unpack(script_data)
+                if match := re.search(r'sources:\[\{file:"(.*?)"', unpacked):
                     m3u8_url = match.group(1)
-                elif match := re.search(r'file:\s*"([^"]*?\.m3u8[^"]*)"', unpacked):
+        else:
+            # Iframe varsa devam et
+            iframe_url = self.fix_url(iframe_src)
+            iframe_headers = default_headers.copy()
+            iframe_headers["Accept-Language"] = "en-US,en;q=0.5"
+            
+            istek    = await self.httpx.get(iframe_url, headers=iframe_headers)
+            response = istek.text
+            secici   = HTMLParser(response)
+            
+            script_data = ""
+            for script in secici.css("script"):
+                if "function(p,a,c,k,e,d)" in script.text():
+                    script_data = script.text()
+                    break
+            
+            if script_data:
+                unpacked = Packer.unpack(script_data)
+                if match := re.search(r'sources:\[\{file:"(.*?)"', unpacked):
                     m3u8_url = match.group(1)
-            except Exception:
-                pass
 
-        # Fallback: Doğrudan response'ta ara
         if not m3u8_url:
+            # Son çare: Normal response içinde ara
             if match := re.search(r'sources:\s*\[\s*\{\s*file:\s*"([^"]+)"', response):
                 m3u8_url = match.group(1)
             elif match := re.search(r'file:\s*"([^"]*?\.m3u8[^"]*)"', response):
@@ -75,5 +89,6 @@ class Filemoon(ExtractorBase):
             name      = self.name,
             url       = self.fix_url(m3u8_url),
             referer   = f"{self.main_url}/",
+            user_agent = default_headers["User-Agent"],
             subtitles = []
         )

{kekikstream-2.2.8 → kekikstream-2.3.0}/KekikStream/Plugins/Dizilla.py

@@ -142,44 +142,70 @@ class Dizilla(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLParser(istek.text)
 
-        # application/ld+json script'lerini al
-        ld_json_scripts = secici.css("script[type='application/ld+json']")
-        if not ld_json_scripts:
+        title = secici.css_first("div.poster.poster h2")
+        title = title.text(strip=True) if title else None
+        if not title:
             return None
 
-        # Son script'i al
-        last_script = ld_json_scripts[-1]
-        veri = loads(last_script.text(strip=True))
+        poster_el = secici.css_first("div.w-full.page-top.relative img")
+        poster = self.fix_url(poster_el.attrs.get("src")) if poster_el else None
 
-        title = veri.get("name")
-        if alt_title := veri.get("alternateName"):
-            title += f" - ({alt_title})"
+        # Year extraction (Kotlin: [1] index for w-fit min-w-fit)
+        info_boxes = secici.css("div.w-fit.min-w-fit")
+        year = None
+        if len(info_boxes) > 1:
+            year_el = info_boxes[1].css_first("span.text-sm.opacity-60")
+            if year_el:
+                year_text = year_el.text(strip=True)
+                year = year_text.split(" ")[-1] if " " in year_text else year_text
+
+        description_el = secici.css_first("div.mt-2.text-sm")
+        description = description_el.text(strip=True) if description_el else None
 
-        poster      = self.fix_url(veri.get("image"))
-        description = veri.get("description")
-        year        = veri.get("datePublished").split("-")[0]
-        
-        # Tags extraction from page content (h3 tag)
         tags_el = secici.css_first("div.poster.poster h3")
-        tags_raw = tags_el.text(strip=True) if tags_el else ""
-        tags     = [t.strip() for t in tags_raw.split(",")] if tags_raw else []
-
-        rating = veri.get("aggregateRating", {}).get("ratingValue")
-        actors = [actor.get("name") for actor in veri.get("actor", []) if actor.get("name")]
-
-        bolumler = []
-        sezonlar = veri.get("containsSeason") if isinstance(veri.get("containsSeason"), list) else [veri.get("containsSeason")]
-        for sezon in sezonlar:
-            episodes = sezon.get("episode")
-            if isinstance(episodes, dict):
-                episodes = [episodes]
+        tags = [t.strip() for t in tags_el.text(strip=True).split(",")] if tags_el else []
+
+        actors = [h5.text(strip=True) for h5 in secici.css("div.global-box h5")]
+
+        episodeses = []
+        # Seasons links iteration
+        season_links = secici.css("div.flex.items-center.flex-wrap.gap-2.mb-4 a")
+        for sezon in season_links:
+            sezon_href = self.fix_url(sezon.attrs.get("href"))
+            sezon_req = await self.httpx.get(sezon_href)
             
-            for bolum in episodes:
-                bolumler.append(Episode(
-                    season  = sezon.get("seasonNumber"),
-                    episode = bolum.get("episodeNumber"),
-                    title   = bolum.get("name"),
-                    url     = await self.url_base_degis(bolum.get("url"), self.main_url),
+            season_num = None
+            try:
+                # URL'den sezon numarasını çek: ...-sezon-X
+                season_match = re.search(r"sezon-(\d+)", sezon_href)
+                if season_match:
+                    season_num = int(season_match.group(1))
+            except:
+                pass
+
+            sezon_secici = HTMLParser(sezon_req.text)
+            for bolum in sezon_secici.css("div.episodes div.cursor-pointer"):
+                # Kotlin: bolum.select("a").last()
+                links = bolum.css("a")
+                if not links:
+                    continue
+                
+                ep_link = links[-1]
+                ep_name = ep_link.text(strip=True)
+                ep_href = self.fix_url(ep_link.attrs.get("href"))
+                
+                # Episode number (first link's text usually)
+                ep_num = None
+                try:
+                    ep_num = int(links[0].text(strip=True))
+                except:
+                    pass
+
+                episodeses.append(Episode(
+                    season  = season_num,
+                    episode = ep_num,
+                    title   = ep_name,
+                    url     = ep_href
                 ))
 
         return SeriesInfo(
@@ -188,9 +214,8 @@ class Dizilla(PluginBase):
             title       = title,
             description = description,
             tags        = tags,
-            rating      = rating,
-            year        = year,
-            episodes    = bolumler,
+            year        = str(year) if year else None,
+            episodes    = episodeses,
             actors      = actors
         )
 
@@ -212,7 +237,7 @@ class Dizilla(PluginBase):
 
         # Get first source (matching Kotlin)
         first_result = results[0]
-        source_content = first_result.get("source_content", "")
+        source_content = str(first_result.get("source_content", ""))
         
         # Clean the source_content string (matching Kotlin: .replace("\"", "").replace("\\", ""))
         cleaned_source = source_content.replace('"', '').replace('\\', '')
@@ -220,10 +245,12 @@ class Dizilla(PluginBase):
         # Parse cleaned HTML
         iframe_el = HTMLParser(cleaned_source).css_first("iframe")
         iframe_src = iframe_el.attrs.get("src") if iframe_el else None
+        
+        # Referer check (matching Kotlin: loadExtractor(iframe, "${mainUrl}/", ...))
         iframe_url = self.fix_url(iframe_src) if iframe_src else None
         
         if not iframe_url:
             return []
 
-        data = await self.extract(iframe_url, prefix=first_result.get('language_name', 'Unknown'))
+        data = await self.extract(iframe_url, referer=f"{self.main_url}/", prefix=first_result.get('language_name', 'Unknown'))
         return [data] if data else []

{kekikstream-2.2.8 → kekikstream-2.3.0}/KekikStream/Plugins/FilmMakinesi.py

@@ -1,7 +1,8 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult
+from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult
 from selectolax.parser import HTMLParser
+import re
 
 class FilmMakinesi(PluginBase):
     name        = "FilmMakinesi"
@@ -81,7 +82,7 @@ class FilmMakinesi(PluginBase):
 
         return results
 
-    async def load_item(self, url: str) -> MovieInfo:
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         istek  = await self.httpx.get(url)
         secici = HTMLParser(istek.text)
 
@@ -115,6 +116,60 @@ class FilmMakinesi(PluginBase):
             if len(parts) > 1:
                 duration = parts[1].strip()
 
+        # Dizi mi kontrol et - sezon/bölüm linkleri var mı?
+        episodes = []
+        all_links = secici.css("a[href]")
+        for link in all_links:
+            href = link.attrs.get("href", "")
+            match = re.search(r"/sezon-(\d+)/bolum-(\d+)", href)
+            if match:
+                season_no = int(match.group(1))
+                ep_no = int(match.group(2))
+                
+                # 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)
+                ))
+        
+        # Bölümler varsa SeriesInfo döndür
+        if episodes:
+            # Tekrar eden bölümleri kaldır
+            seen = set()
+            unique_episodes = []
+            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))
+            
+            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
+            )
+
         return MovieInfo(
             url         = url,
             poster      = self.fix_url(poster) if poster else None,

{kekikstream-2.2.8 → kekikstream-2.3.0}/KekikStream/Plugins/SetFilmIzle.py

@@ -2,7 +2,7 @@
 
 from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult
 from selectolax.parser import HTMLParser
-import re, json
+import re, json, asyncio
 
 class SetFilmIzle(PluginBase):
     name        = "SetFilmIzle"
@@ -229,7 +229,7 @@ class SetFilmIzle(PluginBase):
         istek  = await self.httpx.get(url)
         secici = HTMLParser(istek.text)
 
-        nonce = self._get_nonce("video_nonce", referer=url)
+        nonce = secici.css_first("div#playex").attrs.get("data-nonce") if secici.css_first("div#playex") else ""
 
         # partKey to dil label mapping
         part_key_labels = {
@@ -238,46 +238,49 @@ class SetFilmIzle(PluginBase):
             "orijinal"      : "Orijinal"
         }
 
-        links = []
+        semaphore = asyncio.Semaphore(5)
+        tasks = []
+
+        async def fetch_and_extract(player):
+            async with semaphore:
+                source_id   = player.attrs.get("data-post-id")
+                player_name = player.attrs.get("data-player-name")
+                part_key    = player.attrs.get("data-part-key")
+
+                if not source_id or "event" in source_id or source_id == "":
+                    return None
+
+                try:
+                    resp = self.cloudscraper.post(
+                        f"{self.main_url}/wp-admin/admin-ajax.php",
+                        headers = {"Referer": url},
+                        data    = {
+                            "action"      : "get_video_url",
+                            "nonce"       : nonce,
+                            "post_id"     : source_id,
+                            "player_name" : player_name or "",
+                            "part_key"    : part_key or ""
+                        }
+                    )
+                    data = resp.json()
+                except:
+                    return None
+
+                iframe_url = data.get("data", {}).get("url")
+                if not iframe_url:
+                    return None
+
+                if "setplay" not in iframe_url and part_key:
+                    iframe_url = f"{iframe_url}?partKey={part_key}"
+
+                label = part_key_labels.get(part_key, "")
+                if not label and part_key:
+                    label = part_key.replace("_", " ").title()
+
+                return await self.extract(iframe_url, prefix=label if label else None)
+
         for player in secici.css("nav.player a"):
-            source_id   = player.attrs.get("data-post-id")
-            player_name = player.attrs.get("data-player-name")
-            part_key    = player.attrs.get("data-part-key")
-
-            if not source_id or "event" in source_id or source_id == "":
-                continue
-
-            try:
-                resp = self.cloudscraper.post(
-                    f"{self.main_url}/wp-admin/admin-ajax.php",
-                    headers = {"Referer": url},
-                    data    = {
-                        "action"      : "get_video_url",
-                        "nonce"       : nonce,
-                        "post_id"     : source_id,
-                        "player_name" : player_name or "",
-                        "part_key"    : part_key or ""
-                    }
-                )
-                data = resp.json()
-            except:
-                continue
-
-            iframe_url = data.get("data", {}).get("url")
-            if not iframe_url:
-                continue
-
-            # SetPlay URL'si için part_key ekleme
-            if "setplay" not in iframe_url and part_key:
-                iframe_url = f"{iframe_url}?partKey={part_key}"
-
-            # Dil etiketi oluştur
-            label = part_key_labels.get(part_key, "")
-            if not label and part_key:
-                label = part_key.replace("_", " ").title()
-
-            data = await self.extract(iframe_url, prefix=label if label else None)
-            if data:
-                links.append(data)
-
-        return links
+            tasks.append(fetch_and_extract(player))
+
+        results = await asyncio.gather(*tasks)
+        return [r for r in results if r]

{kekikstream-2.2.8 → kekikstream-2.3.0}/KekikStream/Plugins/SezonlukDizi.py

@@ -2,7 +2,7 @@
 
 from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult
 from selectolax.parser import HTMLParser
-import re
+import re, asyncio
 
 class SezonlukDizi(PluginBase):
     name        = "SezonlukDizi"
@@ -39,6 +39,16 @@ class SezonlukDizi(PluginBase):
         f"{main_url}/diziler.asp?siralama_tipi=id&tur=western&s="    : "Western"
     }
 
+    async def _get_asp_data(self) -> dict:
+        js_req = await self.httpx.get(f"{self.main_url}/js/site.min.js")
+        alt_match   = re.search(r"dataAlternatif(.*?)\.asp", js_req.text)
+        embed_match = re.search(r"dataEmbed(.*?)\.asp", js_req.text)
+        
+        return {
+            "alternatif": alt_match.group(1) if alt_match else "",
+            "embed":      embed_match.group(1) if embed_match else ""
+        }
+
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(f"{url}{page}")
         secici = HTMLParser(istek.text)
@@ -67,7 +77,7 @@ class SezonlukDizi(PluginBase):
         secici = HTMLParser(istek.text)
 
         results = []
-        for afis in secici.css("div.afis a.column"):
+        for afis in secici.css("div.afis a"):
             desc_el = afis.css_first("div.description")
             img_el  = afis.css_first("img")
 
@@ -169,64 +179,54 @@ class SezonlukDizi(PluginBase):
             actors      = actors
         )
 
-    async def get_asp_data(self) -> tuple[str, str]:
-        """Fetch dynamic ASP version numbers from site.min.js"""
-        try:
-            js_content = await self.httpx.get(f"{self.main_url}/js/site.min.js")
-            alternatif_match = re.search(r'dataAlternatif(.*?)\.asp', js_content.text)
-            embed_match = re.search(r'dataEmbed(.*?)\.asp', js_content.text)
-            
-            alternatif_ver = alternatif_match.group(1) if alternatif_match else "22"
-            embed_ver = embed_match.group(1) if embed_match else "22"
-            
-            return (alternatif_ver, embed_ver)
-        except Exception:
-            return ("22", "22")  # Fallback to default versions
-
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek  = await self.httpx.get(url)
         secici = HTMLParser(istek.text)
-
-        dilsec_el = secici.css_first("div#dilsec")
-        bid = dilsec_el.attrs.get("data-id") if dilsec_el else None
+        asp_data = await self._get_asp_data()
+        
+        bid = secici.css_first("div#dilsec").attrs.get("data-id") if secici.css_first("div#dilsec") else None
         if not bid:
             return []
 
-        # Get dynamic ASP versions
-        alternatif_ver, embed_ver = await self.get_asp_data()
+        semaphore = asyncio.Semaphore(5)
+        tasks = []
 
-        results = []
-        for dil, label in [("1", "Altyazı"), ("0", "Dublaj")]:
-            dil_istek = await self.httpx.post(
-                url     = f"{self.main_url}/ajax/dataAlternatif{alternatif_ver}.asp",
+        async def fetch_and_extract(veri, dil_etiketi):
+            async with semaphore:
+                try:
+                    embed_resp = await self.httpx.post(
+                        f"{self.main_url}/ajax/dataEmbed{asp_data['embed']}.asp",
+                        headers = {"X-Requested-With": "XMLHttpRequest"},
+                        data    = {"id": str(veri.get("id"))}
+                    )
+                    embed_secici = HTMLParser(embed_resp.text)
+                    iframe_el = embed_secici.css_first("iframe")
+                    iframe_src = iframe_el.attrs.get("src") if iframe_el else None
+                    
+                    if iframe_src:
+                        if "link.asp" in iframe_src:
+                            return None
+                            
+                        iframe_url = self.fix_url(iframe_src)
+                        return await self.extract(iframe_url, referer=f"{self.main_url}/", prefix=f"{dil_etiketi} - {veri.get('baslik')}")
+                except:
+                    pass
+                return None
+
+        for dil_kodu, dil_etiketi in [("1", "Altyazı"), ("0", "Dublaj")]:
+            altyazi_resp = await self.httpx.post(
+                f"{self.main_url}/ajax/dataAlternatif{asp_data['alternatif']}.asp",
                 headers = {"X-Requested-With": "XMLHttpRequest"},
-                data    = {"bid": bid, "dil": dil},
+                data    = {"bid": bid, "dil": dil_kodu}
             )
-
+            
             try:
-                dil_json = dil_istek.json()
-            except Exception:
+                data_json = altyazi_resp.json()
+                if data_json.get("status") == "success" and data_json.get("data"):
+                    for veri in data_json["data"]:
+                        tasks.append(fetch_and_extract(veri, dil_etiketi))
+            except:
                 continue
 
-            if dil_json.get("status") == "success":
-                for idx, veri in enumerate(dil_json.get("data", [])):
-                    veri_response = await self.httpx.post(
-                        url     = f"{self.main_url}/ajax/dataEmbed{embed_ver}.asp",
-                        headers = {"X-Requested-With": "XMLHttpRequest"},
-                        data    = {"id": veri.get("id")},
-                    )
-                    veri_secici = HTMLParser(veri_response.text)
-
-                    iframe_el = veri_secici.css_first("iframe")
-                    iframe = iframe_el.attrs.get("src") if iframe_el else None
-
-                    if iframe:
-                        if "link.asp" in iframe:
-                            continue
-                            
-                        iframe_url = self.fix_url(iframe)
-                        data = await self.extract(iframe_url, prefix=label)
-                        if data:
-                            results.append(data)
-
-        return results
+        results = await asyncio.gather(*tasks)
+        return [r for r in results if r]

{kekikstream-2.2.8 → kekikstream-2.3.0}/KekikStream/Plugins/Sinefy.py

@@ -175,49 +175,60 @@ class Sinefy(PluginBase):
         year    = year_el.text(strip=True) if year_el else None
         
         episodes = []
-        season_elements = sel.css("section.episodes-box")
+        episodes_box = sel.css_first("section.episodes-box")
         
-        if season_elements:
-            # Get season links
-            season_links = []
-            menu = sel.css("div.ui.vertical.fluid.tabular.menu a")
-            for link in menu:
-                href = link.attrs.get("href")
-                if href:
-                    season_links.append(self.fix_url(href))
+        if episodes_box:
+            # Sezon menüsünden sezon linklerini al
+            season_menu = episodes_box.css("div.ui.vertical.fluid.tabular.menu a.item")
             
-            for s_url in season_links:
-                target_url = s_url if "/bolum-" in s_url else f"{s_url}/bolum-1"
-                
-                try:
-                    s_resp = await self.httpx.get(target_url)
-                    s_sel  = HTMLParser(s_resp.text)
-                    ep_links = s_sel.css("div.ui.list.celled a.item")
+            # Sezon tab içeriklerini al
+            season_tabs = episodes_box.css("div.ui.tab")
+            
+            # Eğer birden fazla sezon varsa, her sezon tab'ından bölümleri çek
+            if season_tabs:
+                for idx, season_tab in enumerate(season_tabs):
+                    # Sezon numarasını belirle
+                    current_season_no = idx + 1
+                    
+                    # Menüden sezon numarasını almaya çalış
+                    if idx < len(season_menu):
+                        menu_href = season_menu[idx].attrs.get("href", "")
+                        match = re.search(r"sezon-(\d+)", menu_href)
+                        if match:
+                            current_season_no = int(match.group(1))
                     
-                    current_season_no = 1
-                    match = re.search(r"sezon-(\d+)", target_url)
-                    if match:
-                        current_season_no = int(match.group(1))
+                    # Bu sezon tab'ından bölüm linklerini çek
+                    ep_links = season_tab.css("a[href*='bolum']")
                     
+                    seen_urls = set()
                     for ep_link in ep_links:
                         href = ep_link.attrs.get("href")
-                        name_el = ep_link.css_first("div.content div.header")
-                        name = name_el.text(strip=True) if name_el else ""
+                        if not href or href in seen_urls:
+                            continue
+                        seen_urls.add(href)
                         
-                        if href:
-                            ep_no = 0
-                            match_ep = re.search(r"bolum-(\d+)", href)
-                            if match_ep:
-                                ep_no = int(match_ep.group(1))
-                                
+                        # Bölüm numarasını URL'den çıkar
+                        ep_no = 0
+                        match_ep = re.search(r"bolum-(\d+)", href)
+                        if match_ep:
+                            ep_no = int(match_ep.group(1))
+                        
+                        # Bölüm başlığını çıkar (önce title attribute, sonra text)
+                        name = ep_link.attrs.get("title", "")
+                        if not name:
+                            name_el = ep_link.css_first("div.content div.header")
+                            if name_el:
+                                name = name_el.text(strip=True)
+                            else:
+                                name = ep_link.text(strip=True)
+                        
+                        if href and ep_no > 0:
                             episodes.append(Episode(
-                                season = current_season_no,
+                                season  = current_season_no,
                                 episode = ep_no,
-                                title = name,
-                                url = self.fix_url(href)
+                                title   = name.strip() if name else f"{ep_no}. Bölüm",
+                                url     = self.fix_url(href)
                             ))
-                except Exception:
-                    pass
         
         if episodes:
             return SeriesInfo(

{kekikstream-2.2.8 → kekikstream-2.3.0}/KekikStream.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KekikStream
-Version: 2.2.8
+Version: 2.3.0
 Summary: terminal üzerinden medya içeriği aramanızı ve VLC/MPV gibi popüler medya oynatıcılar aracılığıyla doğrudan izlemenizi sağlayan modüler ve genişletilebilir bir bıdı bıdı
 Home-page: https://github.com/keyiflerolsun/KekikStream
 Author: keyiflerolsun

{kekikstream-2.2.8 → kekikstream-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KekikStream
-Version: 2.2.8
+Version: 2.3.0
 Summary: terminal üzerinden medya içeriği aramanızı ve VLC/MPV gibi popüler medya oynatıcılar aracılığıyla doğrudan izlemenizi sağlayan modüler ve genişletilebilir bir bıdı bıdı
 Home-page: https://github.com/keyiflerolsun/KekikStream
 Author: keyiflerolsun

{kekikstream-2.2.8 → kekikstream-2.3.0}/setup.py

@@ -6,7 +6,7 @@ from io         import open
 setup(
     # ? Genel Bilgiler
     name         = "KekikStream",
-    version      = "2.2.8",
+    version      = "2.3.0",
     url          = "https://github.com/keyiflerolsun/KekikStream",
     description  = "terminal üzerinden medya içeriği aramanızı ve VLC/MPV gibi popüler medya oynatıcılar aracılığıyla doğrudan izlemenizi sağlayan modüler ve genişletilebilir bir bıdı bıdı",
     keywords     = ["KekikStream", "KekikAkademi", "keyiflerolsun"],