weeb-cli 2.5.0__tar.gz → 2.6.1__tar.gz

{weeb_cli-2.5.0/weeb_cli.egg-info → weeb_cli-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weeb-cli
-Version: 2.5.0
+Version: 2.6.1
 Summary: Tarayıcı yok, reklam yok, dikkat dağıtıcı unsur yok. Sadece siz ve eşsiz bir anime izleme deneyimi.
 Author-email: ewgsta <ewgst@proton.me>
 License-Expression: CC-BY-NC-ND-4.0
@@ -44,6 +44,7 @@ Dynamic: license-file
   <a href="https://github.com/ewgsta/weeb-cli/releases"><img src="https://img.shields.io/github/v/release/ewgsta/weeb-cli?style=flat-square" alt="Release"></a>
   <a href="https://github.com/ewgsta/weeb-cli/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-CC%20BY--NC--ND%204.0-blue?style=flat-square" alt="License"></a>
   <a href="https://github.com/ewgsta/weeb-cli/stargazers"><img src="https://img.shields.io/github/stars/ewgsta/weeb-cli?style=flat-square" alt="Stars"></a>
+  <a href="https://github.com/ewgsta/weeb-cli/actions"><img src="https://img.shields.io/github/actions/workflow/status/ewgsta/weeb-cli/tests.yml?style=flat-square" alt="Tests"></a>
 </p>
 
 <p align="center">
@@ -178,14 +179,27 @@ Yapılandırma: `~/.weeb-cli/weeb.db` (SQLite)
 - [x] Veritabanı yedekleme/geri yükleme
 - [x] Klavye kısayolları
 
-### Planlanan
+## Gelecek Planlar
+
+### v2.6.0 (Planlanan)
+- [ ] Async/await refactoring
+- [ ] Download strategy pattern
+- [ ] Token şifreleme
+- [ ] Progress bar iyileştirmesi
+- [ ] Plugin sistemi
+
+### v2.7.0 (Planlanan)
 - [ ] Anime önerileri
 - [ ] Toplu işlemler
 - [ ] İzleme istatistikleri (grafik)
 - [ ] Tema desteği
 - [ ] Altyazı indirme
-- [ ] Torrent desteği (nyaa.si)
+
+### v3.0.0 (Uzun Vadeli)
+- [ ] Web UI (opsiyonel)
+- [ ] Torrent desteği
 - [ ] Watch party
+- [ ] Mobile app entegrasyonu
 
 ---
 

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/README.md

@@ -12,6 +12,7 @@
   <a href="https://github.com/ewgsta/weeb-cli/releases"><img src="https://img.shields.io/github/v/release/ewgsta/weeb-cli?style=flat-square" alt="Release"></a>
   <a href="https://github.com/ewgsta/weeb-cli/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-CC%20BY--NC--ND%204.0-blue?style=flat-square" alt="License"></a>
   <a href="https://github.com/ewgsta/weeb-cli/stargazers"><img src="https://img.shields.io/github/stars/ewgsta/weeb-cli?style=flat-square" alt="Stars"></a>
+  <a href="https://github.com/ewgsta/weeb-cli/actions"><img src="https://img.shields.io/github/actions/workflow/status/ewgsta/weeb-cli/tests.yml?style=flat-square" alt="Tests"></a>
 </p>
 
 <p align="center">
@@ -146,14 +147,27 @@ Yapılandırma: `~/.weeb-cli/weeb.db` (SQLite)
 - [x] Veritabanı yedekleme/geri yükleme
 - [x] Klavye kısayolları
 
-### Planlanan
+## Gelecek Planlar
+
+### v2.6.0 (Planlanan)
+- [ ] Async/await refactoring
+- [ ] Download strategy pattern
+- [ ] Token şifreleme
+- [ ] Progress bar iyileştirmesi
+- [ ] Plugin sistemi
+
+### v2.7.0 (Planlanan)
 - [ ] Anime önerileri
 - [ ] Toplu işlemler
 - [ ] İzleme istatistikleri (grafik)
 - [ ] Tema desteği
 - [ ] Altyazı indirme
-- [ ] Torrent desteği (nyaa.si)
+
+### v3.0.0 (Uzun Vadeli)
+- [ ] Web UI (opsiyonel)
+- [ ] Torrent desteği
 - [ ] Watch party
+- [ ] Mobile app entegrasyonu
 
 ---
 

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weeb-cli"
-version = "2.5.0"
+version = "2.6.1"
 description = "Tarayıcı yok, reklam yok, dikkat dağıtıcı unsur yok. Sadece siz ve eşsiz bir anime izleme deneyimi."
 readme = "README.md"
 authors = [{ name = "ewgsta", email = "ewgst@proton.me" }]

weeb_cli-2.6.1/tests/test_cache.py

@@ -0,0 +1,90 @@
+"""Tests for cache manager."""
+import pytest
+import time
+from weeb_cli.services.cache import CacheManager, cached
+
+
+class TestCacheManager:
+    """Test cache manager functionality."""
+    
+    def test_set_and_get(self, temp_dir):
+        """Test basic set and get operations."""
+        cache = CacheManager(temp_dir / "cache")
+        
+        cache.set("test_key", "test_value")
+        result = cache.get("test_key")
+        
+        assert result == "test_value"
+    
+    def test_expiration(self, temp_dir):
+        """Test cache expiration."""
+        cache = CacheManager(temp_dir / "cache")
+        
+        cache.set("test_key", "test_value")
+        
+        assert cache.get("test_key", max_age=10) == "test_value"
+        
+        time.sleep(0.1)
+        assert cache.get("test_key", max_age=0) is None
+    
+    def test_delete(self, temp_dir):
+        """Test cache deletion."""
+        cache = CacheManager(temp_dir / "cache")
+        
+        cache.set("test_key", "test_value")
+        cache.delete("test_key")
+        
+        assert cache.get("test_key") is None
+    
+    def test_clear(self, temp_dir):
+        """Test clearing all cache."""
+        cache = CacheManager(temp_dir / "cache")
+        
+        cache.set("key1", "value1")
+        cache.set("key2", "value2")
+        cache.clear()
+        
+        assert cache.get("key1") is None
+        assert cache.get("key2") is None
+    
+    def test_complex_values(self, temp_dir):
+        """Test caching complex data structures."""
+        cache = CacheManager(temp_dir / "cache")
+        
+        data = {
+            "list": [1, 2, 3],
+            "dict": {"nested": "value"},
+            "tuple": (1, 2, 3)
+        }
+        
+        cache.set("complex", data)
+        result = cache.get("complex")
+        
+        assert result == data
+
+
+class TestCachedDecorator:
+    """Test cached decorator."""
+    
+    def test_function_caching(self, temp_dir):
+        """Test that function results are cached."""
+        cache = CacheManager(temp_dir / "cache")
+        call_count = 0
+        
+        @cached(max_age=10, cache_manager=cache)
+        def expensive_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+        
+        result1 = expensive_function(5)
+        assert result1 == 10
+        assert call_count == 1
+        
+        result2 = expensive_function(5)
+        assert result2 == 10
+        assert call_count == 1
+        
+        result3 = expensive_function(10)
+        assert result3 == 20
+        assert call_count == 2

weeb_cli-2.6.1/tests/test_exceptions.py

@@ -0,0 +1,45 @@
+"""Tests for custom exceptions."""
+import pytest
+from weeb_cli.exceptions import (
+    WeebCLIError,
+    ProviderError,
+    DownloadError,
+    NetworkError,
+    AuthenticationError
+)
+
+
+class TestExceptions:
+    """Test custom exception hierarchy."""
+    
+    def test_base_exception(self):
+        """Test base exception."""
+        exc = WeebCLIError("Test message", "TEST_CODE")
+        assert str(exc) == "TEST_CODE: Test message"
+        assert exc.message == "Test message"
+        assert exc.code == "TEST_CODE"
+    
+    def test_exception_without_code(self):
+        """Test exception without error code."""
+        exc = WeebCLIError("Test message")
+        assert str(exc) == "Test message"
+    
+    def test_provider_error(self):
+        """Test provider error."""
+        exc = ProviderError("Provider failed", "PROVIDER_ERROR")
+        assert isinstance(exc, WeebCLIError)
+    
+    def test_download_error(self):
+        """Test download error."""
+        exc = DownloadError("Download failed", "DOWNLOAD_ERROR")
+        assert isinstance(exc, WeebCLIError)
+    
+    def test_network_error(self):
+        """Test network error."""
+        exc = NetworkError("Network failed", "NETWORK_ERROR")
+        assert isinstance(exc, WeebCLIError)
+    
+    def test_authentication_error(self):
+        """Test authentication error."""
+        exc = AuthenticationError("Auth failed", "AUTH_ERROR")
+        assert isinstance(exc, WeebCLIError)

weeb_cli-2.6.1/tests/test_sanitizer.py

@@ -0,0 +1,69 @@
+"""Tests for sanitizer utilities."""
+import pytest
+from weeb_cli.utils.sanitizer import sanitize_filename, validate_url
+
+
+class TestSanitizeFilename:
+    """Test filename sanitization."""
+    
+    def test_basic_sanitization(self):
+        """Test basic character removal."""
+        assert sanitize_filename("test<>file") == "testfile"
+        assert sanitize_filename('test"file') == "testfile"
+        assert sanitize_filename("test|file") == "testfile"
+    
+    def test_path_traversal_prevention(self):
+        """Test path traversal attack prevention."""
+        assert ".." not in sanitize_filename("../../../etc/passwd")
+        assert ".." not in sanitize_filename("test..file")
+    
+    def test_empty_input(self):
+        """Test empty input handling."""
+        assert sanitize_filename("") == "unnamed"
+        assert sanitize_filename("   ") == "unnamed"
+    
+    def test_unicode_handling(self):
+        """Test unicode character handling."""
+        result = sanitize_filename("Anime - 第1話")
+        assert result  # Should not be empty
+        assert len(result) > 0
+    
+    def test_length_limiting(self):
+        """Test filename length limiting."""
+        long_name = "a" * 300
+        result = sanitize_filename(long_name, max_length=200)
+        assert len(result) <= 200
+    
+    def test_windows_reserved_chars(self):
+        """Test Windows reserved character removal."""
+        assert sanitize_filename("file:name") == "filename"
+        assert sanitize_filename("file*name") == "filename"
+        assert sanitize_filename("file?name") == "filename"
+    
+    def test_leading_trailing_dots(self):
+        """Test removal of leading/trailing dots and spaces."""
+        assert sanitize_filename("...file...") == "file"
+        assert sanitize_filename("  file  ") == "file"
+
+
+class TestValidateUrl:
+    """Test URL validation."""
+    
+    def test_valid_urls(self):
+        """Test valid URL patterns."""
+        assert validate_url("https://example.com")
+        assert validate_url("http://example.com")
+        assert validate_url("https://example.com/path")
+        assert validate_url("https://example.com:8080")
+    
+    def test_invalid_urls(self):
+        """Test invalid URL patterns."""
+        assert not validate_url("")
+        assert not validate_url("not a url")
+        assert not validate_url("ftp://example.com")
+        assert not validate_url("javascript:alert(1)")
+    
+    def test_localhost(self):
+        """Test localhost URLs."""
+        assert validate_url("http://localhost")
+        assert validate_url("http://localhost:8080")

weeb_cli-2.6.1/weeb_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.6.1"

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/weeb_cli/commands/search.py

@@ -9,6 +9,7 @@ from weeb_cli.services.player import player
 from weeb_cli.services.progress import progress_tracker
 from weeb_cli.services.downloader import queue_manager
 from weeb_cli.services.scraper import scraper
+from weeb_cli.services.cache import get_cache
 import time
 
 console = Console()
@@ -57,8 +58,15 @@ def search_anime():
 
             progress_tracker.add_search_history(query.strip())
 
-            with console.status(i18n.get("search.searching"), spinner="dots"):
-                data = search(query)
+            cache = get_cache()
+            cache_key = f"search:{query.strip()}"
+            data = cache.get(cache_key, max_age=1800)  # 30 min cache
+            
+            if data is None:
+                with console.status(i18n.get("search.searching"), spinner="dots"):
+                    data = search(query)
+                    if data:
+                        cache.set(cache_key, data)
             
             if data is None:
                 time.sleep(1)
@@ -160,6 +168,8 @@ def show_anime_details(anime):
         show_header(details.get("title", ""))
         
         if show_desc and desc:
+            if len(desc) > 500:
+                desc = desc[:497] + "..."
             console.print(f"\n[dim]{desc}[/dim]\n", justify="left")
         
         try:

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/weeb_cli/commands/settings.py

@@ -174,7 +174,6 @@ def change_language():
             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])
@@ -757,8 +756,6 @@ def restore_backup():
     except KeyboardInterrupt:
         pass
 
-# dursun zaman dokunduğunda sana yine yakınlaştığımda bana öyle baktığındaaaaaaa sessizzceeee  uyandığında sana yine dokunduğumda dursun zaman
-
 
 def shortcuts_menu():
     from weeb_cli.services.shortcuts import shortcut_manager, DEFAULT_SHORTCUTS

weeb_cli-2.6.1/weeb_cli/exceptions.py

@@ -0,0 +1,44 @@
+"""Custom exception hierarchy for Weeb CLI."""
+
+
+class WeebCLIError(Exception):
+    """Base exception for all Weeb CLI errors."""
+    def __init__(self, message: str = "", code: str = ""):
+        self.message = message
+        self.code = code
+        super().__init__(f"{code}: {message}" if code else message)
+
+
+class ProviderError(WeebCLIError):
+    """Raised when a provider operation fails."""
+    pass
+
+
+class DownloadError(WeebCLIError):
+    """Raised when a download operation fails."""
+    pass
+
+
+class NetworkError(WeebCLIError):
+    """Raised when a network operation fails."""
+    pass
+
+
+class AuthenticationError(WeebCLIError):
+    """Raised when authentication fails."""
+    pass
+
+
+class DatabaseError(WeebCLIError):
+    """Raised when a database operation fails."""
+    pass
+
+
+class ValidationError(WeebCLIError):
+    """Raised when input validation fails."""
+    pass
+
+
+class DependencyError(WeebCLIError):
+    """Raised when a required dependency is missing."""
+    pass

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/weeb_cli/providers/allanime.py

@@ -130,23 +130,54 @@ class AllAnimeProvider(BaseProvider):
             
             results.append(AnimeResult(
                 id=anime_id,
-                title=f"{name} ({ep_count} episodes)",
+                title=name,
                 type="series"
             ))
         
         return results
     
     def get_details(self, anime_id: str) -> Optional[AnimeDetails]:
-        episodes = self.get_episodes(anime_id)
+        gql = '''query ($showId: String!) {
+            show(_id: $showId) {
+                _id
+                name
+                description
+                thumbnail
+                availableEpisodesDetail
+            }
+        }'''
+        
+        variables = {"showId": anime_id}
+        data = _graphql_request(gql, variables)
+        
+        if not data or 'data' not in data:
+            return None
         
-        if not episodes:
+        show = data.get('data', {}).get('show', {})
+        
+        if not show:
             return None
         
-        title = anime_id.replace('-', ' ').title()
+        title = show.get('name', anime_id.replace('-', ' ').title())
+        description = show.get('description')
+        thumbnail = show.get('thumbnail')
+        
+        ep_detail = show.get('availableEpisodesDetail', {})
+        ep_list = ep_detail.get(self.mode, [])
+        
+        episodes = []
+        for i, ep_num in enumerate(sorted(ep_list, key=lambda x: float(x) if x.replace('.', '').isdigit() else 0)):
+            episodes.append(Episode(
+                id=f"{anime_id}::ep={ep_num}",
+                number=i + 1,
+                title=f"Episode {ep_num}"
+            ))
         
         return AnimeDetails(
             id=anime_id,
             title=title,
+            description=description,
+            cover=thumbnail,
             episodes=episodes,
             total_episodes=len(episodes)
         )
@@ -180,6 +211,10 @@ class AllAnimeProvider(BaseProvider):
         return episodes
     
     def get_streams(self, anime_id: str, episode_id: str) -> List[StreamLink]:
+        from weeb_cli.services.logger import debug, error
+        
+        debug(f"[ALLANIME] get_streams: anime_id={anime_id}, episode_id={episode_id}")
+        
         if '::ep=' in episode_id:
             parts = episode_id.split('::ep=')
             show_id = parts[0]
@@ -188,6 +223,8 @@ class AllAnimeProvider(BaseProvider):
             show_id = anime_id
             ep_no = episode_id
         
+        debug(f"[ALLANIME] Parsed: show_id={show_id}, ep_no={ep_no}, mode={self.mode}")
+        
         gql = '''query ($showId: String!, $translationType: VaildTranslationTypeEnumType!, $episodeString: String!) {
             episode(showId: $showId translationType: $translationType episodeString: $episodeString) {
                 episodeString
@@ -201,8 +238,14 @@ class AllAnimeProvider(BaseProvider):
             "episodeString": ep_no
         }
         
+        debug(f"[ALLANIME] GraphQL variables: {variables}")
+        
         data = _graphql_request(gql, variables)
+        
+        debug(f"[ALLANIME] GraphQL response: {data}")
+        
         if not data or 'data' not in data:
+            error(f"[ALLANIME] No data in response")
             return []
         
         episode = data.get('data', {}).get('episode', {})

weeb_cli-2.6.1/weeb_cli/services/cache.py

@@ -0,0 +1,171 @@
+"""Simple file-based cache manager for Weeb CLI."""
+import pickle
+import time
+import hashlib
+from pathlib import Path
+from typing import Any, Optional, Callable
+from functools import wraps
+
+
+class CacheManager:
+    """Simple file-based cache with TTL support."""
+    
+    def __init__(self, cache_dir: Path):
+        """
+        Initialize cache manager.
+        
+        Args:
+            cache_dir: Directory to store cache files
+        """
+        self.cache_dir = cache_dir
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self._memory_cache = {}
+    
+    def _get_cache_key(self, key: str) -> str:
+        """Generate a safe cache key from input."""
+        return hashlib.md5(key.encode()).hexdigest()
+    
+    def get(self, key: str, max_age: int = 3600) -> Optional[Any]:
+        """
+        Get value from cache if not expired.
+        
+        Args:
+            key: Cache key
+            max_age: Maximum age in seconds (default: 1 hour)
+        
+        Returns:
+            Cached value or None if expired/not found
+        """
+        if key in self._memory_cache:
+            value, timestamp = self._memory_cache[key]
+            if time.time() - timestamp < max_age:
+                return value
+            else:
+                del self._memory_cache[key]
+        
+        cache_key = self._get_cache_key(key)
+        cache_file = self.cache_dir / f"{cache_key}.cache"
+        
+        if cache_file.exists():
+            age = time.time() - cache_file.stat().st_mtime
+            if age < max_age:
+                try:
+                    with open(cache_file, 'rb') as f:
+                        value = pickle.load(f)
+                        self._memory_cache[key] = (value, time.time())
+                        return value
+                except (pickle.PickleError, EOFError):
+                    cache_file.unlink(missing_ok=True)
+        
+        return None
+    
+    def set(self, key: str, value: Any) -> None:
+        """
+        Store value in cache.
+        
+        Args:
+            key: Cache key
+            value: Value to cache
+        """
+        self._memory_cache[key] = (value, time.time())
+        
+        cache_key = self._get_cache_key(key)
+        cache_file = self.cache_dir / f"{cache_key}.cache"
+        
+        try:
+            with open(cache_file, 'wb') as f:
+                pickle.dump(value, f)
+        except (pickle.PickleError, OSError):
+            pass  # Fail silently for cache writes
+    
+    def delete(self, key: str) -> None:
+        """
+        Delete value from cache.
+        
+        Args:
+            key: Cache key
+        """
+        self._memory_cache.pop(key, None)
+        
+        cache_key = self._get_cache_key(key)
+        cache_file = self.cache_dir / f"{cache_key}.cache"
+        cache_file.unlink(missing_ok=True)
+    
+    def clear(self) -> None:
+        """Clear all cache."""
+        self._memory_cache.clear()
+        
+        for cache_file in self.cache_dir.glob("*.cache"):
+            cache_file.unlink(missing_ok=True)
+    
+    def cleanup(self, max_age: int = 86400) -> int:
+        """
+        Remove expired cache files.
+        
+        Args:
+            max_age: Maximum age in seconds (default: 24 hours)
+        
+        Returns:
+            Number of files removed
+        """
+        removed = 0
+        cutoff = time.time() - max_age
+        
+        for cache_file in self.cache_dir.glob("*.cache"):
+            if cache_file.stat().st_mtime < cutoff:
+                cache_file.unlink(missing_ok=True)
+                removed += 1
+        
+        return removed
+
+
+def cached(max_age: int = 3600, cache_manager: Optional[CacheManager] = None):
+    """
+    Decorator to cache function results.
+    
+    Args:
+        max_age: Cache TTL in seconds
+        cache_manager: CacheManager instance (uses global if None)
+    
+    Example:
+        @cached(max_age=1800)
+        def expensive_function(arg1, arg2):
+            pass
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            key_parts = [func.__name__]
+            key_parts.extend(str(arg) for arg in args)
+            key_parts.extend(f"{k}={v}" for k, v in sorted(kwargs.items()))
+            cache_key = ":".join(key_parts)
+            
+            cm = cache_manager or _get_global_cache()
+            
+            result = cm.get(cache_key, max_age)
+            if result is not None:
+                return result
+            
+            result = func(*args, **kwargs)
+            cm.set(cache_key, result)
+            return result
+        
+        return wrapper
+    return decorator
+
+
+_global_cache = None
+
+
+def _get_global_cache() -> CacheManager:
+    """Get or create global cache instance."""
+    global _global_cache
+    if _global_cache is None:
+        from weeb_cli.config import CONFIG_DIR
+        _global_cache = CacheManager(CONFIG_DIR / "cache")
+    return _global_cache
+
+
+def get_cache() -> CacheManager:
+    """Get global cache instance."""
+    return _get_global_cache()

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/weeb_cli/services/database.py

@@ -26,6 +26,8 @@ class Database:
     
     def _init_db(self):
         with self._conn() as conn:
+            conn.execute('PRAGMA journal_mode=WAL')
+            
             conn.executescript('''
                 CREATE TABLE IF NOT EXISTS config (
                     key TEXT PRIMARY KEY,
@@ -58,7 +60,9 @@ class Database:
                     progress INTEGER DEFAULT 0,
                     eta TEXT DEFAULT '?',
                     error TEXT,
-                    added_at REAL
+                    added_at REAL,
+                    retry_count INTEGER DEFAULT 0,
+                    speed TEXT
                 );
                 
                 CREATE TABLE IF NOT EXISTS external_drives (
@@ -83,6 +87,21 @@ class Database:
                 CREATE INDEX IF NOT EXISTS idx_anime_title ON anime_index(title);
                 CREATE INDEX IF NOT EXISTS idx_anime_source ON anime_index(source_path);
             ''')
+            
+            self._migrate_columns()
+    
+    def _migrate_columns(self):
+        """Add missing columns to existing tables."""
+        with self._conn() as conn:
+            try:
+                conn.execute('SELECT retry_count FROM download_queue LIMIT 1')
+            except:
+                conn.execute('ALTER TABLE download_queue ADD COLUMN retry_count INTEGER DEFAULT 0')
+            
+            try:
+                conn.execute('SELECT speed FROM download_queue LIMIT 1')
+            except:
+                conn.execute('ALTER TABLE download_queue ADD COLUMN speed TEXT')
     
     def _migrate_from_json(self):
         config_dir = Path.home() / ".weeb-cli"

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/weeb_cli/services/downloader.py

@@ -7,6 +7,8 @@ from pathlib import Path
 from rich.console import Console
 from weeb_cli.config import config
 from weeb_cli.services.dependency_manager import dependency_manager
+from weeb_cli.utils.sanitizer import sanitize_filename
+from weeb_cli.exceptions import DownloadError
 
 console = Console()
 
@@ -110,7 +112,8 @@ class QueueManager:
         return added
 
     def _sanitize_filename(self, name):
-        return re.sub(r'[<>:"/\\|?*]', '', name).strip()
+        """Sanitize filename for safe file system operations."""
+        return sanitize_filename(name)
 
     def _manage_queue(self):
         while self.running:
@@ -203,8 +206,6 @@ class QueueManager:
         filename = f"{safe_title} - S{season}B{ep_num}.mp4" 
         output_path = anime_dir / filename
 
-        debug(f"Getting streams for {item['slug']} - {item['episode_id']}")
-        
         stream_data = get_streams(item["slug"], item["episode_id"])
         
         if not stream_data:
@@ -212,16 +213,89 @@ class QueueManager:
             if scraper.last_error:
                 err_msg = f"{err_msg}: {scraper.last_error}"
             log_error(f"Download failed - {err_msg}")
-            raise Exception(err_msg)
+            raise DownloadError(err_msg, code="NO_STREAM_DATA")
+
+        if isinstance(stream_data, dict) and "data" in stream_data and "links" in stream_data["data"]:
+            links = stream_data["data"]["links"]
+            if not links:
+                raise DownloadError("Stream links boş", code="EMPTY_STREAM_LINKS")
+            
+            debug(f"Found {len(links)} stream sources, trying each one...")
+            
+            last_error = None
+            for idx, link in enumerate(links):
+                stream_url = link.get("url")
+                server_name = link.get("server", "unknown")
+                
+                if not stream_url:
+                    continue
+                
+                debug(f"Trying source {idx + 1}/{len(links)}: {server_name} - {stream_url[:80]}...")
+                
+                try:
+                    self._try_download(stream_url, output_path, item)
+                    debug(f"Download successful with source: {server_name}")
+                    return
+                    
+                except Exception as e:
+                    last_error = str(e)
+                    log_error(f"Source {server_name} failed: {e}")
+                    if idx < len(links) - 1:
+                        debug(f"Trying next source...")
+                        continue
+            
+            raise DownloadError(f"Tüm kaynaklar başarısız. Son hata: {last_error}", code="ALL_SOURCES_FAILED")
 
         stream_url = self._extract_url(stream_data)
         
+        debug(f"Extracted stream URL: {stream_url}")
+        
         if not stream_url:
             log_error(f"Download failed - Stream URL bulunamadı. Data: {stream_data}")
-            raise Exception("Stream URL bulunamadı")
+            raise DownloadError("Stream URL bulunamadı", code="NO_STREAM_URL")
 
         debug(f"Stream URL found: {stream_url[:80]}...")
         
+        self._try_download(stream_url, output_path, item)
+
+    def _extract_all_urls(self, data):
+        """Extract all available stream URLs with their server names."""
+        PRIORITY = ["ALUCARD", "AMATERASU", "SIBNET", "MP4UPLOAD", "UQLOAD"]
+        
+        results = []
+        
+        if isinstance(data, dict):
+            node = data
+            for _ in range(3):
+                if "data" in node and isinstance(node["data"], (dict, list)):
+                    node = node["data"]
+                else:
+                    break
+             
+            sources = node if isinstance(node, list) else node.get("links") or node.get("sources")
+            if sources and isinstance(sources, list) and len(sources) > 0:
+                def get_priority(s):
+                    server = (s.get("server") or "").upper()
+                    for i, p in enumerate(PRIORITY):
+                        if p in server:
+                            return i
+                    return 999
+                
+                sorted_sources = sorted(sources, key=get_priority)
+                
+                for src in sorted_sources:
+                    url = src.get("url")
+                    server = src.get("server", "unknown")
+                    if url:
+                        results.append((url, server))
+                        
+            elif isinstance(node, dict) and "url" in node:
+                results.append((node["url"], node.get("server", "unknown")))
+        
+        return results
+    
+    def _try_download(self, stream_url, output_path, item):
+        """Try to download from a stream URL."""
         is_hls = ".m3u8" in stream_url
         
         if is_hls:
@@ -308,7 +382,6 @@ class QueueManager:
                         match = re.search(r'\((\d+)%\)', line)
                         progress = int(match.group(1)) if match else None
                         
-                        # Parse speed (e.g., "DL:1.2MiB")
                         speed = None
                         speed_match = re.search(r'DL:([\d.]+[KMG]?i?B)', line)
                         if speed_match:
@@ -319,7 +392,7 @@ class QueueManager:
                         pass
         
         if process.returncode != 0:
-            raise Exception("Aria2 failed")
+            raise DownloadError("Aria2 download failed", code="ARIA2_FAILED")
 
     def _download_ytdlp(self, url, path, item):
         ytdlp = dependency_manager.check_dependency("yt-dlp")
@@ -344,7 +417,6 @@ class QueueManager:
                         progress = float(p_str)
                         eta = line.split("ETA")[-1].strip() if "ETA" in line else None
                         
-                        # Parse speed (e.g., "at 1.5MiB/s")
                         speed = None
                         speed_match = re.search(r'at\s+([\d.]+[KMG]?i?B/s)', line)
                         if speed_match:
@@ -354,7 +426,7 @@ class QueueManager:
                     except:
                         pass
         if process.returncode != 0:
-            raise Exception("yt-dlp failed")
+            raise DownloadError("yt-dlp download failed", code="YTDLP_FAILED")
 
     def _download_ffmpeg(self, url, path, item):
         self._update_progress(item, eta="")
@@ -390,7 +462,6 @@ class QueueManager:
                             remaining = total - downloaded
                             eta_s = remaining / speed_bytes if speed_bytes > 0 else 0
                             
-                            # Format speed
                             if speed_bytes >= 1024 * 1024:
                                 speed_str = f"{speed_bytes / (1024*1024):.1f}MB/s"
                             elif speed_bytes >= 1024:

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/weeb_cli/services/scraper.py

@@ -68,16 +68,28 @@ class Scraper:
             return []
     
     def get_streams(self, anime_id: str, episode_id: str) -> List[StreamLink]:
+        from weeb_cli.services.logger import debug, error
+        
         self.last_error = None
+        debug(f"[SCRAPER] get_streams called: anime_id={anime_id}, episode_id={episode_id}")
+        debug(f"[SCRAPER] Current provider: {self._provider_name}")
+        
         if not self.provider:
+            error("[SCRAPER] No provider available!")
             return []
+        
         try:
-            return self.provider.get_streams(anime_id, episode_id)
+            debug(f"[SCRAPER] Calling provider.get_streams()")
+            result = self.provider.get_streams(anime_id, episode_id)
+            debug(f"[SCRAPER] Provider returned {len(result) if result else 0} streams")
+            return result
         except ProviderError as e:
             self.last_error = e.code
+            error(f"[SCRAPER] ProviderError: {e.code} - {e.message}")
             return []
         except Exception as e:
             self.last_error = str(e)
+            error(f"[SCRAPER] Exception: {str(e)}")
             return []
     
     def get_available_sources(self) -> List[dict]:

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/weeb_cli/services/watch.py

@@ -1,11 +1,16 @@
 from weeb_cli.services.scraper import scraper
+from weeb_cli.services.logger import debug
 
 def get_streams(anime_id, episode_id):
+    debug(f"[WATCH] Getting streams for {anime_id} - {episode_id}")
     streams = scraper.get_streams(anime_id, episode_id)
+    debug(f"[WATCH] Scraper returned {len(streams) if streams else 0} streams")
+    
     if not streams:
+        debug(f"[WATCH] No streams found, last_error: {scraper.last_error}")
         return None
     
-    return {
+    result = {
         "data": {
             "links": [
                 {
@@ -17,3 +22,5 @@ def get_streams(anime_id, episode_id):
             ]
         }
     }
+    debug(f"[WATCH] Returning {len(result['data']['links'])} links")
+    return result

weeb_cli-2.6.1/weeb_cli/ui/__init__.py

@@ -0,0 +1 @@
+

weeb_cli-2.6.1/weeb_cli/utils/__init__.py

@@ -0,0 +1,4 @@
+"""Utility modules for Weeb CLI."""
+from weeb_cli.utils.sanitizer import sanitize_filename, sanitize_path, validate_url
+
+__all__ = ['sanitize_filename', 'sanitize_path', 'validate_url']

weeb_cli-2.6.1/weeb_cli/utils/sanitizer.py

@@ -0,0 +1,79 @@
+"""Utility functions for sanitizing user input and filenames."""
+import re
+import unicodedata
+from pathlib import Path
+
+
+def sanitize_filename(name: str, max_length: int = 200) -> str:
+    """
+    Sanitize a filename to be safe for all operating systems.
+    
+    Args:
+        name: The filename to sanitize
+        max_length: Maximum length of the filename (default: 200)
+    
+    Returns:
+        A safe filename string
+    """
+    if not name:
+        return "unnamed"
+    
+    name = unicodedata.normalize('NFKD', name)
+    
+    name = re.sub(r'[<>:"/\\|?*\x00-\x1f]', '', name)
+    
+    name = name.replace('..', '')
+    
+    name = name.strip('. ')
+    
+    if not name:
+        return "unnamed"
+    
+    if len(name) > max_length:
+        name = name[:max_length]
+    
+    return name
+
+
+def sanitize_path(path: str) -> Path:
+    """
+    Sanitize a full path to prevent directory traversal.
+    
+    Args:
+        path: The path to sanitize
+    
+    Returns:
+        A safe Path object
+    """
+    p = Path(path)
+    
+    try:
+        resolved = p.resolve()
+        return resolved
+    except (OSError, RuntimeError):
+        raise ValueError(f"Invalid path: {path}")
+
+
+def validate_url(url: str) -> bool:
+    """
+    Validate if a URL is safe to use.
+    
+    Args:
+        url: The URL to validate
+    
+    Returns:
+        True if valid, False otherwise
+    """
+    if not url:
+        return False
+    
+    url_pattern = re.compile(
+        r'^https?://'
+        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'
+        r'localhost|'
+        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'
+        r'(?::\d+)?'
+        r'(?:/?|[/?]\S+)$', re.IGNORECASE
+    )
+    
+    return bool(url_pattern.match(url))

{weeb_cli-2.5.0 → weeb_cli-2.6.1/weeb_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weeb-cli
-Version: 2.5.0
+Version: 2.6.1
 Summary: Tarayıcı yok, reklam yok, dikkat dağıtıcı unsur yok. Sadece siz ve eşsiz bir anime izleme deneyimi.
 Author-email: ewgsta <ewgst@proton.me>
 License-Expression: CC-BY-NC-ND-4.0
@@ -44,6 +44,7 @@ Dynamic: license-file
   <a href="https://github.com/ewgsta/weeb-cli/releases"><img src="https://img.shields.io/github/v/release/ewgsta/weeb-cli?style=flat-square" alt="Release"></a>
   <a href="https://github.com/ewgsta/weeb-cli/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-CC%20BY--NC--ND%204.0-blue?style=flat-square" alt="License"></a>
   <a href="https://github.com/ewgsta/weeb-cli/stargazers"><img src="https://img.shields.io/github/stars/ewgsta/weeb-cli?style=flat-square" alt="Stars"></a>
+  <a href="https://github.com/ewgsta/weeb-cli/actions"><img src="https://img.shields.io/github/actions/workflow/status/ewgsta/weeb-cli/tests.yml?style=flat-square" alt="Tests"></a>
 </p>
 
 <p align="center">
@@ -178,14 +179,27 @@ Yapılandırma: `~/.weeb-cli/weeb.db` (SQLite)
 - [x] Veritabanı yedekleme/geri yükleme
 - [x] Klavye kısayolları
 
-### Planlanan
+## Gelecek Planlar
+
+### v2.6.0 (Planlanan)
+- [ ] Async/await refactoring
+- [ ] Download strategy pattern
+- [ ] Token şifreleme
+- [ ] Progress bar iyileştirmesi
+- [ ] Plugin sistemi
+
+### v2.7.0 (Planlanan)
 - [ ] Anime önerileri
 - [ ] Toplu işlemler
 - [ ] İzleme istatistikleri (grafik)
 - [ ] Tema desteği
 - [ ] Altyazı indirme
-- [ ] Torrent desteği (nyaa.si)
+
+### v3.0.0 (Uzun Vadeli)
+- [ ] Web UI (opsiyonel)
+- [ ] Torrent desteği
 - [ ] Watch party
+- [ ] Mobile app entegrasyonu
 
 ---
 

{weeb_cli-2.5.0 → weeb_cli-2.6.1}/weeb_cli.egg-info/SOURCES.txt

@@ -1,9 +1,13 @@
 LICENSE
 README.md
 pyproject.toml
+tests/test_cache.py
+tests/test_exceptions.py
+tests/test_sanitizer.py
 weeb_cli/__init__.py
 weeb_cli/__main__.py
 weeb_cli/config.py
+weeb_cli/exceptions.py
 weeb_cli/i18n.py
 weeb_cli/main.py
 weeb_cli.egg-info/PKG-INFO
@@ -30,11 +34,13 @@ weeb_cli/providers/turkanime.py
 weeb_cli/providers/extractors/__init__.py
 weeb_cli/providers/extractors/megacloud.py
 weeb_cli/services/__init__.py
+weeb_cli/services/cache.py
 weeb_cli/services/database.py
 weeb_cli/services/dependency_manager.py
 weeb_cli/services/details.py
 weeb_cli/services/discord_rpc.py
 weeb_cli/services/downloader.py
+weeb_cli/services/error_handler.py
 weeb_cli/services/local_library.py
 weeb_cli/services/logger.py
 weeb_cli/services/notifier.py
@@ -49,4 +55,6 @@ weeb_cli/services/watch.py
 weeb_cli/ui/__init__.py
 weeb_cli/ui/header.py
 weeb_cli/ui/menu.py
-weeb_cli/ui/prompt.py
+weeb_cli/ui/prompt.py
+weeb_cli/utils/__init__.py
+weeb_cli/utils/sanitizer.py

weeb_cli-2.5.0/weeb_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.5.0"

weeb_cli-2.5.0/weeb_cli/ui/__init__.py

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