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

weeb_cli/providers/hianime.py

@@ -0,0 +1,294 @@
+import json
+import re
+import urllib.request
+from urllib.parse import quote
+from typing import List, Optional
+from bs4 import BeautifulSoup
+
+from weeb_cli.providers.base import (
+    BaseProvider,
+    AnimeResult,
+    AnimeDetails,
+    Episode,
+    StreamLink
+)
+from weeb_cli.providers.registry import register_provider
+from weeb_cli.providers.extractors.megacloud import extract_stream
+
+BASE_URL = "https://hianime.to"
+AJAX_URL = f"{BASE_URL}/ajax/v2"
+
+HEADERS = {
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0",
+    "Referer": BASE_URL
+}
+
+
+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 ""
+
+
+@register_provider("hianime", lang="en", region="US")
+class HiAnimeProvider(BaseProvider):
+    
+    def __init__(self):
+        super().__init__()
+        self.headers = HEADERS.copy()
+        
+    def search(self, query: str) -> List[AnimeResult]:
+        q = (query or "").strip()
+        if not q:
+            return []
+        
+        url = f"{BASE_URL}/search?keyword={quote(q)}"
+        html = _get_html(url, self.headers)
+        
+        if not html:
+            return []
+        
+        soup = BeautifulSoup(html, 'html.parser')
+        results = []
+        
+        for item in soup.select('.flw-item'):
+            try:
+                title_el = item.select_one('.film-name .dynamic-name')
+                if not title_el:
+                    continue
+                
+                title = title_el.get_text(strip=True)
+                alt_title = title_el.get('data-jname', '')
+                href = title_el.get('href', '')
+                anime_id = href.split('/')[-1].split('?')[0] if href else None
+                
+                if not anime_id or not title:
+                    continue
+                
+                poster = item.select_one('.film-poster-img')
+                cover = poster.get('data-src') if poster else None
+                
+                sub_el = item.select_one('.tick-sub')
+                dub_el = item.select_one('.tick-dub')
+                eps_el = item.select_one('.tick-eps')
+                
+                sub_count = sub_el.get_text(strip=True) if sub_el else "0"
+                dub_count = dub_el.get_text(strip=True) if dub_el else "0"
+                
+                type_el = item.select_one('.fdi-item')
+                anime_type = type_el.get_text(strip=True).lower() if type_el else "tv"
+                
+                duration_el = item.select_one('.fdi-duration')
+                duration = duration_el.get_text(strip=True) if duration_el else ""
+                
+                results.append(AnimeResult(
+                    id=anime_id,
+                    title=title,
+                    type=self._parse_type(anime_type),
+                    cover=cover
+                ))
+            except:
+                continue
+        
+        return results
+    
+    def get_details(self, anime_id: str) -> Optional[AnimeDetails]:
+        url = f"{BASE_URL}/{anime_id}"
+        html = _get_html(url, self.headers)
+        
+        if not html:
+            return None
+        
+        soup = BeautifulSoup(html, 'html.parser')
+        
+        title_el = soup.select_one('.anisc-detail .film-name')
+        title = title_el.get_text(strip=True) if title_el else anime_id
+        
+        alt_title_el = soup.select_one('.film-name[data-jname]')
+        alt_title = alt_title_el.get('data-jname') if alt_title_el else None
+        
+        desc_el = soup.select_one('.film-description .text')
+        description = desc_el.get_text(strip=True) if desc_el else None
+        
+        poster_el = soup.select_one('.film-poster-img')
+        cover = poster_el.get('src') if poster_el else None
+        
+        genres = []
+        for genre_el in soup.select('.item-list a[href*="/genre/"]'):
+            genres.append(genre_el.get_text(strip=True))
+        
+        episodes = self.get_episodes(anime_id)
+        
+        return AnimeDetails(
+            id=anime_id,
+            title=title,
+            description=description,
+            cover=cover,
+            genres=genres,
+            episodes=episodes,
+            total_episodes=len(episodes)
+        )
+    
+    def get_episodes(self, anime_id: str) -> List[Episode]:
+        match = re.search(r'-(\d+)$', anime_id)
+        if not match:
+            return []
+        
+        show_id = match.group(1)
+        url = f"{AJAX_URL}/episode/list/{show_id}"
+        
+        data = _get_json(url, self.headers)
+        if not data or 'html' not in data:
+            return []
+        
+        soup = BeautifulSoup(data['html'], 'html.parser')
+        episodes = []
+        
+        for i, item in enumerate(soup.select('.ssl-item.ep-item')):
+            try:
+                href = item.get('href', '')
+                ep_id = href.replace('/watch/', '').replace('?', '::') if href else None
+                
+                if not ep_id:
+                    continue
+                
+                title = item.get('title', '')
+                alt_title = item.select_one('.ep-name.e-dynamic-name')
+                alt_title = alt_title.get('data-jname') if alt_title else None
+                
+                is_filler = 'ssl-item-filler' in item.get('class', [])
+                ep_num = i + 1
+                
+                episodes.append(Episode(
+                    id=ep_id,
+                    number=ep_num,
+                    title=title
+                ))
+            except:
+                continue
+        
+        return episodes
+    
+    def get_streams(self, anime_id: str, episode_id: str) -> List[StreamLink]:
+        ep_num = episode_id.split('ep=')[-1] if 'ep=' in episode_id else episode_id.split('::')[-1]
+        
+        servers_url = f"{AJAX_URL}/episode/servers?episodeId={ep_num}"
+        servers_data = _get_json(servers_url, self.headers)
+        
+        if not servers_data or 'html' not in servers_data:
+            return []
+        
+        soup = BeautifulSoup(servers_data['html'], 'html.parser')
+        
+        servers = {"sub": [], "dub": []}
+        
+        for server_item in soup.select('.servers-sub .server-item'):
+            try:
+                server_id = server_item.get('data-id')
+                server_index = server_item.get('data-server-id')
+                server_name = server_item.select_one('a')
+                server_name = server_name.get_text(strip=True).lower() if server_name else 'unknown'
+                
+                if server_id:
+                    servers["sub"].append({
+                        "id": int(server_id),
+                        "index": int(server_index) if server_index else None,
+                        "name": server_name,
+                        "type": "sub"
+                    })
+            except:
+                continue
+        
+        for server_item in soup.select('.servers-dub .server-item'):
+            try:
+                server_id = server_item.get('data-id')
+                server_index = server_item.get('data-server-id')
+                server_name = server_item.select_one('a')
+                server_name = server_name.get_text(strip=True).lower() if server_name else 'unknown'
+                
+                if server_id:
+                    servers["dub"].append({
+                        "id": int(server_id),
+                        "index": int(server_index) if server_index else None,
+                        "name": server_name,
+                        "type": "dub"
+                    })
+            except:
+                continue
+        
+        streams = []
+        
+        for server_type in ["sub", "dub"]:
+            for server in servers[server_type]:
+                try:
+                    stream_data = extract_stream(
+                        server_id=server["id"],
+                        episode_id=episode_id,
+                        server_type=server_type,
+                        server_name=server["name"]
+                    )
+                    
+                    if stream_data and stream_data.get("file"):
+                        streams.append(StreamLink(
+                            url=stream_data["file"],
+                            quality="auto",
+                            server=f"{server['name']}-{server_type}",
+                            headers={"Referer": "https://megacloud.tv"},
+                            subtitles=self._get_subtitle_url(stream_data.get("tracks", []))
+                        ))
+                except:
+                    continue
+        
+        if not streams:
+            for server_type in ["sub", "dub"]:
+                for server in servers[server_type]:
+                    streams.append(StreamLink(
+                        url=f"embedded:{server['id']}:{episode_id}:{server_type}:{server['name']}",
+                        quality="auto",
+                        server=f"{server['name']}-{server_type} (embedded)",
+                        headers={"Referer": BASE_URL}
+                    ))
+        
+        return streams
+    
+    def _get_subtitle_url(self, tracks: List[dict]) -> Optional[str]:
+        for track in tracks:
+            if track.get('kind') in ['captions', 'subtitles']:
+                label = track.get('label', '').lower()
+                if 'english' in label:
+                    return track.get('file')
+        
+        for track in tracks:
+            if track.get('kind') in ['captions', 'subtitles']:
+                return track.get('file')
+        
+        return None
+    
+    def _parse_type(self, type_str: str) -> str:
+        type_str = (type_str or "").lower()
+        if "movie" in type_str:
+            return "movie"
+        if "ova" in type_str:
+            return "ova"
+        if "ona" in type_str:
+            return "ona"
+        if "special" in type_str:
+            return "special"
+        return "series"

weeb_cli/services/database.py

@@ -0,0 +1,313 @@
+import sqlite3
+import json
+import os
+from pathlib import Path
+from datetime import datetime
+from contextlib import contextmanager
+
+DB_PATH = Path.home() / ".weeb-cli" / "weeb.db"
+
+class Database:
+    def __init__(self):
+        self.db_path = DB_PATH
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_db()
+        self._migrate_from_json()
+    
+    @contextmanager
+    def _conn(self):
+        conn = sqlite3.connect(self.db_path, timeout=10)
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def _init_db(self):
+        with self._conn() as conn:
+            conn.executescript('''
+                CREATE TABLE IF NOT EXISTS config (
+                    key TEXT PRIMARY KEY,
+                    value TEXT
+                );
+                
+                CREATE TABLE IF NOT EXISTS progress (
+                    slug TEXT PRIMARY KEY,
+                    title TEXT,
+                    last_watched INTEGER DEFAULT 0,
+                    total_episodes INTEGER DEFAULT 0,
+                    completed TEXT DEFAULT '[]',
+                    last_watched_at TEXT
+                );
+                
+                CREATE TABLE IF NOT EXISTS search_history (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    query TEXT UNIQUE,
+                    searched_at TEXT
+                );
+                
+                CREATE TABLE IF NOT EXISTS download_queue (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    anime_title TEXT,
+                    episode_number INTEGER,
+                    episode_id TEXT,
+                    slug TEXT,
+                    status TEXT DEFAULT 'pending',
+                    progress INTEGER DEFAULT 0,
+                    eta TEXT DEFAULT '?',
+                    error TEXT,
+                    added_at REAL
+                );
+                
+                CREATE TABLE IF NOT EXISTS external_drives (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    path TEXT UNIQUE,
+                    name TEXT,
+                    added_at TEXT
+                );
+                
+                CREATE TABLE IF NOT EXISTS anime_index (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    title TEXT,
+                    source_path TEXT,
+                    source_name TEXT,
+                    folder_path TEXT,
+                    episode_count INTEGER DEFAULT 0,
+                    indexed_at TEXT
+                );
+                
+                CREATE INDEX IF NOT EXISTS idx_queue_status ON download_queue(status);
+                CREATE INDEX IF NOT EXISTS idx_progress_slug ON progress(slug);
+                CREATE INDEX IF NOT EXISTS idx_anime_title ON anime_index(title);
+                CREATE INDEX IF NOT EXISTS idx_anime_source ON anime_index(source_path);
+            ''')
+    
+    def _migrate_from_json(self):
+        config_dir = Path.home() / ".weeb-cli"
+        
+        config_file = config_dir / "config.json"
+        if config_file.exists():
+            try:
+                with open(config_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                for key, value in data.items():
+                    self.set_config(key, value)
+                config_file.rename(config_file.with_suffix('.json.bak'))
+            except:
+                pass
+        
+        progress_file = config_dir / "progress.json"
+        if progress_file.exists():
+            try:
+                with open(progress_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                for slug, info in data.items():
+                    self.save_progress(
+                        slug,
+                        info.get("title", slug),
+                        info.get("last_watched", 0),
+                        info.get("total_episodes", 0),
+                        info.get("completed", []),
+                        info.get("last_watched_at")
+                    )
+                progress_file.rename(progress_file.with_suffix('.json.bak'))
+            except:
+                pass
+        
+        history_file = config_dir / "search_history.json"
+        if history_file.exists():
+            try:
+                with open(history_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                for query in reversed(data):
+                    self.add_search_history(query)
+                history_file.rename(history_file.with_suffix('.json.bak'))
+            except:
+                pass
+        
+        queue_file = config_dir / "download_queue.json"
+        if queue_file.exists():
+            try:
+                with open(queue_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                for item in data:
+                    self.add_to_queue(item)
+                queue_file.rename(queue_file.with_suffix('.json.bak'))
+            except:
+                pass
+    
+    def get_config(self, key, default=None):
+        with self._conn() as conn:
+            row = conn.execute('SELECT value FROM config WHERE key = ?', (key,)).fetchone()
+            if row:
+                try:
+                    return json.loads(row['value'])
+                except:
+                    return row['value']
+            return default
+    
+    def set_config(self, key, value):
+        with self._conn() as conn:
+            conn.execute(
+                'INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)',
+                (key, json.dumps(value))
+            )
+    
+    def get_all_config(self):
+        with self._conn() as conn:
+            rows = conn.execute('SELECT key, value FROM config').fetchall()
+            result = {}
+            for row in rows:
+                try:
+                    result[row['key']] = json.loads(row['value'])
+                except:
+                    result[row['key']] = row['value']
+            return result
+    
+    def save_progress(self, slug, title, last_watched, total_episodes, completed, last_watched_at=None):
+        with self._conn() as conn:
+            conn.execute('''
+                INSERT OR REPLACE INTO progress 
+                (slug, title, last_watched, total_episodes, completed, last_watched_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+            ''', (slug, title, last_watched, total_episodes, json.dumps(completed), last_watched_at))
+    
+    def get_progress(self, slug):
+        with self._conn() as conn:
+            row = conn.execute('SELECT * FROM progress WHERE slug = ?', (slug,)).fetchone()
+            if row:
+                return {
+                    "slug": row['slug'],
+                    "title": row['title'],
+                    "last_watched": row['last_watched'],
+                    "total_episodes": row['total_episodes'],
+                    "completed": json.loads(row['completed'] or '[]'),
+                    "last_watched_at": row['last_watched_at']
+                }
+            return {"last_watched": 0, "completed": [], "title": "", "total_episodes": 0, "last_watched_at": None}
+    
+    def get_all_progress(self):
+        with self._conn() as conn:
+            rows = conn.execute('SELECT * FROM progress').fetchall()
+            result = {}
+            for row in rows:
+                result[row['slug']] = {
+                    "title": row['title'],
+                    "last_watched": row['last_watched'],
+                    "total_episodes": row['total_episodes'],
+                    "completed": json.loads(row['completed'] or '[]'),
+                    "last_watched_at": row['last_watched_at']
+                }
+            return result
+    
+    def add_search_history(self, query):
+        with self._conn() as conn:
+            conn.execute('DELETE FROM search_history WHERE query = ?', (query,))
+            conn.execute(
+                'INSERT INTO search_history (query, searched_at) VALUES (?, ?)',
+                (query, datetime.now().isoformat())
+            )
+            conn.execute('''
+                DELETE FROM search_history WHERE id NOT IN (
+                    SELECT id FROM search_history ORDER BY searched_at DESC LIMIT 10
+                )
+            ''')
+    
+    def get_search_history(self):
+        with self._conn() as conn:
+            rows = conn.execute(
+                'SELECT query FROM search_history ORDER BY searched_at DESC LIMIT 10'
+            ).fetchall()
+            return [row['query'] for row in rows]
+    
+    def add_to_queue(self, item):
+        with self._conn() as conn:
+            existing = conn.execute(
+                'SELECT id FROM download_queue WHERE episode_id = ? AND status IN (?, ?)',
+                (item.get('episode_id'), 'pending', 'processing')
+            ).fetchone()
+            if existing:
+                return False
+            
+            conn.execute('''
+                INSERT INTO download_queue 
+                (anime_title, episode_number, episode_id, slug, status, progress, eta, added_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                item.get('anime_title'),
+                item.get('episode_number'),
+                item.get('episode_id'),
+                item.get('slug'),
+                item.get('status', 'pending'),
+                item.get('progress', 0),
+                item.get('eta', '?'),
+                item.get('added_at', datetime.now().timestamp())
+            ))
+            return True
+    
+    def get_queue(self):
+        with self._conn() as conn:
+            rows = conn.execute('SELECT * FROM download_queue ORDER BY added_at').fetchall()
+            return [dict(row) for row in rows]
+    
+    def update_queue_item(self, episode_id, **kwargs):
+        with self._conn() as conn:
+            sets = ', '.join(f'{k} = ?' for k in kwargs.keys())
+            values = list(kwargs.values()) + [episode_id]
+            conn.execute(f'UPDATE download_queue SET {sets} WHERE episode_id = ?', values)
+    
+    def clear_completed_queue(self):
+        with self._conn() as conn:
+            conn.execute('DELETE FROM download_queue WHERE status NOT IN (?, ?)', ('pending', 'processing'))
+    
+    def get_external_drives(self):
+        with self._conn() as conn:
+            rows = conn.execute('SELECT * FROM external_drives ORDER BY name').fetchall()
+            return [dict(row) for row in rows]
+    
+    def add_external_drive(self, path, name=None):
+        with self._conn() as conn:
+            conn.execute(
+                'INSERT OR REPLACE INTO external_drives (path, name, added_at) VALUES (?, ?, ?)',
+                (path, name or os.path.basename(path), datetime.now().isoformat())
+            )
+    
+    def remove_external_drive(self, path):
+        with self._conn() as conn:
+            conn.execute('DELETE FROM external_drives WHERE path = ?', (path,))
+    
+    def update_drive_name(self, path, name):
+        with self._conn() as conn:
+            conn.execute('UPDATE external_drives SET name = ? WHERE path = ?', (name, path))
+    
+    def index_anime(self, title, source_path, source_name, folder_path, episode_count):
+        with self._conn() as conn:
+            conn.execute('DELETE FROM anime_index WHERE folder_path = ?', (folder_path,))
+            conn.execute('''
+                INSERT INTO anime_index (title, source_path, source_name, folder_path, episode_count, indexed_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+            ''', (title, source_path, source_name, folder_path, episode_count, datetime.now().isoformat()))
+    
+    def clear_source_index(self, source_path):
+        with self._conn() as conn:
+            conn.execute('DELETE FROM anime_index WHERE source_path = ?', (source_path,))
+    
+    def get_all_indexed_anime(self):
+        with self._conn() as conn:
+            rows = conn.execute('SELECT * FROM anime_index ORDER BY title').fetchall()
+            return [dict(row) for row in rows]
+    
+    def search_indexed_anime(self, query):
+        with self._conn() as conn:
+            rows = conn.execute(
+                'SELECT * FROM anime_index WHERE title LIKE ? ORDER BY title',
+                (f'%{query}%',)
+            ).fetchall()
+            return [dict(row) for row in rows]
+    
+    def remove_indexed_anime(self, folder_path):
+        with self._conn() as conn:
+            conn.execute('DELETE FROM anime_index WHERE folder_path = ?', (folder_path,))
+
+db = Database()