KekikStream 1.5.6__py3-none-any.whl → 1.5.7__py3-none-any.whl

KekikStream/CLI/pypi_kontrol.py

@@ -1,16 +1,16 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from .             import konsol
-from rich.panel    import Panel
-from pkg_resources import get_distribution
-from requests      import get
-from subprocess    import check_call
+from .          import konsol
+from rich.panel import Panel
+from importlib  import metadata
+from requests   import get
+from subprocess import check_call
 import sys
 
 def pypi_kontrol_guncelle(paket_adi: str):
     try:
         konsol.print(f"[bold cyan] {paket_adi} Güncellemesi kontrol ediliyor...[/bold cyan]")
-        mevcut_surum = get_distribution(paket_adi).version
+        mevcut_surum = metadata.version(paket_adi)
         konsol.print(Panel(f"[cyan]Yüklü sürüm:[/cyan] [bold yellow]{mevcut_surum}[/bold yellow]"))
 
         istek = get(f"https://pypi.org/pypi/{paket_adi}/json")

KekikStream/Core/Media/MediaHandler.py

@@ -34,11 +34,11 @@ class MediaHandler:
         if "Cookie" in self.headers or extract_data.subtitles:
             return self.play_with_mpv(extract_data)
 
-        return self.play_with_vlc(extract_data)
+        return self.play_with_vlc(extract_data) or self.play_with_mpv(extract_data)
 
     def play_with_vlc(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] VLC ile Oynatılıyor : {extract_data.url}")
-        konsol.print(self.headers)
+        # konsol.print(self.headers)
         try:
             vlc_command = ["vlc", "--quiet"]
 
@@ -62,16 +62,19 @@ class MediaHandler:
             with open(os.devnull, "w") as devnull:
                 subprocess.run(vlc_command, stdout=devnull, stderr=devnull, check=True)
 
+            return True
         except subprocess.CalledProcessError as hata:
             konsol.print(f"[red]VLC oynatma hatası: {hata}[/red]")
             konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
         except FileNotFoundError:
             konsol.print("[red]VLC bulunamadı! VLC kurulu olduğundan emin olun.[/red]")
-            konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            # konsol.print({"title": self.title, "url": extract_data.url, "headers": self.headers})
+            return False
 
     def play_with_mpv(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] MPV ile Oynatılıyor : {extract_data.url}")
-        konsol.print(self.headers)
+        # konsol.print(self.headers)
         try:
             mpv_command = ["mpv"]
 
@@ -98,7 +101,7 @@ class MediaHandler:
 
     def play_with_ytdlp(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] yt-dlp ile Oynatılıyor : {extract_data.url}")
-        konsol.print(self.headers)
+        # konsol.print(self.headers)
         try:
             ytdlp_command = ["yt-dlp", "--quiet", "--no-warnings"]
 
@@ -131,7 +134,7 @@ class MediaHandler:
 
     def play_with_android_mxplayer(self, extract_data: ExtractResult):
         konsol.log(f"[yellow][»] MxPlayer ile Oynatılıyor : {extract_data.url}")
-        konsol.print(self.headers)
+        # konsol.print(self.headers)
         paketler = [
             "com.mxtech.videoplayer.ad/.ActivityScreen",  # Free sürüm
             "com.mxtech.videoplayer.pro/.ActivityScreen"  # Pro sürüm

KekikStream/Core/Plugin/PluginBase.py

@@ -1,11 +1,12 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from abc                  import ABC, abstractmethod
-from httpx                import AsyncClient, Timeout
-from cloudscraper         import CloudScraper
-from .PluginModels        import MainPageResult, SearchResult, MovieInfo
-from ..Media.MediaHandler import MediaHandler
-from urllib.parse         import urljoin
+from abc                          import ABC, abstractmethod
+from httpx                        import AsyncClient, Timeout
+from cloudscraper                 import CloudScraper
+from .PluginModels                import MainPageResult, SearchResult, MovieInfo
+from ..Media.MediaHandler         import MediaHandler
+from ..Extractor.ExtractorManager import ExtractorManager
+from urllib.parse                 import urljoin
 import re
 
 class PluginBase(ABC):
@@ -34,6 +35,7 @@ class PluginBase(ABC):
         )
         self.media_handler = MediaHandler()
         self.cloudscraper  = CloudScraper()
+        self.ex_manager    = ExtractorManager()
         self.httpx.headers.update(self.cloudscraper.headers)
         self.httpx.cookies.update(self.cloudscraper.cookies)
 
@@ -53,8 +55,28 @@ class PluginBase(ABC):
         pass
 
     @abstractmethod
-    async def load_links(self, url: str) -> list[str]:
-        """Bir medya öğesi için oynatma bağlantılarını döndürür."""
+    async def load_links(self, url: str) -> list[dict]:
+        """
+        Bir medya öğesi için oynatma bağlantılarını döndürür.
+        
+        Args:
+            url: Medya URL'si
+            
+        Returns:
+            Dictionary listesi, her biri şu alanları içerir:
+            - url (str, zorunlu): Video URL'si
+            - name (str, zorunlu): Gösterim adı (tüm bilgileri içerir)
+            - referer (str, opsiyonel): Referer header
+            - subtitles (list, opsiyonel): Altyazı listesi
+        
+        Example:
+            [
+                {
+                    "url": "https://example.com/video.m3u8",
+                    "name": "HDFilmCehennemi | 1080p TR Dublaj"
+                }
+            ]
+        """
         pass
 
     async def close(self):

KekikStream/Core/Plugin/PluginLoader.py

@@ -20,9 +20,9 @@ class PluginLoader:
         plugins = {}
 
         # Global eklentileri yükle
-        # if self.global_plugins_dir.exists():
+        if self.global_plugins_dir.exists():
             # konsol.log(f"[green][*] Global Eklenti dizininden yükleniyor: {self.global_plugins_dir}[/green]")
-            # plugins |= self._load_from_directory(self.global_plugins_dir)
+            plugins |= self._load_from_directory(self.global_plugins_dir)
 
         # Yerel eklentileri yükle
         if self.local_plugins_dir.exists():

KekikStream/Extractors/CloseLoad.py

@@ -1,31 +1,12 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from KekikStream.Core import ExtractorBase, ExtractResult
-from Kekik.Sifreleme  import Packer
-import re, base64
-
-def get_m3u_link(data: str) -> str:
-    first = base64.b64decode(data)
-    first_reversed = first[::-1]
-    
-    second = base64.b64decode(first_reversed)
-    
-    parts = second.decode('utf-8').split("|")
-    if len(parts) < 2:
-        raise ValueError("Decoded data has an unexpected format.")
-    
-    return parts[1]
-
-def extract_data(raw_script: str) -> str:
-    pattern = re.compile(r'return result\}var .*?=.*?\("(.*?)"\)')
-    if match := pattern.search(raw_script):
-        return match[1]
-    else:
-        raise Exception("data not found")
+from Kekik.Sifreleme  import Packer, StreamDecoder
+import re
 
 class CloseLoadExtractor(ExtractorBase):
     name     = "CloseLoad"
-    main_url = "https://closeload.filmmakinesi.de"
+    main_url = "https://closeload.filmmakinesi.sh"
 
     async def extract(self, url, referer=None) -> ExtractResult:
         if referer:
@@ -35,7 +16,7 @@ class CloseLoadExtractor(ExtractorBase):
         istek.raise_for_status()
 
         eval_func = re.compile(r'\s*(eval\(function[\s\S].*)\s*').findall(istek.text)[0]
-        m3u_link  = get_m3u_link(extract_data(Packer.unpack(eval_func)))
+        m3u_link  = StreamDecoder.extract_stream_url(Packer.unpack(eval_func))
 
         await self.close()
         return ExtractResult(

KekikStream/Extractors/VidMoly.py

@@ -18,24 +18,13 @@ class VidMoly(ExtractorBase):
         })
 
         if self.main_url.endswith(".me"):
-            self.main_url = self.main_url.replace(".me", ".to")
-            url           = url.replace(".me", ".to")
+            self.main_url = self.main_url.replace(".me", ".net")
+            url = url.replace(".me", ".net")
 
-        # Embed URL oluştur
-        embed_url      = url.replace("/w/", "/embed-") + "-920x360.html" if "/w/" in url else url
-        script_content = None
-        attempts       = 0
+        response = await self.httpx.get(url)
 
-        # Script verisini almak için deneme yap
-        while attempts < 10 and not script_content:
-            attempts += 1
-            response = await self.httpx.get(embed_url)
-            response.raise_for_status()
-
-            script_match   = re.search(r"sources:\s*\[(.*?)\],", response.text, re.DOTALL)
-            script_content = script_match[1] if script_match else None
-            if not script_content:
-                await asyncio.sleep(0.5)
+        script_match   = re.search(r"sources:\s*\[(.*?)\],", response.text, re.DOTALL)
+        script_content = script_match[1] if script_match else None
 
         if not script_content:
             raise ValueError("Gerekli script bulunamadı.")

KekikStream/Plugins/DiziBox.py

@@ -40,7 +40,7 @@ class DiziBox(PluginBase):
         f"{main_url}/dizi-arsivi/page/SAYFA/?tur[0]=yarisma&yil&imdb"    : "Yarışma"
     }
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek = await self.httpx.get(
             url              = f"{url.replace('SAYFA', str(page))}",
@@ -58,7 +58,7 @@ class DiziBox(PluginBase):
                 for veri in secici.css("article.detailed-article")
         ]
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
         self.httpx.cookies.update({
             "LockUser"      : "true",
@@ -77,7 +77,7 @@ class DiziBox(PluginBase):
                 for item in secici.css("article.detailed-article")
         ]
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> SeriesInfo:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
@@ -124,13 +124,19 @@ class DiziBox(PluginBase):
             actors      = actors,
         )
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def _iframe_decode(self, name:str, iframe_link:str, referer:str) -> list[str]:
         results = []
 
+        self.httpx.headers.update({"Referer": referer})
+        self.httpx.cookies.update({
+            "LockUser"      : "true",
+            "isTrustedUser" : "true",
+            "dbxu"          : "1722403730363"
+        })
+
         if "/player/king/king.php" in iframe_link:
             iframe_link = iframe_link.replace("king.php?v=", "king.php?wmode=opaque&v=")
-            self.httpx.headers.update({"Referer": referer})
 
             istek  = await self.httpx.get(iframe_link)
             secici = Selector(istek.text)
@@ -150,7 +156,6 @@ class DiziBox(PluginBase):
 
         elif "/player/moly/moly.php" in iframe_link:
             iframe_link = iframe_link.replace("moly.php?h=", "moly.php?wmode=opaque&h=")
-            self.httpx.headers.update({"Referer": referer})
             while True:
                 await asyncio.sleep(.3)
                 with contextlib.suppress(Exception):
@@ -171,15 +176,20 @@ class DiziBox(PluginBase):
 
         return results
 
-    @kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[str]:
+    #@kekik_cache(ttl=15*60)
+    async def load_links(self, url: str) -> list[dict]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
-        iframes = []
+        results = []
         if main_iframe := secici.css("div#video-area iframe::attr(src)").get():
             if decoded := await self._iframe_decode(self.name, main_iframe, url):
-                iframes.extend(decoded)
+                for iframe in decoded:
+                    extractor = self.ex_manager.find_extractor(iframe)
+                    results.append({
+                        "url"  : iframe,
+                        "name" : f"{extractor.name if extractor else 'Main Player'}"
+                    })
 
         for alternatif in secici.css("div.video-toolbar option[value]"):
             alt_name = alternatif.css("::text").get()
@@ -195,6 +205,11 @@ class DiziBox(PluginBase):
             alt_secici = Selector(alt_istek.text)
             if alt_iframe := alt_secici.css("div#video-area iframe::attr(src)").get():
                 if decoded := await self._iframe_decode(alt_name, alt_iframe, url):
-                    iframes.extend(decoded)
-
-        return iframes
+                    for iframe in decoded:
+                        extractor = self.ex_manager.find_extractor(iframe)
+                        results.append({
+                            "url"  : iframe,
+                            "name" : f"{extractor.name if extractor else alt_name}"
+                        })
+
+        return results

KekikStream/Plugins/DiziYou.py

@@ -7,7 +7,7 @@ import re
 class DiziYou(PluginBase):
     name        = "DiziYou"
     language    = "tr"
-    main_url    = "https://www.diziyou3.com"
+    main_url    = "https://www.diziyou.mx"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "Diziyou en kaliteli Türkçe dublaj ve altyazılı yabancı dizi izleme sitesidir. Güncel ve efsanevi dizileri 1080p Full HD kalitede izlemek için hemen tıkla!"
 
@@ -31,7 +31,7 @@ class DiziYou(PluginBase):
 
     _data = {}
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     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 = Selector(istek.text)
@@ -46,7 +46,7 @@ class DiziYou(PluginBase):
                 for veri in secici.css("div.single-item")
         ]
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
         istek  = await self.httpx.get(f"{self.main_url}/?s={query}")
         secici = Selector(istek.text)
@@ -60,7 +60,7 @@ class DiziYou(PluginBase):
                 for afis in secici.css("div.incontent div#list-series")
         ]
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> SeriesInfo:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
@@ -107,8 +107,8 @@ class DiziYou(PluginBase):
             actors      = actors
         )
 
-    @kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[str]:
+    #@kekik_cache(ttl=15*60)
+    async def load_links(self, url: str) -> list[dict]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
@@ -130,7 +130,7 @@ class DiziYou(PluginBase):
                         url  = self.fix_url(f"{self.main_url.replace('www', 'storage')}/subtitles/{item_id}/tr.vtt"),
                     ))
                     veri = {
-                        "dil": "Orjinal Dil",
+                        "dil": "Orjinal Dil (TR Altyazı)",
                         "url": f"{self.main_url.replace('www', 'storage')}/episodes/{item_id}/play.m3u8"
                     }
                     if veri not in stream_urls:
@@ -141,28 +141,27 @@ class DiziYou(PluginBase):
                         url  = self.fix_url(f"{self.main_url.replace('www', 'storage')}/subtitles/{item_id}/en.vtt"),
                     ))
                     veri = {
-                        "dil": "Orjinal Dil",
+                        "dil": "Orjinal Dil (EN Altyazı)",
                         "url": f"{self.main_url.replace('www', 'storage')}/episodes/{item_id}/play.m3u8"
                     }
                     if veri not in stream_urls:
                         stream_urls.append(veri)
                 case "turkceDublaj":
                     stream_urls.append({
-                        "dil": "Dublaj",
+                        "dil": "Türkçe Dublaj",
                         "url": f"{self.main_url.replace('www', 'storage')}/episodes/{item_id}_tr/play.m3u8"
                     })
 
-
+        results = []
         for stream in stream_urls:
-            self._data[stream.get("url")] = {
-                "ext_name"  : f"{self.name} | {stream.get('dil')}",
-                "name"      : f"{self.name} | {stream.get('dil')} | {item_title} - {ep_name}",
+            results.append({
+                "url"       : stream.get("url"),
+                "name"      : f"{stream.get('dil')}",
                 "referer"   : url,
-                "headers"   : self.media_handler.headers,
                 "subtitles" : subtitles
-            }
+            })
 
-        return [stream.get("url") for stream in stream_urls]
+        return results
 
     async def play(self, name: str, url: str, referer: str, subtitles: list[Subtitle]):
         extract_result = ExtractResult(name=name, url=url, referer=referer, subtitles=subtitles)

KekikStream/Plugins/Dizilla.py

@@ -4,11 +4,13 @@ from KekikStream.Core import kekik_cache, PluginBase, MainPageResult, SearchResu
 from parsel           import Selector
 from json             import loads
 from urllib.parse     import urlparse, urlunparse
+from Crypto.Cipher    import AES
+from base64           import b64decode
 
 class Dizilla(PluginBase):
     name        = "Dizilla"
     language    = "tr"
-    main_url    = "https://dizilla.nl"
+    main_url    = "https://dizilla40.com"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "Dizilla tüm yabancı dizileri ücretsiz olarak Türkçe Dublaj ve altyazılı seçenekleri ile 1080P kalite izleyebileceğiniz yeni nesil yabancı dizi izleme siteniz."
 
@@ -22,7 +24,7 @@ class Dizilla(PluginBase):
         f"{main_url}/dizi-turu/komedi"      : "Komedi"
     }
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
@@ -65,32 +67,32 @@ class Dizilla(PluginBase):
 
         return ana_sayfa
 
-    @kekik_cache(ttl=60*60)
+    async def decrypt_response(self, response: str) -> dict:
+        # 32 bytes key
+        key = "9bYMCNQiWsXIYFWYAu7EkdsSbmGBTyUI".encode("utf-8")
+
+        # IV = 16 bytes of zero
+        iv = bytes([0] * 16)
+
+        # Base64 decode
+        encrypted_bytes = b64decode(response)
+
+        # AES/CBC/PKCS5Padding
+        cipher    = AES.new(key, AES.MODE_CBC, iv)
+        decrypted = cipher.decrypt(encrypted_bytes)
+
+        # PKCS5/PKCS7 padding remove
+        pad_len   = decrypted[-1]
+        decrypted = decrypted[:-pad_len]
+
+        # JSON decode
+        return loads(decrypted.decode("utf-8"))
+
+    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
-        ilk_istek  = await self.httpx.get(self.main_url)
-        ilk_secici = Selector(ilk_istek.text)
-        cKey       = ilk_secici.css("input[name='cKey']::attr(value)").get()
-        cValue     = ilk_secici.css("input[name='cValue']::attr(value)").get()
-
-        self.httpx.headers.update({
-            "Accept"           : "application/json, text/javascript, */*; q=0.01",
-            "X-Requested-With" : "XMLHttpRequest",
-            "Referer"          : f"{self.main_url}/"
-        })
-        self.httpx.cookies.update({
-            "showAllDaFull"   : "true",
-            "PHPSESSID"       : ilk_istek.cookies.get("PHPSESSID"),
-        })
-
-        arama_istek = await self.httpx.post(
-            url  = f"{self.main_url}/bg/searchcontent",
-            data = {
-                "cKey"       : cKey,
-                "cValue"     : cValue,
-                "searchterm" : query
-            }
-        )
-        arama_veri = arama_istek.json().get("data", {}).get("result", [])
+        arama_istek = await self.httpx.post(f"{self.main_url}/api/bg/searchcontent?searchterm={query}")
+        decrypted   = await self.decrypt_response(arama_istek.json().get("response"))
+        arama_veri  = decrypted.get("result", [])
 
         return [
             SearchResult(
@@ -101,7 +103,7 @@ class Dizilla(PluginBase):
                 for veri in arama_veri
         ]
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def url_base_degis(self, eski_url:str, yeni_base:str) -> str:
         parsed_url       = urlparse(eski_url)
         parsed_yeni_base = urlparse(yeni_base)
@@ -112,7 +114,7 @@ class Dizilla(PluginBase):
 
         return urlunparse(yeni_url)
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> SeriesInfo:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
@@ -152,15 +154,27 @@ class Dizilla(PluginBase):
             actors      = actors
         )
 
-    @kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[str]:
-        istek  = await self.httpx.get(url)
-        secici = Selector(istek.text)
-
-        iframes = [self.fix_url(secici.css("div#playerLsDizilla iframe::attr(src)").get())]
-        for alternatif in secici.css("a[href*='player']"):
-            alt_istek  = await self.httpx.get(self.fix_url(alternatif.css("::attr(href)").get()))
-            alt_secici = Selector(alt_istek.text)
-            iframes.append(self.fix_url(alt_secici.css("div#playerLsDizilla iframe::attr(src)").get()))
-
-        return iframes
+    #@kekik_cache(ttl=15*60)
+    async def load_links(self, url: str) -> list[dict]:
+        istek   = await self.httpx.get(url)
+        secici  = Selector(istek.text)
+
+        next_data   = loads(secici.css("script#__NEXT_DATA__::text").get())
+        secure_data = next_data.get("props", {}).get("pageProps", {}).get("secureData", {})
+        decrypted   = await self.decrypt_response(secure_data)
+        results     = decrypted.get("RelatedResults", {}).get("getEpisodeSources", {}).get("result", [])
+
+        links = []
+        for result in results:
+            iframe_src = Selector(result.get("source_content")).css("iframe::attr(src)").get()
+            iframe_url = self.fix_url(iframe_src)
+            if not iframe_url:
+                continue
+
+            extractor = self.ex_manager.find_extractor(iframe_url)
+            links.append({
+                "url"  : iframe_url,
+                "name" : f"{extractor.name if extractor else 'Main Player'} | {result.get('language_name')}",
+            })
+
+        return links

KekikStream/Plugins/FilmMakinesi.py

@@ -6,7 +6,7 @@ from parsel           import Selector
 class FilmMakinesi(PluginBase):
     name        = "FilmMakinesi"
     language    = "tr"
-    main_url    = "https://filmmakinesi.de"
+    main_url    = "https://filmmakinesi.sh"
     favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
     description = "Film Makinesi, en yeni ve en güncel filmleri sitemizde full HD kalite farkı ile izleyebilirsiniz. HD film izle denildiğinde akla gelen en kaliteli film izleme sitesi."
 
@@ -34,7 +34,7 @@ class FilmMakinesi(PluginBase):
         f"{main_url}/film-izle/spor/page/"                         : "Spor"
     }
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
         istek  = self.cloudscraper.get(f"{url}{page}")
         secici = Selector(istek.text)
@@ -51,15 +51,15 @@ class FilmMakinesi(PluginBase):
                 for veri in veriler
         ]
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
-        istek  = await self.httpx.get(f"{self.main_url}/?s={query}")
+        istek  = await self.httpx.get(f"{self.main_url}/arama/?s={query}")
         secici = Selector(istek.text)
 
         results = []
-        for article in secici.css("section#film_posts article"):
-            title  = article.css("h6 a::text").get()
-            href   = article.css("h6 a::attr(href)").get()
+        for article in secici.css("div.item-relative"):
+            title  = article.css("div.title::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:
@@ -73,40 +73,47 @@ class FilmMakinesi(PluginBase):
 
         return results
 
-    @kekik_cache(ttl=60*60)
+    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> MovieInfo:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
-        title       = secici.css("h1.single_h1 a::text").get().strip()
-        poster      = secici.css("[property='og:image']::attr(content)").get().strip()
-        description = secici.css("section#film_single article p:last-of-type::text").get().strip()
-        tags        = secici.css("dt:contains('Tür:') + dd a::text").get().strip()
-        rating      = secici.css("dt:contains('IMDB Puanı:') + dd::text").get().strip()
-        year        = secici.css("dt:contains('Yapım Yılı:') + dd a::text").get().strip()
-        actors      = secici.css("dt:contains('Oyuncular:') + dd::text").get().strip()
-        duration    = secici.css("dt:contains('Film Süresi:') + dd time::attr(datetime)").get().strip()
-
-        duration_minutes = 0
-        if duration and duration.startswith("PT") and duration.endswith("M"):
-            duration_minutes = int(duration[2:-1])
+        title       = secici.css("h1.title::text").get().strip()
+        poster      = secici.css("img.cover-img::attr(src)").get().strip()
+        description = secici.css("div.info-description p::text").get().strip()
+        rating      = secici.css("div.score::text").get().strip()
+        year        = secici.css("span.date a::text").get().strip()
+        actors      = secici.css("div.cast-name::text").getall()
+        duration    = secici.css("div.time::text").get().split()[1].strip()
 
         return MovieInfo(
             url         = url,
             poster      = self.fix_url(poster),
-            title       = title,
+            title       = self.clean_title(title),
             description = description,
-            tags        = tags,
             rating      = rating,
             year        = year,
             actors      = actors,
-            duration    = duration_minutes
+            duration    = duration
         )
 
-    @kekik_cache(ttl=15*60)
-    async def load_links(self, url: str) -> list[str]:
+    #@kekik_cache(ttl=15*60)
+    async def load_links(self, url: str) -> list[dict]:
         istek  = await self.httpx.get(url)
         secici = Selector(istek.text)
 
-        iframe_src = secici.css("div.player-div iframe::attr(src)").get() or secici.css("div.player-div iframe::attr(data-src)").get()
-        return [self.fix_url(iframe_src)] if iframe_src else []
+        iframe_src = secici.css("iframe::attr(data-src)").get()
+
+        all_links = [iframe_src] if iframe_src else []
+        for link in secici.css("div.video-parts a[data-video_url]"):
+            all_links.append(link.attrib.get("data-video_url"))
+
+        response = []
+        for idx, link in enumerate(all_links):
+            extractor = self.ex_manager.find_extractor(link)
+            response.append({
+                "url"  : link,
+                "name" : f"{extractor.name if extractor else f'Player {idx + 1}'}",
+            })
+
+        return response