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

weeb_cli/__init__.py

@@ -1 +1 @@
-__version__ = "1.0.0"
+__version__ = "2.0.0"

weeb_cli/commands/downloads.py

@@ -1,29 +1,79 @@
 import questionary
+from pathlib import Path
 from rich.console import Console
 from rich.live import Live
 from rich.table import Table
 from weeb_cli.services.downloader import queue_manager
+from weeb_cli.services.local_library import local_library
+from weeb_cli.services.player import player
+from weeb_cli.services.progress import progress_tracker
 from weeb_cli.i18n import i18n
 from weeb_cli.ui.header import show_header
 import time
 
 console = Console()
 
+AUTOCOMPLETE_STYLE = questionary.Style([
+    ('qmark', 'fg:cyan'),
+    ('question', 'fg:white bold'),
+    ('answer', 'fg:cyan bold'),
+    ('pointer', 'fg:cyan bold'),
+    ('highlighted', 'fg:white bg:ansiblack bold'),
+    ('selected', 'fg:white'),
+])
+
 def show_downloads():
+    local_library.smart_index_all()
+    
     while True:
         console.clear()
         show_header(i18n.get("downloads.title"))
         
-        pending = queue_manager.get_pending_count()
-        is_running = queue_manager.is_running()
+        sources = local_library.get_all_sources()
+        active_queue = [i for i in queue_manager.queue if i["status"] in ["pending", "processing"]]
         
-        if pending > 0:
+        choices = []
+        
+        indexed_count = len(local_library.get_indexed_anime())
+        if indexed_count > 0:
+            choices.append(questionary.Choice(
+                f"⌕ {i18n.get('downloads.search_all')} ({indexed_count} anime)",
+                value={"type": "search_all"}
+            ))
+        
+        for source in sources:
+            if source["available"]:
+                library = local_library.scan_library(source["path"])
+                count = len(library)
+                if count > 0:
+                    choices.append(questionary.Choice(
+                        f"● {source['name']} ({count} anime)",
+                        value={"type": "source", "data": source}
+                    ))
+            else:
+                indexed = [a for a in local_library.get_indexed_anime() if a["source_path"] == source["path"]]
+                count = len(indexed)
+                if count > 0:
+                    choices.append(questionary.Choice(
+                        f"○ {source['name']} ({count} anime) - {i18n.get('downloads.offline')}",
+                        value={"type": "offline", "data": source}
+                    ))
+        
+        if active_queue:
+            is_running = queue_manager.is_running()
             status = i18n.get("downloads.queue_running") if is_running else i18n.get("downloads.queue_stopped")
-            console.print(f"[cyan]{i18n.t('downloads.pending_count', count=pending)}[/cyan] - {status}\n")
+            choices.append(questionary.Choice(
+                f"{i18n.get('downloads.active_downloads')} ({len(active_queue)}) - {status}",
+                value={"type": "active"}
+            ))
         
-        queue = queue_manager.queue
+        if queue_manager.queue:
+            choices.append(questionary.Choice(
+                i18n.get("downloads.manage_queue"),
+                value={"type": "manage"}
+            ))
         
-        if not queue:
+        if not choices:
             console.print(f"[dim]{i18n.get('downloads.empty')}[/dim]")
             try:
                 input(i18n.get("common.continue_key"))
@@ -31,6 +81,288 @@ def show_downloads():
                 pass
             return
         
+        try:
+            action = questionary.select(
+                i18n.get("downloads.action_prompt"),
+                choices=choices,
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if action is None:
+                return
+            
+            if action["type"] == "search_all":
+                search_all_sources()
+            elif action["type"] == "source":
+                library = local_library.scan_library(action["data"]["path"])
+                show_completed_library(library, action["data"]["name"])
+            elif action["type"] == "offline":
+                show_offline_library(action["data"])
+            elif action["type"] == "active":
+                show_queue_live()
+            elif action["type"] == "manage":
+                manage_queue()
+                
+        except KeyboardInterrupt:
+            return
+
+def fuzzy_match(query: str, text: str) -> float:
+    from difflib import SequenceMatcher
+    query = query.lower()
+    text = text.lower()
+    
+    if query == text:
+        return 1.0
+    if query in text:
+        return 0.9
+    
+    return SequenceMatcher(None, query, text).ratio()
+
+def search_all_sources():
+    while True:
+        console.clear()
+        show_header(i18n.get("downloads.search_all"))
+        
+        all_indexed = local_library.get_indexed_anime()
+        
+        anime_map = {}
+        for anime in all_indexed:
+            progress = local_library.get_anime_progress(anime["title"])
+            watched = len(progress.get("completed", []))
+            total = anime["episode_count"]
+            available = local_library.is_source_available(anime["source_path"])
+            
+            status_icon = "●" if available else "○"
+            
+            if watched >= total and total > 0:
+                watch_status = " [✓]"
+            elif watched > 0:
+                watch_status = f" [{watched}/{total}]"
+            else:
+                watch_status = ""
+            
+            label = f"{status_icon} {anime['title']} [{anime['source_name']}]{watch_status}"
+            anime_map[label] = anime
+        
+        all_choices = list(anime_map.keys())
+        
+        if not all_choices:
+            console.print(f"[dim]{i18n.get('downloads.no_indexed')}[/dim]")
+            time.sleep(1.5)
+            return
+        
+        try:
+            selected_label = questionary.autocomplete(
+                i18n.get("downloads.search_anime"),
+                choices=all_choices,
+                match_middle=True,
+                style=AUTOCOMPLETE_STYLE,
+            ).ask()
+            
+            if selected_label is None:
+                return
+            
+            if selected_label in anime_map:
+                anime_info = anime_map[selected_label]
+                
+                if not local_library.is_source_available(anime_info["source_path"]):
+                    console.print(f"[yellow]{i18n.t('downloads.connect_drive', name=anime_info['source_name'])}[/yellow]")
+                    time.sleep(1.5)
+                    continue
+                
+                anime_data = {
+                    "title": anime_info["title"],
+                    "path": anime_info["folder_path"],
+                    "episode_count": anime_info["episode_count"],
+                    "episodes": local_library._scan_anime_folder(Path(anime_info["folder_path"]))
+                }
+                show_anime_episodes(anime_data)
+            
+        except KeyboardInterrupt:
+            return
+
+def show_offline_library(source):
+    while True:
+        console.clear()
+        show_header(f"{source['name']} ({i18n.get('downloads.offline')})")
+        
+        indexed = [a for a in local_library.get_indexed_anime() if a["source_path"] == source["path"]]
+        
+        if not indexed:
+            console.print(f"[dim]{i18n.get('downloads.no_indexed')}[/dim]")
+            time.sleep(1.5)
+            return
+        
+        ep_short = i18n.get("downloads.episode_short")
+        anime_map = {}
+        for anime in indexed:
+            progress = local_library.get_anime_progress(anime["title"])
+            watched = len(progress.get("completed", []))
+            total = anime["episode_count"]
+            
+            if watched >= total and total > 0:
+                status = " [✓]"
+            elif watched > 0:
+                status = f" [{watched}/{total}]"
+            else:
+                status = ""
+            
+            label = f"{anime['title']} [{total} {ep_short}]{status}"
+            anime_map[label] = anime
+        
+        all_choices = list(anime_map.keys())
+        
+        try:
+            selected_label = questionary.autocomplete(
+                i18n.get("downloads.search_anime"),
+                choices=all_choices,
+                match_middle=True,
+                style=AUTOCOMPLETE_STYLE,
+            ).ask()
+            
+            if selected_label is None:
+                return
+            
+            if selected_label in anime_map:
+                console.print(f"[yellow]{i18n.t('downloads.connect_drive', name=source['name'])}[/yellow]")
+                time.sleep(1.5)
+            
+        except KeyboardInterrupt:
+            return
+
+def show_completed_library(library, source_name=None):
+    while True:
+        console.clear()
+        title = source_name or i18n.get("downloads.completed_downloads")
+        show_header(title)
+        
+        ep_short = i18n.get("downloads.episode_short")
+        anime_map = {}
+        for anime in library:
+            progress = local_library.get_anime_progress(anime["title"])
+            watched = len(progress.get("completed", []))
+            total = anime["episode_count"]
+            
+            if watched >= total and total > 0:
+                status = " [✓]"
+            elif watched > 0:
+                status = f" [{watched}/{total}]"
+            else:
+                status = ""
+            
+            label = f"{anime['title']} [{total} {ep_short}]{status}"
+            anime_map[label] = anime
+        
+        all_choices = list(anime_map.keys())
+        
+        choices = [
+            questionary.Choice(f"⌕ {i18n.get('downloads.search_anime')}", value="search"),
+        ]
+        for label in all_choices:
+            choices.append(questionary.Choice(label, value=label))
+        
+        try:
+            selected = questionary.select(
+                i18n.get("downloads.action_prompt"),
+                choices=choices,
+                pointer=">",
+                use_shortcuts=False,
+            ).ask()
+            
+            if selected is None:
+                return
+            
+            if selected == "search":
+                search_result = questionary.autocomplete(
+                    i18n.get("downloads.search_anime"),
+                    choices=all_choices,
+                    match_middle=True,
+                    style=AUTOCOMPLETE_STYLE,
+                ).ask()
+                
+                if search_result and search_result in anime_map:
+                    show_anime_episodes(anime_map[search_result])
+            elif selected in anime_map:
+                show_anime_episodes(anime_map[selected])
+            
+        except KeyboardInterrupt:
+            return
+
+def show_anime_episodes(anime):
+    while True:
+        console.clear()
+        show_header(anime["title"])
+        
+        progress = local_library.get_anime_progress(anime["title"])
+        completed_eps = set(progress.get("completed", []))
+        last_watched = progress.get("last_watched", 0)
+        next_ep = last_watched + 1
+        
+        episodes = anime["episodes"]
+        
+        choices = []
+        for ep in episodes:
+            num = ep["number"]
+            size = local_library.format_size(ep["size"])
+            
+            prefix = "   "
+            if num in completed_eps:
+                prefix = "✓  "
+            elif num == next_ep:
+                prefix = "●  "
+            
+            choices.append(questionary.Choice(
+                f"{prefix}{i18n.get('details.episode')} {num} ({size})",
+                value=ep
+            ))
+        
+        try:
+            selected = questionary.select(
+                i18n.get("details.select_episode"),
+                choices=choices,
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if selected is None:
+                return
+            
+            play_local_episode(anime, selected)
+            
+        except KeyboardInterrupt:
+            return
+
+def play_local_episode(anime, episode):
+    console.print(f"[green]{i18n.get('details.player_starting')}[/green]")
+    
+    title = f"{anime['title']} - {i18n.get('details.episode')} {episode['number']}"
+    success = player.play(episode["path"], title=title)
+    
+    if success:
+        try:
+            ans = questionary.confirm(i18n.get("details.mark_watched")).ask()
+            if ans:
+                local_library.mark_episode_watched(
+                    anime["title"],
+                    episode["number"],
+                    anime["episode_count"]
+                )
+        except:
+            pass
+
+def manage_queue():
+    while True:
+        console.clear()
+        show_header(i18n.get("downloads.manage_queue"))
+        
+        pending = queue_manager.get_pending_count()
+        is_running = queue_manager.is_running()
+        
+        if pending > 0:
+            status = i18n.get("downloads.queue_running") if is_running else i18n.get("downloads.queue_stopped")
+            console.print(f"[cyan]{i18n.t('downloads.pending_count', count=pending)}[/cyan] - {status}\n")
+        
         opt_view = i18n.get("downloads.view_queue")
         opt_start = i18n.get("downloads.start_queue")
         opt_stop = i18n.get("downloads.stop_queue")
@@ -66,8 +398,7 @@ def show_downloads():
                 console.print(f"[yellow]{i18n.get('downloads.queue_stopped')}[/yellow]")
                 time.sleep(0.5)
             elif action == opt_clear:
-                queue_manager.queue = [i for i in queue_manager.queue if i["status"] in ["pending", "processing"]]
-                queue_manager._save_queue()
+                queue_manager.clear_completed()
                 console.print(f"[green]{i18n.get('downloads.cleared')}[/green]")
                 time.sleep(0.5)
                 

weeb_cli/commands/settings.py

@@ -49,6 +49,7 @@ def open_settings():
         opt_lang = i18n.get("settings.language")
         opt_source = f"{i18n.get('settings.source')} [{display_source}]"
         opt_download = i18n.get("settings.download_settings")
+        opt_drives = i18n.get("settings.external_drives")
         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}]"
@@ -56,7 +57,7 @@ def open_settings():
         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]
+        choices = [opt_lang, opt_source, opt_download, opt_drives, opt_desc, opt_aria2]
         if config.get("aria2_enabled"):
             choices.append(opt_aria2_conf)
             
@@ -85,6 +86,8 @@ def open_settings():
             change_source()
         elif answer == opt_download:
             download_settings_menu()
+        elif answer == opt_drives:
+            external_drives_menu()
         elif answer == opt_desc:
             toggle_description()
         elif answer == opt_aria2:
@@ -252,3 +255,126 @@ def ytdlp_settings_menu():
                 return
         except KeyboardInterrupt:
             return
+
+
+def external_drives_menu():
+    from weeb_cli.services.local_library import local_library
+    from pathlib import Path
+    
+    while True:
+        console.clear()
+        show_header(i18n.get("settings.external_drives"))
+        
+        drives = local_library.get_external_drives()
+        
+        opt_add = i18n.get("settings.add_drive")
+        
+        choices = [questionary.Choice(opt_add, value="add")]
+        
+        for drive in drives:
+            path = Path(drive["path"])
+            status = "● " if path.exists() else "○ "
+            choices.append(questionary.Choice(
+                f"{status}{drive['name']} ({drive['path']})",
+                value=drive
+            ))
+        
+        try:
+            sel = questionary.select(
+                i18n.get("settings.external_drives"),
+                choices=choices,
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if sel is None:
+                return
+            
+            if sel == "add":
+                add_external_drive()
+            else:
+                manage_drive(sel)
+                
+        except KeyboardInterrupt:
+            return
+
+def add_external_drive():
+    from weeb_cli.services.local_library import local_library
+    
+    try:
+        path = questionary.text(
+            i18n.get("settings.enter_drive_path"),
+            qmark=">"
+        ).ask()
+        
+        if not path:
+            return
+        
+        from pathlib import Path
+        if not Path(path).exists():
+            console.print(f"[yellow]{i18n.get('settings.drive_not_found')}[/yellow]")
+            time.sleep(1)
+            return
+        
+        name = questionary.text(
+            i18n.get("settings.enter_drive_name"),
+            default=os.path.basename(path) or path,
+            qmark=">"
+        ).ask()
+        
+        if name:
+            local_library.add_external_drive(path, name)
+            console.print(f"[green]{i18n.get('settings.drive_added')}[/green]")
+            time.sleep(0.5)
+            
+    except KeyboardInterrupt:
+        pass
+
+def manage_drive(drive):
+    from weeb_cli.services.local_library import local_library
+    
+    while True:
+        console.clear()
+        show_header(drive["name"])
+        
+        console.print(f"[dim]{drive['path']}[/dim]\n")
+        
+        opt_rename = i18n.get("settings.rename_drive")
+        opt_remove = i18n.get("settings.remove_drive")
+        
+        try:
+            sel = questionary.select(
+                i18n.get("downloads.action_prompt"),
+                choices=[opt_rename, opt_remove],
+                pointer=">",
+                use_shortcuts=False
+            ).ask()
+            
+            if sel is None:
+                return
+            
+            if sel == opt_rename:
+                new_name = questionary.text(
+                    i18n.get("settings.enter_drive_name"),
+                    default=drive["name"],
+                    qmark=">"
+                ).ask()
+                if new_name:
+                    local_library.rename_external_drive(drive["path"], new_name)
+                    drive["name"] = new_name
+                    console.print(f"[green]{i18n.get('settings.drive_renamed')}[/green]")
+                    time.sleep(0.5)
+                    
+            elif sel == opt_remove:
+                confirm = questionary.confirm(
+                    i18n.get("settings.confirm_remove"),
+                    default=False
+                ).ask()
+                if confirm:
+                    local_library.remove_external_drive(drive["path"])
+                    console.print(f"[green]{i18n.get('settings.drive_removed')}[/green]")
+                    time.sleep(0.5)
+                    return
+                    
+        except KeyboardInterrupt:
+            return

weeb_cli/config.py

@@ -1,10 +1,8 @@
-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,  
@@ -15,36 +13,28 @@ DEFAULT_CONFIG = {
     "download_dir": os.path.join(os.getcwd(), "weeb-downloads"),
     "ytdlp_format": "bestvideo+bestaudio/best",
     "scraping_source": "animecix",
-    "show_description": True
+    "show_description": True,
+    "debug_mode": False
 }
 
 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)
-
+        self._db = None
+    
+    @property
+    def db(self):
+        if self._db is None:
+            from weeb_cli.services.database import db
+            self._db = db
+        return self._db
+    
     def get(self, key, default=None):
-        return self.data.get(key, default)
-
+        val = self.db.get_config(key)
+        if val is None:
+            return DEFAULT_CONFIG.get(key, default)
+        return val
+    
     def set(self, key, value):
-        self.data[key] = value
-        self._save(self.data)
+        self.db.set_config(key, value)
 
 config = Config()

weeb_cli/locales/en.json

@@ -48,7 +48,18 @@
         "source_changed": "Source changed to {source}.",
         "no_sources": "No sources available for this language.",
         "toggle_on": "{tool} enabled.",
-        "toggle_off": "{tool} disabled."
+        "toggle_off": "{tool} disabled.",
+        "external_drives": "External Drives",
+        "add_drive": "Add Drive",
+        "enter_drive_path": "Enter drive path (e.g. D:\\Anime)",
+        "enter_drive_name": "Nickname for drive",
+        "drive_not_found": "Specified path not found.",
+        "drive_added": "Drive added.",
+        "rename_drive": "Rename",
+        "remove_drive": "Remove Drive",
+        "confirm_remove": "Are you sure you want to remove this drive?",
+        "drive_renamed": "Drive renamed.",
+        "drive_removed": "Drive removed."
     },
     "setup": {
         "welcome": "Welcome to Weeb CLI!",
@@ -139,7 +150,7 @@
         "no_streams": "No streams found"
     },
     "downloads": {
-        "title": "Download History",
+        "title": "Downloads",
         "empty": "You haven't downloaded anything yet.",
         "status": "Status",
         "progress": "Progress",
@@ -163,6 +174,23 @@
         "queue_stopped": "Queue stopped.",
         "queue_running": "Running",
         "pending_count": "{count} download(s) pending",
-        "cleared": "Cleared."
+        "cleared": "Cleared.",
+        "completed_downloads": "Completed Downloads",
+        "active_downloads": "Active Downloads",
+        "manage_queue": "Queue Management",
+        "select_anime": "Select Anime",
+        "search_library": "Search",
+        "search_anime": "Enter anime name",
+        "search_all": "Search All Sources",
+        "offline": "Offline",
+        "reindex": "Reindex",
+        "indexing": "Indexing...",
+        "indexed": "{count} anime indexed",
+        "no_indexed": "No indexed anime. Connect a drive and index first.",
+        "drive_not_connected": "Drive not connected",
+        "connect_drive": "Connect {name} drive",
+        "notification_title": "Weeb CLI",
+        "notification_complete": "{anime} - Episode {episode} downloaded",
+        "episode_short": "Ep"
     }
 }