weeb-cli 2.15.0__tar.gz → 2.16.0__tar.gz

{weeb_cli-2.15.0/weeb_cli.egg-info → weeb_cli-2.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weeb-cli
-Version: 2.15.0
+Version: 2.16.0
 Summary: No browser, no ads, no distractions. Just you and an unparalleled anime viewing experience.
 Author-email: ewgsta <ewgst@proton.me>
 License-Expression: GPL-3.0-only

{weeb_cli-2.15.0 → weeb_cli-2.16.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weeb-cli"
-version = "2.15.0"
+version = "2.16.0"
 description = "No browser, no ads, no distractions. Just you and an unparalleled anime viewing experience."
 readme = "README.md"
 authors = [{ name = "ewgsta", email = "ewgst@proton.me" }]

{weeb_cli-2.15.0 → weeb_cli-2.16.0}/weeb_cli/__init__.py

@@ -31,7 +31,7 @@ Attributes:
     __version__ (str): Current version of Weeb CLI.
 """
 
-__version__ = "2.15.0"
+__version__ = "2.16.0"
 
 # SDK exports for easy import
 from weeb_cli.sdk import WeebSDK, list_providers, get_provider_info

{weeb_cli-2.15.0 → weeb_cli-2.16.0}/weeb_cli/config.py

@@ -127,9 +127,9 @@ class Config:
                 val = self.db.get_config(key)
                 if val is not None:
                     return val
-            except Exception as e:
-                from weeb_cli.services.logger import debug
-                debug(f"[Config] DB read failed for '{key}': {e}")
+            except Exception:
+                # Avoid circular import with logger, just pass silently
+                pass
 
         # Special handling for download_dir
         if key == "download_dir":

weeb_cli-2.16.0/weeb_cli/constants.py

@@ -0,0 +1,53 @@
+"""Application-wide constants and enumerations.
+
+This module defines constants used throughout the application to avoid
+magic strings and improve code maintainability.
+"""
+
+from enum import Enum
+
+
+class ConfigKey(str, Enum):
+    """Configuration key names."""
+    
+    LANGUAGE = "language"
+    ARIA2_ENABLED = "aria2_enabled"
+    YTDLP_ENABLED = "ytdlp_enabled"
+    ARIA2_MAX_CONNECTIONS = "aria2_max_connections"
+    MAX_CONCURRENT_DOWNLOADS = "max_concurrent_downloads"
+    DOWNLOAD_DIR = "download_dir"
+    YTDLP_FORMAT = "ytdlp_format"
+    SCRAPING_SOURCE = "scraping_source"
+    SHOW_DESCRIPTION = "show_description"
+    DEBUG_MODE = "debug_mode"
+    DOWNLOAD_MAX_RETRIES = "download_max_retries"
+    DOWNLOAD_RETRY_DELAY = "download_retry_delay"
+    DISCORD_RPC_ENABLED = "discord_rpc_enabled"
+    SHORTCUTS_ENABLED = "shortcuts_enabled"
+    ANISKIP_ENABLED = "aniskip_enabled"
+
+
+class DownloadStatus(str, Enum):
+    """Download queue item status values."""
+    
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class ErrorType(str, Enum):
+    """Error classification types."""
+    
+    TRANSIENT = "transient"
+    PERMANENT = "permanent"
+
+
+class Language(str, Enum):
+    """Supported language codes."""
+    
+    ENGLISH = "en"
+    TURKISH = "tr"
+    GERMAN = "de"
+    POLISH = "pl"

{weeb_cli-2.15.0 → weeb_cli-2.16.0}/weeb_cli/providers/registry.py

@@ -40,17 +40,22 @@ Example:
 
 import importlib
 import pkgutil
+import pickle
 from pathlib import Path
 from typing import Dict, List, Type, Optional
 
 from weeb_cli.providers.base import BaseProvider
 from weeb_cli.services.logger import debug
+from weeb_cli.config import CONFIG_DIR
 
 # Global registry storage
 _providers: Dict[str, Type[BaseProvider]] = {}
 _provider_meta: Dict[str, dict] = {}
 _initialized: bool = False
 
+# Cache file location
+PROVIDER_CACHE_FILE = CONFIG_DIR / "provider_cache.pkl"
+
 
 def register_provider(name: str, lang: str = "tr", region: str = "TR", disabled: bool = False):
     """Decorator for registering provider classes.
@@ -103,11 +108,19 @@ def _discover_providers() -> None:
     
     This function is called automatically on first registry access.
     Uses a global flag to ensure it only runs once.
+    
+    Attempts to load from cache first for faster startup.
     """
-    global _initialized
+    global _initialized, _providers, _provider_meta
     if _initialized:
         return
-        
+    
+    # Try to load from cache first
+    if _load_from_cache():
+        _initialized = True
+        debug("[Registry] Loaded providers from cache")
+        return
+    
     base_path = Path(__file__).parent
     
     # Scan language directories
@@ -124,9 +137,69 @@ def _discover_providers() -> None:
                     except Exception as e:
                         debug(f"[Registry] Error loading provider {lang}/{name}: {e}")
     
+    # Save to cache for next time
+    _save_to_cache()
     _initialized = True
 
 
+def _load_from_cache() -> bool:
+    """Load provider registry from cache file.
+    
+    Returns:
+        True if cache was loaded successfully, False otherwise.
+    """
+    global _providers, _provider_meta
+    
+    if not PROVIDER_CACHE_FILE.exists():
+        return False
+    
+    try:
+        with open(PROVIDER_CACHE_FILE, 'rb') as f:
+            cache_data = pickle.load(f)
+        
+        # Validate cache structure
+        if not isinstance(cache_data, dict) or 'providers' not in cache_data:
+            return False
+        
+        # Import all provider modules to register classes
+        for module_path in cache_data.get('modules', []):
+            try:
+                importlib.import_module(module_path)
+            except Exception as e:
+                debug(f"[Registry] Failed to import cached module {module_path}: {e}")
+                return False
+        
+        return True
+    except Exception as e:
+        debug(f"[Registry] Failed to load provider cache: {e}")
+        return False
+
+
+def _save_to_cache() -> None:
+    """Save provider registry to cache file."""
+    try:
+        PROVIDER_CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Collect module paths for all registered providers
+        modules = set()
+        for name, cls in _providers.items():
+            module_path = cls.__module__
+            modules.add(module_path)
+        
+        cache_data = {
+            'providers': list(_providers.keys()),
+            'modules': list(modules),
+            'meta': _provider_meta
+        }
+        
+        with open(PROVIDER_CACHE_FILE, 'wb') as f:
+            pickle.dump(cache_data, f)
+        
+        debug(f"[Registry] Saved {len(_providers)} providers to cache")
+    except Exception as e:
+        debug(f"[Registry] Failed to save provider cache: {e}")
+
+
 def get_provider(name: str) -> Optional[BaseProvider]:
     """Get provider instance by name.
     

{weeb_cli-2.15.0 → weeb_cli-2.16.0}/weeb_cli/services/database.py

@@ -6,14 +6,101 @@ from pathlib import Path
 from datetime import datetime
 from contextlib import contextmanager
 from typing import Optional, List, Dict, Any
+from queue import Queue, Empty
 
 DB_PATH = Path.home() / ".weeb-cli" / "weeb.db"
 
+
+class ConnectionPool:
+    """Simple connection pool for SQLite database.
+    
+    Maintains a pool of reusable connections to reduce overhead
+    of creating new connections for each operation.
+    """
+    
+    def __init__(self, db_path: Path, pool_size: int = 5):
+        self.db_path = db_path
+        self.pool_size = pool_size
+        self._pool: Queue = Queue(maxsize=pool_size)
+        self._lock = threading.Lock()
+        self._initialized = False
+    
+    def _create_connection(self) -> sqlite3.Connection:
+        """Create a new database connection with optimal settings."""
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        conn = sqlite3.connect(
+            self.db_path,
+            timeout=30,
+            check_same_thread=False,
+            isolation_level="DEFERRED"
+        )
+        conn.row_factory = sqlite3.Row
+        conn.execute('PRAGMA journal_mode=WAL')
+        conn.execute('PRAGMA synchronous=NORMAL')
+        conn.execute('PRAGMA cache_size=-64000')
+        conn.execute('PRAGMA foreign_keys=ON')
+        conn.execute('PRAGMA busy_timeout=30000')
+        return conn
+    
+    def _initialize_pool(self):
+        """Initialize the connection pool."""
+        with self._lock:
+            if self._initialized:
+                return
+            for _ in range(self.pool_size):
+                conn = self._create_connection()
+                self._pool.put(conn)
+            self._initialized = True
+    
+    @contextmanager
+    def get_connection(self):
+        """Get a connection from the pool.
+        
+        Yields:
+            sqlite3.Connection: A database connection.
+        """
+        if not self._initialized:
+            self._initialize_pool()
+        
+        conn = None
+        try:
+            # Try to get a connection from pool, create new if pool is empty
+            try:
+                conn = self._pool.get(block=False)
+            except Empty:
+                conn = self._create_connection()
+            
+            yield conn
+            conn.commit()
+        except Exception:
+            if conn:
+                conn.rollback()
+            raise
+        finally:
+            if conn:
+                # Try to return to pool, close if pool is full
+                try:
+                    self._pool.put(conn, block=False)
+                except:
+                    conn.close()
+    
+    def close_all(self):
+        """Close all connections in the pool."""
+        with self._lock:
+            while not self._pool.empty():
+                try:
+                    conn = self._pool.get(block=False)
+                    conn.close()
+                except Empty:
+                    break
+            self._initialized = False
+
+
 class Database:
     def __init__(self) -> None:
         self.db_path: Path = DB_PATH
         self._initialized: bool = False
-        self._connection: Optional[sqlite3.Connection] = None
+        self._pool: Optional[ConnectionPool] = None
         self._lock: threading.RLock = threading.RLock()
 
     def _ensure_initialized(self) -> None:
@@ -23,40 +110,19 @@ class Database:
         self._initialized = True
         self._migrate_from_json()
     
-    def _get_connection(self) -> sqlite3.Connection:
+    def _get_pool(self) -> ConnectionPool:
+        """Get or create the connection pool."""
         with self._lock:
-            if self._connection is None:
-                self.db_path.parent.mkdir(parents=True, exist_ok=True)
-                self._connection = sqlite3.connect(
-                    self.db_path,
-                    timeout=30,  # Increased timeout for better reliability
-                    check_same_thread=False,
-                    isolation_level="DEFERRED"  # Removed autocommit for safe transactions
-                )
-                self._connection.row_factory = sqlite3.Row
-                # WAL mode for better concurrent access
-                self._connection.execute('PRAGMA journal_mode=WAL')
-                # NORMAL is safe with WAL mode
-                self._connection.execute('PRAGMA synchronous=NORMAL')
-                # Larger cache for better performance
-                self._connection.execute('PRAGMA cache_size=-64000')
-                # Enable foreign keys
-                self._connection.execute('PRAGMA foreign_keys=ON')
-                # Busy timeout for concurrent access
-                self._connection.execute('PRAGMA busy_timeout=30000')
-            return self._connection
+            if self._pool is None:
+                self._pool = ConnectionPool(self.db_path, pool_size=5)
+            return self._pool
     
     @contextmanager
     def _raw_conn(self):
         self._ensure_initialized()
-        conn = self._get_connection()
-        with self._lock:
-            try:
-                yield conn
-                conn.commit()
-            except Exception:
-                conn.rollback()
-                raise
+        pool = self._get_pool()
+        with pool.get_connection() as conn:
+            yield conn
 
     @contextmanager
     def _conn(self):
@@ -64,14 +130,15 @@ class Database:
             yield conn
     
     def close(self) -> None:
+        """Close all database connections."""
         with self._lock:
-            if self._connection:
-                self._connection.close()
-                self._connection = None
+            if self._pool:
+                self._pool.close_all()
+                self._pool = None
     
     def _init_db(self):
-        conn = self._get_connection()
-        with self._lock:
+        pool = self._get_pool()
+        with pool.get_connection() as conn:
             conn.executescript('''
                 CREATE TABLE IF NOT EXISTS config (
                     key TEXT PRIMARY KEY,
@@ -151,8 +218,8 @@ class Database:
         self._migrate_columns()
     
     def _migrate_columns(self):
-        conn = self._get_connection()
-        with self._lock:
+        pool = self._get_pool()
+        with pool.get_connection() as conn:
             try:
                 conn.execute('SELECT retry_count FROM download_queue LIMIT 1')
             except sqlite3.OperationalError:
@@ -168,8 +235,6 @@ class Database:
             except sqlite3.OperationalError:
                 conn.execute('ALTER TABLE progress ADD COLUMN current_time REAL DEFAULT 0')
                 conn.execute('ALTER TABLE progress ADD COLUMN duration REAL DEFAULT 0')
-            
-            conn.commit()
     
     def _migrate_from_json(self):
         config_dir = Path.home() / ".weeb-cli"

weeb_cli-2.16.0/weeb_cli/services/download/__init__.py

@@ -0,0 +1,10 @@
+"""Download service with strategy-based architecture.
+
+This package provides a modular download system with multiple strategies
+for different download methods (Aria2, yt-dlp, FFmpeg, generic HTTP).
+"""
+
+from weeb_cli.services.download.manager import DownloadManager
+from weeb_cli.services.download.queue import QueueManager, queue_manager
+
+__all__ = ['DownloadManager', 'QueueManager', 'queue_manager']

weeb_cli-2.16.0/weeb_cli/services/download/context.py

@@ -0,0 +1,21 @@
+"""Download context and data structures."""
+
+from dataclasses import dataclass
+from typing import Optional, Dict
+
+
+@dataclass
+class DownloadContext:
+    """Context information for a download operation.
+    
+    Attributes:
+        url: Stream URL to download.
+        output_path: Full path where file should be saved.
+        headers: HTTP headers to use for the request.
+        item: Queue item metadata (anime title, episode number, etc.).
+    """
+    
+    url: str
+    output_path: str
+    headers: Optional[Dict[str, str]] = None
+    item: Optional[dict] = None

weeb_cli-2.16.0/weeb_cli/services/download/manager.py

@@ -0,0 +1,69 @@
+"""Download manager with strategy pattern."""
+
+from typing import List
+from pathlib import Path
+
+from weeb_cli.services.download.context import DownloadContext
+from weeb_cli.services.download.strategies import (
+    DownloadStrategy,
+    Aria2Strategy,
+    YtdlpStrategy,
+    FFmpegStrategy,
+    GenericStrategy
+)
+from weeb_cli.services.logger import debug
+from weeb_cli.exceptions import DownloadError
+
+
+class DownloadManager:
+    """Manages download operations using multiple strategies.
+    
+    Tries strategies in priority order until one succeeds.
+    """
+    
+    def __init__(self):
+        self.strategies: List[DownloadStrategy] = [
+            Aria2Strategy(),
+            YtdlpStrategy(),
+            FFmpegStrategy(),
+            GenericStrategy()
+        ]
+        self.strategies.sort(key=lambda s: s.get_priority())
+    
+    def download(self, url: str, output_path: str, item: dict = None) -> None:
+        """Download a file using the best available strategy.
+        
+        Args:
+            url: Stream URL to download.
+            output_path: Path where file should be saved.
+            item: Optional queue item metadata for progress tracking.
+        
+        Raises:
+            DownloadError: If all strategies fail.
+        """
+        context = DownloadContext(
+            url=url,
+            output_path=output_path,
+            item=item
+        )
+        
+        last_error = None
+        
+        for strategy in self.strategies:
+            if not strategy.can_handle(url):
+                continue
+            
+            strategy_name = strategy.__class__.__name__
+            debug(f"[DownloadManager] Trying {strategy_name} for {url[:80]}...")
+            
+            try:
+                strategy.download(context)
+                debug(f"[DownloadManager] Success with {strategy_name}")
+                return
+            except Exception as e:
+                last_error = e
+                debug(f"[DownloadManager] {strategy_name} failed: {e}")
+                continue
+        
+        error_msg = f"All download strategies failed. Last error: {last_error}"
+        raise DownloadError(error_msg, code="ALL_STRATEGIES_FAILED")