ani-cli-ar 1.8.4__py3-none-any.whl

ani_cli_arabic/discord_rpc.py

@@ -0,0 +1,361 @@
+import time
+import threading
+try:
+    from pypresence import Presence, PipeClosed
+    try:
+        from pypresence import ActivityType
+    except ImportError:
+        class ActivityType:
+            PLAYING = 0
+            STREAMING = 1
+            LISTENING = 2
+            WATCHING = 3
+            CUSTOM = 4
+            COMPETING = 5
+    DISCORD_RPC_AVAILABLE = True
+except ImportError:
+    DISCORD_RPC_AVAILABLE = False
+
+from .config import DISCORD_CLIENT_ID, DISCORD_LOGO_URL, DISCORD_LOGO_TEXT
+
+class DiscordRPCManager:
+    def __init__(self):
+        self.rpc = None
+        self.connected = False
+        self.current_state = "Browsing"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self.update_thread = None
+        self.running = False
+        self._anime_poster_url = None
+        
+    def connect(self):
+        if not DISCORD_RPC_AVAILABLE:
+            return False
+            
+        try:
+            self.rpc = Presence(DISCORD_CLIENT_ID)
+            self.rpc.connect()
+            self.connected = True
+            self.running = True
+            
+            self.update_browsing()
+            
+            self.update_thread = threading.Thread(target=self._auto_update, daemon=True)
+            self.update_thread.start()
+            
+            return True
+        except Exception:
+            self.connected = False
+            return False
+    
+    def _auto_update(self):
+        while self.running:
+            time.sleep(15)
+            if self.connected:
+                try:
+                    self._update_presence()
+                except PipeClosed:
+                    try:
+                        self.rpc.connect()
+                        self._update_presence()
+                    except Exception:
+                        self.connected = False
+                except Exception:
+                    pass
+
+    def _update_presence(self):
+        if not self.connected or not self.rpc:
+            return
+        
+        buttons = [{"label": "View on GitHub", "url": "https://np4abdou1.github.io/ani-cli-arabic"}]
+        
+        try:
+            if self.current_state == "Watching":
+                self.rpc.update(
+                    activity_type=ActivityType.WATCHING,
+                    details=f"Episode {self.current_episode}",
+                    state=self.current_anime,
+                    start=self.start_time,
+                    large_image=self._get_anime_poster(),
+                    large_text=self.current_anime,
+                    small_image=DISCORD_LOGO_URL,
+                    small_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Choosing Quality":
+                self.rpc.update(
+                    details=self.current_anime,
+                    state=f"⚙️ Choosing quality for Episode {self.current_episode}",
+                    start=self.start_time,
+                    large_image=self._get_anime_poster(),
+                    large_text=self.current_anime,
+                    small_image=DISCORD_LOGO_URL,
+                    small_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Loading":
+                self.rpc.update(
+                    details=self.current_anime,
+                    state=f"⏳ Loading Episode {self.current_episode}",
+                    start=self.start_time,
+                    large_image=self._get_anime_poster(),
+                    large_text=self.current_anime,
+                    small_image=DISCORD_LOGO_URL,
+                    small_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Viewing":
+                self.rpc.update(
+                    details=self.current_anime,
+                    state="📖 Viewing details",
+                    start=self.start_time,
+                    large_image=self._get_anime_poster(),
+                    large_text=self.current_anime,
+                    small_image=DISCORD_LOGO_URL,
+                    small_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Selecting Episode":
+                self.rpc.update(
+                    details=self.current_anime,
+                    state="📺 Browsing episodes",
+                    start=self.start_time,
+                    large_image=self._get_anime_poster(),
+                    large_text=self.current_anime,
+                    small_image=DISCORD_LOGO_URL,
+                    small_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Searching":
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="🔍 Searching for anime",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Trending":
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="🔥 Browsing trending anime",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Popular":
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="🏆 Browsing popular anime",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Genres":
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="🎭 Browsing genres",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Studios":
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="🏢 Browsing studios",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Featured":
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="⭐ Browsing featured anime",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "History":
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="📜 Viewing watch history",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Favorites":
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="❤️ Browsing favorites",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            elif self.current_state == "Settings":
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="⚙️ Configuring settings",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+            else:
+                self.rpc.update(
+                    details="ani-cli-ar",
+                    state="🏠 Browsing",
+                    start=self.start_time,
+                    large_image=DISCORD_LOGO_URL,
+                    large_text=DISCORD_LOGO_TEXT,
+                    buttons=buttons
+                )
+        except Exception:
+            pass
+    
+    def _get_anime_poster(self) -> str:
+        if hasattr(self, '_anime_poster_url') and self._anime_poster_url:
+            return self._anime_poster_url
+        return DISCORD_LOGO_URL
+    
+    def update_browsing(self):
+        self.current_state = "Browsing"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+    
+    def update_searching(self):
+        self.current_state = "Searching"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+    
+    def update_viewing_anime(self, anime_title: str, poster_url: str = None):
+        self.current_state = "Viewing"
+        self.current_anime = anime_title
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = poster_url
+        self._update_presence()
+    
+    def update_selecting_episode(self, anime_title: str, poster_url: str = None):
+        self.current_state = "Selecting Episode"
+        self.current_anime = anime_title
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = poster_url
+        self._update_presence()
+    
+    def update_watching(self, anime_title: str, episode_num: str, poster_url: str = None):
+        self.current_state = "Watching"
+        self.current_anime = anime_title
+        self.current_episode = episode_num
+        self.start_time = int(time.time())
+        self._anime_poster_url = poster_url
+        self._update_presence()
+    
+    def update_choosing_quality(self, anime_title: str, episode_num: str, poster_url: str = None):
+        self.current_state = "Choosing Quality"
+        self.current_anime = anime_title
+        self.current_episode = episode_num
+        self.start_time = int(time.time())
+        self._anime_poster_url = poster_url
+        self._update_presence()
+    
+    def update_loading(self, anime_title: str, episode_num: str, poster_url: str = None):
+        self.current_state = "Loading"
+        self.current_anime = anime_title
+        self.current_episode = episode_num
+        self.start_time = int(time.time())
+        self._anime_poster_url = poster_url
+        self._update_presence()
+    
+    def update_trending(self):
+        self.current_state = "Trending"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+
+    def update_popular(self):
+        self.current_state = "Popular"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+
+    def update_genres(self):
+        self.current_state = "Genres"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+
+    def update_studios(self):
+        self.current_state = "Studios"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+
+    def update_featured(self):
+        self.current_state = "Featured"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+    
+    def update_history(self):
+        self.current_state = "History"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+    
+    def update_favorites(self):
+        self.current_state = "Favorites"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+    
+    def update_settings(self):
+        self.current_state = "Settings"
+        self.current_anime = None
+        self.current_episode = None
+        self.start_time = int(time.time())
+        self._anime_poster_url = None
+        self._update_presence()
+    
+    def disconnect(self):
+        self.running = False
+        if self.connected and self.rpc:
+            try:
+                self.rpc.clear()
+            except Exception:
+                pass
+            try:
+                self.rpc.close()
+            except Exception:
+                pass
+            finally:
+                self.connected = False

ani_cli_arabic/favorites.py

@@ -0,0 +1,72 @@
+import json
+from pathlib import Path
+from datetime import datetime
+from .storage import atomic_write_json
+
+class FavoritesManager:
+    # Maximum favorites to prevent database bloat and ensure performance
+    MAX_FAVORITES = 100
+    
+    def __init__(self):
+        self.file_path = self._get_path()
+        self.favorites = self._load()
+
+    def _get_path(self) -> Path:
+        home_dir = Path.home()
+        db_dir = home_dir / ".ani-cli-arabic" / "database"
+        db_dir.mkdir(parents=True, exist_ok=True)
+        return db_dir / "favorites.json"
+
+    def _load(self) -> dict:
+        if not self.file_path.exists():
+            return {}
+        try:
+            with open(self.file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                if not isinstance(data, dict):
+                    return {}
+                return data
+        except (json.JSONDecodeError, IOError, OSError):
+            return {}
+
+    def save(self):
+        try:
+            atomic_write_json(self.file_path, self.favorites, indent=4, ensure_ascii=False)
+        except (IOError, OSError, ValueError, TypeError) as e:
+            import sys
+            print(f"Warning: Failed to save favorites: {e}", file=sys.stderr)
+
+    def add(self, anime_id, title, thumbnail):
+        anime_id_str = str(anime_id)
+        if anime_id_str in self.favorites:
+            # Update existing favorite
+            self.favorites[anime_id_str]['added_at'] = datetime.now().isoformat()
+            self.save()
+            return
+        
+        if len(self.favorites) >= self.MAX_FAVORITES:
+            oldest = min(self.favorites.items(), key=lambda x: x[1]['added_at'])
+            del self.favorites[oldest[0]]
+        
+        self.favorites[str(anime_id)] = {
+            'title': title,
+            'thumbnail': thumbnail,
+            'added_at': datetime.now().isoformat()
+        }
+        self.save()
+
+    def remove(self, anime_id):
+        if str(anime_id) in self.favorites:
+            del self.favorites[str(anime_id)]
+            self.save()
+
+    def is_favorite(self, anime_id):
+        return str(anime_id) in self.favorites
+
+    def get_all(self):
+        # Return list sorted by added date (newest first)
+        return sorted(
+            [{'anime_id': k, 'id': k, **v} for k, v in self.favorites.items()],
+            key=lambda x: x['added_at'],
+            reverse=True
+        )

ani_cli_arabic/history.py

@@ -0,0 +1,72 @@
+import json
+from pathlib import Path
+from datetime import datetime
+from .storage import atomic_write_json
+
+class HistoryManager:
+    # Maximum history entries to maintain reasonable file size and load times
+    MAX_HISTORY_SIZE = 100
+    
+    def __init__(self):
+        self.history_file = self._get_history_path()
+        self.history = self._load_history()
+
+    def _get_history_path(self) -> Path:
+        home_dir = Path.home()
+        db_dir = home_dir / ".ani-cli-arabic" / "database"
+        db_dir.mkdir(parents=True, exist_ok=True)
+        return db_dir / "history.json"
+
+    def _load_history(self) -> dict:
+        if not self.history_file.exists():
+            return {}
+        try:
+            with open(self.history_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                if not isinstance(data, dict):
+                    return {}
+                return data
+        except (json.JSONDecodeError, IOError, OSError):
+            return {}
+
+    def save_history(self):
+        try:
+            if len(self.history) > self.MAX_HISTORY_SIZE:
+                sorted_items = sorted(
+                    self.history.items(),
+                    key=lambda x: x[1].get('last_updated', ''),
+                    reverse=True
+                )
+                self.history = dict(sorted_items[:self.MAX_HISTORY_SIZE])
+
+            atomic_write_json(self.history_file, self.history, indent=4, ensure_ascii=False)
+        except (IOError, OSError, ValueError, TypeError) as e:
+            import sys
+            print(f"Warning: Failed to save history: {e}", file=sys.stderr)
+
+    def mark_watched(self, anime_id, episode_num, anime_title):
+        self.history[str(anime_id)] = {
+            'episode': str(episode_num),
+            'title': anime_title,
+            'last_updated': datetime.now().isoformat()
+        }
+        self.save_history()
+
+    def get_last_watched(self, anime_id):
+        data = self.history.get(str(anime_id))
+        if data:
+            return data.get('episode')
+        return None
+    
+    def get_history(self):
+        items = []
+        for anime_id, data in self.history.items():
+            items.append({
+                'anime_id': anime_id,
+                'title': data.get('title', 'Unknown'),
+                'episode': data.get('episode', '?'),
+                'last_updated': data.get('last_updated', '')
+            })
+        # Sort by last_updated, most recent first
+        items.sort(key=lambda x: x['last_updated'], reverse=True)
+        return items

ani_cli_arabic/models.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+
+@dataclass
+class AnimeResult:
+    id: str
+    title_en: str
+    title_jp: str
+    type: str
+    episodes: str
+    status: str
+    genres: str
+    mal_id: str
+    relation_id: str
+    score: str
+    rank: str
+    popularity: str
+    rating: str
+    premiered: str
+    creators: str
+    duration: str
+    thumbnail: str
+    title_romaji: str = ""
+    trailer: str = ""
+    yt_trailer: str = ""
+
+@dataclass
+class Episode:
+    number: str
+    type: str
+    display_num: int
+
+@dataclass
+class QualityOption:
+    name: str
+    server_key: str
+    style: str

ani_cli_arabic/monitoring.py

@@ -0,0 +1,92 @@
+import platform
+import hashlib
+import threading
+import requests
+from datetime import datetime, timezone
+from .api import _get_endpoint_config
+from .config import CURRENT_VERSION
+
+class MonitoringSystem:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(MonitoringSystem, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if hasattr(self, '_initialized') and self._initialized:
+            return
+        self._initialized = True
+        self.user_fingerprint = self._generate_fingerprint()
+
+    def _generate_fingerprint(self) -> str:
+        try:
+            components = [
+                platform.node(),
+                platform.machine(),
+                platform.system(),
+                platform.release(),
+                platform.processor()
+            ]
+            
+            raw_str = "|".join(str(c) for c in components)
+            return hashlib.sha256(raw_str.encode()).hexdigest()[:16]
+        except Exception:
+            return "unknown_user"
+
+    def _send_data(self, action: str, details: dict):
+        """Send analytics data only if user has opted in."""
+        try:
+            from .settings import SettingsManager
+            settings = SettingsManager()
+            if not settings.get('analytics'):
+                return
+        except Exception:
+            return
+        
+        def worker():
+            try:
+                endpoint_url, auth_secret = _get_endpoint_config()
+                
+                payload = {
+                    "fingerprint": self.user_fingerprint,
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "action": action,
+                    "details": details
+                }
+                
+                headers = {
+                    'Content-Type': 'application/json',
+                    'X-Auth-Key': auth_secret,
+                    'User-Agent': 'AniCliAr-Monitor/1.0'
+                }
+                
+                requests.post(
+                    f"{endpoint_url}/monitor", 
+                    json=payload, 
+                    headers=headers, 
+                    timeout=3
+                )
+            except (requests.RequestException, ValueError, KeyError):
+                pass
+
+        thread = threading.Thread(target=worker, daemon=True)
+        thread.start()
+
+    def track_app_start(self):
+        self._send_data("app_start", {
+            "version": CURRENT_VERSION,
+            "os": platform.system()
+        })
+
+    def track_video_play(self, anime_title: str, episode: str, mode: str = "stream"):
+        self._send_data("video_play", {
+            "anime": anime_title,
+            "episode": episode,
+            "mode": mode
+        })
+
+# Global instance
+monitor = MonitoringSystem()