KekikStream 2.3.3__py3-none-any.whl → 2.3.5__py3-none-any.whl

KekikStream/Plugins/DiziWatch.py

@@ -0,0 +1,217 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, ExtractResult, HTMLHelper
+import urllib.parse
+
+class DiziWatch(PluginBase):
+    name        = "DiziWatch"
+    language    = "tr"
+    main_url    = "https://diziwatch.to"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Diziwatch; en güncel yabancı dizileri ve animeleri, Türkçe altyazılı ve dublaj seçenekleriyle izleyebileceğiniz platform."
+
+    main_page = {
+        f"{main_url}/episodes" : "Yeni Bölümler",
+        "9"   : "Aksiyon", 
+        "17"  : "Animasyon",
+        "5"   : "Bilim Kurgu",
+        "2"   : "Dram",
+        "12"  : "Fantastik",
+        "3"   : "Gizem",
+        "4"   : "Komedi",
+        "8"   : "Korku",
+        "24"  : "Macera",
+        "14"  : "Müzik",
+        "7"   : "Romantik",
+        "23"  : "Spor",
+        "1"   : "Suç",
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.c_key   = None
+        self.c_value = None
+
+    async def _init_session(self):
+        if self.c_key and self.c_value:
+            return
+        
+        # Fetch anime-arsivi to get CSRF tokens
+        resp = await self.httpx.get(f"{self.main_url}/anime-arsivi")
+        sel  = HTMLHelper(resp.text)
+        
+        # form.bg-[rgba(255,255,255,.15)] > input
+        # We can just look for the first two inputs in that specific form
+        inputs = sel.select("form.bg-\\[rgba\\(255\\,255\\,255\\,\\.15\\)\\] input")
+        if len(inputs) >= 2:
+            self.c_key   = inputs[0].attrs.get("value")
+            self.c_value = inputs[1].attrs.get("value")
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        await self._init_session()
+        
+        if url.startswith("https://"):
+            full_url = f"{url}?page={page}"
+            resp = await self.httpx.get(full_url, headers={"Referer": f"{self.main_url}/"})
+            sel  = HTMLHelper(resp.text)
+            items = sel.select("div.swiper-slide a")
+        else:
+            # Category ID based
+            full_url = f"{self.main_url}/anime-arsivi?category={url}&minImdb=&name=&release_year=&sort=date_desc&page={page}"
+            resp = await self.httpx.get(full_url, headers={"Referer": f"{self.main_url}/"})
+            sel  = HTMLHelper(resp.text)
+            items = sel.select("div.content-inner a")
+
+        results = []
+        for item in items:
+            title  = sel.select_text("h2", item)
+            href   = item.attrs.get("href") if item.tag == "a" else sel.select_attr("a", "href", item)
+            poster = sel.select_attr("img", "src", item) or sel.select_attr("img", "data-src", item)
+
+            if title and href:
+                # If it's an episode link, clean it to get show link
+                # Regex in Kotlin: /sezon-\d+/bolum-\d+/?$
+                clean_href = HTMLHelper(href).regex_replace(r"/sezon-\d+/bolum-\d+/?$", "")
+                
+                # If cleaning changed something, it was an episode link, maybe add it to title
+                if clean_href != href:
+                    se_info = sel.select_text("div.flex.gap-1.items-center", item)
+                    if se_info:
+                        title = f"{title} - {se_info}"
+
+                results.append(MainPageResult(
+                    category = category,
+                    title    = title,
+                    url      = self.fix_url(clean_href),
+                    poster   = self.fix_url(poster) if poster else None
+                ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        await self._init_session()
+        
+        post_url = f"{self.main_url}/bg/searchcontent"
+        data = {
+            "cKey"       : self.c_key,
+            "cValue"     : self.c_value,
+            "searchterm" : query
+        }
+        
+        headers = {
+            "X-Requested-With" : "XMLHttpRequest",
+            "Accept"           : "application/json, text/javascript, */*; q=0.01",
+            "Referer"          : f"{self.main_url}/"
+        }
+        
+        resp = await self.httpx.post(post_url, data=data, headers=headers)
+        
+        try:
+            raw = resp.json()
+            # Kotlin maps this to ApiResponse -> DataWrapper -> Icerikler
+            res_array = raw.get("data", {}).get("result", [])
+            
+            results = []
+            for item in res_array:
+                title  = item.get("object_name", "").replace("\\", "")
+                slug   = item.get("used_slug", "").replace("\\", "")
+                poster = item.get("object_poster_url", "")
+                
+                # Cleanup poster URL as in Kotlin
+                if poster:
+                    poster = poster.replace("images-macellan-online.cdn.ampproject.org/i/s/", "") \
+                                   .replace("file.dizilla.club", "file.macellan.online") \
+                                   .replace("images.dizilla.club", "images.macellan.online") \
+                                   .replace("images.dizimia4.com", "images.macellan.online") \
+                                   .replace("file.dizimia4.com", "file.macellan.online")
+                    poster = HTMLHelper(poster).regex_replace(r"(file\.)[\w\.]+\/?", r"\1macellan.online/")
+                    poster = HTMLHelper(poster).regex_replace(r"(images\.)[\w\.]+\/?", r"\1macellan.online/")
+                    poster = poster.replace("/f/f/", "/630/910/")
+
+                if title and slug:
+                    results.append(SearchResult(
+                        title  = title,
+                        url    = self.fix_url(slug),
+                        poster = self.fix_url(poster) if poster else None
+                    ))
+            return results
+        except Exception:
+            return []
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+
+        title    = sel.select_text("h2")
+        poster   = sel.select_attr("img.rounded-md", "src")
+        description = sel.select_text("div.text-sm")
+        
+        year = sel.regex_first(r"Yap\u0131m Y\u0131l\u0131\s*:\s*(\d+)", resp.text)
+        
+        tags = []
+        tags_raw = sel.regex_first(r"T\u00fcr\s*:\s*([^<]+)", resp.text)
+        if tags_raw:
+            tags = [t.strip() for t in tags_raw.split(",")]
+
+        rating = sel.select_text(".font-semibold.text-white")
+        if rating:
+            rating = rating.replace(",", ".").strip()
+
+        actors = [a.text(strip=True) for a in sel.select("span.valor a")]
+        
+        trailer_match = sel.regex_first(r"embed\/(.*)\?rel", resp.text)
+        trailer = f"https://www.youtube.com/embed/{trailer_match}" if trailer_match else None
+
+        duration_text = sel.select_text("span.runtime")
+        duration = duration_text.split(" ")[0] if duration_text else None
+
+        episodes = []
+        # ul a handles episodes
+        for ep_link in sel.select("ul a"):
+            href = ep_link.attrs.get("href")
+            if not href or "/sezon-" not in href:
+                continue
+                
+            ep_name = sel.select_text("span.hidden.sm\\:block", ep_link)
+            
+            season_match = sel.regex_first(r"sezon-(\d+)", href)
+            episode_match = sel.regex_first(r"bolum-(\d+)", href)
+            
+            season = season_match if season_match else None
+            episode_num = episode_match if episode_match else None
+
+            episodes.append(Episode(
+                season  = int(season) if season and season.isdigit() else None,
+                episode = int(episode_num) if episode_num and episode_num.isdigit() else None,
+                title   = ep_name if ep_name else f"{season}x{episode_num}",
+                url     = self.fix_url(href)
+            ))
+
+        return SeriesInfo(
+            title       = title,
+            url         = url,
+            poster      = self.fix_url(poster) if poster else None,
+            description = description,
+            rating      = rating,
+            tags        = tags,
+            actors      = actors,
+            year        = year,
+            episodes    = episodes,
+            duration    = int(duration) if duration and str(duration).isdigit() else None
+        )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        resp = await self.httpx.get(url)
+        sel  = HTMLHelper(resp.text)
+        
+        iframe = sel.select_attr("iframe", "src")
+        if not iframe:
+            return []
+            
+        iframe_url = self.fix_url(iframe)
+        data = await self.extract(iframe_url, referer=f"{self.main_url}/")
+        
+        if not data:
+            return []
+            
+        return data if isinstance(data, list) else [data]

KekikStream/Plugins/DiziYou.py

@@ -1,8 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, Subtitle, ExtractResult
-from selectolax.parser import HTMLParser
-import re
+from KekikStream.Core  import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, Subtitle, ExtractResult, HTMLHelper
 
 class DiziYou(PluginBase):
     name        = "DiziYou"
@@ -31,16 +29,13 @@ class DiziYou(PluginBase):
 
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(f"{url.replace('SAYFA', str(page))}")
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         results = []
-        for veri in secici.css("div.single-item"):
-            title_el = veri.css_first("div#categorytitle a")
-            img_el   = veri.css_first("img")
-
-            title  = title_el.text(strip=True) if title_el else None
-            href   = title_el.attrs.get("href") if title_el else None
-            poster = img_el.attrs.get("src") if img_el else None
+        for veri in secici.select("div.single-item"):
+            title  = secici.select_text("div#categorytitle a", veri)
+            href   = secici.select_attr("div#categorytitle a", "href", veri)
+            poster = secici.select_attr("img", "src", veri)
 
             if title and href:
                 results.append(MainPageResult(
@@ -54,16 +49,13 @@ class DiziYou(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 afis in secici.css("div.incontent div#list-series"):
-            title_el = afis.css_first("div#categorytitle a")
-            img_el   = afis.css_first("img")
-
-            title  = title_el.text(strip=True) if title_el else None
-            href   = title_el.attrs.get("href") if title_el else None
-            poster = (img_el.attrs.get("src") or img_el.attrs.get("data-src")) if img_el else None
+        for afis in secici.select("div.incontent div#list-series"):
+            title  = secici.select_text("div#categorytitle a", afis)
+            href   = secici.select_attr("div#categorytitle a", "href", afis)
+            poster = (secici.select_attr("img", "src", afis) or secici.select_attr("img", "data-src", afis))
 
             if title and href:
                 results.append(SearchResult(
@@ -76,90 +68,92 @@ class DiziYou(PluginBase):
 
     async def load_item(self, url: str) -> SeriesInfo:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
         html_text = istek.text
 
         # Title - div.title h1 içinde
-        title_el = secici.css_first("div.title h1")
-        title    = title_el.text(strip=True) if title_el else ""
-        
+        title = secici.select_text("div.title h1")
+
         # Fallback: Eğer title boşsa URL'den çıkar (telif kısıtlaması olan sayfalar için)
         if not title:
             # URL'den slug'ı al: https://www.diziyou.one/jasmine/ -> jasmine -> Jasmine
             slug = url.rstrip('/').split('/')[-1]
             title = slug.replace('-', ' ').title()
-        
+
         # Poster
-        poster_el = secici.css_first("div.category_image img")
-        poster    = self.fix_url(poster_el.attrs.get("src")) if poster_el else ""
+        poster_src = secici.select_attr("div.category_image img", "src")
+        poster = self.fix_url(poster_src) if poster_src else ""
 
         # Year - regex ile çıkarma (xpath yerine)
-        year = None
-        year_match = re.search(r"Yapım Yılı.*?(\d{4})", html_text, re.DOTALL | re.IGNORECASE)
-        if year_match:
-            year = year_match.group(1)
+        year = secici.regex_first(r"(?is)Yapım Yılı.*?(\d{4})", secici.html)
 
-        desc_el = secici.css_first("div.diziyou_desc")
         description = None
-        if desc_el:
-            # HTML'i al ve script + meta div'lerini temizle
-            desc_html = desc_el.html
+        # Extract inner HTML via regex and clean
+        desc_html = secici.regex_first(r'(?s)<div class="diziyou_desc">(.*?)</div>', secici.html)
+        if desc_html:
             # Script taglarını kaldır
-            desc_html = re.sub(r"<script.*?</script>", "", desc_html, flags=re.DOTALL)
+            desc_html = HTMLHelper(desc_html).regex_replace(r"(?s)<script.*?</script>", "")
             # div#icerikcat2 ve sonrasını kaldır (meta bilgileri içeriyor)
-            desc_html = re.sub(r"<div id=\"icerikcat2\".*", "", desc_html, flags=re.DOTALL)
+            desc_html = HTMLHelper(desc_html).regex_replace(r"(?s)<div id=\"icerikcat2\".*", "")
             # Kalan HTML'den text çıkar
-            clean_sel = HTMLParser(desc_html)
-            description = clean_sel.text(strip=True)
+            clean_sel = HTMLHelper(desc_html)
+            description = clean_sel.select_text()
 
-        tags = [a.text(strip=True) for a in secici.css("div.genres a") if a.text(strip=True)]
+        tags = [secici.select_text(None, a) for a in secici.select("div.genres a") if secici.select_text(None, a)]
 
         # Rating - daha spesifik regex ile
-        rating = None
-        rating_match = re.search(r"IMDB\s*:\s*</span>([0-9.]+)", html_text, re.DOTALL | re.IGNORECASE)
-        if rating_match:
-            rating = rating_match.group(1)
+        rating = secici.regex_first(r"(?is)IMDB\s*:\s*</span>([0-9.]+)", secici.html)
 
         # Actors - regex ile
-        actors = []
-        actors_match = re.search(r"Oyuncular.*?</span>([^<]+)", html_text, re.DOTALL | re.IGNORECASE)
-        if actors_match:
-            actors = [actor.strip() for actor in actors_match.group(1).split(",") if actor.strip()]
+        actors_raw = secici.regex_first(r"(?is)Oyuncular.*?</span>([^<]+)", secici.html)
+        actors = [actor.strip() for actor in actors_raw.split(",") if actor.strip()] if actors_raw else []
 
         episodes = []
-        # Episodes - bolumust div içeren a linklerini bul
-        for link in secici.css("a"):
-            bolumust = link.css_first("div.bolumust")
-            if not bolumust:
-                continue
-
-            baslik_el = link.css_first("div.baslik")
-            if not baslik_el:
-                continue
-
-            ep_name = baslik_el.text(strip=True)
-            ep_href = link.attrs.get("href")
+        # Episodes - daha fazla DOM/URL kalıbını destekle
+        for link in secici.select("a"):
+            ep_href = secici.select_attr("a", "href", link)
             if not ep_href:
                 continue
 
-            # Bölüm ismi varsa al
-            bolumismi_el = link.css_first("div.bolumismi")
-            ep_name_clean = bolumismi_el.text(strip=True).replace("(", "").replace(")", "").strip() if bolumismi_el else ep_name
-
-            ep_episode_match = re.search(r"(\d+)\. Bölüm", ep_name)
-            ep_season_match  = re.search(r"(\d+)\. Sezon", ep_name)
-
-            ep_episode = ep_episode_match.group(1) if ep_episode_match else None
-            ep_season  = ep_season_match.group(1) if ep_season_match else None
-
-            if ep_episode and ep_season:
-                episode = Episode(
-                    season  = ep_season,
-                    episode = ep_episode,
-                    title   = ep_name_clean,
+            # Link metni veya alt başlık al
+            ep_name = (secici.select_text(None, link) or "").strip()
+            title_child = secici.select_text("div.baslik", link) or secici.select_text("div.bolumismi", link)
+            if title_child:
+                ep_name = title_child
+
+            # Önce metin üzerinden sezon/bölüm çıkart
+            s_val, e_val = HTMLHelper.extract_season_episode(ep_name)
+
+            # URL bazlı kalıplar: -1-sezon-2-bolum gibi
+            if not (s_val or e_val):
+                    pairs = HTMLHelper(ep_href).regex_all(r"-(\d+)-sezon-(\d+)-bolum")
+                    if pairs:
+                        s_val, e_val = int(pairs[0][0]), int(pairs[0][1])
+                    else:
+                        pairs = HTMLHelper(ep_href).regex_all(r"(\d+)-sezon-(\d+)-bolum")
+                        if pairs:
+                            s_val, e_val = int(pairs[0][0]), int(pairs[0][1])
+                        else:
+                            e_val_str = HTMLHelper(ep_href).regex_first(r"(\d+)-bolum")
+                            if e_val_str:
+                                e_val = int(e_val_str)
+            # Metin üzerinden son bir deneme
+            if not e_val:
+                e_str = HTMLHelper(ep_name).regex_first(r"(\d+)\s*\.\s*[Bb]ölüm")
+                if e_str:
+                    e_val = int(e_str)
+            if not s_val:
+                s_str = HTMLHelper(ep_name).regex_first(r"(\d+)\s*\.\s*[Ss]ezon")
+                if s_str:
+                    s_val = int(s_str)
+
+            if e_val or HTMLHelper(ep_href).regex_first(r"-\d+-sezon-\d+-bolum"):
+                episodes.append(Episode(
+                    season  = s_val,
+                    episode = e_val,
+                    title   = ep_name if ep_name else None,
                     url     = self.fix_url(ep_href),
-                )
-                episodes.append(episode)
+                ))
 
         return SeriesInfo(
             url         = url,
@@ -175,29 +169,42 @@ class DiziYou(PluginBase):
 
     async def load_links(self, url: str) -> list[ExtractResult]:
         istek  = await self.httpx.get(url)
-        secici = HTMLParser(istek.text)
+        secici = HTMLHelper(istek.text)
 
         # Title ve episode name - None kontrolü ekle
-        title_el = secici.css_first("div.title h1")
-        item_title = title_el.text(strip=True) if title_el else ""
-        
-        ep_name_el = secici.css_first("div#bolum-ismi")
-        ep_name = ep_name_el.text(strip=True) if ep_name_el else ""
+        item_title = secici.select_text("div.title h1")
+        ep_name = secici.select_text("div#bolum-ismi")
         
         # Player src'den item_id çıkar
-        player_el = secici.css_first("iframe#diziyouPlayer")
-        player_src = player_el.attrs.get("src") if player_el else None
+        # Player src'den item_id çıkar - önce özel player seçicisini dene
+        player_src = None
+        # Yaygın locatorlar
+        for sel in ["iframe#diziyouPlayer", "div.player iframe", "iframe[src*='/episodes/']", "iframe"]:
+            p = secici.select_attr(sel, "src")
+            if p and "youtube.com" not in p.lower():
+                player_src = p
+                break
+
+        # Eğer hâlâ bulunamadıysa, varsa bir bölüm sayfasına git ve oradan player'ı çek
+        if not player_src:
+            for a in secici.select("a"):
+                href = secici.select_attr("a", "href", a)
+                if not href:
+                    continue
+                if HTMLHelper(href).regex_first(r"(-\d+-sezon-\d+-bolum|/bolum|/episode|/episodes|/play)"):
+                        break
+
         if not player_src:
             return []  # Player bulunamadıysa boş liste döndür
-        
+
         item_id = player_src.split("/")[-1].replace(".html", "")
 
         subtitles   = []
         stream_urls = []
 
-        for secenek in secici.css("span.diziyouOption"):
-            opt_id  = secenek.attrs.get("id")
-            op_name = secenek.text(strip=True)
+        for secenek in secici.select("span.diziyouOption"):
+            opt_id  = secici.select_attr("span.diziyouOption", "id", secenek)
+            op_name = secici.select_text("span.diziyouOption", secenek)
 
             match opt_id:
                 case "turkceAltyazili":