KekikStream 1.7.1__py3-none-any.whl → 2.0.2__py3-none-any.whl

KekikStream/Plugins/SineWix.py

@@ -1,6 +1,6 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from KekikStream.Core import kekik_cache, PluginBase, MainPageResult, SearchResult, MovieInfo, Episode, SeriesInfo, ExtractResult, Subtitle
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, Episode, SeriesInfo, ExtractResult, Subtitle
 import json
 
 class SineWix(PluginBase):
@@ -35,9 +35,8 @@ class SineWix(PluginBase):
         f"{main_url}/sinewix/movies/36"     : "Tarih",
     }
 
-    #@kekik_cache(ttl=60*60)
     async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
-        istek   = await self.cffi.get(f"{url}/{page}")
+        istek   = await self.httpx.get(f"{url}/{page}")
         veriler = istek.json()
 
         return [
@@ -50,9 +49,8 @@ class SineWix(PluginBase):
                 for veri in veriler.get("data")
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def search(self, query: str) -> list[SearchResult]:
-        istek = await self.cffi.get(f"{self.main_url}/sinewix/search/{query}")
+        istek = await self.httpx.get(f"{self.main_url}/sinewix/search/{query}")
 
         return [
             SearchResult(
@@ -63,12 +61,11 @@ class SineWix(PluginBase):
                 for veri in istek.json().get("search")
         ]
 
-    #@kekik_cache(ttl=60*60)
     async def load_item(self, url: str) -> MovieInfo | SeriesInfo:
         item_type = url.split("?type=")[-1].split("&id=")[0]
         item_id   = url.split("&id=")[-1]
 
-        istek = await self.cffi.get(f"{self.main_url}/sinewix/{item_type}/{item_id}")
+        istek = await self.httpx.get(f"{self.main_url}/sinewix/{item_type}/{item_id}")
         veri  = istek.json()
 
         match item_type:
@@ -126,7 +123,6 @@ class SineWix(PluginBase):
                     episodes    = episodes,
                 )
 
-    #@kekik_cache(ttl=15*60)
     async def load_links(self, url: str) -> list[dict]:
         try:
             veri = json.loads(url)
@@ -143,7 +139,7 @@ class SineWix(PluginBase):
         if not url.startswith(self.main_url) and not url.startswith("{"):
              return [{"url": url, "name": "Video"}]
 
-        istek = await self.cffi.get(url)
+        istek = await self.httpx.get(url)
         veri  = istek.json()
 
         org_title = veri.get("title")
@@ -161,9 +157,9 @@ class SineWix(PluginBase):
 
         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)
-        self.media_handler.title = name
+    async def play(self, **kwargs):
+        extract_result = ExtractResult(**kwargs)
+        self.media_handler.title = kwargs.get("name")
         if self.name not in self.media_handler.title:
             self.media_handler.title = f"{self.name} | {self.media_handler.title}"
 

KekikStream/Plugins/Sinefy.py

@@ -0,0 +1,238 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, SeriesInfo, Episode, MovieInfo
+from parsel           import Selector
+import re, json, urllib.parse
+
+class Sinefy(PluginBase):
+    name        = "Sinefy"
+    language    = "tr"
+    main_url    = "https://sinefy3.com"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Yabancı film izle olarak vizyondaki en yeni yabancı filmleri türkçe dublaj ve altyazılı olarak en hızlı şekilde full hd olarak sizlere sunuyoruz."
+
+    main_page = {
+        f"{main_url}/page/"                      : "Son Eklenenler",
+        f"{main_url}/en-yenifilmler"             : "Yeni Filmler",
+        f"{main_url}/netflix-filmleri-izle"      : "Netflix Filmleri",
+        f"{main_url}/dizi-izle/netflix"          : "Netflix Dizileri",
+        f"{main_url}/gozat/filmler/animasyon" 	 : "Animasyon",
+        f"{main_url}/gozat/filmler/komedi" 		 : "Komedi",
+        f"{main_url}/gozat/filmler/suc" 		 : "Suç",
+        f"{main_url}/gozat/filmler/aile" 		 : "Aile",
+        f"{main_url}/gozat/filmler/aksiyon" 	 : "Aksiyon",
+        f"{main_url}/gozat/filmler/macera" 		 : "Macera",
+        f"{main_url}/gozat/filmler/fantastik" 	 : "Fantastik",
+        f"{main_url}/gozat/filmler/korku" 		 : "Korku",
+        f"{main_url}/gozat/filmler/romantik" 	 : "Romantik",
+        f"{main_url}/gozat/filmler/savas" 		 : "Savaş",
+        f"{main_url}/gozat/filmler/gerilim" 	 : "Gerilim",
+        f"{main_url}/gozat/filmler/bilim-kurgu"  : "Bilim Kurgu",
+        f"{main_url}/gozat/filmler/dram" 		 : "Dram",
+        f"{main_url}/gozat/filmler/gizem" 		 : "Gizem",
+        f"{main_url}/gozat/filmler/western" 	 : "Western",
+        f"{main_url}/gozat/filmler/ulke/turkiye" : "Türk Filmleri",
+        f"{main_url}/gozat/filmler/ulke/kore"    : "Kore Filmleri"
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        if "page/" in url:
+             full_url = f"{url}{page}"
+        elif "en-yenifilmler" in url or "netflix" in url:
+             full_url = f"{url}/{page}"
+        else:
+             full_url = f"{url}&page={page}"
+
+        resp = await self.httpx.get(full_url)
+        sel  = Selector(resp.text)
+
+        results = []
+        # Kotlin: div.poster-with-subject, div.dark-segment div.poster-md.poster
+        for item in sel.css("div.poster-with-subject, div.dark-segment div.poster-md.poster"):
+             title  = item.css("h2::text").get()
+             href   = item.css("a::attr(href)").get()
+             poster = item.css("img::attr(data-srcset)").get()
+             if poster:
+                  poster = poster.split(",")[0].split(" ")[0]
+
+             if title and href:
+                 results.append(MainPageResult(
+                     category = category,
+                     title    = title,
+                     url      = self.fix_url(href),
+                     poster   = self.fix_url(poster)
+                 ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        # Try to get dynamic keys from main page first
+        c_key   = "ca1d4a53d0f4761a949b85e51e18f096"
+        c_value = "MTc0NzI2OTAwMDU3ZTEwYmZjMDViNWFmOWIwZDViODg0MjU4MjA1ZmYxOThmZTYwMDdjMWQzMzliNzY5NzFlZmViMzRhMGVmNjgwODU3MGIyZA=="
+
+        try:
+             resp = await self.httpx.get(self.main_url)
+             sel  = Selector(resp.text)
+             cke  = sel.css("input[name='cKey']::attr(value)").get()
+             cval = sel.css("input[name='cValue']::attr(value)").get()
+             if cke and cval:
+                 c_key   = cke
+                 c_value = cval
+
+        except Exception:
+            pass
+
+        post_url = f"{self.main_url}/bg/searchcontent"
+        data = {
+            "cKey"       : c_key,
+            "cValue"     : c_value,
+            "searchTerm" : query
+        }
+        
+        headers = {
+            "User-Agent"       : "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0",
+            "Accept"           : "application/json, text/javascript, */*; q=0.01",
+            "X-Requested-With" : "XMLHttpRequest",
+            "Content-Type"     : "application/x-www-form-urlencoded; charset=UTF-8"
+        }
+        
+        response = await self.httpx.post(post_url, data=data, headers=headers)
+        
+        try:
+            # Extract JSON data from response (might contain garbage chars at start)
+            raw = response.text
+            json_start = raw.find('{')
+            if json_start != -1:
+                clean_json = raw[json_start:]
+                data = json.loads(clean_json)
+                
+                results = []
+                # Result array is in data['data']['result']
+                res_array = data.get("data", {}).get("result", [])
+                
+                if not res_array:
+                     # Fallback manual parsing ?
+                     pass
+
+                for item in res_array:
+                     name = item.get("object_name")
+                     slug = item.get("used_slug")
+                     poster = item.get("object_poster_url")
+                     
+                     if name and slug:
+                         if "cdn.ampproject.org" in poster:
+                              poster = "https://images.macellan.online/images/movie/poster/180/275/80/" + poster.split("/")[-1]
+                         
+                         results.append(SearchResult(
+                             title=name,
+                             url=self.fix_url(slug),
+                             poster=self.fix_url(poster)
+                         ))
+                return results
+
+        except Exception:
+            pass
+        return []
+
+    async def load_item(self, url: str) -> SeriesInfo:
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+        
+        title       = sel.css("h1::text").get()
+        poster_info = sel.css("div.ui.items img::attr(data-srcset)").get()
+        poster      = None
+        if poster_info:
+             # take 1x
+             parts = str(poster_info).split(",")
+             for p in parts:
+                 if "1x" in p:
+                     poster = p.strip().split(" ")[0]
+                     break
+        
+        description = sel.css("p#tv-series-desc::text").get()
+        tags        = sel.css("div.item.categories a::text").getall()
+        rating      = sel.css("span.color-imdb::text").get()
+        actors      = sel.css("div.content h5::text").getall()
+        year        = sel.css("span.item.year::text").get()  # Year bilgisi eklendi
+        
+        episodes = []
+        season_elements = sel.css("section.episodes-box")
+        
+        if season_elements:
+             # Get season links
+             season_links = []
+             menu = sel.css("div.ui.vertical.fluid.tabular.menu a")
+             for link in menu:
+                 href = link.css("::attr(href)").get()
+                 if href:
+                     season_links.append(self.fix_url(href))
+             
+             for s_url in season_links:
+                 target_url = s_url if "/bolum-" in s_url else f"{s_url}/bolum-1"
+                 
+                 try:
+                     s_resp = await self.httpx.get(target_url)
+                     s_sel  = Selector(s_resp.text)
+                     ep_links = s_sel.css("div.ui.list.celled a.item")
+                     
+                     current_season_no = 1
+                     match = re.search(r"sezon-(\d+)", target_url)
+                     if match:
+                         current_season_no = int(match.group(1))
+                     
+                     for ep_link in ep_links:
+                         href = ep_link.css("::attr(href)").get()
+                         name = ep_link.css("div.content div.header::text").get()
+                         
+                         if href:
+                             ep_no = 0
+                             match_ep = re.search(r"bolum-(\d+)", href)
+                             if match_ep:
+                                 ep_no = int(match_ep.group(1))
+                                 
+                             episodes.append(Episode(
+                                 season = current_season_no,
+                                 episode = ep_no,
+                                 title = name.strip() if name else "",
+                                 url = self.fix_url(href)
+                             ))
+                 except Exception:
+                     pass
+        
+        if episodes:
+            return SeriesInfo(
+                title    = title,
+                url      = url,
+                poster   = self.fix_url(poster),
+                description = description,
+                rating   = rating,
+                tags     = tags,
+                actors   = actors,
+                year     = year,
+                episodes = episodes
+            )
+        else:
+            return MovieInfo(
+                title       = title,
+                url         = url,
+                poster      = self.fix_url(poster),
+                description = description,
+                rating      = rating,
+                tags        = tags,
+                actors      = actors,
+                year        = year
+            )
+
+    async def load_links(self, url: str) -> list[dict]:
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+        
+        iframe = sel.css("iframe::attr(src)").get()
+        if iframe:
+            iframe = self.fix_url(iframe)
+            extractor = self.ex_manager.find_extractor(iframe)
+            return [{
+                "url"  : iframe,
+                "name" : extractor.name if extractor else "Iframe"
+            }]
+        return []

KekikStream/Plugins/SinemaCX.py

@@ -0,0 +1,157 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo, ExtractResult, Subtitle
+from parsel import Selector
+import re
+
+class SinemaCX(PluginBase):
+    name        = "SinemaCX"
+    language    = "tr"
+    main_url    = "https://www.sinema.fit"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "HD Film izle, Türkçe Dublaj ve Altyazılı filmler."
+
+    main_page   = {
+        f"{main_url}/page/SAYFA"                            : "Son Eklenen Filmler",
+        f"{main_url}/izle/aile-filmleri/page/SAYFA"         : "Aile Filmleri",
+        f"{main_url}/izle/aksiyon-filmleri/page/SAYFA"      : "Aksiyon Filmleri",
+        f"{main_url}/izle/animasyon-filmleri/page/SAYFA"    : "Animasyon Filmleri",
+        f"{main_url}/izle/belgesel/page/SAYFA"              : "Belgesel Filmleri",
+        f"{main_url}/izle/bilim-kurgu-filmleri/page/SAYFA"  : "Bilim Kurgu Filmler",
+        f"{main_url}/izle/biyografi/page/SAYFA"             : "Biyografi Filmleri",
+        f"{main_url}/izle/fantastik-filmler/page/SAYFA"     : "Fantastik Filmler",
+        f"{main_url}/izle/gizem-filmleri/page/SAYFA"        : "Gizem Filmleri",
+        f"{main_url}/izle/komedi-filmleri/page/SAYFA"       : "Komedi Filmleri",
+        f"{main_url}/izle/korku-filmleri/page/SAYFA"        : "Korku Filmleri",
+        f"{main_url}/izle/macera-filmleri/page/SAYFA"       : "Macera Filmleri",
+        f"{main_url}/izle/romantik-filmler/page/SAYFA"      : "Romantik Filmler",
+        f"{main_url}/izle/erotik-filmler/page/SAYFA"        : "Erotik Film",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        istek  = await self.httpx.get(url.replace("SAYFA", str(page)))
+        secici = Selector(istek.text)
+
+        return [
+            MainPageResult(
+                category = category,
+                title    = veri.css("div.yanac span::text").get(),
+                url      = self.fix_url(veri.css("div.yanac a::attr(href)").get()),
+                poster   = self.fix_url(veri.css("a.resim img::attr(data-src)").get() or veri.css("a.resim img::attr(src)").get()),
+            )
+                for veri in secici.css("div.son div.frag-k, div.icerik div.frag-k")
+                    if veri.css("div.yanac span::text").get()
+        ]
+
+    async def search(self, query: str) -> list[SearchResult]:
+        istek  = await self.httpx.get(f"{self.main_url}/?s={query}")
+        secici = Selector(istek.text)
+
+        return [
+            SearchResult(
+                title  = veri.css("div.yanac span::text").get(),
+                url    = self.fix_url(veri.css("div.yanac a::attr(href)").get()),
+                poster = self.fix_url(veri.css("a.resim img::attr(data-src)").get() or veri.css("a.resim img::attr(src)").get()),
+            )
+                for veri in secici.css("div.icerik div.frag-k")
+                    if veri.css("div.yanac span::text").get()
+        ]
+
+    async def load_item(self, url: str) -> MovieInfo:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        duration_match = re.search(r"Süre:.*?(\d+)\s*Dakika", istek.text)
+        description = secici.css("div.ackl div.scroll-liste::text").get()
+
+        return MovieInfo(
+            url         = url,
+            poster      = self.fix_url(secici.css("link[rel='image_src']::attr(href)").get()),
+            title       = secici.css("div.f-bilgi h1::text").get(),
+            description = description.strip() if description else None,
+            tags        = [a.css("::text").get() for a in secici.css("div.f-bilgi div.tur a")],
+            year        = secici.css("div.f-bilgi ul.detay a[href*='yapim']::text").get(),
+            actors      = [li.css("span.isim::text").get() for li in secici.css("li.oync li.oyuncu-k")],
+            duration    = int(duration_match[1]) if duration_match else None,
+        )
+
+    async def load_links(self, url: str) -> list[dict]:
+        istek  = await self.httpx.get(url)
+        secici = Selector(istek.text)
+
+        iframe_list = [iframe.css("::attr(data-vsrc)").get() for iframe in secici.css("iframe")]
+        iframe_list = [i for i in iframe_list if i]
+
+        # Sadece fragman varsa /2/ sayfasından dene
+        has_only_trailer = all(
+            "youtube" in (i or "").lower() or "fragman" in (i or "").lower() or "trailer" in (i or "").lower()
+            for i in iframe_list
+        )
+
+        if has_only_trailer:
+            alt_url   = url.rstrip("/") + "/2/"
+            alt_istek = await self.httpx.get(alt_url)
+            alt_sec   = Selector(alt_istek.text)
+            iframe_list = [iframe.css("::attr(data-vsrc)").get() for iframe in alt_sec.css("iframe")]
+            iframe_list = [i for i in iframe_list if i]
+
+        if not iframe_list:
+            return []
+
+        iframe = self.fix_url(iframe_list[0].split("?img=")[0])
+        if not iframe:
+            return []
+
+        results = []
+
+        # Altyazı kontrolü
+        self.httpx.headers.update({"Referer": f"{self.main_url}/"})
+        iframe_istek = await self.httpx.get(iframe)
+        iframe_text  = iframe_istek.text
+
+        subtitles = []
+        sub_match = re.search(r'playerjsSubtitle\s*=\s*"(.+?)"', iframe_text)
+        if sub_match:
+            sub_section = sub_match[1]
+            for sub in re.finditer(r'\[(.*?)](https?://[^\s",]+)', sub_section):
+                subtitles.append(Subtitle(name=sub[1], url=self.fix_url(sub[2])))
+
+        # player.filmizle.in kontrolü
+        if "player.filmizle.in" in iframe.lower():
+            base_match = re.search(r"https?://([^/]+)", iframe)
+            if base_match:
+                base_url = base_match[1]
+                vid_id   = iframe.split("/")[-1]
+
+                self.httpx.headers.update({"X-Requested-With": "XMLHttpRequest"})
+                vid_istek = await self.httpx.post(
+                    f"https://{base_url}/player/index.php?data={vid_id}&do=getVideo",
+                )
+                vid_data = vid_istek.json()
+
+                if vid_data.get("securedLink"):
+                    results.append({
+                        "name"      : f"{self.name}",
+                        "url"       : vid_data["securedLink"],
+                        "referer"   : iframe,
+                        "subtitles" : subtitles
+                    })
+        else:
+            # Extractor'a yönlendir
+            extractor = self.ex_manager.find_extractor(iframe)
+            results.append({
+                "name"      : f"{extractor.name if extractor else self.name}",
+                "url"       : iframe,
+                "referer"   : f"{self.main_url}/",
+                "subtitles" : subtitles
+            })
+
+        return results
+
+    async def play(self, **kwargs):
+        extract_result = ExtractResult(**kwargs)
+        self.media_handler.title = kwargs.get("name")
+        if self.name not in self.media_handler.title:
+            self.media_handler.title = f"{self.name} | {self.media_handler.title}"
+
+        self.media_handler.play_media(extract_result)

KekikStream/Plugins/Sinezy.py

@@ -0,0 +1,146 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from KekikStream.Core import PluginBase, MainPageResult, SearchResult, MovieInfo
+from parsel           import Selector
+import re, base64
+
+class Sinezy(PluginBase):
+    name        = "Sinezy"
+    language    = "tr"
+    main_url    = "https://sinezy.fit"
+    favicon     = f"https://www.google.com/s2/favicons?domain={main_url}&sz=64"
+    description = "Yerli ve yabancı film izle! Türkçe Dublaj ve Alt Yazılı Seçenekleriyle full hd film izlemek için En çok tercih edilen adres!"
+
+    main_page = {
+        f"{main_url}/izle/en-yeni-filmler/"        : "Yeni Filmler",
+        f"{main_url}/izle/en-yi-filmler/"          : "En İyi Filmler",
+        f"{main_url}/izle/aksiyon-filmleri/"       : "Aksiyon ",
+        f"{main_url}/izle/animasyon-filmleri/"     : "Animasyon",
+        f"{main_url}/izle/belgesel-izle/"          : "Belgesel",
+        f"{main_url}/izle/bilim-kurgu-filmleri/"   : "Bilim Kurgu ",
+        f"{main_url}/izle/biyografi-filmleri/"     : "Biyografi ",
+        f"{main_url}/izle/dram-filmleri/"          : "Dram",
+        f"{main_url}/izle/erotik-film-izle/"       : "Erotik ",
+        f"{main_url}/izle/fantastik-filmler/"      : "Fantastik",
+        f"{main_url}/izle/gelecek-filmler/"        : "Yakında",
+        f"{main_url}/izle/gerilim-filmleri/"       : "Gerilim ",
+        f"{main_url}/izle/gizem-filmleri/"         : "Gizem ",
+        f"{main_url}/izle/komedi-filmleri/"        : "Komedi ",
+        f"{main_url}/izle/korku-filmleri/"         : "Korku ",
+        f"{main_url}/izle/macera-filmleri/"        : "Macera ",
+        f"{main_url}/izle/muzikal-izle/"           : "Müzikal",
+        f"{main_url}/izle/romantik-film/"          : "Romantik ",
+        f"{main_url}/izle/savas-filmleri/"         : "Savaş ",
+        f"{main_url}/izle/spor-filmleri/"          : "Spor ",
+        f"{main_url}/izle/suc-filmleri/"           : "Suç ",
+        f"{main_url}/izle/tarih-filmleri/"         : "Tarih ",
+        f"{main_url}/izle/turkce-altyazili-promo/" : "Altyazılı Pro",
+        f"{main_url}/izle/yabanci-dizi/"           : "Yabancı Dizi",
+        f"{main_url}/izle/en-iyi-filmler/"         : "En İyi Filmler",
+        f"{main_url}/izle/en-yeni-filmler/"        : "Yeni Filmler",
+        f"{main_url}/izle/yerli-filmler/"          : "Yerli Filmler",
+        f"{main_url}/izle/yetiskin-film/"          : "Yetişkin +18",
+    }
+
+    async def get_main_page(self, page: int, url: str, category: str) -> list[MainPageResult]:
+        full_url = f"{url}page/{page}/"
+        resp     = await self.httpx.get(full_url)
+        sel      = Selector(resp.text)
+        
+        results = []
+        for item in sel.css("div.container div.content div.movie_box.move_k"):
+             title  = item.css("a::attr(title)").get()
+             href   = item.css("a::attr(href)").get()
+             poster = item.css("img::attr(data-src)").get()
+             
+             if title and href:
+                 results.append(MainPageResult(
+                     category = category,
+                     title    = title,
+                     url      = self.fix_url(href),
+                     poster   = self.fix_url(poster)
+                 ))
+
+        return results
+
+    async def search(self, query: str) -> list[SearchResult]:
+        url  = f"{self.main_url}/arama/?s={query}"
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+
+        results = []
+        for item in sel.css("div.movie_box.move_k"):
+             title  = item.css("a::attr(title)").get()
+             href   = item.css("a::attr(href)").get()
+             poster = item.css("img::attr(data-src)").get()
+
+             if title and href:
+                 results.append(SearchResult(
+                     title   = title,
+                     url     = self.fix_url(href),
+                     poster  = self.fix_url(poster)
+                 ))
+
+        return results
+
+    async def load_item(self, url: str) -> MovieInfo:
+        resp = await self.httpx.get(url)
+        sel  = Selector(resp.text)
+
+        title       = sel.css("div.detail::attr(title)").get()
+        poster      = sel.css("div.move_k img::attr(data-src)").get()
+        description = sel.css("div.desc.yeniscroll p::text").get()
+        rating      = sel.css("span.info span.imdb::text").get()
+
+        tags   = sel.css("div.detail span a::text").getall()
+        actors = sel.css("span.oyn p::text").getall()        # Might need splitting logic
+        
+        year = None
+        info_text = sel.css("span.info::text").get()
+        if info_text:
+            year_match = re.search(r'\b(19\d{2}|20\d{2})\b', info_text)
+            if year_match:
+                year = year_match.group(1)
+        
+        # Bulunamadıysa tüm sayfada ara
+        if not year:
+            all_text = " ".join(sel.css("::text").getall())
+            year_match = re.search(r'\b(19\d{2}|20\d{2})\b', all_text)
+            if year_match:
+                year = year_match.group(1)
+
+        return MovieInfo(
+            title       = title,
+            url         = url,
+            poster      = self.fix_url(poster),
+            description = description,
+            tags        = tags,
+            rating      = rating,
+            actors      = actors,
+            year        = year
+        )
+
+    async def load_links(self, url: str) -> list[dict]:
+        resp = await self.httpx.get(url)
+
+        match = re.search(r"ilkpartkod\s*=\s*'([^']+)'", resp.text, re.IGNORECASE)
+        if match:
+             encoded = match.group(1)
+             try:
+                 decoded = base64.b64decode(encoded).decode('utf-8')
+                 iframe_match = re.search(r'src="([^"]*)"', decoded)
+
+                 if iframe_match:
+                     iframe = iframe_match.group(1)
+                     iframe = self.fix_url(iframe)
+                     
+                     extractor = self.ex_manager.find_extractor(iframe)
+
+                     return [{
+                         "url"  : iframe,
+                         "name" : extractor.name if extractor else "Iframe"
+                     }]
+             except Exception:
+                 pass
+
+        return []