de-aniworld provider

Author: ewgsta

weeb_cli/commands/search/watch_flow.py

@@ -98,7 +98,7 @@ def _handle_single_season_watch(slug, details, episodes, season=1):
             if selected_ep is None:
                 return
 
-            success = _play_episode(slug, selected_ep, details, season, episodes)
+            success = _play_episode(slug, selected_ep, details, season, episodes, completed_ids)
 
             if success:
                 ep_num = selected_ep.get("number") or selected_ep.get("ep_num")
@@ -148,7 +148,7 @@ def _build_episode_choices(episodes, season, completed_ids, next_ep_num):
 
     return ep_choices
 
-def _play_episode(slug, selected_ep, details, season, episodes):
+def _play_episode(slug, selected_ep, details, season, episodes, completed_ids):
     ep_id = selected_ep.get("id")
     ep_num = selected_ep.get("number") or selected_ep.get("ep_num")
 
@@ -184,8 +184,6 @@ def _play_episode(slug, selected_ep, details, season, episodes):
         time.sleep(1.5)
         return False
 
-    if len(valid_streams) < len(streams_list):
-        console.print(f"[dim]{len(valid_streams)}/{len(streams_list)} {i18n.t('details.streams_valid')}[/dim]")    
     streams_list = sort_streams(valid_streams)
 
     selected_stream = _select_stream(streams_list)

weeb_cli/locales/de.json

@@ -226,7 +226,7 @@
         "results": "Search Results",
         "cancel": "Cancel",
         "error": "Search failed.",
-        "recent": "Recent searches"
+        "recent": "Recent Searches"
     },
     "details": {
         "error_slug": "Error: Invalid anime ID.",

weeb_cli/locales/en.json

@@ -226,7 +226,7 @@
         "results": "Arama Sonuçları",
         "cancel": "İptal",
         "error": "Arama başarısız.",
-        "recent": "Son aramalar"
+        "recent": "Son Aramalar"
     },
     "details": {
         "error_slug": "Hata: Geçersiz anime ID.",

weeb_cli/locales/tr.json

@@ -0,0 +1,119 @@
+import json, re, requests
+from typing import List, Optional
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin
+from weeb_cli.providers.base import BaseProvider, AnimeResult, AnimeDetails, Episode, StreamLink
+from weeb_cli.providers.registry import register_provider
+from weeb_cli.services.logger import debug
+
+BASE_URL = "https://aniworld.to"
+AJAX_URL = "https://aniworld.to/ajax/search"
+STREAM_BASE = "https://aniworld.to/anime/stream/"
+
+@register_provider(name="aniworld", lang="de", region="DE")
+class AniWorldProvider(BaseProvider):
+    def __init__(self):
+        super().__init__()
+        self.session = requests.Session()
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "Referer": "https://aniworld.to/"
+        }
+
+    def _get(self, url):
+        try:
+            resp = self.session.get(url, headers=self.headers, timeout=10)
+            resp.raise_for_status()
+            return resp.text
+        except Exception as e:
+            debug(f"[AniWorld] GET Error: {e}"); return ""
+
+    def _post(self, url, data):
+        try:
+            h = self.headers.copy(); h["X-Requested-With"] = "XMLHttpRequest"
+            resp = self.session.post(url, data=data, headers=h, timeout=10)
+            return resp.text
+        except Exception as e:
+            debug(f"[AniWorld] POST Error: {e}"); return ""
+
+    def search(self, query: str) -> List[AnimeResult]:
+        res = self._post(AJAX_URL, {"keyword": query})
+        if not res: return []
+        try:
+            data = json.loads(res)
+            results = []
+            for item in data:
+                link = item.get("link", "")
+                if link.startswith("/anime/stream/"):
+                    slug = link.replace("/anime/stream/", "").split("/")[0]
+                    title = item.get("title", "").replace("<em>", "").replace("</em>", "")
+                    results.append(AnimeResult(id=slug, title=title, type="series"))
+            return results
+        except: return []
+
+    def get_details(self, anime_id: str) -> Optional[AnimeDetails]:
+        slug = anime_id.split("/")[0]
+        html = self._get(urljoin(STREAM_BASE, slug))
+        if not html: return None
+        soup = BeautifulSoup(html, "html.parser")
+        title = soup.find("h1", itemprop="name").text.strip() if soup.find("h1", itemprop="name") else slug
+        season_matches = re.findall(r"staffel-(\d+)", html)
+        unique_seasons = sorted(list(set(int(s) for s in season_matches)))
+        if not unique_seasons: unique_seasons = [1]
+        all_episodes = []
+        for s_num in unique_seasons:
+            s_html = self._get(f"{STREAM_BASE}{slug}/staffel-{s_num}")
+            ep_matches = re.findall(f"staffel-{s_num}/episode-(\\d+)", s_html)
+            unique_eps = sorted(list(set(int(m) for m in ep_matches)))
+            for e_num in unique_eps:
+                all_episodes.append(Episode(
+                    id=f"{slug}/staffel-{s_num}/episode-{e_num}",
+                    number=e_num, title=f"Folge {e_num}" if s_num > 0 else f"Film {e_num}",
+                    season=s_num
+                ))
+        return AnimeDetails(id=slug, title=title, description="", cover=None, total_episodes=len(all_episodes), episodes=all_episodes)
+
+    def get_episodes(self, anime_id: str, season: int = 1) -> List[Episode]:
+        slug = anime_id.split("/")[0]
+        html = self._get(f"{STREAM_BASE}{slug}/staffel-{season}")
+        if not html: return []
+        ep_matches = re.findall(f"staffel-{season}/episode-(\\d+)", html)
+        unique_eps = sorted(list(set(int(m) for m in ep_matches)))
+        return [Episode(id=f"{slug}/staffel-{season}/episode-{num}", number=num, title=f"Folge {num}" if season > 0 else f"Film {num}", season=season) for num in unique_eps]
+
+    def get_streams(self, anime_id: str, episode_id: str) -> List[StreamLink]:
+        from weeb_cli.providers.extractors.voe import extract_voe
+        from weeb_cli.providers.extractors.filemoon import extract_filemoon
+        from weeb_cli.providers.extractors.streamtape import extract_streamtape
+        from weeb_cli.providers.extractors.vidoza import extract_vidoza
+        from weeb_cli.providers.extractors.doodstream import extract_doodstream
+        html = self._get(urljoin(STREAM_BASE, episode_id))
+        if not html: return []
+        soup = BeautifulSoup(html, "html.parser")
+        lang_map = {"1": "GerDub", "2": "GerSub", "3": "EngSub"}
+        streams = []
+        hoster_items = soup.find_all("li", attrs={"data-link-target": True})
+        for item in hoster_items:
+            target = item["data-link-target"]
+            if not target.startswith("/redirect/"): continue
+            l_key = item.get("data-lang-key", "0")
+            lang_name = lang_map.get(l_key, "N/A")
+            h_name = "Unknown"
+            icon = item.find("i", class_="icon")
+            if icon:
+                for cls in icon.get("class", []):
+                    if cls != "icon": h_name = cls; break
+            if h_name == "Unknown" and item.find("h4"): h_name = item.find("h4").text.strip()
+            try:
+                resp = self.session.get(urljoin(BASE_URL, target), headers=self.headers, timeout=10, allow_redirects=True)
+                e_url = resp.url
+                v_url = None; h_low = h_name.lower()
+                if "voe" in h_low: v_url = extract_voe(e_url)
+                elif "filemoon" in h_low: v_url = extract_filemoon(e_url)
+                elif "streamtape" in h_low: v_url = extract_streamtape(e_url)
+                elif "vidoza" in h_low: v_url = extract_vidoza(e_url)
+                elif "dood" in h_low: v_url = extract_doodstream(e_url)
+                f_url = v_url or e_url
+                if f_url: streams.append(StreamLink(url=f_url, quality=f"[{lang_name}]", server=h_name))
+            except: continue
+        return streams

weeb_cli/providers/de/aniworld.py

@@ -0,0 +1,12 @@
+import re, requests, time, random, string
+def extract_doodstream(url):
+    try:
+        h = {"User-Agent": "Mozilla/5.0", "Referer": "https://aniworld.to/"}
+        html = requests.get(url, headers=h, timeout=10).text
+        m = re.search(r"\$.get\('(/pass_md5/[^']+)'", html)
+        if not m: return None
+        purl = f"https://dood.so{m.group(1)}"
+        base = requests.get(purl, headers={"Referer": url, "User-Agent": h["User-Agent"]}, timeout=10).text
+        tok = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(10))
+        return f"{base}{tok}?token={purl.split('/')[-1]}&expiry={int(time.time() * 1000)}"
+    except: return None

weeb_cli/providers/extractors/doodstream.py

@@ -0,0 +1,31 @@
+import re, requests
+from weeb_cli.services.logger import debug
+
+def decode_packer(p, r, c, d):
+    def replace(m):
+        try:
+            idx = int(m.group(0), r)
+            return d[idx] if idx < len(d) and d[idx] else m.group(0)
+        except: return m.group(0)
+    return re.compile(r'\b[0-9a-zA-Z]+\b').sub(replace, p)
+
+def extract_filemoon(url):
+    h = {"User-Agent": "Mozilla/5.0", "Referer": "https://aniworld.to/"}
+    try:
+        s = requests.Session()
+        html = s.get(url, headers=h, timeout=10).text
+        ifm = re.search(r'<iframe[^>]*src="([^"]+)"', html)
+        if not ifm: return None
+        iurl = ifm.group(1)
+        if iurl.startswith('//'): iurl = 'https:' + iurl
+        ihtml = s.get(iurl, headers={"User-Agent": h["User-Agent"], "Referer": "https://filemoon.to/"}, timeout=10).text
+        ev = re.search(r"eval\(function\(p,a,c,k,e,d\){[\s\S]+?}\('([\s\S]+?)',(\d+),(\d+),'([\s\S]+?)'\.split\('\|'\)\)\)", ihtml)
+        if not ev: return None
+        p, r, c, d = ev.groups()
+        un = decode_packer(p, int(r), int(c), d.split('|'))
+        m3 = re.search(r'file:"([^"]+\.m3u8[^"]*)"', un)
+        if m3: return m3.group(1)
+        sm = re.search(r'sources:\[{file:"([^"]+)"', un)
+        return sm.group(1) if sm else None
+    except Exception as e:
+        debug(f"[Filemoon] Error: {e}"); return None

weeb_cli/providers/extractors/filemoon.py

@@ -0,0 +1,8 @@
+import re, requests
+def extract_streamtape(url):
+    try:
+        h = {"User-Agent": "Mozilla/5.0", "Referer": "https://aniworld.to/"}
+        html = requests.get(url, headers=h, timeout=10).text
+        m = re.search(r"document\.getElementById\('robotlink'\)\.innerHTML\s*=\s*'([^']+)'\s*\+\s*'([^']+)'", html)
+        return f"https:{m.group(1)}{m.group(2)}" if m else None
+    except: return None

weeb_cli/providers/extractors/streamtape.py

@@ -0,0 +1,7 @@
+import re, requests
+def extract_vidoza(url):
+    try:
+        html = requests.get(url, headers={"User-Agent": "Mozilla/5.0"}, timeout=10).text
+        m = re.search(r'<source\s+src="([^"]+\.mp4)"', html)
+        return m.group(1) if m else None
+    except: return None

weeb_cli/providers/extractors/vidoza.py

@@ -0,0 +1,38 @@
+import base64, json, re, requests
+from typing import Optional
+from weeb_cli.services.logger import debug
+
+def rot13(s):
+    res = ""
+    for c in s:
+        if 'a' <= c <= 'z': res += chr((ord(c) - ord('a') + 13) % 26 + ord('a'))
+        elif 'A' <= c <= 'Z': res += chr((ord(c) - ord('A') + 13) % 26 + ord('A'))
+        else: res += c
+    return res
+
+def caesar_shift(s, shift): return "".join(chr(ord(c) + shift) for c in s)
+
+def deobfuscate(encoded):
+    res = rot13(encoded)
+    for sep in ['@$', '^^', '~@', '%?', '*~', '!!', '#&']: res = res.replace(sep, '')
+    res = base64.b64decode(res).decode('utf-8')
+    res = caesar_shift(res, -3)[::-1]
+    return json.loads(base64.b64decode(res).decode('utf-8'))
+
+def extract_voe(url):
+    headers = {"User-Agent": "Mozilla/5.0", "Referer": "https://aniworld.to/"}
+    try:
+        s = requests.Session()
+        html = s.get(url, headers=headers, timeout=10, allow_redirects=True).text
+        m = re.search(r"window\.location\.href\s*=\s*'([^']+)'", html)
+        if m: html = s.get(m.group(1), headers=headers, timeout=10).text
+        js = re.search(r'<script\s+type="application/json"[^>]*>([\s\S]*?)</script>', html)
+        if not js: return None
+        data = deobfuscate(js.group(1).strip())
+        val = data.get("file") or data.get("source")
+        if not val and data.get("fallback_mp4"):
+            f = data.get("fallback_mp4")
+            val = f[0] if isinstance(f, list) else f
+        return val
+    except Exception as e:
+        debug(f"[VOE] Error: {e}"); return None