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

KekikStream/Plugins/Filmatek.py

@@ -0,0 +1,188 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, HTMLHelper
+import re
+from json import loads
+
+class Filmatek(PluginBase):
+    name        = "Filmatek"
+    language    = "tr"
+    main_url    = "https://filmatek.net"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Sosyalizmin Sineması Veritabanı"
+
+    # Main page categories
+    main_page = {
+        f"{main_url}/tur/aile/page"             : "Aile",
+        f"{main_url}/tur/aksiyon/page"          : "Aksiyon",
+        f"{main_url}/tur/animasyon/page"        : "Animasyon",
+        f"{main_url}/tur/bilim-kurgu/page"      : "Bilim Kurgu",
+        f"{main_url}/tur/komedi/page"           : "Komedi",
+        f"{main_url}/tur/korku/page"            : "Korku",
+        f"{main_url}/tur/macera/page"           : "Macera",
+        f"{main_url}/tur/romantik/page"         : "Romantik",
+        f"{main_url}/tur/suc/page"              : "Suç",
+        f"{main_url}/tur/yerli-filmler/page"    : "Yerli Filmler",
+        f"{main_url}/film-arsivi/page"          : "Tüm Filmler",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        target_url = f"{url}/{page}/"
+        istek = await self.httpx.get(target_url)
+        helper = HTMLHelper(istek.text)
+
+        items = helper.select("div.items article, #archive-content article")
+        results = []
+
+        for item in items:
+            title_el = helper.select_first("div.data h3 a, h3 a", item)
+            if not title_el: continue
+
+            title = title_el.text(strip=True)
+            href = self.fix_url(title_el.attrs.get("href"))
+            
+            img_el = helper.select_first("img", item)
+            poster = self.fix_url(img_el.attrs.get("data-src") or img_el.attrs.get("src")) if img_el else None
+
+            results.append(MainPageResult(
+                category = category,
+                title    = title,
+                url      = href,
+                poster   = poster
+            ))
+            
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        url = f"{self.main_url}/?s={query}"
+        istek = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+
+        items = helper.select("div.result-item")
+        results = []
+
+        for item in items:
+            title_el = helper.select_first("div.title a", item)
+            if not title_el: continue
+
+            title = title_el.text(strip=True)
+            href = self.fix_url(title_el.attrs.get("href"))
+            
+            img_el = helper.select_first("div.image img", item)
+            poster = self.fix_url(img_el.attrs.get("src")) if img_el else None
+
+            results.append(SearchResult(
+                title  = title,
+                url    = href,
+                poster = poster
+            ))
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo:
+        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
+        
+        score_text = helper.select_text("span.dt_rating_vmanual")
+        rating = score_text.strip() if score_text else None
+
+        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
+
+        return MovieInfo(
+            url         = url,
+            title       = title,
+            description = description,
+            poster      = poster,
+            year        = year,
+            rating      = rating,
+            tags        = tags,
+            actors      = actors
+        )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek = await self.httpx.get(url)
+        html = istek.text
+        helper = HTMLHelper(html)
+
+        # Get Post ID from body class usually "postid-123"
+        body_class = helper.select_attr("body", "class") or ""
+        post_id_match = re.search(r"postid-(\d+)", body_class)
+        
+        results = []
+        
+        if post_id_match:
+            post_id = post_id_match.group(1)
+            
+            # AJAX request for player
+            ajax_url = f"{self.main_url}/wp-admin/admin-ajax.php"
+            data = {
+                "action": "doo_player_ajax",
+                "post": post_id,
+                "nume": "1", # Usually implies source number 1? Kotlin uses "1" hardcoded.
+                "type": "movie"
+            }
+            
+            headers = {
+                "X-Requested-With": "XMLHttpRequest",
+                "Referer": url,
+                "Content-Type": "application/x-www-form-urlencoded"
+            }
+            
+            try:
+                # Need to use post with data
+                player_resp = await self.httpx.post(ajax_url, data=data, headers=headers)
+                
+                # Kotlin parses it as text and cleans slashes
+                content = player_resp.text.replace(r"\/", "/")
+                
+                # Regex for URL
+                # Kotlin: (?:src|url)["']?\s*[:=]\s*["']([^"']+)["']
+                src_match = re.search(r'(?:src|url)["\']?\s*[:=]\s*["\']([^"\']+)["\']', content)
+                
+                if src_match:
+                    iframe_url = src_match.group(1)
+                    if iframe_url.startswith("/"):
+                        iframe_url = self.main_url + iframe_url
+                        
+                    iframe_url = self.fix_url(iframe_url)
+                    
+                    extracted = await self.extract(iframe_url)
+                    if extracted:
+                        if isinstance(extracted, list):
+                            results.extend(extracted)
+                        else:
+                            results.append(extracted)
+                    else:
+                        results.append(ExtractResult(
+                            name = "Filmatek | External",
+                            url  = iframe_url,
+                            referer = url
+                        ))
+            except Exception as e:
+                # print(f"Filmatek Error: {e}")
+                pass
+
+        return results

KekikStream/Plugins/Full4kizle.py

@@ -0,0 +1,190 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, HTMLHelper
+import re
+
+class Full4kizle(PluginBase):
+    name        = "Full4kizle"
+    language    = "tr"
+    main_url    = "https://izlehdfilm.cc"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Filmci Baba, film izleme sitesi 4k Full film izle, 1080p ve 4k kalite de sinema filmleri ve dizileri, tek parça hd kalitede türkçe dublajlı filmler seyret."
+
+    main_page = {
+        f"{main_url}/Kategori/en-populer-filmler/page"        : "En Popüler Filmler",
+        f"{main_url}/Kategori/vizyondaki-filmler-izle/page"   : "Vizyondaki Filmler",
+        f"{main_url}/Kategori/yerli-filmler-izle/page"        : "Yerli Filmler",
+        f"{main_url}/Kategori/yabanci-diziler/page"           : "Yabancı Diziler",
+        f"{main_url}/Kategori/netflix-filmleri-izle/page"     : "Netflix Filmleri",
+        f"{main_url}/Kategori/netflix-dizileri/page"          : "Netflix Dizileri",
+        f"{main_url}/Kategori/anime-izle/page"                : "Anime İzle",
+        f"{main_url}/Kategori/cizgi-filmler/page"             : "Çizgi Filmler",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        target_url = f"{url}/{page}/"
+        istek = await self.httpx.get(target_url)
+        helper = HTMLHelper(istek.text)
+        
+        items = helper.select("div.movie-preview")
+        results = []
+        
+        for item in items:
+            title_el = helper.select_first(".movie-title a", item)
+            if not title_el: continue
+            
+            title = title_el.text(strip=True)
+            # Remove " izle" case insensitive
+            title = re.sub(r"(?i) izle", "", title).strip()
+            
+            href = self.fix_url(title_el.attrs.get("href"))
+            
+            poster_el = helper.select_first(".movie-poster img", item)
+            poster = self.fix_url(poster_el.attrs.get("src")) if poster_el else None
+            
+            results.append(MainPageResult(
+                category = category,
+                title    = title,
+                url      = href,
+                poster   = poster
+            ))
+            
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        url = f"{self.main_url}/?s={query}"
+        istek = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+        
+        items = helper.select("div.movie-preview")
+        results = []
+        
+        for item in items:
+            title_el = helper.select_first(".movie-title a", item)
+            if not title_el: continue
+            
+            title = title_el.text(strip=True)
+            # Remove " izle" case insensitive
+            title = re.sub(r"(?i) izle", "", title).strip()
+            
+            href = self.fix_url(title_el.attrs.get("href"))
+            
+            poster_el = helper.select_first(".movie-poster img", item)
+            poster = self.fix_url(poster_el.attrs.get("src")) if poster_el else None
+            
+            results.append(SearchResult(
+                title  = title,
+                url    = href,
+                poster = poster
+            ))
+            
+        return results
+
+    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")
+        
+        year_text = helper.select_text(".release a")
+        year = year_text.strip() if year_text else None
+        
+        rating_text = helper.select_text(".imdb-rating")
+        rating = None
+        if rating_text:
+            rating_text = rating_text.replace("IMDB Puanı", "").strip()
+            rating = rating_text
+            
+        # Check for Episodes to decide if Series or Movie
+        ep_elements = helper.select(".parts-middle a, .parts-middle .part.active")
+        
+        if not ep_elements:
+            # Movie
+            return MovieInfo(
+                url         = url,
+                title       = title,
+                description = description,
+                poster      = poster,
+                year        = year,
+                rating      = rating,
+                tags        = None, # Tags usually in genres list, implementation skipped for now or add if easy
+                actors      = None  # Actors not extracted in Kotlin reference provided
+            )
+        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,
+                tags        = None,
+                actors      = None,
+                episodes    = episodes
+            )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        istek = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+        
+        iframe = helper.select_attr(".center-container iframe", "src")
+        if not iframe:
+            iframe = helper.select_attr("iframe[src*='hotstream.club']", "src")
+            
+        results = []
+        
+        if iframe:
+            iframe = self.fix_url(iframe)
+            
+            # Use general extract method
+            extracted = await self.extract(iframe)
+            if extracted:
+                if isinstance(extracted, list):
+                    results.extend(extracted)
+                else:
+                    results.append(extracted)
+            else:
+                 results.append(ExtractResult(
+                    name = "Full4kizle | External",
+                    url  = iframe,
+                    referer = url
+                ))
+                
+        return results

KekikStream/Plugins/RecTV.py

@@ -2,6 +2,7 @@
 
 from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, Episode, SeriesInfo, ExtractResult, HTMLHelper
 from json             import dumps, loads
+import re
 
 class RecTV(PluginBase):
     name        = "RecTV"
@@ -75,26 +76,38 @@ class RecTV(PluginBase):
 
                 episodes = []
                 for season in dizi_veri:
+                    season_title = season.get("title", "").strip()
                     for episode in season.get("episodes"):
-                        # Bölüm için gerekli bilgileri JSON olarak sakla
-                        ep_data = {
-                            "url"        : self.fix_url(episode.get("sources")[0].get("url")),
-                            "title"      : f"{veri.get('title')} | {season.get('title', '1. Sezon')} {episode.get('title', '1. Bölüm')}",
-                            "is_episode" : True
-                        }
-                        
-                        # 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  = s1 or 1,
-                            episode = e2 or 1,
-                            title   = episode.get("title"),
-                            url     = dumps(ep_data),
-                        )
-
-                        episodes.append(ep_model)
+                        ep_label = episode.get("title", "").strip()
+                        for source in episode.get("sources"):
+                            # Bölüm için gerekli bilgileri JSON olarak sakla
+                            ep_data = {
+                                "url"        : self.fix_url(source.get("url")),
+                                "title"      : f"{veri.get('title')} | {season_title} {ep_label} - {source.get('title')}",
+                                "is_episode" : True
+                            }
+
+                            # Extract season/episode numbers using helper
+                            s1, _ = HTMLHelper.extract_season_episode(season_title or "")
+                            _, e2 = HTMLHelper.extract_season_episode(ep_label or "")
+
+                            tag = ""
+                            clean_season = season_title
+                            if "dublaj" in season_title.lower():
+                                tag = " (Dublaj)"
+                                clean_season = re.sub(r"\s*dublaj\s*", "", season_title, flags=re.I).strip()
+                            elif any(x in season_title.lower() for x in ["altyazı", "altyazi"]):
+                                tag = " (Altyazı)"
+                                clean_season = re.sub(r"\s*altyaz[ıi]\s*", "", season_title, flags=re.I).strip()
+
+                            ep_model = Episode(
+                                season  = s1 or 1,
+                                episode = e2 or 1,
+                                title   = f"{clean_season} {ep_label}{tag} - {source.get('title')}",
+                                url     = dumps(ep_data),
+                            )
+
+                            episodes.append(ep_model)
 
                 # Süreyi dakikaya çevir (Örn: "1h 59min")
                 duration_raw = veri.get("duration")

KekikStream/Plugins/Watch32.py

@@ -0,0 +1,185 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, SeriesInfo, Episode, ExtractResult, HTMLHelper
+from json             import dumps, loads
+import re
+
+class Watch32(PluginBase):
+    name        = "Watch32"
+    language    = "en"
+    main_url    = "https://watch32.sx"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64" 
+    description = "Watch Your Favorite Movies & TV Shows Online - Streaming For Free. With Movies & TV Shows Full HD. Find Your Movies & Watch NOW!"
+
+    main_page = {
+        f"{main_url}/movie?page="      : "Popular Movies",
+        f"{main_url}/tv-show?page="    : "Popular TV Shows",
+        f"{main_url}/coming-soon?page=" : "Coming Soon",
+        f"{main_url}/top-imdb?page="   : "Top IMDB Rating",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = await self.httpx.get(f"{url}{page}")
+        helper = HTMLHelper(istek.text)
+        items  = helper.select("div.flw-item")
+
+        return [
+            MainPageResult(
+                category = category,
+                title    = helper.select_attr("h2.film-name a", "title", veri),
+                url      = self.fix_url(helper.select_attr("h2.film-name a", "href", veri)),
+                poster   = helper.select_attr("img.film-poster-img", "data-src", veri)
+            )
+            for veri in items
+        ]
+
+    async def search(self, query: str) -> list[SearchResult]:
+        slug = query.replace(" ", "-")
+        url  = f"{self.main_url}/search/{slug}"
+        
+        istek  = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+        items  = helper.select("div.flw-item")
+
+        return [
+            SearchResult(
+                title  = helper.select_attr("h2.film-name a", "title", veri),
+                url    = self.fix_url(helper.select_attr("h2.film-name a", "href", veri)),
+                poster = helper.select_attr("img.film-poster-img", "data-src", veri)
+            )
+            for veri in items
+        ]
+
+    async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
+        istek  = await self.httpx.get(url)
+        helper = HTMLHelper(istek.text)
+        
+        content_id = helper.select_attr("div.detail_page-watch", "data-id")
+        details    = helper.select_first("div.detail_page-infor")
+        name       = helper.select_text("h2.heading-name > a", details)
+        
+        poster      = helper.select_attr("div.film-poster > img", "src", details)
+        description = helper.select_text("div.description", details)
+        
+        # Release year extraction
+        year_text = helper.regex_first(r"Released:\s*(\d{4})")
+        if not year_text:
+             # Fallback for series
+             year_text = helper.regex_first(r"Released:.+?(\d{4})")
+        
+        # Tags/Genres
+        tags = helper.select_all_text("div.row-line:has(> span.type > strong:contains(Genre)) a")
+        
+        # Rating
+        rating = helper.select_text("button.btn-imdb")
+        if rating:
+            rating = rating.replace("N/A", "").split(":")[-1].strip()
+
+        # Actors
+        actors = helper.select_all_text("div.row-line:has(> span.type > strong:contains(Casts)) a")
+
+        if "movie" in url:
+            return MovieInfo(
+                url         = url,
+                poster      = self.fix_url(poster),
+                title       = name,
+                description = description,
+                tags        = tags,
+                rating      = rating,
+                year        = year_text,
+                actors      = actors
+            )
+        else:
+            episodes = []
+            seasons_resp = await self.httpx.get(f"{self.main_url}/ajax/season/list/{content_id}")
+            sh = HTMLHelper(seasons_resp.text)
+            seasons = sh.select("a.dropdown-item") # Relaxed selector from a.ss-item
+            
+            for season in seasons:
+                season_id = season.attrs.get("data-id")
+                season_num_text = season.text().replace("Season ", "").replace("Series", "").strip()
+                season_num = int(season_num_text) if season_num_text.isdigit() else 1
+                
+                episodes_resp = await self.httpx.get(f"{self.main_url}/ajax/season/episodes/{season_id}")
+                eh = HTMLHelper(episodes_resp.text)
+                eps = eh.select("a.eps-item")
+                
+                for ep in eps:
+                    ep_id = ep.attrs.get("data-id")
+                    ep_title_raw = ep.attrs.get("title", "")
+                    # Eps 1: Name
+                    m = re.search(r"Eps (\d+): (.+)", ep_title_raw)
+                    if m:
+                        ep_num  = int(m.group(1))
+                        ep_name = m.group(2)
+                    else:
+                        ep_num  = 1
+                        ep_name = ep_title_raw
+                        
+                    episodes.append(Episode(
+                        season  = season_num,
+                        episode = ep_num,
+                        title   = ep_name,
+                        url     = f"servers/{ep_id}"
+                    ))
+            
+            return SeriesInfo(
+                url         = url,
+                poster      = self.fix_url(poster),
+                title       = name,
+                description = description,
+                tags        = tags,
+                rating      = rating,
+                year        = year_text,
+                actors      = actors,
+                episodes    = episodes
+            )
+
+    async def load_links(self, url: str) -> list[ExtractResult]:
+        # url in load_links might be the full page URL for movies or "servers/epId" for episodes
+        if "servers/" in url:
+            data = url.split("/")[-1]
+        if "servers/" in url:
+            data = url.split("/")[-1]
+            servers_url = f"servers/{data}"
+        elif "list/" in url:
+            data = url.split("/")[-1]
+            servers_url = f"list/{data}"
+        else:
+             # Re-fetch page to get contentId only if we don't have list/ or servers/
+             istek = await self.httpx.get(url)
+             helper = HTMLHelper(istek.text)
+             content_id = helper.select_attr("div.detail_page-watch", "data-id")
+             if not content_id:
+                # Try to get id from url if direct parse fails, similar to Kotlin logic
+                # But Kotlin parses search first. Here we assume we are at the page.
+                # If no content_id found, maybe it's not a valid page or structure changed.
+                return []
+             servers_url = f"list/{content_id}"
+
+        servers_resp = await self.httpx.get(f"{self.main_url}/ajax/episode/{servers_url}")
+        sh = HTMLHelper(servers_resp.text)
+        servers = sh.select("a.link-item")
+        
+        results = []
+        for server in servers:
+            link_id = server.attrs.get("data-linkid") or server.attrs.get("data-id")
+            source_resp = await self.httpx.get(f"{self.main_url}/ajax/episode/sources/{link_id}")
+            source_data = source_resp.json()
+            video_url = source_data.get("link")
+            
+            if video_url:
+                # Use extractors if possible
+                extract_result = await self.extract(video_url)
+                if extract_result:
+                    if isinstance(extract_result, list):
+                        results.extend(extract_result)
+                    else:
+                        results.append(extract_result)
+                else:
+                    results.append(ExtractResult(
+                        url  = video_url,
+                        name = f"{self.name} | {server.text()}"
+                    ))
+                    
+        return results

{kekikstream-2.3.9.dist-info → kekikstream-2.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KekikStream
-Version: 2.3.9
+Version: 2.4.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
@@ -63,13 +63,13 @@ Terminal üzerinden içerik arayın, VLC/MPV ile doğrudan izleyin veya kendi AP
 
 ## 🚦 Ne Sunar?
 
-KekikStream, Türkçe medya kaynaklarını tek CLI arayüzünde toplayarak hızlı arama ve oynatma sunar. Plugin mimarisi sayesinde yeni kaynaklar eklemek ve [KekikStreamAPI](https://github.com/keyiflerolsun/KekikStreamAPI) ile web/API üzerinden yayın yapmak kolaydır.
+KekikStream, Türkçe medya kaynaklarını tek CLI arayüzünde toplayarak hızlı arama ve oynatma sunar. Plugin mimarisi sayesinde yeni kaynaklar eklemek ve [WatchBuddy](https://github.com/WatchBuddy-tv/Stream) ile web/API üzerinden yayın yapmak kolaydır.
 
 - 🎥 Çoklu kaynak desteği: Onlarca Türkçe medya sitesi  
 - 🔌 Plugin mimarisi: Yeni kaynak eklemek dakikalar sürer  
 - 🎬 Çoklu oynatıcı: VLC, MPV, MX Player  
 - 🖥️ CLI & kütüphane: Terminalde veya kod içinde kullanın  
-- 🌐 API/Web UI: KekikStreamAPI üzerinden uzak erişim
+- 🌐 API/Web UI: WatchBuddy üzerinden uzak erişim
 
 ---