weeb-cli 1.0.0__py3-none-any.whl

weeb_cli/services/dependency_manager.py

@@ -0,0 +1,321 @@
+import os
+import sys
+import platform
+import shutil
+import requests
+import zipfile
+import tarfile
+import stat
+import subprocess
+from pathlib import Path
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, DownloadColumn, TransferSpeedColumn
+from ..config import config
+from ..i18n import i18n
+
+try:
+    import py7zr
+except ImportError:
+    py7zr = None
+
+console = Console()
+
+class DependencyManager:
+    def __init__(self):
+        self.os_type = platform.system().lower()
+        self.arch = platform.machine().lower()
+        self.bin_dir = Path.home() / ".weeb-cli" / "bin"
+        self._ensure_bin_dir()
+
+        mpv_macos_url = "https://laboratory.stolendata.net/~djinn/mpv_osx/mpv-latest.tar.gz"
+        if self.arch == "arm64":
+            mpv_macos_url = "https://laboratory.stolendata.net/~djinn/mpv_osx/mpv-arm64-latest.tar.gz"
+
+        self.dependencies = {
+            "windows": {
+                "yt-dlp": {
+                    "url": ["https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe"],
+                    "type": "binary",
+                    "filename": "yt-dlp.exe",
+                    "pkg": {"winget": "yt-dlp", "choco": "yt-dlp", "scoop": "yt-dlp"}
+                },
+                "ffmpeg": {
+                    "url": [
+                        "https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip",
+                        "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-win64-gpl.zip"
+                    ],
+                    "type": "archive",
+                    "files": ["ffmpeg.exe", "ffprobe.exe"],
+                    "pkg": {"winget": "Gyan.FFmpeg", "choco": "ffmpeg", "scoop": "ffmpeg"}
+                },
+                "mpv": {
+                    "url": [
+                        "https://github.com/shinchiro/mpv-winbuild-cmake/releases/download/v20240114/mpv-x86_64-v3-20240114-git-07ec82e.7z", 
+                        "https://sourceforge.net/projects/mpv-player-windows/files/64bit/mpv-x86_64-20231224-git-0a30b42.7z/download"
+                    ],
+                    "type": "archive", 
+                    "filename": "mpv.exe",
+                    "pkg": {"winget": "MutanteOz.mpv", "choco": "mpv", "scoop": "mpv"}
+                },
+                "aria2": {
+                     "url": ["https://github.com/aria2/aria2/releases/download/release-1.37.0/aria2-1.37.0-win-64bit-build1.zip"],
+                     "type": "archive",
+                     "files": ["aria2c.exe"],
+                     "pkg": {"winget": "aria2", "choco": "aria2", "scoop": "aria2"}
+                }
+            },
+            "linux": {
+                "yt-dlp": {
+                    "url": ["https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp"],
+                    "type": "binary",
+                    "filename": "yt-dlp",
+                    "pkg": {"brew": "yt-dlp", "yay": "yt-dlp", "pacman": "yt-dlp", "apt": "yt-dlp"}
+                },
+                "ffmpeg": {
+                    "url": ["https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz"],
+                    "type": "archive",
+                    "files": ["ffmpeg", "ffprobe"],
+                    "pkg": {"brew": "ffmpeg", "yay": "ffmpeg", "pacman": "ffmpeg", "apt": "ffmpeg"}
+                },
+                 "aria2": {
+                     "url": ["https://github.com/q3aql/aria2-static-builds/releases/download/v1.36.0/aria2-1.36.0-linux-gnu-64bit-build1.tar.bz2"],
+                     "type": "archive",
+                     "files": ["aria2c"],
+                     "pkg": {"brew": "aria2", "yay": "aria2", "pacman": "aria2", "apt": "aria2"}
+                },
+                "mpv": {
+                    "url": ["https://github.com/pkgforge-dev/mpv-AppImage/releases/latest/download/mpv-x86_64.AppImage"],
+                    "type": "binary",
+                    "filename": "mpv",
+                    "pkg": {"brew": "mpv", "yay": "mpv-git", "pacman": "mpv", "apt": "mpv"}
+                }
+            },
+            "darwin": { 
+                 "yt-dlp": {
+                    "url": ["https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp_macos"],
+                    "type": "binary",
+                    "filename": "yt-dlp",
+                    "pkg": {"brew": "yt-dlp"}
+                },
+                "ffmpeg": {
+                     "url": ["https://evermeet.cx/ffmpeg/getrelease/zip"],
+                     "type": "archive",
+                     "files": ["ffmpeg", "ffprobe"],
+                     "pkg": {"brew": "ffmpeg"}
+                },
+                "mpv": {
+                    "url": [mpv_macos_url],
+                    "type": "archive",
+                    "files": ["mpv"],
+                    "pkg": {"brew": "mpv"}
+                }
+            }
+        }
+
+    def _ensure_bin_dir(self):
+        if not self.bin_dir.exists():
+            self.bin_dir.mkdir(parents=True, exist_ok=True)
+        if str(self.bin_dir) not in os.environ["PATH"]:
+            os.environ["PATH"] += os.pathsep + str(self.bin_dir)
+
+    def check_dependency(self, name):
+        exe_name = f"{name}.exe" if self.os_type == "windows" else name
+        local_path = self.bin_dir / exe_name
+        
+        if local_path.exists():
+            return str(local_path)
+            
+        system_path = shutil.which(name)
+        return system_path
+
+    def install_dependency(self, name):
+        if self.os_type not in self.dependencies or name not in self.dependencies[self.os_type]:
+            console.print(f"[yellow]{i18n.t('setup.manual_required', tool=name)}[/yellow]")
+            return False
+
+        if self._try_package_managers(name):
+            return True
+            
+        return self._install_direct(name)
+
+    def _try_package_managers(self, name):
+        info = self.dependencies[self.os_type][name]
+        pkg_map = info.get("pkg", {})
+        
+        managers = {
+            "winget": ["winget", "install", "-e", "--id"],
+            "choco": ["choco", "install", "-y"],
+            "scoop": ["scoop", "install"],
+            "brew": ["brew", "install"],
+            "yay": ["yay", "-S", "--noconfirm"],
+            "pacman": ["sudo", "pacman", "-S", "--noconfirm"],
+            "apt": ["sudo", "apt", "install", "-y"],
+        }
+        
+        for mgr, cmd_prefix in managers.items():
+            if mgr in pkg_map and shutil.which(mgr):
+                pkg_name = pkg_map[mgr]
+                console.print(f"[cyan]{i18n.t('setup.pkg_manager_try', manager=mgr)}[/cyan]")
+                
+                full_cmd = cmd_prefix + [pkg_name]
+                try:
+                    subprocess.run(full_cmd, check=True)
+                    console.print(f"[green]{i18n.t('setup.success', tool=name)}[/green]")
+                    return True
+                except subprocess.CalledProcessError:
+                    continue
+        return False
+
+    def _install_direct(self, name):
+        info = self.dependencies[self.os_type][name]
+        urls = info["url"]
+        
+        console.print(f"[cyan]{i18n.t('setup.downloading', tool=name)}[/cyan]")
+        
+        success = False
+        downloaded_file = None
+
+        for url in urls:
+            try:
+                downloaded_file = self._download_file(url, f"temp_{name}")
+                success = True
+                break
+            except Exception as e:
+                console.print(f"[red]{i18n.t('common.error')}: {e}[/red]")
+                continue
+        
+        if not success or not downloaded_file:
+            console.print(f"[red]{i18n.t('setup.failed', tool=name)}[/red]")
+            return False
+
+        try:
+            if info["type"] == "binary":
+                target = self.bin_dir / info["filename"]
+                
+                if target.exists():
+                    os.remove(target)
+                
+                shutil.move(downloaded_file, target)
+                self._make_executable(target)
+            
+            elif info["type"] == "archive":
+                self._extract_and_install(downloaded_file, info.get("files", []), name)
+            
+            console.print(f"[green]{i18n.t('setup.success', tool=name)}[/green]")
+            return True
+            
+        except Exception as e:
+            console.print(f"[red]{i18n.t('setup.failed', tool=name)}: {e}[/red]")
+            return False
+        finally:
+            if downloaded_file and os.path.exists(downloaded_file):
+                os.remove(downloaded_file)
+
+    def _get_temp_dir(self):
+        temp_dir = self.bin_dir / "temp"
+        temp_dir.mkdir(exist_ok=True)
+        return temp_dir
+
+    def _download_file(self, url, prefix):
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        
+        total_size = int(response.headers.get('content-length', 0))
+        filename = url.split("/")[-1]
+        temp_path = self._get_temp_dir() / (prefix + "_" + filename)
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+        ) as progress:
+            task = progress.add_task(f"[cyan]Downloading...", total=total_size)
+            
+            with open(temp_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+                    progress.update(task, advance=len(chunk))
+                    
+        return temp_path
+
+    def _extract_and_install(self, archive_path, target_files, tool_name):
+        archive_path = str(archive_path)
+        
+        temp_extract = self._get_temp_dir() / "extract"
+        if temp_extract.exists():
+            shutil.rmtree(temp_extract)
+        temp_extract.mkdir()
+
+        try:
+            if archive_path.endswith(".zip"):
+                with zipfile.ZipFile(archive_path, 'r') as zip_ref:
+                    zip_ref.extractall(temp_extract)
+            elif archive_path.endswith(".7z"):
+                if not py7zr:
+                    raise Exception("py7zr missing")
+                with py7zr.SevenZipFile(archive_path, mode='r') as z:
+                    z.extractall(path=temp_extract)
+            elif archive_path.endswith((".tar.gz", ".tar.xz", ".tar.bz2", ".tgz")):
+                with tarfile.open(archive_path, "r:*") as tar_ref:
+                    tar_ref.extractall(temp_extract)
+            else:
+                raise Exception("Unsupported format")
+
+            found_count = 0
+            for root, dirs, files in os.walk(temp_extract):
+                for file in files:
+                    is_target = False
+                    
+                    if file in target_files:
+                        is_target = True
+                    
+                    if self.os_type == "windows" and not is_target:
+                        simple_name = file.lower().replace(".exe", "")
+                        if f"{simple_name}.exe" == file.lower() and \
+                           (simple_name in target_files or simple_name == tool_name):
+                            is_target = True
+                    
+                    if self.os_type == "darwin" and tool_name == "mpv" and file == "mpv":
+                         if "Contents" in root and "MacOS" in root:
+                             is_target = True
+
+                    if is_target:
+                         source = Path(root) / file
+                         target_name = file
+                         target = self.bin_dir / target_name
+                         
+                         if target.exists():
+                             os.remove(target)
+                             
+                         shutil.move(str(source), str(target))
+                         self._make_executable(target)
+                         found_count += 1
+            
+            if found_count == 0:
+                for root, dirs, files in os.walk(temp_extract):
+                    for file in files:
+                        if file.startswith(tool_name) and (file.endswith(".exe") or "." not in file):
+                            source = Path(root) / file
+                            target = self.bin_dir / file
+                            if target.exists():
+                                os.remove(target)
+                            shutil.move(str(source), str(target))
+                            self._make_executable(target)
+                            found_count += 1
+                            break
+
+            if found_count == 0:
+                raise Exception("Binary not found in archive")
+
+        finally:
+            if temp_extract.exists():
+                shutil.rmtree(temp_extract)
+
+    def _make_executable(self, path):
+        if self.os_type != "windows":
+            st = os.stat(path)
+            os.chmod(path, st.st_mode | stat.S_IEXEC)
+
+dependency_manager = DependencyManager()

weeb_cli/services/details.py

@@ -0,0 +1,32 @@
+from weeb_cli.services.scraper import scraper
+
+def get_details(anime_id):
+    details = scraper.get_details(anime_id)
+    if not details:
+        return None
+    
+    return {
+        "id": details.id,
+        "slug": details.id,
+        "title": details.title,
+        "name": details.title,
+        "description": details.description,
+        "synopsis": details.description,
+        "cover": details.cover,
+        "genres": details.genres,
+        "year": details.year,
+        "status": details.status,
+        "total_episodes": details.total_episodes,
+        "episodes": [
+            {
+                "id": ep.id,
+                "number": ep.number,
+                "ep_num": ep.number,
+                "title": ep.title,
+                "name": ep.title or f"Bölüm {ep.number}",
+                "season": ep.season,
+                "url": ep.url
+            }
+            for ep in details.episodes
+        ]
+    }

weeb_cli/services/downloader.py

@@ -0,0 +1,308 @@
+import os
+import json
+import re
+import threading
+import time
+import subprocess
+from pathlib import Path
+from rich.console import Console
+from weeb_cli.config import config
+from weeb_cli.services.dependency_manager import dependency_manager
+
+console = Console()
+
+class QueueManager:
+    def __init__(self):
+        self.config_dir = Path.home() / ".weeb-cli"
+        self.queue_file = self.config_dir / "download_queue.json"
+        self.queue = []
+        self.active_downloads = 0
+        self.lock = threading.Lock()
+        self.running = False
+        self.worker_thread = None
+        self._load_queue()
+
+    def _load_queue(self):
+        if self.queue_file.exists():
+            try:
+                with open(self.queue_file, 'r', encoding='utf-8') as f:
+                    self.queue = json.load(f)
+            except:
+                self.queue = []
+
+    def _save_queue(self):
+        with self.lock:
+            with open(self.queue_file, 'w', encoding='utf-8') as f:
+                json.dump(self.queue, f, indent=2, ensure_ascii=False)
+
+    def start_queue(self):
+        if self.running:
+            return
+        self.running = True
+        if self.worker_thread is None or not self.worker_thread.is_alive():
+            self.worker_thread = threading.Thread(target=self._manage_queue, daemon=True)
+            self.worker_thread.start()
+
+    def stop_queue(self):
+        self.running = False
+
+    def is_running(self):
+        return self.running and self.worker_thread is not None and self.worker_thread.is_alive()
+
+    def has_incomplete_downloads(self):
+        return any(item["status"] in ["pending", "processing"] for item in self.queue)
+
+    def get_incomplete_count(self):
+        return len([item for item in self.queue if item["status"] in ["pending", "processing"]])
+
+    def get_pending_count(self):
+        return len([item for item in self.queue if item["status"] == "pending"])
+
+    def resume_incomplete(self):
+        for item in self.queue:
+            if item["status"] == "processing":
+                item["status"] = "pending"
+        self._save_queue()
+        self.start_queue()
+
+    def cancel_incomplete(self):
+        self.queue = [item for item in self.queue if item["status"] not in ["pending", "processing"]]
+        self._save_queue()
+
+    def is_downloading(self, slug, episode_id=None):
+        for item in self.queue:
+            if item["slug"] == slug and item["status"] in ["pending", "processing"]:
+                if episode_id is None or item["episode_id"] == episode_id:
+                    return True
+        return False
+
+    def add_to_queue(self, anime_title, episodes, slug):
+        added = 0
+        with self.lock:
+            for ep in episodes:
+                ep_id = ep.get("id")
+                if self.is_downloading(slug, ep_id):
+                    continue
+                    
+                item = {
+                    "anime_title": anime_title,
+                    "episode_number": ep.get("number") or ep.get("ep_num"),
+                    "episode_id": ep_id,
+                    "slug": slug,
+                    "status": "pending",
+                    "added_at": time.time(),
+                    "progress": 0,
+                    "eta": "?"
+                }
+                if not any(x['episode_id'] == item['episode_id'] and x['status'] in ['pending', 'processing'] for x in self.queue):
+                    self.queue.append(item)
+                    added += 1
+        self._save_queue()
+        return added
+
+    def _sanitize_filename(self, name):
+        return re.sub(r'[<>:"/\\|?*]', '', name).strip()
+
+    def _manage_queue(self):
+        while self.running:
+            max_workers = config.get("max_concurrent_downloads", 3)
+            
+            with self.lock:
+                active_count = len([x for x in self.queue if x["status"] == "processing"])
+                pending = [x for x in self.queue if x["status"] == "pending"]
+
+            if active_count < max_workers and pending:
+                to_start = pending[0]
+                to_start["status"] = "processing"
+                self._save_queue()
+                
+                t = threading.Thread(target=self._run_task, args=(to_start,))
+                t.start()
+            
+            if not pending and active_count == 0:
+                self.running = False
+                break
+            
+            time.sleep(1)
+
+    def _run_task(self, item):
+        try:
+            self._download_item(item)
+            item["status"] = "completed"
+            item["progress"] = 100
+            item["eta"] = "-"
+        except Exception as e:
+            item["status"] = "failed"
+            item["error"] = str(e)
+            item["eta"] = ""
+        self._save_queue()
+
+    def _download_item(self, item):
+        from weeb_cli.services.watch import get_streams
+        download_dir = Path(config.get("download_dir"))
+        safe_title = self._sanitize_filename(item["anime_title"])
+        anime_dir = download_dir / safe_title
+        anime_dir.mkdir(parents=True, exist_ok=True)
+
+        ep_num = item["episode_number"]
+        filename = f"{safe_title} - S1B{ep_num}.mp4" 
+        output_path = anime_dir / filename
+
+        stream_data = get_streams(item["slug"], item["episode_id"])
+        if not stream_data: 
+            raise Exception("No stream data")
+
+        stream_url = self._extract_url(stream_data)
+        if not stream_url:
+            raise Exception("No stream URL")
+
+        is_hls = ".m3u8" in stream_url
+        
+        if is_hls:
+            if config.get("ytdlp_enabled") and dependency_manager.check_dependency("yt-dlp"):
+                self._download_ytdlp(stream_url, output_path, item)
+            else:
+                self._download_ffmpeg(stream_url, output_path, item)
+        else:
+            if config.get("aria2_enabled") and dependency_manager.check_dependency("aria2"):
+                self._download_aria2(stream_url, output_path, item)
+            else:
+                self._download_generic(stream_url, output_path, item)
+
+    def _extract_url(self, data):
+        PRIORITY = ["ALUCARD", "AMATERASU", "SIBNET", "MP4UPLOAD", "UQLOAD"]
+        
+        if isinstance(data, dict):
+            node = data
+            for _ in range(3):
+                if "data" in node and isinstance(node["data"], (dict, list)):
+                    node = node["data"]
+                else:
+                    break
+             
+            sources = node if isinstance(node, list) else node.get("links") or node.get("sources")
+            if sources and isinstance(sources, list) and len(sources) > 0:
+                def get_priority(s):
+                    server = (s.get("server") or "").upper()
+                    for i, p in enumerate(PRIORITY):
+                        if p in server:
+                            return i
+                    return 999
+                
+                sorted_sources = sorted(sources, key=get_priority)
+                
+                for src in sorted_sources:
+                    url = src.get("url")
+                    if url:
+                        return url
+                        
+            elif isinstance(node, dict) and "url" in node:
+                return node["url"]
+        return None
+
+    def _download_aria2(self, url, path, item):
+        aria2 = dependency_manager.check_dependency("aria2")
+        conn = config.get("aria2_max_connections", 16)
+        cmd = [
+            aria2, 
+            url, 
+            "-d", str(path.parent), 
+            "-o", path.name,
+            "-x", str(conn),
+            "-s", str(conn),
+            "-j", "1",
+            "-c",
+            "--summary-interval=2",
+            "--console-log-level=warn" 
+        ]
+        
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, encoding='utf-8', errors='replace')
+        
+        while True:
+            line = process.stdout.readline()
+            if not line and process.poll() is not None:
+                break
+            if line:
+                if "ETA:" in line:
+                    try:
+                        parts = line.split("ETA:")
+                        eta_part = parts[1].split("]")[0]
+                        item["eta"] = eta_part.strip()
+                        
+                        match = re.search(r'\((\d+)%\)', line)
+                        if match:
+                            item["progress"] = int(match.group(1))
+                    except:
+                        pass
+        
+        if process.returncode != 0:
+            raise Exception("Aria2 failed")
+
+    def _download_ytdlp(self, url, path, item):
+        ytdlp = dependency_manager.check_dependency("yt-dlp")
+        fmt = config.get("ytdlp_format", "best")
+        cmd = [
+            ytdlp, 
+            "-f", fmt,
+            "-o", str(path),
+            "--no-part", 
+            "--newline",
+            url
+        ]
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, encoding='utf-8', errors='replace')
+        while True:
+            line = process.stdout.readline()
+            if not line and process.poll() is not None:
+                break
+            if line:
+                if "[download]" in line and "%" in line:
+                    try:
+                        p_str = line.split("%")[0].split()[-1]
+                        item["progress"] = float(p_str)
+                        if "ETA" in line:
+                            item["eta"] = line.split("ETA")[-1].strip()
+                    except:
+                        pass
+        if process.returncode != 0:
+            raise Exception("yt-dlp failed")
+
+    def _download_ffmpeg(self, url, path, item):
+        item["eta"] = ""
+        ffmpeg = dependency_manager.check_dependency("ffmpeg")
+        cmd = [
+            ffmpeg,
+            "-i", url,
+            "-c", "copy",
+            "-bsf:a", "aac_adtstoasc",
+            str(path),
+            "-y"
+        ]
+        subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+    def _download_generic(self, url, path, item):
+        import requests
+        item["eta"] = "..."
+        with requests.get(url, stream=True) as r:
+            r.raise_for_status()
+            total = int(r.headers.get('content-length', 0))
+            if total > 0:
+                downloaded = 0
+                start_time = time.time()
+                with open(path, 'wb') as f:
+                    for chunk in r.iter_content(chunk_size=8192):
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        item["progress"] = int((downloaded / total) * 100)
+                        
+                        elapsed = time.time() - start_time
+                        if elapsed > 0:
+                            speed = downloaded / elapsed
+                            remaining = total - downloaded
+                            eta_s = remaining / speed
+                            item["eta"] = f"{int(eta_s)}s"
+            else:
+                with open(path, 'wb') as f:
+                    for chunk in r.iter_content(chunk_size=8192):
+                        f.write(chunk)
+
+queue_manager = QueueManager()