KekikStream 0.0.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

KekikStream/Managers/ExtractorManager.py

@@ -21,7 +21,7 @@ class ExtractorManager:
             for extractor_cls in self.extractors:
                 extractor:ExtractorBase = extractor_cls()
                 if extractor.can_handle_url(link):
-                    mapping[link] = extractor.name
+                    mapping[link] = f"{extractor.name:<30} » {link.replace(extractor.main_url, '')}"
                     break
 
         return mapping

KekikStream/Managers/PluginManager.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from ..Core import PluginLoader
+from ..Core import PluginLoader, PluginBase
 
 class PluginManager:
     def __init__(self, plugin_dir="Plugins"):
@@ -8,11 +8,12 @@ class PluginManager:
         self.plugins       = self.plugin_loader.load_all()
 
     def get_plugin_names(self):
-        return list(self.plugins.keys())
+        return sorted(list(self.plugins.keys()))
 
     def select_plugin(self, plugin_name):
         return self.plugins.get(plugin_name)
 
     async def close_plugins(self):
         for plugin in self.plugins.values():
-            await plugin.close()
+            if isinstance(plugin, PluginBase):
+                await plugin.close()

KekikStream/Managers/UIManager.py

@@ -13,7 +13,17 @@ class UIManager:
 
     @staticmethod
     async def select_from_list(message, choices):
-        return await inquirer.select(message=message, choices=choices).execute_async()
+        return await inquirer.select(message=message, choices=choices, max_height="75%").execute_async()
+
+    @staticmethod
+    async def select_from_fuzzy(message, choices):
+        return await inquirer.fuzzy(
+            message    = message,
+            choices    = choices,
+            validate   = lambda result: result in [choice if isinstance(choice, str) else choice["value"] for choice in choices],
+            filter     = lambda result: result,
+            max_height = "75%"
+        ).execute_async()
 
     @staticmethod
     async def prompt_text(message):
@@ -26,6 +36,9 @@ class UIManager:
         table.add_column(style="magenta")
 
         for key, value in media_info.dict().items():
+            if key == "episodes":
+                continue
+
             if value:
                 table.add_row(f"[bold cyan]{key.capitalize()}[/bold cyan]", str(value))
 

KekikStream/Plugins/JetFilmizle.py

@@ -0,0 +1,96 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, SearchResult, MovieInfo
+from parsel           import Selector
+
+class JetFilmizle(PluginBase):
+    name     = "JetFilmizle"
+    main_url = "https://jetfilmizle.media"
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek  = await self.oturum.post(
+            url     = f"{self.main_url}/filmara.php",
+            data    = {"s": query},
+            headers = {"Referer": f"{self.main_url}/"}
+        )
+        secici = Selector(istek.text)
+
+        results = []
+        for article in secici.css("article.movie"):
+            title  = self.clean_title(article.css("h2 a::text, h3 a::text, h4 a::text, h5 a::text, h6 a::text").get())
+            href   = article.css("a::attr(href)").get()
+            poster = article.css("img::attr(data-src)").get() or article.css("img::attr(src)").get()
+
+            if title and href:
+                results.append(
+                    SearchResult(
+                        title  = title.strip(),
+                        url    = self.fix_url(href.strip()),
+                        poster = self.fix_url(poster.strip()) if poster else None,
+                    )
+                )
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo:
+        istek  = await self.oturum.get(url)
+        secici = Selector(istek.text)
+
+        title       = self.clean_title(secici.css("div.movie-exp-title::text").get())
+        poster      = secici.css("section.movie-exp img::attr(data-src), section.movie-exp img::attr(src)").get().strip()
+        description = secici.css("section.movie-exp p.aciklama::text").get().strip()
+        tags        = secici.css("section.movie-exp div.catss a::text").getall()
+        rating      = secici.css("section.movie-exp div.imdb_puan span::text").get().strip()
+        year        = secici.xpath("//div[@class='yap' and (contains(., 'Vizyon') or contains(., 'Yapım'))]/text()").get().strip()
+        actors      = secici.css("div[itemprop='actor'] a span::text").getall()
+
+        return MovieInfo(
+            url         = url,
+            poster      = self.fix_url(poster),
+            title       = title,
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            year        = year,
+            actors      = actors
+        )
+
+    async def load_links(self, url: str) -> list[str]:
+        istek  = await self.oturum.get(url)
+        secici = Selector(istek.text)
+
+        iframes = []
+        main_iframe = secici.css("div#movie iframe::attr(data-src), div#movie iframe::attr(data), div#movie iframe::attr(src)").get()
+        if main_iframe:
+            iframes.append(self.fix_url(main_iframe))
+
+        for part in secici.css("div.film_part a"):
+            part_href = part.attrib.get("href")
+            if not part_href:
+                continue
+
+            part_istek  = await self.oturum.get(part_href)
+            part_secici = Selector(part_istek.text)
+
+            iframe = part_secici.css("div#movie iframe::attr(data-src), div#movie iframe::attr(data), div#movie iframe::attr(src)").get()
+            if iframe:
+                iframes.append(self.fix_url(iframe))
+            else:
+                for link in part_secici.css("div#movie p a"):
+                    download_link = link.attrib.get("href")
+                    if download_link:
+                        iframes.append(self.fix_url(download_link))
+
+        processed_iframes = []
+        for iframe in iframes:
+            if "jetv.xyz" in iframe:
+                jetv_istek  = await self.oturum.get(iframe)
+                jetv_secici = Selector(jetv_istek.text)
+
+                jetv_iframe = jetv_secici.css("iframe::attr(src)").get()
+                if jetv_iframe:
+                    processed_iframes.append(self.fix_url(jetv_iframe))
+            else:
+                processed_iframes.append(iframe)
+
+        return processed_iframes

KekikStream/Plugins/SezonlukDizi.py

@@ -0,0 +1,108 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, SearchResult, SeriesInfo, Episode
+from parsel           import Selector
+
+class SezonlukDizi(PluginBase):
+    name     = "SezonlukDizi"
+    main_url = "https://sezonlukdizi6.com"
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek  = await self.oturum.get(f"{self.main_url}/diziler.asp?adi={query}")
+        secici = Selector(istek.text)
+
+        return [
+            SearchResult(
+                title  = afis.css("div.description::text").get(default="").strip(),
+                url    = self.fix_url(afis.attrib.get("href")),
+                poster = self.fix_url(afis.css("img::attr(data-src)").get()),
+            )
+                for afis in secici.css("div.afis a.column")
+        ]
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        istek  = await self.oturum.get(url)
+        secici = Selector(istek.text)
+
+        title       = secici.css("div.header::text").get(default="").strip()
+        poster      = self.fix_url(secici.css("div.image img::attr(data-src)").get(default="").strip())
+        year        = secici.css("div.extra span::text").re_first(r"(\d{4})")
+        description = secici.css("span#tartismayorum-konu::text").get(default="").strip()
+        tags        = secici.css("div.labels a[href*='tur']::text").getall()
+        rating      = secici.css("div.dizipuani a div::text").re_first(r"[\d.,]+")
+        actors      = []
+
+        actors_istek  = await self.oturum.get(f"{self.main_url}/oyuncular/{url.split('/')[-1]}")
+        actors_secici = Selector(actors_istek.text)
+        actors = [
+            actor.css("div.header::text").get().strip()
+                for actor in actors_secici.css("div.doubling div.ui")
+        ]
+
+        episodes_istek  = await self.oturum.get(f"{self.main_url}/bolumler/{url.split('/')[-1]}")
+        episodes_secici = Selector(episodes_istek.text)
+        episodes        = []
+
+        for sezon in episodes_secici.css("table.unstackable"):
+            for bolum in sezon.css("tbody tr"):
+                ep_name    = bolum.css("td:nth-of-type(4) a::text").get(default="").strip()
+                ep_href    = self.fix_url(bolum.css("td:nth-of-type(4) a::attr(href)").get())
+                ep_episode = bolum.css("td:nth-of-type(3) a::text").re_first(r"(\d+)")
+                ep_season  = bolum.css("td:nth-of-type(2)::text").re_first(r"(\d+)")
+
+                if ep_name and ep_href:
+                    episode = Episode(
+                        season  = ep_season,
+                        episode = ep_episode,
+                        title   = ep_name,
+                        url     = ep_href,
+                    )
+                    episodes.append(episode)
+
+        return SeriesInfo(
+            url         = url,
+            poster      = poster,
+            title       = title,
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            year        = year,
+            episodes    = episodes,
+            actors      = actors
+        )
+
+    async def load_links(self, url: str) -> list[str]:
+        istek  = await self.oturum.get(url)
+        secici = Selector(istek.text)
+
+        bid = secici.css("div#dilsec::attr(data-id)").get()
+        if not bid:
+            return []
+
+        links = []
+        for dil, label in [("1", "AltYazı"), ("0", "Dublaj")]:
+            dil_istek = await self.oturum.post(
+                url     = f"{self.main_url}/ajax/dataAlternatif2.asp",
+                headers = {"X-Requested-With": "XMLHttpRequest"},
+                data    = {"bid": bid, "dil": dil},
+            )
+
+            try:
+                dil_json = dil_istek.json()
+            except Exception:
+                continue
+
+            if dil_json.get("status") == "success":
+                for veri in dil_json.get("data", []):
+                    veri_response = await self.oturum.post(
+                        url     = f"{self.main_url}/ajax/dataEmbed.asp",
+                        headers = {"X-Requested-With": "XMLHttpRequest"},
+                        data    = {"id": veri.get("id")},
+                    )
+                    secici = Selector(veri_response.text)
+
+                    if iframe := secici.css("iframe::attr(src)").get():
+                        video_url = self.fix_url(iframe)
+                        links.append(video_url)
+
+        return links

KekikStream/Plugins/SineWix.py

@@ -0,0 +1,105 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core                 import PluginBase, SearchResult, MovieInfo, Episode, SeriesInfo
+from KekikStream.Core.ExtractorModels import ExtractResult, Subtitle
+
+class SineWix(PluginBase):
+    name     = "SineWix"
+    main_url = "https://ythls.kekikakademi.org"
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek = await self.oturum.get(f"{self.main_url}/sinewix/search/{query}")
+
+        return [
+            SearchResult(
+                title  = veri.get("name"),
+                url    = f"?type={veri.get('type')}&id={veri.get('id')}",
+                poster = self.fix_url(veri.get("poster_path")),
+            )
+                for veri in istek.json().get("search")
+        ]
+
+    async def load_item(self, url: str) -> MovieInfo:
+        item_type = url.split("?type=")[-1].split("&id=")[0]
+        item_id   = url.split("&id=")[-1]
+
+        istek = await self.oturum.get(f"{self.main_url}/sinewix/{item_type}/{item_id}")
+        veri  = istek.json()
+
+        match item_type:
+            case "movie":
+                org_title = veri.get("title")
+                alt_title = veri.get("original_name") or ""
+                title     = f"{org_title} - {alt_title}" if (alt_title and org_title != alt_title)  else org_title
+
+                return MovieInfo(
+                    url         = self.fix_url(f"{self.main_url}/sinewix/{item_type}/{item_id}"),
+                    poster      = self.fix_url(veri.get("poster_path")),
+                    title       = title,
+                    description = veri.get("overview"),
+                    tags        = [genre.get("name") for genre in veri.get("genres")],
+                    rating      = veri.get("vote_average"),
+                    year        = veri.get("release_date"),
+                    actors      = [actor.get("name") for actor in veri.get("casterslist")],
+                )
+            case _:
+                org_title = veri.get("name")
+                alt_title = veri.get("original_name") or ""
+                title     = f"{org_title} - {alt_title}" if (alt_title and org_title != alt_title)  else org_title
+
+                episodes = []
+                for season in veri.get("seasons"):
+                    for episode in season.get("episodes"):
+                        ep_model = Episode(
+                            season  = season.get("season_number"),
+                            episode = episode.get("episode_number"),
+                            title   = episode.get("name"),
+                            url     = self.fix_url(episode.get("videos")[0].get("link")),
+                        )
+
+                        episodes.append(ep_model)
+
+                        self._data[ep_model.url] = {
+                            "name"      : f"{ep_model.season}. Sezon {ep_model.episode}. Bölüm - {ep_model.title}",
+                            "referer"   : self.main_url,
+                            "subtitles" : []
+                        }
+
+                return SeriesInfo(
+                    url         = self.fix_url(f"{self.main_url}/sinewix/{item_type}/{item_id}"),
+                    poster      = self.fix_url(veri.get("poster_path")),
+                    title       = title,
+                    description = veri.get("overview"),
+                    tags        = [genre.get("name") for genre in veri.get("genres")],
+                    rating      = veri.get("vote_average"),
+                    year        = veri.get("first_air_date"),
+                    actors      = [actor.get("name") for actor in veri.get("casterslist")],
+                    episodes    = episodes,
+                )
+
+    async def load_links(self, url: str) -> list[str]:
+        if not url.startswith(self.main_url):
+            return [url]
+
+        istek = await self.oturum.get(url)
+        veri  = istek.json()
+
+        org_title = veri.get("title")
+        alt_title = veri.get("original_name") or ""
+        title     = f"{org_title} - {alt_title}" if (alt_title and org_title != alt_title)  else org_title
+        title     = f"{self.name} | {title}"
+
+        for video in veri.get("videos"):
+            video_link = video.get("link").split("_blank\">")[-1]
+            self._data[video_link] = {
+                "name"      : title,
+                "referer"   : self.main_url,
+                "subtitles" : []
+            }
+
+        return list(self._data.keys())
+
+    async def play(self, name: str, url: str, referer: str, subtitles: list[Subtitle]):
+        extract_result = ExtractResult(name=name, url=url, referer=referer, subtitles=subtitles)
+        self.media_handler.title = name
+        self.media_handler.play_with_vlc(extract_result)

KekikStream/__init__.py

@@ -2,7 +2,7 @@
 
 from .CLI      import konsol, cikis_yap, hata_yakala
 from .Managers import PluginManager, ExtractorManager, UIManager, MediaManager
-from .Core     import PluginBase, ExtractorBase
+from .Core     import PluginBase, ExtractorBase, SeriesInfo
 from asyncio   import run
 
 class KekikStream:
@@ -26,16 +26,18 @@ class KekikStream:
             await self.plugin_manager.close_plugins()
 
     async def select_plugin(self):
-        plugin_name = await self.ui_manager.select_from_list(
-            message = "Bir eklenti seçin:",
-            choices = self.plugin_manager.get_plugin_names()
+        plugin_name = await self.ui_manager.select_from_fuzzy(
+            message = "Arama yapılacak eklentiyi seçin:",
+            choices = ["Tüm Eklentilerde Ara", *self.plugin_manager.get_plugin_names()]
         )
 
-        self.current_plugin = self.plugin_manager.select_plugin(plugin_name)
+        if plugin_name == "Tüm Eklentilerde Ara":
+            await self.search_all()
+        else:
+            self.current_plugin = self.plugin_manager.select_plugin(plugin_name)
+            await self.search_single_plugin()
 
-        await self.search()
-
-    async def search(self):
+    async def search_single_plugin(self):
         self.ui_manager.clear_console()
         konsol.rule(f"[bold cyan]{self.current_plugin.name} Eklentisinde Arama Yapın[/bold cyan]")
 
@@ -46,38 +48,89 @@ class KekikStream:
             konsol.print("[bold red]Arama sonucu bulunamadı![/bold red]")
             return
 
-        await self.select_result(results)
+        selected_result = await self.select_result(results)
+
+        if selected_result:
+            await self.show_details({"plugin": self.current_plugin.name, "url": selected_result})
+
+    async def search_all(self):
+        self.ui_manager.clear_console()
+        konsol.rule("[bold cyan]Tüm Eklentilerde Arama Yapın[/bold cyan]")
+
+        query   = await self.ui_manager.prompt_text("Arama sorgusu girin:")
+        results = await self.search_all_plugins(query)
+
+        if not results:
+            return
+
+        selected_result = await self.select_from_all_results(results)
+
+        if selected_result:
+            await self.show_details(selected_result)
 
     async def select_result(self, results):
-        selected_url = await self.ui_manager.select_from_list(
-            message = "Bir içerik seçin:",
+        selected_url = await self.ui_manager.select_from_fuzzy(
+            message = "İçerik sonuçlarından birini seçin:",
             choices = [{"name": res.title, "value": res.url} for res in results]
         )
 
-        await self.show_details(selected_url)
+        if selected_url:
+            return selected_url
 
-    async def show_details(self, url):
+    async def show_details(self, selected_result):
         try:
+            if isinstance(selected_result, dict) and "plugin" in selected_result:
+                plugin_name = selected_result["plugin"]
+                url         = selected_result["url"]
+
+                self.current_plugin = self.plugin_manager.select_plugin(plugin_name)
+            else:
+                url = selected_result
+
             media_info = await self.current_plugin.load_item(url)
         except Exception as hata:
-            konsol.log(url)
+            konsol.log(selected_result)
             hata_yakala(hata)
             return
 
         self.media_manager.set_title(f"{self.current_plugin.name} | {media_info.title}")
 
-        self.ui_manager.display_media_info(self.current_plugin.name, media_info)
-
-        links = await self.current_plugin.load_links(url)
-        await self.show_options(links)
+        self.ui_manager.display_media_info(f"{self.current_plugin.name} | {media_info.title}", media_info)
+
+        if isinstance(media_info, SeriesInfo):
+            selected_episode = await self.ui_manager.select_from_fuzzy(
+                message = "İzlemek istediğiniz bölümü seçin:",
+                choices = [
+                    {"name": f"{episode.season}. Sezon {episode.episode}. Bölüm - {episode.title}", "value": episode.url}
+                        for episode in media_info.episodes
+                ]
+            )
+            if selected_episode:
+                links = await self.current_plugin.load_links(selected_episode)
+                await self.show_options(links)
+        else:
+            links = await self.current_plugin.load_links(media_info.url)
+            await self.show_options(links)
 
     async def show_options(self, links):
         mapping = self.extractor_manager.map_links_to_extractors(links)
-        if not mapping:
+        has_play_method = hasattr(self.current_plugin, "play") and callable(getattr(self.current_plugin, "play", None))    
+        # ! DEBUG
+        # konsol.print(links)
+        if not mapping and not has_play_method:
             konsol.print("[bold red]Hiçbir Extractor bulunamadı![/bold red]")
             konsol.print(links)
             return
 
+        if not mapping:
+            selected_link = await self.ui_manager.select_from_list(
+                message = "Doğrudan oynatmak için bir bağlantı seçin:",
+                choices = [{"name": self.current_plugin.name, "value": link} for link in links]
+            )
+            if selected_link:
+                await self.play_media(selected_link)
+            return
+
         action  = await self.ui_manager.select_from_list(
             message = "Ne yapmak istersiniz?",
             choices = ["İzle", "Geri Git", "Ana Menü"]
@@ -86,7 +139,7 @@ class KekikStream:
         match action:
             case "İzle":
                 selected_link = await self.ui_manager.select_from_list(
-                    message = "Bir bağlantı seçin:", 
+                    message = "İzlemek için bir bağlantı seçin:", 
                     choices = [{"name": extractor_name, "value": link} for link, extractor_name in mapping.items()]
                 )
                 if selected_link:
@@ -99,22 +152,81 @@ class KekikStream:
                 await self.run()
 
     async def play_media(self, selected_link):
-        extractor:ExtractorBase = self.extractor_manager.find_extractor(selected_link)
+        if hasattr(self.current_plugin, "play") and callable(self.current_plugin.play):
+            await self.current_plugin.play(
+                name      = self.current_plugin._data[selected_link]["name"],
+                url       = selected_link,
+                referer   = self.current_plugin._data[selected_link]["referer"],
+                subtitles = self.current_plugin._data[selected_link]["subtitles"]
+            )
+            return
+
+        extractor: ExtractorBase = self.extractor_manager.find_extractor(selected_link)
         if not extractor:
             konsol.print("[bold red]Uygun Extractor bulunamadı.[/bold red]")
             return
 
         extract_data = await extractor.extract(selected_link, referer=self.current_plugin.main_url)
-        if extract_data.headers.get("Cookie"):
-            self.media_manager.set_headers({"Cookie": extract_data.headers.get("Cookie")})
 
-        self.media_manager.set_title(f"{self.media_manager.get_title()} | {extract_data.name}")
-        self.media_manager.set_headers({"Referer": extract_data.referer})
-        self.media_manager.play_media(extract_data)
+        if isinstance(extract_data, list):
+            selected_data = await self.ui_manager.select_from_list(
+                message = "Birden fazla bağlantı bulundu, lütfen birini seçin:",
+                choices = [{"name": data.name, "value": data} for data in extract_data]
+            )
+        else:
+            selected_data = extract_data
+
+        if selected_data.headers.get("Cookie"):
+            self.media_manager.set_headers({"Cookie": selected_data.headers.get("Cookie")})
+
+        self.media_manager.set_title(f"{self.media_manager.get_title()} | {selected_data.name}")
+        self.media_manager.set_headers({"Referer": selected_data.referer})
+        self.media_manager.play_media(selected_data)
+
+    async def search_all_plugins(self, query: str):
+        all_results = []
+
+        for plugin_name, plugin in self.plugin_manager.plugins.items():
+            if not isinstance(plugin, PluginBase):
+                konsol.print(f"[yellow][!] {plugin_name} geçerli bir PluginBase değil, atlanıyor...[/yellow]")
+                continue
+
+            konsol.log(f"[yellow][~] {plugin_name:<18} eklentisinde arama yapılıyor...[/]")
+            try:
+                results = await plugin.search(query)
+                if results:
+                    all_results.extend(
+                        [{"plugin": plugin_name, "title": result.title, "url": result.url, "poster": result.poster} for result in results]
+                    )
+            except Exception as hata:
+                konsol.print(f"[bold red]{plugin_name} eklentisinde hata oluştu: {hata}[/bold red]")
+
+        if not all_results:
+            konsol.print("[bold red]Hiçbir sonuç bulunamadı![/bold red]")
+            return []
+
+        return all_results
+
+    async def select_from_all_results(self, results):
+        choices = [
+            {"name": f"[{res['plugin']}] {res['title']}", "value": res}
+                for res in results
+        ]
+
+        selected_result = await self.ui_manager.select_from_fuzzy(
+            message = "Arama sonuçlarından bir içerik seçin:",
+            choices = choices
+        )
 
+        return selected_result
+
+from .CLI import check_and_update_package
 
 def basla():
     try:
+        konsol.print("[bold cyan]Güncelleme kontrol ediliyor...[/bold cyan]")
+        check_and_update_package("KekikStream")
+
         app = KekikStream()
         run(app.run())
         cikis_yap(False)

{KekikStream-0.0.7.dist-info → KekikStream-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: KekikStream
-Version: 0.0.7
+Version: 0.2.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
@@ -10,7 +10,7 @@ Keywords: KekikStream,KekikAkademi,keyiflerolsun
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: setuptools
@@ -66,6 +66,10 @@ KekikStream
 
 **[☕️ Kahve Ismarla](https://KekikAkademi.org/Kahve)**
 
+### 🎁 Teşekkürler
+
+- [DeoDorqnt387/aniwatch-tr](https://github.com/DeoDorqnt387/aniwatch-tr)
+
 ## 🌐 Telif Hakkı ve Lisans
 
 * *Copyright (C) 2024 by* [keyiflerolsun](https://github.com/keyiflerolsun) ❤️️