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

weeb_cli/services/downloader.py

@@ -1,5 +1,4 @@
 import os
-import json
 import re
 import threading
 import time
@@ -13,27 +12,21 @@ 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._db = None
         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)
+    
+    @property
+    def db(self):
+        if self._db is None:
+            from weeb_cli.services.database import db
+            self._db = db
+        return self._db
+    
+    @property
+    def queue(self):
+        return self.db.get_queue()
 
     def start_queue(self):
         if self.running:
@@ -61,13 +54,14 @@ class QueueManager:
     def resume_incomplete(self):
         for item in self.queue:
             if item["status"] == "processing":
-                item["status"] = "pending"
-        self._save_queue()
+                self.db.update_queue_item(item["episode_id"], status="pending")
         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()
+        self.db.clear_completed_queue()
+        for item in self.queue:
+            if item["status"] in ["pending", "processing"]:
+                self.db.update_queue_item(item["episode_id"], status="cancelled")
 
     def is_downloading(self, slug, episode_id=None):
         for item in self.queue:
@@ -83,7 +77,7 @@ class QueueManager:
                 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"),
@@ -94,10 +88,8 @@ class QueueManager:
                     "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)
+                if self.db.add_to_queue(item):
                     added += 1
-        self._save_queue()
         return added
 
     def _sanitize_filename(self, name):
@@ -107,14 +99,13 @@ class QueueManager:
         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"]
+            queue = self.queue
+            active_count = len([x for x in queue if x["status"] == "processing"])
+            pending = [x for x in queue if x["status"] == "pending"]
 
             if active_count < max_workers and pending:
                 to_start = pending[0]
-                to_start["status"] = "processing"
-                self._save_queue()
+                self.db.update_queue_item(to_start["episode_id"], status="processing")
                 
                 t = threading.Thread(target=self._run_task, args=(to_start,))
                 t.start()
@@ -126,16 +117,25 @@ class QueueManager:
             time.sleep(1)
 
     def _run_task(self, item):
+        from weeb_cli.services.notifier import send_notification
+        from weeb_cli.services.logger import debug, error
+        from weeb_cli.i18n import i18n
+        
+        debug(f"Starting download: {item['anime_title']} - Ep {item['episode_number']}")
+        
         try:
             self._download_item(item)
-            item["status"] = "completed"
-            item["progress"] = 100
-            item["eta"] = "-"
+            self.db.update_queue_item(item["episode_id"], status="completed", progress=100, eta="-")
+            
+            debug(f"Download completed: {item['anime_title']} - Ep {item['episode_number']}")
+            
+            title = i18n.get("downloads.notification_title", "Weeb CLI")
+            msg = i18n.t("downloads.notification_complete", anime=item['anime_title'], episode=item['episode_number'])
+            send_notification(title, msg)
+            
         except Exception as e:
-            item["status"] = "failed"
-            item["error"] = str(e)
-            item["eta"] = ""
-        self._save_queue()
+            self.db.update_queue_item(item["episode_id"], status="failed", error=str(e), eta="")
+            error(f"Download failed: {item['anime_title']} - {str(e)}")
 
     def _download_item(self, item):
         from weeb_cli.services.watch import get_streams
@@ -200,6 +200,15 @@ class QueueManager:
                 return node["url"]
         return None
 
+    def _update_progress(self, item, progress=None, eta=None):
+        updates = {}
+        if progress is not None:
+            updates["progress"] = progress
+        if eta is not None:
+            updates["eta"] = eta
+        if updates:
+            self.db.update_queue_item(item["episode_id"], **updates)
+
     def _download_aria2(self, url, path, item):
         aria2 = dependency_manager.check_dependency("aria2")
         conn = config.get("aria2_max_connections", 16)
@@ -227,11 +236,10 @@ class QueueManager:
                     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))
+                        progress = int(match.group(1)) if match else None
+                        self._update_progress(item, progress=progress, eta=eta_part.strip())
                     except:
                         pass
         
@@ -258,16 +266,16 @@ class QueueManager:
                 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()
+                        progress = float(p_str)
+                        eta = line.split("ETA")[-1].strip() if "ETA" in line else None
+                        self._update_progress(item, progress=progress, eta=eta)
                     except:
                         pass
         if process.returncode != 0:
             raise Exception("yt-dlp failed")
 
     def _download_ffmpeg(self, url, path, item):
-        item["eta"] = ""
+        self._update_progress(item, eta="")
         ffmpeg = dependency_manager.check_dependency("ffmpeg")
         cmd = [
             ffmpeg,
@@ -281,7 +289,7 @@ class QueueManager:
 
     def _download_generic(self, url, path, item):
         import requests
-        item["eta"] = "..."
+        self._update_progress(item, eta="...")
         with requests.get(url, stream=True) as r:
             r.raise_for_status()
             total = int(r.headers.get('content-length', 0))
@@ -292,17 +300,20 @@ class QueueManager:
                     for chunk in r.iter_content(chunk_size=8192):
                         f.write(chunk)
                         downloaded += len(chunk)
-                        item["progress"] = int((downloaded / total) * 100)
+                        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"
+                            self._update_progress(item, progress=progress, 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)
 
+    def clear_completed(self):
+        self.db.clear_completed_queue()
+
 queue_manager = QueueManager()

weeb_cli/services/local_library.py

@@ -0,0 +1,263 @@
+import os
+import re
+from pathlib import Path
+from typing import List, Dict, Optional
+from weeb_cli.config import config
+from weeb_cli.services.progress import progress_tracker
+
+class LocalLibrary:
+    def __init__(self):
+        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_all_sources(self) -> List[Dict]:
+        sources = []
+        
+        download_dir = Path(config.get("download_dir"))
+        if download_dir.exists():
+            sources.append({
+                "path": str(download_dir),
+                "name": "İndirilenler",
+                "type": "local",
+                "available": True
+            })
+        
+        for drive in self.db.get_external_drives():
+            path = Path(drive["path"])
+            sources.append({
+                "path": drive["path"],
+                "name": drive["name"],
+                "type": "external",
+                "available": path.exists()
+            })
+        
+        return sources
+    
+    def scan_library(self, source_path: str = None) -> List[Dict]:
+        if source_path:
+            return self._scan_folder(Path(source_path))
+        
+        download_dir = Path(config.get("download_dir"))
+        return self._scan_folder(download_dir)
+    
+    def scan_all_sources(self) -> List[Dict]:
+        all_anime = []
+        seen_titles = set()
+        
+        for source in self.get_all_sources():
+            if not source["available"]:
+                continue
+            
+            anime_list = self._scan_folder(Path(source["path"]))
+            for anime in anime_list:
+                anime["source"] = source["name"]
+                anime["source_path"] = source["path"]
+                
+                key = anime["title"].lower()
+                if key not in seen_titles:
+                    seen_titles.add(key)
+                    all_anime.append(anime)
+        
+        return sorted(all_anime, key=lambda x: x["title"].lower())
+    
+    def _scan_folder(self, folder: Path) -> List[Dict]:
+        if not folder.exists():
+            return []
+        
+        anime_list = []
+        
+        for anime_folder in folder.iterdir():
+            if not anime_folder.is_dir():
+                continue
+            
+            episodes = self._scan_anime_folder(anime_folder)
+            if episodes:
+                anime_list.append({
+                    "title": anime_folder.name,
+                    "path": str(anime_folder),
+                    "episodes": episodes,
+                    "episode_count": len(episodes)
+                })
+        
+        return sorted(anime_list, key=lambda x: x["title"].lower())
+    
+    def _scan_anime_folder(self, folder: Path) -> List[Dict]:
+        episodes = []
+        video_extensions = {'.mp4', '.mkv', '.avi', '.webm', '.m4v'}
+        
+        for file in folder.iterdir():
+            if file.is_file() and file.suffix.lower() in video_extensions:
+                ep_num = self._extract_episode_number(file.name)
+                episodes.append({
+                    "filename": file.name,
+                    "path": str(file),
+                    "number": ep_num,
+                    "size": file.stat().st_size
+                })
+        
+        return sorted(episodes, key=lambda x: x["number"])
+    
+    def _extract_episode_number(self, filename: str) -> int:
+        patterns = [
+            r'S\d+B(\d+)',
+            r'[Ee]p?(\d+)',
+            r'[Bb]ölüm\s*(\d+)',
+            r'[Ee]pisode\s*(\d+)',
+            r'- (\d+)',
+            r'\[(\d+)\]',
+            r'(\d+)\.',
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, filename, re.IGNORECASE)
+            if match:
+                return int(match.group(1))
+        
+        return 0
+    
+    def get_anime_progress(self, anime_title: str) -> Dict:
+        slug = self._title_to_slug(anime_title)
+        return progress_tracker.get_anime_progress(slug)
+    
+    def mark_episode_watched(self, anime_title: str, ep_number: int, total_episodes: int):
+        slug = self._title_to_slug(anime_title)
+        progress_tracker.mark_watched(slug, ep_number, title=anime_title, total_episodes=total_episodes)
+    
+    def _title_to_slug(self, title: str) -> str:
+        slug = title.lower()
+        slug = re.sub(r'[^a-z0-9\s-]', '', slug)
+        slug = re.sub(r'\s+', '-', slug)
+        return slug
+    
+    def get_next_episode(self, anime_title: str, episodes: List[Dict]) -> Optional[Dict]:
+        progress = self.get_anime_progress(anime_title)
+        last_watched = progress.get("last_watched", 0)
+        
+        for ep in episodes:
+            if ep["number"] > last_watched:
+                return ep
+        
+        return episodes[0] if episodes else None
+    
+    def format_size(self, size_bytes: int) -> str:
+        for unit in ['B', 'KB', 'MB', 'GB']:
+            if size_bytes < 1024:
+                return f"{size_bytes:.1f} {unit}"
+            size_bytes /= 1024
+        return f"{size_bytes:.1f} TB"
+    
+    def add_external_drive(self, path: str, name: str = None):
+        self.db.add_external_drive(path, name)
+    
+    def remove_external_drive(self, path: str):
+        self.db.remove_external_drive(path)
+    
+    def rename_external_drive(self, path: str, name: str):
+        self.db.update_drive_name(path, name)
+    
+    def get_external_drives(self):
+        return self.db.get_external_drives()
+    
+    def index_source(self, source_path: str, source_name: str):
+        path = Path(source_path)
+        if not path.exists():
+            return 0
+        
+        self.db.clear_source_index(source_path)
+        
+        count = 0
+        for anime_folder in path.iterdir():
+            if not anime_folder.is_dir():
+                continue
+            
+            episodes = self._scan_anime_folder(anime_folder)
+            if episodes:
+                self.db.index_anime(
+                    title=anime_folder.name,
+                    source_path=source_path,
+                    source_name=source_name,
+                    folder_path=str(anime_folder),
+                    episode_count=len(episodes)
+                )
+                count += 1
+        
+        return count
+    
+    def smart_index_source(self, source_path: str, source_name: str):
+        path = Path(source_path)
+        if not path.exists():
+            return 0
+        
+        indexed = {a["folder_path"]: a for a in self.db.get_all_indexed_anime() if a["source_path"] == source_path}
+        
+        current_folders = set()
+        added = 0
+        
+        for anime_folder in path.iterdir():
+            if not anime_folder.is_dir():
+                continue
+            
+            folder_path = str(anime_folder)
+            current_folders.add(folder_path)
+            
+            episodes = self._scan_anime_folder(anime_folder)
+            if not episodes:
+                continue
+            
+            if folder_path in indexed:
+                if indexed[folder_path]["episode_count"] != len(episodes):
+                    self.db.index_anime(
+                        title=anime_folder.name,
+                        source_path=source_path,
+                        source_name=source_name,
+                        folder_path=folder_path,
+                        episode_count=len(episodes)
+                    )
+            else:
+                self.db.index_anime(
+                    title=anime_folder.name,
+                    source_path=source_path,
+                    source_name=source_name,
+                    folder_path=folder_path,
+                    episode_count=len(episodes)
+                )
+                added += 1
+        
+        for folder_path in indexed:
+            if folder_path not in current_folders:
+                self.db.remove_indexed_anime(folder_path)
+        
+        return added
+    
+    def smart_index_all(self):
+        total = 0
+        for source in self.get_all_sources():
+            if source["available"]:
+                total += self.smart_index_source(source["path"], source["name"])
+        return total
+    
+    def index_all_sources(self):
+        total = 0
+        for source in self.get_all_sources():
+            if source["available"]:
+                total += self.index_source(source["path"], source["name"])
+        return total
+    
+    def get_indexed_anime(self) -> List[Dict]:
+        return self.db.get_all_indexed_anime()
+    
+    def search_all_indexed(self, query: str) -> List[Dict]:
+        if not query:
+            return self.db.get_all_indexed_anime()
+        return self.db.search_indexed_anime(query)
+    
+    def is_source_available(self, source_path: str) -> bool:
+        return Path(source_path).exists()
+
+local_library = LocalLibrary()

weeb_cli/services/logger.py

@@ -0,0 +1,55 @@
+import logging
+import os
+from pathlib import Path
+from datetime import datetime
+from weeb_cli.config import config
+
+_logger = None
+
+def get_logger():
+    global _logger
+    if _logger is None:
+        _logger = _setup_logger()
+    return _logger
+
+def _setup_logger():
+    logger = logging.getLogger("weeb-cli")
+    logger.setLevel(logging.DEBUG)
+    logger.handlers = []
+    
+    if config.get("debug_mode", False):
+        log_dir = Path.home() / ".weeb-cli" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        
+        log_file = log_dir / f"debug_{datetime.now().strftime('%Y%m%d')}.log"
+        
+        handler = logging.FileHandler(log_file, encoding='utf-8')
+        handler.setLevel(logging.DEBUG)
+        
+        formatter = logging.Formatter(
+            '%(asctime)s | %(levelname)s | %(module)s:%(lineno)d | %(message)s',
+            datefmt='%H:%M:%S'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    else:
+        logger.addHandler(logging.NullHandler())
+    
+    return logger
+
+def debug(msg, *args):
+    get_logger().debug(msg, *args)
+
+def info(msg, *args):
+    get_logger().info(msg, *args)
+
+def warning(msg, *args):
+    get_logger().warning(msg, *args)
+
+def error(msg, *args):
+    get_logger().error(msg, *args)
+
+def reload():
+    global _logger
+    _logger = None
+    get_logger()

weeb_cli/services/notifier.py

@@ -0,0 +1,41 @@
+import platform
+import subprocess
+import threading
+
+def send_notification(title: str, message: str):
+    threading.Thread(target=_send_notification_sync, args=(title, message), daemon=True).start()
+
+def _send_notification_sync(title: str, message: str):
+    system = platform.system()
+    
+    try:
+        if system == "Windows":
+            _notify_windows(title, message)
+        elif system == "Darwin":
+            _notify_macos(title, message)
+        else:
+            _notify_linux(title, message)
+    except:
+        pass
+
+def _notify_windows(title: str, message: str):
+    try:
+        from win10toast import ToastNotifier
+        toaster = ToastNotifier()
+        toaster.show_toast(title, message, duration=5, threaded=True)
+        return
+    except ImportError:
+        pass
+    
+    try:
+        import ctypes
+        ctypes.windll.user32.MessageBoxW(0, message, title, 0x40)
+    except:
+        pass
+
+def _notify_macos(title: str, message: str):
+    script = f'display notification "{message}" with title "{title}"'
+    subprocess.run(["osascript", "-e", script], capture_output=True)
+
+def _notify_linux(title: str, message: str):
+    subprocess.run(["notify-send", title, message], capture_output=True)