weeb-cli 1.0.0__py3-none-any.whl

weeb_cli/commands/settings.py

@@ -0,0 +1,254 @@
+import questionary
+from rich.console import Console
+from weeb_cli.i18n import i18n
+from weeb_cli.config import config
+import time
+from weeb_cli.ui.header import show_header
+import os
+from weeb_cli.services.dependency_manager import dependency_manager
+
+console = Console()
+
+
+def toggle_config(key, name):
+    current = config.get(key)
+    new_val = not current
+    
+    if new_val:
+        dep_name = name.lower()
+        if "aria2" in dep_name: dep_name = "aria2"
+        elif "yt-dlp" in dep_name: dep_name = "yt-dlp"
+        
+        path = dependency_manager.check_dependency(dep_name)
+        if not path:
+             console.print(f"[cyan]{i18n.t('setup.downloading', tool=name)}...[/cyan]")
+             if not dependency_manager.install_dependency(dep_name):
+                 console.print(f"[red]{i18n.t('setup.failed', tool=name)}[/red]")
+                 time.sleep(1)
+                 return
+
+    config.set(key, new_val)
+    
+    msg_key = "settings.toggle_on" if new_val else "settings.toggle_off"
+    console.print(f"[green]{i18n.t(msg_key, tool=name)}[/green]")
+    time.sleep(0.5)
+
+def open_settings():
+    while True:
+        console.clear()
+        show_header(i18n.get("settings.title"))
+        
+        lang = config.get("language")
+        source = config.get("scraping_source", "local")
+        display_source = "weeb" if source == "local" else source
+
+        aria2_state = i18n.get("common.enabled") if config.get("aria2_enabled") else i18n.get("common.disabled")
+        ytdlp_state = i18n.get("common.enabled") if config.get("ytdlp_enabled") else i18n.get("common.disabled")
+        desc_state = i18n.get("common.enabled") if config.get("show_description", True) else i18n.get("common.disabled")
+        
+        opt_lang = i18n.get("settings.language")
+        opt_source = f"{i18n.get('settings.source')} [{display_source}]"
+        opt_download = i18n.get("settings.download_settings")
+        opt_desc = f"{i18n.get('settings.show_description')} [{desc_state}]"
+        opt_aria2 = f"{i18n.get('settings.aria2')} [{aria2_state}]"
+        opt_ytdlp = f"{i18n.get('settings.ytdlp')} [{ytdlp_state}]"
+        
+        opt_aria2_conf = f"  ↳ {i18n.get('settings.aria2_config')}"
+        opt_ytdlp_conf = f"  ↳ {i18n.get('settings.ytdlp_config')}"
+        
+        choices = [opt_lang, opt_source, opt_download, opt_desc, opt_aria2]
+        if config.get("aria2_enabled"):
+            choices.append(opt_aria2_conf)
+            
+        choices.append(opt_ytdlp)
+        if config.get("ytdlp_enabled"):
+            choices.append(opt_ytdlp_conf)
+        
+        try:
+            answer = questionary.select(
+                i18n.get("settings.title"),
+                choices=choices,
+                pointer=">",
+                use_shortcuts=False,
+                style=questionary.Style([
+                    ('pointer', 'fg:cyan bold'),
+                    ('highlighted', 'fg:cyan'),
+                    ('selected', 'fg:cyan bold'),
+                ])
+            ).ask()
+        except KeyboardInterrupt:
+            return
+
+        if answer == opt_lang:
+            change_language()
+        elif answer == opt_source:
+            change_source()
+        elif answer == opt_download:
+            download_settings_menu()
+        elif answer == opt_desc:
+            toggle_description()
+        elif answer == opt_aria2:
+            toggle_config("aria2_enabled", "Aria2")
+        elif answer == opt_aria2_conf:
+            aria2_settings_menu()
+        elif answer == opt_ytdlp:
+            toggle_config("ytdlp_enabled", "yt-dlp")
+        elif answer == opt_ytdlp_conf:
+            ytdlp_settings_menu()
+        elif answer is None:
+            return
+
+def toggle_description():
+    current = config.get("show_description", True)
+    config.set("show_description", not current)
+    msg_key = "settings.toggle_on" if not current else "settings.toggle_off"
+    console.print(f"[green]{i18n.t(msg_key, tool=i18n.get('settings.show_description'))}[/green]")
+    time.sleep(0.5)
+
+def change_language():
+    from weeb_cli.services.scraper import scraper
+    
+    langs = {"Türkçe": "tr", "English": "en"}
+    try:
+        selected = questionary.select(
+            "Select Language / Dil Seçiniz:",
+            choices=list(langs.keys()),
+            pointer=">",
+            use_shortcuts=False
+        ).ask()
+        
+        if selected:
+            lang_code = langs[selected]
+            i18n.set_language(lang_code)
+            
+            # Dil için varsayılan kaynağı ayarla
+            sources = scraper.get_sources_for_lang(lang_code)
+            if sources:
+                config.set("scraping_source", sources[0])
+            
+            console.print(f"[green]{i18n.get('settings.language_changed')}[/green]")
+            time.sleep(1)
+    except KeyboardInterrupt:
+        pass
+
+def change_source():
+    from weeb_cli.services.scraper import scraper
+    
+    current_lang = config.get("language", "tr")
+    sources = scraper.get_sources_for_lang(current_lang)
+    
+    if not sources:
+        console.print(f"[yellow]{i18n.get('settings.no_sources')}[/yellow]")
+        time.sleep(1)
+        return
+        
+    try:
+        selected = questionary.select(
+            i18n.get("settings.source"),
+            choices=sources,
+            pointer=">",
+            use_shortcuts=False
+        ).ask()
+        
+        if selected:
+            config.set("scraping_source", selected)
+            console.print(f"[green]{i18n.t('settings.source_changed', source=selected)}[/green]")
+            time.sleep(1)
+    except KeyboardInterrupt:
+        pass
+        
+
+
+def aria2_settings_menu():
+    while True:
+        console.clear()
+        show_header(i18n.get("settings.aria2_config"))
+        
+        curr_conn = config.get("aria2_max_connections", 16)
+        
+        opt_conn = f"{i18n.get('settings.max_conn')} [{curr_conn}]"
+        
+        try:
+            sel = questionary.select(
+                i18n.get("settings.aria2_config"),
+                choices=[opt_conn],
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if sel == opt_conn:
+                val = questionary.text(f"{i18n.get('settings.enter_conn')}:", default=str(curr_conn)).ask()
+                if val and val.isdigit():
+                    config.set("aria2_max_connections", int(val))
+            elif sel is None:
+                return
+        except KeyboardInterrupt:
+            return
+
+def download_settings_menu():
+    while True:
+        console.clear()
+        show_header(i18n.get("settings.download_settings"))
+        
+        curr_dir = config.get("download_dir")
+        console.print(f"[dim]Current: {curr_dir}[/dim]\n", justify="left")
+        
+        curr_concurrent = config.get("max_concurrent_downloads", 3)
+        
+        opt_name = i18n.get("settings.change_folder_name")
+        opt_path = i18n.get("settings.change_full_path")
+        opt_concurrent = f"{i18n.get('settings.concurrent_downloads')} [{curr_concurrent}]"
+        
+        try:
+            sel = questionary.select(
+                i18n.get("settings.download_settings"),
+                choices=[opt_name, opt_path, opt_concurrent],
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if sel == opt_name:
+                val = questionary.text("Folder Name:", default="weeb-downloads").ask()
+                if val:
+                    new_path = os.path.join(os.getcwd(), val)
+                    config.set("download_dir", new_path)
+            elif sel == opt_path:
+                val = questionary.text("Full Path:", default=curr_dir).ask()
+                if val:
+                    config.set("download_dir", val)
+            elif sel == opt_concurrent:
+                val = questionary.text(i18n.get("settings.enter_concurrent"), default=str(curr_concurrent)).ask()
+                if val and val.isdigit():
+                    n = int(val)
+                    if 1 <= n <= 5:
+                        config.set("max_concurrent_downloads", n)
+            elif sel is None:
+                return
+        except KeyboardInterrupt:
+            return
+
+
+def ytdlp_settings_menu():
+    while True:
+        console.clear()
+        show_header(i18n.get("settings.ytdlp_config"))
+        
+        curr_fmt = config.get("ytdlp_format", "best")
+        opt_fmt = f"{i18n.get('settings.format')} [{curr_fmt}]"
+        
+        try:
+            sel = questionary.select(
+                i18n.get("settings.ytdlp_config"), 
+                choices=[opt_fmt], 
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if sel == opt_fmt:
+                val = questionary.text(f"{i18n.get('settings.enter_format')}:", default=curr_fmt).ask()
+                if val:
+                    config.set("ytdlp_format", val)
+            elif sel is None:
+                return
+        except KeyboardInterrupt:
+            return

weeb_cli/commands/setup.py

@@ -0,0 +1,26 @@
+from rich.console import Console
+from rich.panel import Panel
+from ..services.dependency_manager import dependency_manager
+from ..i18n import i18n
+
+console = Console()
+
+def start_setup_wizard(force=False):
+    console.print(Panel(f"[bold cyan]{i18n.t('setup.wizard_title')}[/bold cyan]", expand=False))
+    
+    tools = ["yt-dlp", "ffmpeg", "aria2", "mpv"]
+    
+    for tool in tools:
+        console.print(f"\n[bold]{tool.upper()}[/bold]")
+        console.print(i18n.t('setup.check', tool=tool))
+        
+        path = dependency_manager.check_dependency(tool)
+        if path and not force:
+            console.print(f"[green]{i18n.t('setup.found', path=path)}[/green]")
+            continue
+            
+        console.print(f"[yellow]{i18n.t('setup.not_found', tool=tool)}[/yellow]")
+        dependency_manager.install_dependency(tool)
+    
+    console.print(f"\n[bold green]{i18n.t('setup.complete')}[/bold green]")
+    console.print(f"[dim]{i18n.t('setup.location', path=dependency_manager.bin_dir)}[/dim]")

weeb_cli/commands/watchlist.py

@@ -0,0 +1,130 @@
+import questionary
+from rich.console import Console
+from rich.table import Table
+from weeb_cli.i18n import i18n
+from weeb_cli.ui.header import show_header
+from weeb_cli.services.progress import progress_tracker
+
+console = Console()
+
+def show_watchlist():
+    while True:
+        console.clear()
+        show_header(i18n.get("menu.options.watchlist"))
+        
+        stats = progress_tracker.get_stats()
+        
+        console.print(f"[cyan]{i18n.get('watchlist.total_anime')}:[/cyan] {stats['total_anime']}", justify="left")
+        console.print(f"[cyan]{i18n.get('watchlist.total_episodes')}:[/cyan] {stats['total_episodes']}", justify="left")
+        console.print(f"[cyan]{i18n.get('watchlist.total_hours')}:[/cyan] {stats['total_hours']}h", justify="left")
+        
+        if stats['last_watched']:
+            last = stats['last_watched']
+            console.print(f"\n[dim]{i18n.get('watchlist.last_watched')}:[/dim] {last['title']} - {i18n.get('details.episode')} {last['last_watched']}", justify="left")
+        
+        console.print("")
+        
+        opt_completed = i18n.get("watchlist.completed")
+        opt_in_progress = i18n.get("watchlist.in_progress")
+        
+        try:
+            choice = questionary.select(
+                i18n.get("watchlist.select_category"),
+                choices=[opt_in_progress, opt_completed],
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if choice is None:
+                return
+            
+            if choice == opt_completed:
+                show_completed_list()
+            elif choice == opt_in_progress:
+                show_in_progress_list()
+                
+        except KeyboardInterrupt:
+            return
+
+def show_completed_list():
+    console.clear()
+    show_header(i18n.get("watchlist.completed"))
+    
+    completed = progress_tracker.get_completed_anime()
+    
+    if not completed:
+        console.print(f"[dim]{i18n.get('watchlist.no_completed')}[/dim]")
+        try:
+            input(i18n.get("common.continue_key"))
+        except KeyboardInterrupt:
+            pass
+        return
+    
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("#", width=4)
+    table.add_column(i18n.get("watchlist.anime_title"), width=40)
+    table.add_column(i18n.get("watchlist.episodes_watched"), width=15, justify="center")
+    
+    for i, anime in enumerate(completed, 1):
+        watched = len(anime.get("completed", []))
+        total = anime.get("total_episodes", watched)
+        table.add_row(
+            str(i),
+            anime.get("title", anime["slug"]),
+            f"[green]{watched}/{total}[/green]"
+        )
+    
+    console.print(table)
+    
+    try:
+        input(i18n.get("common.continue_key"))
+    except KeyboardInterrupt:
+        pass
+
+def show_in_progress_list():
+    from weeb_cli.commands.search import show_anime_details
+    
+    console.clear()
+    show_header(i18n.get("watchlist.in_progress"))
+    
+    in_progress = progress_tracker.get_in_progress_anime()
+    
+    if not in_progress:
+        console.print(f"[dim]{i18n.get('watchlist.no_in_progress')}[/dim]")
+        try:
+            input(i18n.get("common.continue_key"))
+        except KeyboardInterrupt:
+            pass
+        return
+    
+    choices = []
+    for anime in in_progress:
+        watched = len(anime.get("completed", []))
+        total = anime.get("total_episodes", 0)
+        total_str = str(total) if total > 0 else "?"
+        title = anime.get("title", anime["slug"])
+        next_ep = anime.get("last_watched", 0) + 1
+        choices.append(questionary.Choice(
+            title=f"{title} [{watched}/{total_str}] - {i18n.get('watchlist.next')}: {next_ep}",
+            value=anime
+        ))
+    
+    try:
+        selected = questionary.select(
+            i18n.get("watchlist.select_anime"),
+            choices=choices,
+            pointer=">",
+            use_shortcuts=False
+        ).ask()
+        
+        if selected:
+            anime_data = {
+                "id": selected["slug"],
+                "slug": selected["slug"],
+                "title": selected.get("title", selected["slug"]),
+                "name": selected.get("title", selected["slug"])
+            }
+            show_anime_details(anime_data)
+            
+    except KeyboardInterrupt:
+        pass

weeb_cli/config.py

@@ -0,0 +1,50 @@
+import json
+import os
+from pathlib import Path
+
+APP_NAME = "weeb-cli"
+CONFIG_DIR = Path.home() / f".{APP_NAME}"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+DEFAULT_CONFIG = {
+    "language": None,  
+    "aria2_enabled": True,
+    "ytdlp_enabled": True,
+    "aria2_max_connections": 16,
+    "max_concurrent_downloads": 3,
+    "download_dir": os.path.join(os.getcwd(), "weeb-downloads"),
+    "ytdlp_format": "bestvideo+bestaudio/best",
+    "scraping_source": "animecix",
+    "show_description": True
+}
+
+class Config:
+    def __init__(self):
+        self._ensure_config_exists()
+        self.data = self._load()
+
+    def _ensure_config_exists(self):
+        if not CONFIG_DIR.exists():
+            CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        if not CONFIG_FILE.exists():
+            self._save(DEFAULT_CONFIG)
+
+    def _load(self):
+        try:
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, FileNotFoundError):
+            return DEFAULT_CONFIG.copy()
+
+    def _save(self, data):
+        with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+    def get(self, key, default=None):
+        return self.data.get(key, default)
+
+    def set(self, key, value):
+        self.data[key] = value
+        self._save(self.data)
+
+config = Config()

weeb_cli/i18n.py

@@ -0,0 +1,65 @@
+import json
+import os
+import sys
+from pathlib import Path
+from weeb_cli.config import config
+
+def get_locales_dir():
+    if getattr(sys, 'frozen', False):
+        base_path = Path(sys._MEIPASS)
+        possible_path = base_path / "weeb_cli" / "locales"
+        if possible_path.exists():
+            return possible_path
+        return base_path / "locales"
+    
+    return Path(__file__).parent / "locales"
+
+LOCALES_DIR = get_locales_dir()
+
+class I18n:
+    def __init__(self):
+        self.language = config.get("language", "en")
+        self.translations = {}
+        self.load_translations()
+
+    def set_language(self, language_code):
+        self.language = language_code
+        config.set("language", language_code)
+        self.load_translations()
+
+    def load_translations(self):
+        file_path = LOCALES_DIR / f"{self.language}.json"
+        if not file_path.exists():
+            file_path = LOCALES_DIR / "en.json"
+        
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                self.translations = json.load(f)
+        except Exception as e:
+            print(f"Error loading translations: {e}")
+            self.translations = {}
+
+    def get(self, key_path, **kwargs):
+        keys = key_path.split(".")
+        value = self.translations
+        
+        for key in keys:
+            if isinstance(value, dict):
+                value = value.get(key)
+            else:
+                return key_path
+
+        if value is None:
+            return key_path
+
+        if isinstance(value, str):
+            try:
+                return value.format(**kwargs)
+            except KeyError:
+                return value
+        
+        return value
+    
+    t = get
+
+i18n = I18n()