weeb-cli 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

weeb_cli/locales/tr.json

@@ -48,7 +48,18 @@
         "source_changed": "Kaynak {source} olarak değiştirildi.",
         "no_sources": "Bu dil için kaynak bulunamadı.",
         "toggle_on": "{tool} aktif edildi.",
-        "toggle_off": "{tool} devre dışı bırakıldı."
+        "toggle_off": "{tool} devre dışı bırakıldı.",
+        "external_drives": "Harici Diskler",
+        "add_drive": "Disk Ekle",
+        "enter_drive_path": "Disk yolunu girin (örn. D:\\Anime)",
+        "enter_drive_name": "Disk için takma isim",
+        "drive_not_found": "Belirtilen yol bulunamadı.",
+        "drive_added": "Disk eklendi.",
+        "rename_drive": "İsmi Değiştir",
+        "remove_drive": "Diski Kaldır",
+        "confirm_remove": "Bu diski kaldırmak istediğinize emin misiniz?",
+        "drive_renamed": "Disk ismi değiştirildi.",
+        "drive_removed": "Disk kaldırıldı."
     },
     "setup": {
         "welcome": "Weeb CLI'a Hoş Geldiniz!",
@@ -139,7 +150,7 @@
         "no_streams": "Stream bulunamadı"
     },
     "downloads": {
-        "title": "Geçmiş İndirmeler",
+        "title": "İndirmeler",
         "empty": "Henüz hiç indirme yapmamışsınız.",
         "status": "Durum",
         "progress": "İlerleme",
@@ -163,6 +174,23 @@
         "queue_stopped": "Kuyruk durduruldu.",
         "queue_running": "Çalışıyor",
         "pending_count": "{count} indirme bekliyor",
-        "cleared": "Temizlendi."
+        "cleared": "Temizlendi.",
+        "completed_downloads": "Tamamlanan İndirmeler",
+        "active_downloads": "Aktif İndirmeler",
+        "manage_queue": "Kuyruk Yönetimi",
+        "select_anime": "Anime Seçin",
+        "search_library": "Ara",
+        "search_anime": "Anime adı girin",
+        "search_all": "Tum Dizinlerde Ara",
+        "offline": "Cevrimdisi",
+        "reindex": "Yeniden Indexle",
+        "indexing": "Indexleniyor...",
+        "indexed": "{count} anime indexlendi",
+        "no_indexed": "Indexlenmis anime yok. Once bir disk baglayip indexleyin.",
+        "drive_not_connected": "Disk bağlı değil",
+        "connect_drive": "{name} diskini bağlayın",
+        "notification_title": "Weeb CLI",
+        "notification_complete": "{anime} - {episode}. bölüm indirildi",
+        "episode_short": "Blm"
     }
 }

weeb_cli/providers/__init__.py

@@ -10,6 +10,8 @@ from weeb_cli.providers.registry import (
 from weeb_cli.providers import animecix
 from weeb_cli.providers import anizle
 from weeb_cli.providers import turkanime
+from weeb_cli.providers import hianime
+from weeb_cli.providers import allanime
 
 __all__ = [
     "BaseProvider",

weeb_cli/providers/allanime.py

@@ -0,0 +1,252 @@
+import json
+import re
+import urllib.request
+from urllib.parse import quote, urlencode
+from typing import List, Optional
+
+from weeb_cli.providers.base import (
+    BaseProvider,
+    AnimeResult,
+    AnimeDetails,
+    Episode,
+    StreamLink
+)
+from weeb_cli.providers.registry import register_provider
+
+API_URL = "https://api.allanime.day/api"
+REFERER = "https://allmanga.to"
+
+HEADERS = {
+    "Accept": "application/json",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/121.0",
+    "Referer": REFERER
+}
+
+DECODE_MAP = {
+    '79': 'A', '7a': 'B', '7b': 'C', '7c': 'D', '7d': 'E', '7e': 'F', '7f': 'G',
+    '70': 'H', '71': 'I', '72': 'J', '73': 'K', '74': 'L', '75': 'M', '76': 'N',
+    '77': 'O', '68': 'P', '69': 'Q', '6a': 'R', '6b': 'S', '6c': 'T', '6d': 'U',
+    '6e': 'V', '6f': 'W', '60': 'X', '61': 'Y', '62': 'Z', '59': 'a', '5a': 'b',
+    '5b': 'c', '5c': 'd', '5d': 'e', '5e': 'f', '5f': 'g', '50': 'h', '51': 'i',
+    '52': 'j', '53': 'k', '54': 'l', '55': 'm', '56': 'n', '57': 'o', '48': 'p',
+    '49': 'q', '4a': 'r', '4b': 's', '4c': 't', '4d': 'u', '4e': 'v', '4f': 'w',
+    '40': 'x', '41': 'y', '42': 'z', '08': '0', '09': '1', '0a': '2', '0b': '3',
+    '0c': '4', '0d': '5', '0e': '6', '0f': '7', '00': '8', '01': '9', '15': '-',
+    '16': '.', '67': '_', '46': '~', '02': ':', '17': '/', '07': '?', '1b': '#',
+    '63': '[', '65': ']', '78': '@', '19': '!', '1c': '$', '1e': '&', '10': '(',
+    '11': ')', '12': '*', '13': '+', '14': ',', '03': ';', '05': '=', '1d': '%'
+}
+
+
+def _decode_provider_id(encoded: str) -> str:
+    result = []
+    i = 0
+    while i < len(encoded):
+        pair = encoded[i:i+2]
+        if pair in DECODE_MAP:
+            result.append(DECODE_MAP[pair])
+        i += 2
+    decoded = ''.join(result)
+    return decoded.replace('/clock', '/clock.json')
+
+
+def _http_get(url: str, headers: dict = None, timeout: int = 15) -> bytes:
+    req = urllib.request.Request(url, headers=headers or HEADERS)
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return resp.read()
+
+
+def _get_json(url: str, headers: dict = None, timeout: int = 15):
+    try:
+        data = _http_get(url, headers, timeout)
+        return json.loads(data)
+    except Exception:
+        return None
+
+
+def _graphql_request(query: str, variables: dict) -> dict:
+    params = {
+        'variables': json.dumps(variables),
+        'query': query
+    }
+    url = f"{API_URL}?{urlencode(params)}"
+    return _get_json(url, HEADERS)
+
+
+@register_provider("allanime", lang="en", region="US")
+class AllAnimeProvider(BaseProvider):
+    
+    def __init__(self):
+        super().__init__()
+        self.mode = "sub"
+        self.headers = HEADERS.copy()
+        
+    def search(self, query: str) -> List[AnimeResult]:
+        q = (query or "").strip()
+        if not q:
+            return []
+        
+        gql = '''query($search: SearchInput $limit: Int $page: Int $translationType: VaildTranslationTypeEnumType $countryOrigin: VaildCountryOriginEnumType) {
+            shows(search: $search limit: $limit page: $page translationType: $translationType countryOrigin: $countryOrigin) {
+                edges {
+                    _id
+                    name
+                    availableEpisodes
+                    __typename
+                }
+            }
+        }'''
+        
+        variables = {
+            "search": {
+                "allowAdult": False,
+                "allowUnknown": False,
+                "query": q
+            },
+            "limit": 40,
+            "page": 1,
+            "translationType": self.mode,
+            "countryOrigin": "ALL"
+        }
+        
+        data = _graphql_request(gql, variables)
+        if not data or 'data' not in data:
+            return []
+        
+        shows = data.get('data', {}).get('shows', {}).get('edges', [])
+        results = []
+        
+        for show in shows:
+            anime_id = show.get('_id')
+            name = show.get('name')
+            episodes = show.get('availableEpisodes', {})
+            
+            if not anime_id or not name:
+                continue
+            
+            ep_count = episodes.get(self.mode, 0)
+            if ep_count == 0:
+                continue
+            
+            results.append(AnimeResult(
+                id=anime_id,
+                title=f"{name} ({ep_count} episodes)",
+                type="series"
+            ))
+        
+        return results
+    
+    def get_details(self, anime_id: str) -> Optional[AnimeDetails]:
+        episodes = self.get_episodes(anime_id)
+        
+        if not episodes:
+            return None
+        
+        title = anime_id.replace('-', ' ').title()
+        
+        return AnimeDetails(
+            id=anime_id,
+            title=title,
+            episodes=episodes,
+            total_episodes=len(episodes)
+        )
+    
+    def get_episodes(self, anime_id: str) -> List[Episode]:
+        gql = '''query ($showId: String!) {
+            show(_id: $showId) {
+                _id
+                availableEpisodesDetail
+            }
+        }'''
+        
+        variables = {"showId": anime_id}
+        data = _graphql_request(gql, variables)
+        
+        if not data or 'data' not in data:
+            return []
+        
+        show = data.get('data', {}).get('show', {})
+        ep_detail = show.get('availableEpisodesDetail', {})
+        ep_list = ep_detail.get(self.mode, [])
+        
+        episodes = []
+        for i, ep_num in enumerate(sorted(ep_list, key=lambda x: float(x) if x.replace('.', '').isdigit() else 0)):
+            episodes.append(Episode(
+                id=f"{anime_id}::ep={ep_num}",
+                number=i + 1,
+                title=f"Episode {ep_num}"
+            ))
+        
+        return episodes
+    
+    def get_streams(self, anime_id: str, episode_id: str) -> List[StreamLink]:
+        if '::ep=' in episode_id:
+            parts = episode_id.split('::ep=')
+            show_id = parts[0]
+            ep_no = parts[1]
+        else:
+            show_id = anime_id
+            ep_no = episode_id
+        
+        gql = '''query ($showId: String!, $translationType: VaildTranslationTypeEnumType!, $episodeString: String!) {
+            episode(showId: $showId translationType: $translationType episodeString: $episodeString) {
+                episodeString
+                sourceUrls
+            }
+        }'''
+        
+        variables = {
+            "showId": show_id,
+            "translationType": self.mode,
+            "episodeString": ep_no
+        }
+        
+        data = _graphql_request(gql, variables)
+        if not data or 'data' not in data:
+            return []
+        
+        episode = data.get('data', {}).get('episode', {})
+        source_urls = episode.get('sourceUrls', [])
+        
+        streams = []
+        
+        for source in source_urls:
+            try:
+                source_url = source.get('sourceUrl', '')
+                source_name = source.get('sourceName', 'unknown')
+                
+                if not source_url or not source_url.startswith('--'):
+                    continue
+                
+                encoded = source_url[2:]
+                decoded_path = _decode_provider_id(encoded)
+                
+                if not decoded_path:
+                    continue
+                
+                full_url = f"https://allanime.day{decoded_path}"
+                
+                stream_data = _get_json(full_url, self.headers)
+                if not stream_data:
+                    continue
+                
+                links = stream_data.get('links', [])
+                for link in links:
+                    link_url = link.get('link')
+                    resolution = link.get('resolutionStr', 'auto')
+                    
+                    if link_url:
+                        streams.append(StreamLink(
+                            url=link_url,
+                            quality=resolution,
+                            server=source_name.lower(),
+                            headers={"Referer": REFERER}
+                        ))
+            except Exception:
+                continue
+        
+        return streams
+    
+    def set_mode(self, mode: str):
+        if mode in ['sub', 'dub']:
+            self.mode = mode

weeb_cli/providers/extractors/megacloud.py

@@ -0,0 +1,238 @@
+import re
+import json
+import time
+import urllib.request
+from typing import Optional, Dict, Any, List
+from bs4 import BeautifulSoup
+
+try:
+    from Crypto.Cipher import AES
+    from Crypto.Util.Padding import unpad
+    import base64
+    HAS_CRYPTO = True
+except ImportError:
+    HAS_CRYPTO = False
+
+HIANIME_BASE = "https://hianime.to"
+KEY_URL = "https://raw.githubusercontent.com/ryanwtf88/megacloud-keys/refs/heads/master/key.txt"
+MEGAPLAY_URL = "https://megaplay.buzz/stream/s-2/"
+VIDWISH_URL = "https://vidwish.live/stream/s-2/"
+REFERER = "https://megacloud.tv"
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0",
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+}
+
+_cached_key = None
+_key_fetched_at = 0
+KEY_CACHE_DURATION = 3600
+
+
+def _http_get(url: str, headers: dict = None, timeout: int = 15) -> bytes:
+    req = urllib.request.Request(url, headers=headers or HEADERS)
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return resp.read()
+
+
+def _get_json(url: str, headers: dict = None) -> Optional[dict]:
+    try:
+        data = _http_get(url, headers)
+        return json.loads(data)
+    except:
+        return None
+
+
+def _get_html(url: str, headers: dict = None) -> str:
+    try:
+        data = _http_get(url, headers)
+        return data.decode('utf-8')
+    except:
+        return ""
+
+
+def _get_decryption_key() -> Optional[str]:
+    global _cached_key, _key_fetched_at
+    
+    now = time.time()
+    if _cached_key and (now - _key_fetched_at) < KEY_CACHE_DURATION:
+        return _cached_key
+    
+    try:
+        data = _http_get(KEY_URL)
+        _cached_key = data.decode('utf-8').strip()
+        _key_fetched_at = now
+        return _cached_key
+    except:
+        return _cached_key
+
+
+def _decrypt_aes(encrypted: str, key: str) -> Optional[List[dict]]:
+    if not HAS_CRYPTO:
+        return None
+    
+    try:
+        key_bytes = key.encode('utf-8')
+        encrypted_bytes = base64.b64decode(encrypted)
+        
+        cipher = AES.new(key_bytes, AES.MODE_ECB)
+        decrypted = unpad(cipher.decrypt(encrypted_bytes), AES.block_size)
+        return json.loads(decrypted.decode('utf-8'))
+    except:
+        pass
+    
+    try:
+        key_bytes = bytes.fromhex(key)
+        encrypted_bytes = base64.b64decode(encrypted)
+        
+        cipher = AES.new(key_bytes, AES.MODE_ECB)
+        decrypted = unpad(cipher.decrypt(encrypted_bytes), AES.block_size)
+        return json.loads(decrypted.decode('utf-8'))
+    except:
+        return None
+
+
+def _extract_token(url: str) -> Optional[str]:
+    html = _get_html(url, {
+        **HEADERS,
+        "Referer": f"{HIANIME_BASE}/"
+    })
+    
+    if not html:
+        return None
+    
+    soup = BeautifulSoup(html, 'html.parser')
+    
+    meta = soup.select_one('meta[name="_gg_fb"]')
+    if meta and meta.get('content'):
+        return meta['content']
+    
+    data_dpi = soup.select_one('[data-dpi]')
+    if data_dpi and data_dpi.get('data-dpi'):
+        return data_dpi['data-dpi']
+    
+    for script in soup.select('script[nonce]'):
+        nonce = script.get('nonce')
+        if nonce and len(nonce) >= 10:
+            return nonce
+    
+    patterns = [
+        r'window\.\w+\s*=\s*["\']([a-zA-Z0-9_-]{10,})["\']',
+        r'data-k\s*=\s*["\']([a-zA-Z0-9_-]{10,})["\']',
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, html)
+        if match:
+            return match.group(1)
+    
+    return None
+
+
+def _get_fallback_source(ep_id: str, server_type: str, server_name: str) -> Optional[dict]:
+    providers = [
+        ("megaplay", MEGAPLAY_URL),
+        ("vidwish", VIDWISH_URL)
+    ]
+    
+    if server_name.lower() == "hd-2":
+        providers = providers[::-1]
+    
+    for name, base_url in providers:
+        try:
+            url = f"{base_url}{ep_id}/{server_type}"
+            html = _get_html(url, {
+                **HEADERS,
+                "Referer": f"https://{name}.{'buzz' if name == 'megaplay' else 'live'}/"
+            })
+            
+            if not html:
+                continue
+            
+            match = re.search(r'data-id=["\'](\d+)["\']', html)
+            if not match:
+                continue
+            
+            real_id = match.group(1)
+            domain = "megaplay.buzz" if name == "megaplay" else "vidwish.live"
+            sources_url = f"https://{domain}/stream/getSources?id={real_id}"
+            
+            data = _get_json(sources_url, {
+                **HEADERS,
+                "X-Requested-With": "XMLHttpRequest",
+                "Referer": f"https://{domain}/"
+            })
+            
+            if data and data.get('sources', {}).get('file'):
+                return {
+                    "file": data['sources']['file'],
+                    "tracks": data.get('tracks', []),
+                    "server": name
+                }
+        except:
+            continue
+    
+    return None
+
+
+def extract_stream(server_id: int, episode_id: str, server_type: str = "sub", server_name: str = "hd-1") -> Optional[dict]:
+    ep_id = episode_id.split('ep=')[-1] if 'ep=' in episode_id else episode_id.split('::')[-1]
+    
+    sources_url = f"{HIANIME_BASE}/ajax/v2/episode/sources?id={server_id}"
+    ajax_data = _get_json(sources_url, {**HEADERS, "Referer": HIANIME_BASE})
+    
+    if not ajax_data or 'link' not in ajax_data:
+        return _get_fallback_source(ep_id, server_type, server_name)
+    
+    embed_link = ajax_data['link']
+    
+    match = re.search(r'/([^/?]+)\?', embed_link)
+    source_id = match.group(1) if match else None
+    
+    match = re.search(r'^(https?://[^/]+(?:/[^/]+){3})', embed_link)
+    base_url = match.group(1) if match else None
+    
+    if not source_id or not base_url:
+        return _get_fallback_source(ep_id, server_type, server_name)
+    
+    token_url = f"{base_url}/{source_id}?k=1&autoPlay=0&oa=0&asi=1"
+    token = _extract_token(token_url)
+    
+    if not token:
+        return _get_fallback_source(ep_id, server_type, server_name)
+    
+    get_sources_url = f"{base_url}/getSources?id={source_id}&_k={token}"
+    sources_data = _get_json(get_sources_url, {
+        **HEADERS,
+        "X-Requested-With": "XMLHttpRequest",
+        "Referer": f"{base_url}/{source_id}"
+    })
+    
+    if not sources_data:
+        return _get_fallback_source(ep_id, server_type, server_name)
+    
+    encrypted = sources_data.get('sources')
+    
+    if isinstance(encrypted, list) and encrypted:
+        return {
+            "file": encrypted[0].get('file'),
+            "tracks": sources_data.get('tracks', []),
+            "intro": sources_data.get('intro'),
+            "outro": sources_data.get('outro'),
+            "server": server_name
+        }
+    
+    if isinstance(encrypted, str):
+        key = _get_decryption_key()
+        if key:
+            decrypted = _decrypt_aes(encrypted, key)
+            if decrypted and decrypted[0].get('file'):
+                return {
+                    "file": decrypted[0]['file'],
+                    "tracks": sources_data.get('tracks', []),
+                    "intro": sources_data.get('intro'),
+                    "outro": sources_data.get('outro'),
+                    "server": server_name
+                }
+    
+    return _get_fallback_source(ep_id, server_type, server_name)