weeb-cli 1.0.0__py3-none-any.whl

weeb_cli/services/player.py

@@ -0,0 +1,47 @@
+import subprocess
+import shutil
+import sys
+from rich.console import Console
+
+from weeb_cli.services.dependency_manager import dependency_manager
+from weeb_cli.i18n import i18n
+
+console = Console()
+
+class Player:
+    def __init__(self):
+        self.mpv_path = dependency_manager.check_dependency("mpv")
+    
+    def is_installed(self):
+        return self.mpv_path is not None
+
+    def play(self, url, title=None, start_time=None, headers=None):
+        if not self.mpv_path:
+            console.print(f"[yellow]{i18n.get('player.installing_mpv')}[/yellow]")
+            if dependency_manager.install_dependency("mpv"):
+                self.mpv_path = dependency_manager.check_dependency("mpv")
+            
+        if not self.mpv_path:
+            console.print(f"[red]{i18n.get('player.install_failed')}[/red]")
+            return False
+
+        cmd = [self.mpv_path, url]
+        if title:
+            cmd.extend([f"--force-media-title={title}"])
+        
+        if headers:
+            header_strs = [f"{k}: {v}" for k, v in headers.items()]
+            cmd.append(f"--http-header-fields={','.join(header_strs)}")
+        
+        cmd.append("--fs")
+
+        cmd.append("--save-position-on-quit")
+            
+        try:
+            subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return True
+        except Exception as e:
+            console.print(f"[red]Error running player: {e}[/red]")
+            return False
+
+player = Player()

weeb_cli/services/progress.py

@@ -0,0 +1,136 @@
+import json
+from pathlib import Path
+from datetime import datetime
+
+class ProgressTracker:
+    def __init__(self):
+        self.config_dir = Path.home() / ".weeb-cli"
+        self.progress_file = self.config_dir / "progress.json"
+        self.history_file = self.config_dir / "search_history.json"
+        self._ensure_file()
+
+    def _ensure_file(self):
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        if not self.progress_file.exists():
+            with open(self.progress_file, 'w') as f:
+                json.dump({}, f)
+        if not self.history_file.exists():
+            with open(self.history_file, 'w') as f:
+                json.dump([], f)
+
+    def load_progress(self):
+        try:
+            with open(self.progress_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return {}
+
+    def save_progress(self, data):
+        with open(self.progress_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+    def get_anime_progress(self, slug):
+        data = self.load_progress()
+        return data.get(slug, {
+            "last_watched": 0,
+            "completed": [],
+            "title": "",
+            "total_episodes": 0,
+            "last_watched_at": None
+        })
+
+    def mark_watched(self, slug, ep_number, title=None, total_episodes=None):
+        data = self.load_progress()
+        if slug not in data:
+            data[slug] = {
+                "last_watched": 0,
+                "completed": [],
+                "title": title or slug,
+                "total_episodes": total_episodes or 0,
+                "last_watched_at": None
+            }
+        
+        completed_set = set(data[slug].get("completed", []))
+        completed_set.add(ep_number)
+        data[slug]["completed"] = sorted(list(completed_set))
+        
+        if ep_number > data[slug].get("last_watched", 0):
+            data[slug]["last_watched"] = ep_number
+        
+        data[slug]["last_watched_at"] = datetime.now().isoformat()
+        
+        if title:
+            data[slug]["title"] = title
+        if total_episodes:
+            data[slug]["total_episodes"] = total_episodes
+             
+        self.save_progress(data)
+
+    def get_all_anime(self):
+        return self.load_progress()
+
+    def get_stats(self):
+        data = self.load_progress()
+        total_anime = len(data)
+        total_episodes = sum(len(a.get("completed", [])) for a in data.values())
+        total_hours = round(total_episodes * 24 / 60, 1)
+        
+        last_watched = None
+        last_time = None
+        for slug, info in data.items():
+            watched_at = info.get("last_watched_at")
+            if watched_at:
+                if last_time is None or watched_at > last_time:
+                    last_time = watched_at
+                    last_watched = {"slug": slug, **info}
+        
+        return {
+            "total_anime": total_anime,
+            "total_episodes": total_episodes,
+            "total_hours": total_hours,
+            "last_watched": last_watched
+        }
+
+    def get_completed_anime(self):
+        data = self.load_progress()
+        completed = []
+        for slug, info in data.items():
+            total = info.get("total_episodes", 0)
+            watched = len(info.get("completed", []))
+            if total > 0 and watched >= total:
+                completed.append({"slug": slug, **info})
+        return completed
+
+    def get_in_progress_anime(self):
+        data = self.load_progress()
+        in_progress = []
+        for slug, info in data.items():
+            total = info.get("total_episodes", 0)
+            watched = len(info.get("completed", []))
+            if watched > 0 and (total == 0 or watched < total):
+                in_progress.append({"slug": slug, **info})
+        return sorted(in_progress, key=lambda x: x.get("last_watched_at") or "", reverse=True)
+
+    def add_search_history(self, query):
+        try:
+            with open(self.history_file, 'r', encoding='utf-8') as f:
+                history = json.load(f)
+        except:
+            history = []
+        
+        if query in history:
+            history.remove(query)
+        history.insert(0, query)
+        history = history[:10]
+        
+        with open(self.history_file, 'w', encoding='utf-8') as f:
+            json.dump(history, f, ensure_ascii=False)
+
+    def get_search_history(self):
+        try:
+            with open(self.history_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except:
+            return []
+
+progress_tracker = ProgressTracker()

weeb_cli/services/scraper.py

@@ -0,0 +1,91 @@
+from typing import List, Optional, Tuple
+from weeb_cli.config import config
+from weeb_cli.providers import get_provider, get_default_provider, list_providers
+from weeb_cli.providers.base import AnimeResult, AnimeDetails, Episode, StreamLink, ProviderError
+
+
+class Scraper:
+    
+    def __init__(self):
+        self._provider = None
+        self._provider_name = None
+        self.last_error = None
+    
+    @property
+    def provider(self):
+        current_source = config.get("scraping_source", "")
+        
+        if self._provider_name != current_source:
+            self._provider_name = current_source
+            self._provider = get_provider(current_source)
+            
+            if not self._provider:
+                lang = config.get("language", "tr")
+                default = get_default_provider(lang)
+                if default:
+                    self._provider = get_provider(default)
+                    self._provider_name = default
+        
+        return self._provider
+    
+    def search(self, query: str) -> List[AnimeResult]:
+        self.last_error = None
+        if not self.provider:
+            return []
+        try:
+            return self.provider.search(query)
+        except ProviderError as e:
+            self.last_error = e.code
+            return []
+        except Exception as e:
+            self.last_error = str(e)
+            return []
+    
+    def get_details(self, anime_id: str) -> Optional[AnimeDetails]:
+        self.last_error = None
+        if not self.provider:
+            return None
+        try:
+            return self.provider.get_details(anime_id)
+        except ProviderError as e:
+            self.last_error = e.code
+            return None
+        except Exception as e:
+            self.last_error = str(e)
+            return None
+    
+    def get_episodes(self, anime_id: str) -> List[Episode]:
+        self.last_error = None
+        if not self.provider:
+            return []
+        try:
+            return self.provider.get_episodes(anime_id)
+        except ProviderError as e:
+            self.last_error = e.code
+            return []
+        except Exception as e:
+            self.last_error = str(e)
+            return []
+    
+    def get_streams(self, anime_id: str, episode_id: str) -> List[StreamLink]:
+        self.last_error = None
+        if not self.provider:
+            return []
+        try:
+            return self.provider.get_streams(anime_id, episode_id)
+        except ProviderError as e:
+            self.last_error = e.code
+            return []
+        except Exception as e:
+            self.last_error = str(e)
+            return []
+    
+    def get_available_sources(self) -> List[dict]:
+        return list_providers()
+    
+    def get_sources_for_lang(self, lang: str) -> List[str]:
+        from weeb_cli.providers import get_providers_for_lang
+        return get_providers_for_lang(lang)
+
+
+scraper = Scraper()

weeb_cli/services/search.py

@@ -0,0 +1,16 @@
+from weeb_cli.services.scraper import scraper
+
+def search(query):
+    results = scraper.search(query)
+    return [
+        {
+            "id": r.id,
+            "title": r.title,
+            "name": r.title,
+            "slug": r.id,
+            "type": r.type,
+            "cover": r.cover,
+            "year": r.year
+        }
+        for r in results
+    ]

weeb_cli/services/updater.py

@@ -0,0 +1,199 @@
+import requests
+from packaging import version
+from weeb_cli import __version__
+from rich.console import Console
+import questionary
+from weeb_cli.i18n import i18n
+import sys
+import os
+import platform
+import subprocess
+import tempfile
+
+console = Console()
+
+def get_install_method():
+    if getattr(sys, 'frozen', False):
+        return "exe"
+    
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "show", "weeb-cli"],
+            capture_output=True, text=True, timeout=5
+        )
+        if result.returncode == 0:
+            return "pip"
+    except Exception:
+        pass
+    
+    return "standalone"
+
+def get_platform_info():
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    
+    if system == "windows":
+        return "windows", "exe"
+    elif system == "darwin":
+        return "macos", "macos" if "arm" in machine else "macos-intel"
+    elif system == "linux":
+        return "linux", "linux"
+    else:
+        return system, system
+
+def check_for_updates():
+    try:
+        url = "https://api.github.com/repos/ewgsta/weeb-cli/releases/latest"
+        response = requests.get(url, timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            latest_tag = data.get("tag_name", "").lstrip("v")
+            assets = data.get("assets", [])
+            
+            if not latest_tag:
+                return False, None, None
+                
+            current_ver = version.parse(__version__)
+            latest_ver = version.parse(latest_tag)
+            
+            if latest_ver > current_ver:
+                return True, latest_tag, assets
+                
+    except Exception:
+        pass
+        
+    return False, None, None
+
+def find_asset_for_platform(assets):
+    system, platform_key = get_platform_info()
+    
+    for asset in assets:
+        name = asset.get("name", "").lower()
+        download_url = asset.get("browser_download_url", "")
+        
+        if system == "windows" and name.endswith(".exe"):
+            return download_url, name
+        elif system == "darwin" and ("macos" in name or "darwin" in name):
+            return download_url, name
+        elif system == "linux" and "linux" in name:
+            return download_url, name
+    
+    return None, None
+
+def download_exe(url, filename):
+    try:
+        console.print(f"[cyan]{i18n.get('update.downloading')}...[/cyan]")
+        
+        response = requests.get(url, stream=True, timeout=60)
+        response.raise_for_status()
+        
+        total_size = int(response.headers.get('content-length', 0))
+        
+        if getattr(sys, 'frozen', False):
+            current_exe = sys.executable
+            download_dir = os.path.dirname(current_exe)
+            new_exe_path = os.path.join(download_dir, f"weeb-cli-new.exe")
+        else:
+            download_dir = tempfile.gettempdir()
+            new_exe_path = os.path.join(download_dir, filename)
+        
+        downloaded = 0
+        with open(new_exe_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+                    downloaded += len(chunk)
+                    if total_size > 0:
+                        percent = int((downloaded / total_size) * 100)
+                        console.print(f"\r[cyan]İndiriliyor: {percent}%[/cyan]", end="")
+        
+        console.print(f"\n[green]{i18n.get('update.downloaded')}[/green]")
+        console.print(f"[dim]Konum: {new_exe_path}[/dim]")
+        
+        if getattr(sys, 'frozen', False):
+            batch_content = f'''@echo off
+timeout /t 2 /nobreak >nul
+del "{current_exe}"
+move "{new_exe_path}" "{current_exe}"
+start "" "{current_exe}"
+del "%~f0"
+'''
+            batch_path = os.path.join(download_dir, "update.bat")
+            with open(batch_path, 'w') as f:
+                f.write(batch_content)
+            
+            console.print(f"[green]{i18n.get('update.restarting')}...[/green]")
+            subprocess.Popen(['cmd', '/c', batch_path], 
+                           creationflags=subprocess.CREATE_NO_WINDOW if hasattr(subprocess, 'CREATE_NO_WINDOW') else 0)
+            sys.exit(0)
+        
+        return True
+        
+    except Exception as e:
+        console.print(f"[red]{i18n.get('update.error')}: {e}[/red]")
+        return False
+
+def update_via_pip():
+    try:
+        console.print(f"[cyan]{i18n.get('update.updating_pip')}...[/cyan]")
+        
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "weeb-cli"],
+            capture_output=True, text=True, timeout=120
+        )
+        
+        if result.returncode == 0:
+            console.print(f"[green]{i18n.get('update.success')}[/green]")
+            console.print(f"[dim]{i18n.get('update.restart_required')}[/dim]")
+            return True
+        else:
+            console.print(f"[red]{i18n.get('update.error')}[/red]")
+            console.print(f"[dim]{result.stderr}[/dim]")
+            return False
+            
+    except Exception as e:
+        console.print(f"[red]{i18n.get('update.error')}: {e}[/red]")
+        return False
+
+def update_prompt():
+    is_available, latest_ver, assets = check_for_updates()
+    
+    if not is_available:
+        return
+    
+    console.clear()
+    console.print(f"\n[green bold]{i18n.get('update.available')} (v{latest_ver})[/green bold]")
+    console.print(f"[dim]{i18n.get('update.current')}: v{__version__}[/dim]\n")
+    
+    should_update = questionary.confirm(
+        i18n.get("update.prompt"),
+        default=True
+    ).ask()
+    
+    if not should_update:
+        return
+    
+    install_method = get_install_method()
+    
+    if install_method == "exe":
+        asset_url, asset_name = find_asset_for_platform(assets or [])
+        if asset_url:
+            download_exe(asset_url, asset_name)
+        else:
+            console.print(f"[red]{i18n.get('update.no_asset')}[/red]")
+            
+    elif install_method == "pip":
+        update_via_pip()
+        
+    else:
+        asset_url, asset_name = find_asset_for_platform(assets or [])
+        if asset_url:
+            system, _ = get_platform_info()
+            if system == "windows":
+                download_exe(asset_url, asset_name)
+            else:
+                console.print(f"[cyan]{i18n.get('update.download_url')}:[/cyan]")
+                console.print(f"[blue]{asset_url}[/blue]")
+        else:
+            console.print(f"[yellow]{i18n.get('update.manual_update')}[/yellow]")
+            console.print("[blue]pip install --upgrade weeb-cli[/blue]")

weeb_cli/services/watch.py

@@ -0,0 +1,19 @@
+from weeb_cli.services.scraper import scraper
+
+def get_streams(anime_id, episode_id):
+    streams = scraper.get_streams(anime_id, episode_id)
+    if not streams:
+        return None
+    
+    return {
+        "data": {
+            "links": [
+                {
+                    "url": s.url,
+                    "quality": s.quality,
+                    "server": s.server
+                }
+                for s in streams
+            ]
+        }
+    }

weeb_cli/ui/__init__.py

@@ -0,0 +1 @@
+# Init UI package

weeb_cli/ui/header.py

@@ -0,0 +1,30 @@
+from rich import print
+from rich.text import Text
+from rich.console import Console
+from weeb_cli.config import config
+from weeb_cli import __version__
+
+console = Console()
+
+def show_header(title="Weeb API", show_version=False, show_source=False):
+    console.clear()
+    
+    text = Text()
+    text.append(f" {title} ", style="bold white on blue")
+    
+    parts = []
+    
+    if show_source:
+        cfg_source = config.get("scraping_source", "local")
+        disp_source = "weeb" if cfg_source == "local" else cfg_source
+        parts.append(disp_source)
+        
+    if show_version:
+        parts.append(f"v{__version__}")
+        
+    if parts:
+        joined = " | ".join(parts)
+        text.append(f" | {joined}", style="dim white")
+    
+    console.print(text, justify="left")
+    print()

weeb_cli/ui/menu.py

@@ -0,0 +1,59 @@
+import questionary
+from rich.console import Console
+import sys
+from .header import show_header
+from weeb_cli.i18n import i18n
+from weeb_cli.commands.search import search_anime
+from weeb_cli.commands.settings import open_settings
+from weeb_cli.commands.watchlist import show_watchlist
+from weeb_cli.commands.downloads import show_downloads
+
+console = Console()
+
+def show_main_menu():
+    console.clear()
+    show_header("Weeb API", show_version=True, show_source=True)
+    
+    opt_search = i18n.get("menu.options.search")
+    opt_watchlist = i18n.get("menu.options.watchlist")
+    opt_downloads = i18n.get("menu.options.downloads")
+    opt_settings = i18n.get("menu.options.settings")
+    opt_exit = i18n.get("menu.options.exit")
+    
+    try:
+        selected = questionary.select(
+            i18n.get("menu.prompt"),
+            choices=[
+                opt_search,
+                opt_watchlist,
+                opt_downloads,
+                opt_settings,
+                opt_exit
+            ],
+            pointer=">",
+            use_shortcuts=False,
+            style=questionary.Style([
+                ('pointer', 'fg:cyan bold'),
+                ('highlighted', 'fg:cyan'),
+                ('selected', 'fg:cyan bold'),
+            ])
+        ).ask()
+        
+        console.clear()
+        
+        if selected == opt_search:
+            search_anime()
+        elif selected == opt_watchlist:
+            show_watchlist()
+        elif selected == opt_downloads:
+            show_downloads()
+        elif selected == opt_settings:
+            open_settings()
+        elif selected == opt_exit or selected is None:
+            console.print(f"[yellow] {i18n.get('common.success')}...[/yellow]")
+            sys.exit(0)
+            
+        show_main_menu()
+        
+    except KeyboardInterrupt:
+        sys.exit(0)