ani-cli-ar 1.9.2__tar.gz → 1.9.3__tar.gz

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ani-cli-ar
-Version: 1.9.2
+Version: 1.9.3
 Summary: Terminal-based anime streaming with Arabic subtitles
 Author: NoBy
 Maintainer: NoBy

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/ani_cli_ar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ani-cli-ar
-Version: 1.9.2
+Version: 1.9.3
 Summary: Terminal-based anime streaming with Arabic subtitles
 Author: NoBy
 Maintainer: NoBy

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/ani_cli_ar.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ ani_cli_arabic/models.py
 ani_cli_arabic/monitoring.py
 ani_cli_arabic/player.py
 ani_cli_arabic/settings.py
+ani_cli_arabic/stats.py
 ani_cli_arabic/storage.py
 ani_cli_arabic/ui.py
 ani_cli_arabic/updater.py

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/ani_cli_arabic/api.py

@@ -284,7 +284,25 @@ class AnimeAPI:
         except (requests.RequestException, ValueError, TypeError):
             return []
 
-    def get_streaming_servers(self, anime_id: str, episode_num: str, anime_type: str = 'SERIES') -> Optional[Dict]:
+    def _report_api_error(self, error_msg: str, context: dict = None,
+                          exception: BaseException = None, url: str = ""):
+        """Report an Arabic-API failure to telemetry without blocking the caller."""
+        try:
+            import sys as _sys
+            from .monitoring import monitor
+            details = dict(context or {})
+            details.setdefault("translation_mode", "arabic_sub")
+            if url:
+                details["server_url"] = url
+            if exception is not None:
+                monitor.track_error(error_msg, details, exception=exception)
+            else:
+                monitor.track_error(error_msg, details, exc_info=_sys.exc_info())
+        except Exception:
+            pass
+
+    def get_streaming_servers(self, anime_id: str, episode_num: str, anime_type: str = 'SERIES',
+                              context: dict = None) -> Optional[Dict]:
         endpoint = get_api_base() + "anime/load_servers.php"
         payload = {
             'UserId': '0',
@@ -298,10 +316,12 @@ class AnimeAPI:
             response = requests.post(endpoint, data=payload, timeout=10)
             response.raise_for_status()
             return response.json()
-        except (requests.RequestException, ValueError, TypeError):
+        except (requests.RequestException, ValueError, TypeError) as e:
+            self._report_api_error("Arabic server list request failed", context,
+                                   exception=e, url=endpoint)
             return None
 
-    def extract_mediafire_direct(self, mf_url: str) -> Optional[str]:
+    def extract_mediafire_direct(self, mf_url: str, context: dict = None) -> Optional[str]:
         try:
             headers = {
                 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
@@ -309,8 +329,13 @@ class AnimeAPI:
             response = requests.get(mf_url, headers=headers, timeout=10)
             response.raise_for_status()
             match = re.search(r'(https://download[^"]+)', response.text)
+            if not match:
+                self._report_api_error("MediaFire page did not contain a download link",
+                                       context, url=mf_url)
             return match.group(1) if match else None
-        except (requests.RequestException, AttributeError):
+        except (requests.RequestException, AttributeError) as e:
+            self._report_api_error("MediaFire direct link extraction failed", context,
+                                   exception=e, url=mf_url)
             return None
 
     def build_mediafire_url(self, server_id: str) -> str:

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/ani_cli_arabic/app.py

@@ -1,6 +1,7 @@
 import sys
 import atexit
 import re
+import time
 from pathlib import Path
 from rich.align import Align
 from rich.panel import Panel
@@ -55,10 +56,17 @@ class AniCliArApp:
         parser.add_argument('--dub', action='store_true', help="Override: use English Dubbed streams")
         parser.add_argument('--provider', type=str, default=None,
                             help="Preferred English stream provider (overrides auto-fallback)")
+        parser.add_argument('--stats', action='store_true',
+                            help="Show streaming history summary from telemetry/local history and exit")
         parser.add_argument('query', nargs='*', help="Anime name to search for")
         
         args = parser.parse_args()
-        
+
+        if args.stats:
+            from .stats import render_stats
+            render_stats()
+            sys.exit(0)
+
         if args.version:
             from .version import __version__
             print(f"ani-cli-arabic v{__version__}")
@@ -130,6 +138,7 @@ class AniCliArApp:
             threading.Thread(target=connect_rpc, daemon=True).start()
         
         threading.Thread(target=lambda: monitor.track_app_start(), daemon=True).start()
+        monitor.track_app_session()
         
         def check_updates_bg():
             try:
@@ -737,7 +746,9 @@ class AniCliArApp:
         
         self.ui.console.print(Align.center(panel, vertical="middle", height=self.ui.console.height))
         
+        monitor.set_activity("watching", anime.title_en, None)
         self.player.play(trailer_url, f"Trailer - {anime.title_en}")
+        monitor.set_activity("idle")
 
     def handle_episode_selection(self, selected_anime, episodes, initial_idx=0):
         current_idx = max(0, min(int(initial_idx or 0), len(episodes) - 1))
@@ -812,7 +823,10 @@ class AniCliArApp:
                         self.api.get_streaming_servers,
                         selected_anime.id,
                         selected_ep.number,
-                        selected_anime.type
+                        selected_anime.type,
+                        {"anime": selected_anime.title_en,
+                         "episode": str(selected_ep.display_num),
+                         "provider": "arabic_api"}
                     )
 
                     if not server_data:
@@ -887,10 +901,20 @@ class AniCliArApp:
         pm = ProviderManager(preferred_provider=preferred if preferred else None)
 
         mode = "dub" if dub else "sub"
-        url, headers, _ = asyncio.run(
-            pm.resolve_stream(anime_title, episode_num, mode=mode, language="english", provider=provider)
-        )
-        return url, headers
+        try:
+            url, headers, used_provider = asyncio.run(
+                pm.resolve_stream(anime_title, episode_num, mode=mode, language="english", provider=provider)
+            )
+        except Exception:
+            exc_type, exc_val, exc_tb = sys.exc_info()
+            monitor.track_error(
+                "English stream resolution failed",
+                {"anime": anime_title, "episode": str(episode_num), "provider": provider or "auto",
+                 "mode": mode, "translation_mode": mode},
+                exc_info=(exc_type, exc_val, exc_tb),
+            )
+            return "", {}, ""
+        return url, headers, used_provider or ""
 
     def _pick_default_download_quality_option(self, current_ep_data):
         qualities = [
@@ -912,16 +936,20 @@ class AniCliArApp:
         return None
 
     def resolve_default_download_target(self, selected_anime, selected_ep, show_loading=False):
+        _ctx = {"anime": selected_anime.title_en,
+                "episode": str(selected_ep.display_num),
+                "provider": "arabic_api"}
         if show_loading:
             server_data = self.ui.run_with_loading(
                 "Loading servers...",
                 self.api.get_streaming_servers,
                 selected_anime.id,
                 selected_ep.number,
-                selected_anime.type
+                selected_anime.type,
+                _ctx
             )
         else:
-            server_data = self.api.get_streaming_servers(selected_anime.id, selected_ep.number, selected_anime.type)
+            server_data = self.api.get_streaming_servers(selected_anime.id, selected_ep.number, selected_anime.type, _ctx)
 
         if not server_data:
             return None, None, "No servers found for this episode."
@@ -940,10 +968,11 @@ class AniCliArApp:
             direct_url = self.ui.run_with_loading(
                 "Extracting direct link...",
                 self.api.extract_mediafire_direct,
-                mediafire_url
+                mediafire_url,
+                _ctx
             )
         else:
-            direct_url = self.api.extract_mediafire_direct(mediafire_url)
+            direct_url = self.api.extract_mediafire_direct(mediafire_url, _ctx)
 
         if not direct_url:
             return None, None, "Failed to extract direct link from MediaFire."
@@ -1059,7 +1088,10 @@ class AniCliArApp:
         direct_url = self.ui.run_with_loading(
             "Extracting direct link...",
             self.api.extract_mediafire_direct,
-            self.api.build_mediafire_url(server_id)
+            self.api.build_mediafire_url(server_id),
+            {"anime": selected_anime.title_en,
+             "episode": str(selected_ep.display_num),
+             "provider": "arabic_api"}
         )
         
         if direct_url:
@@ -1110,8 +1142,6 @@ class AniCliArApp:
                 
                 self.rpc.update_watching(selected_anime.title_en, str(selected_ep.display_num), selected_anime.thumbnail)
                 
-                monitor.track_video_play(selected_anime.title_en, str(selected_ep.display_num))
-                
                 ipc_socket = None
                 rc_port = None
                 if self.watch_host is not None:
@@ -1121,7 +1151,20 @@ class AniCliArApp:
                         ipc_socket = self.watch_host.socket_path
                     self.watch_host.notify_load(selected_anime.title_en, selected_ep.display_num, "Arabic Sub")
                 
-                self.player.play(direct_url, f"{selected_anime.title_en} - Ep {selected_ep.display_num} ({quality.name})", player_type=player_type, ipc_socket=ipc_socket, rc_port=rc_port)
+                watch_start = time.time()
+                monitor.set_activity("watching", selected_anime.title_en, str(selected_ep.display_num))
+                selected_player = self.player.play(direct_url, f"{selected_anime.title_en} - Ep {selected_ep.display_num} ({quality.name})", player_type=player_type, ipc_socket=ipc_socket, rc_port=rc_port)
+                watch_end = time.time()
+                monitor.set_activity("idle")
+                monitor.track_video_play(
+                    selected_anime.title_en,
+                    str(selected_ep.display_num),
+                    player=selected_player or player_type or "",
+                    provider="arabic_api",
+                    quality=quality_tag or "",
+                    watch_start=watch_start,
+                    watch_end=watch_end,
+                )
                 if self.watch_host is not None:
                     self.watch_host.notify_stop()
                 self.ui.clear()
@@ -1129,6 +1172,17 @@ class AniCliArApp:
                 self.rpc.update_selecting_episode(selected_anime.title_en, selected_anime.thumbnail)
                 return "watch"
         else:
+            monitor.track_error(
+                "Failed to extract direct link from MediaFire",
+                {
+                    "anime": selected_anime.title_en,
+                    "episode": str(selected_ep.display_num),
+                    "language": "Arabic",
+                    "provider": "arabic_api",
+                    "translation_mode": "arabic_sub",
+                    "server_url": "www.mediafire.com",
+                },
+            )
             self.ui.render_message(
                 "✗ Error", 
                 "Failed to extract direct link from MediaFire.", 
@@ -1185,6 +1239,17 @@ class AniCliArApp:
         )
 
         if not (url_and_headers and url_and_headers[0]):
+            monitor.track_error(
+                "No working English stream found",
+                {
+                    "anime": selected_anime.title_en,
+                    "episode": str(selected_ep.display_num),
+                    "provider": provider_choice or "auto",
+                    "quality": quality_name,
+                    "dub": dub,
+                    "translation_mode": "dub" if dub else "sub",
+                },
+            )
             self.ui.render_message(
                 "Error",
                 f"No working English stream found via {label}. Please try another provider.",
@@ -1192,7 +1257,7 @@ class AniCliArApp:
             )
             return None
 
-        direct_url, stream_headers = url_and_headers
+        direct_url, stream_headers, provider_name = url_and_headers
         player_type = self.watch_host.player_kind if self.watch_host else self.settings.get('player')
         suffix = " [English Dub]" if dub else " [English Sub]"
 
@@ -1218,7 +1283,6 @@ class AniCliArApp:
         self.ui.console.print(Align.center(watching_panel, vertical="middle", height=self.ui.console.height))
 
         self.rpc.update_watching(selected_anime.title_en, str(selected_ep.display_num), selected_anime.thumbnail)
-        monitor.track_video_play(selected_anime.title_en, str(selected_ep.display_num))
 
         ipc_socket = None
         rc_port = None
@@ -1233,7 +1297,20 @@ class AniCliArApp:
                 "English Dub" if dub else "English Sub",
             )
 
-        self.player.play(direct_url, f"{selected_anime.title_en} - Ep {selected_ep.display_num}", player_type=player_type, headers=stream_headers, ipc_socket=ipc_socket, rc_port=rc_port)
+        watch_start = time.time()
+        monitor.set_activity("watching", selected_anime.title_en, str(selected_ep.display_num))
+        selected_player = self.player.play(direct_url, f"{selected_anime.title_en} - Ep {selected_ep.display_num}", player_type=player_type, headers=stream_headers, ipc_socket=ipc_socket, rc_port=rc_port)
+        watch_end = time.time()
+        monitor.set_activity("idle")
+        monitor.track_video_play(
+            selected_anime.title_en,
+            str(selected_ep.display_num),
+            player=selected_player or player_type or "",
+            provider=provider_name or "",
+            quality=quality_name or "",
+            watch_start=watch_start,
+            watch_end=watch_end,
+        )
         if self.watch_host is not None:
             self.watch_host.notify_stop()
         self.ui.clear()

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/ani_cli_arabic/cli.py

@@ -581,6 +581,11 @@ def run_simple_cli(query=None, deps=None):
 
 def main():
     """Entry point for running the CLI directly: python -m ani_cli_arabic.cli"""
+    if "--stats" in sys.argv:
+        from ani_cli_arabic.stats import render_stats
+        render_stats()
+        return
+
     from ani_cli_arabic.api import AnimeAPI
     from ani_cli_arabic.player import PlayerManager
     from ani_cli_arabic.history import HistoryManager

ani_cli_ar-1.9.3/ani_cli_arabic/monitoring.py

@@ -0,0 +1,355 @@
+import platform
+import getpass
+import hashlib
+import sys
+import threading
+import traceback as _traceback
+from typing import Optional
+from urllib.parse import urlsplit
+import requests
+import time
+import atexit
+from datetime import datetime, timezone
+from .api import _get_analytics_endpoint_config
+from .config import CURRENT_VERSION
+from .version import __version__
+
+_MAX_TRACEBACK_LINES = 6
+_HEARTBEAT_INTERVAL = 30
+
+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()
+        self.current_activity = {
+            "status": "idle",
+            "current_anime": None,
+            "current_episode": None,
+            "watch_started_at": None,
+        }
+        self._activity_lock = threading.Lock()
+        self._session_start = None
+        self._heartbeat_started = False
+
+    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, sync: bool = False):
+        """Send analytics data only if user has opted in.
+
+        System/user context (os, user_name, app_version) is attached to every
+        payload. `sync=True` sends inline (used at exit where daemon threads
+        would be killed); both paths swallow errors so telemetry never blocks.
+        """
+        try:
+            from .settings import SettingsManager
+            settings = SettingsManager()
+            if not settings.get('analytics'):
+                return
+        except Exception:
+            return
+
+        enriched = dict(details or {})
+        for key, value in self._system_context().items():
+            if value is not None and str(value) != "":
+                enriched.setdefault(key, value)
+
+        def worker():
+            try:
+                endpoint_url, auth_secret = _get_analytics_endpoint_config()
+                
+                payload = {
+                    "fingerprint": self.user_fingerprint,
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "action": action,
+                    "details": enriched
+                }
+                
+                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 Exception:
+                pass
+
+        if sync:
+            worker()
+        else:
+            thread = threading.Thread(target=worker, daemon=True)
+            thread.start()
+
+    def track_app_start(self):
+        self._send_data("app_start", {
+            "version": CURRENT_VERSION,
+        })
+
+    def track_app_session(self):
+        """Record the app session start and report 'app_session_end' on exit."""
+        try:
+            self._session_start = time.time()
+            atexit.register(self._send_session_end)
+            self._start_heartbeat()
+        except Exception:
+            pass
+
+    def _start_heartbeat(self):
+        """Start the live 'heartbeat' reporter thread (daemon)."""
+        if self._heartbeat_started:
+            return
+        self._heartbeat_started = True
+
+        def loop():
+            while True:
+                time.sleep(_HEARTBEAT_INTERVAL)
+                try:
+                    self._send_heartbeat()
+                except Exception:
+                    pass
+
+        threading.Thread(target=loop, daemon=True).start()
+
+    def set_activity(self, status: str, anime: str = None, episode=None):
+        """Update the global current-activity state used by heartbeats.
+
+        status is "watching" or "idle". While watching, anime/episode are the
+        currently playing title and its episode identifier.
+        """
+        status = (status or "idle").lower()
+        if status not in ("idle", "watching"):
+            status = "idle"
+        with self._activity_lock:
+            self.current_activity["status"] = status
+            if status == "watching":
+                self.current_activity["current_anime"] = anime
+                self.current_activity["current_episode"] = episode
+                self.current_activity["watch_started_at"] = time.time()
+            else:
+                self.current_activity["current_anime"] = None
+                self.current_activity["current_episode"] = None
+                self.current_activity["watch_started_at"] = None
+
+    def _send_heartbeat(self):
+        with self._activity_lock:
+            activity = dict(self.current_activity)
+        start = self._session_start or time.time()
+        details = {
+            "session_start": datetime.fromtimestamp(start, timezone.utc).isoformat(),
+            "elapsed_session_seconds": round(time.time() - start, 3),
+            "status": activity.get("status", "idle"),
+            "current_anime": activity.get("current_anime"),
+            "current_episode": activity.get("current_episode"),
+        }
+        watch_started = activity.get("watch_started_at")
+        if watch_started:
+            details["watch_started_at"] = datetime.fromtimestamp(watch_started, timezone.utc).isoformat()
+        self._send_data("heartbeat", details)
+
+    def _send_session_end(self):
+        try:
+            end = time.time()
+            start = getattr(self, "_session_start", None) or end
+            self._send_data("app_session_end", {
+                "session_start": datetime.fromtimestamp(start, timezone.utc).isoformat(),
+                "session_end": datetime.fromtimestamp(end, timezone.utc).isoformat(),
+                "session_duration_seconds": round(end - start, 3),
+            }, sync=True)
+        except Exception:
+            pass
+
+    def track_video_play(self, anime_title: str, episode: str, mode: str = "stream", player: str = "", provider: str = "", quality: str = "",
+                         watch_start: float = None, watch_end: float = None):
+        details = {
+            "anime": anime_title,
+            "episode": episode,
+            "mode": mode,
+            "player": player or "",
+            "provider": provider or "",
+            "quality": quality or ""
+        }
+        if watch_start is not None and watch_end is not None:
+            try:
+                start = float(watch_start)
+                end = float(watch_end)
+                details["watch_start"] = datetime.fromtimestamp(start, timezone.utc).isoformat()
+                details["watch_end"] = datetime.fromtimestamp(end, timezone.utc).isoformat()
+                details["watch_duration_seconds"] = round(max(end - start, 0.0), 3)
+            except (TypeError, ValueError, OverflowError):
+                pass
+        self._send_data("video_play", details)
+
+    @staticmethod
+    def _host_of(url) -> str:
+        try:
+            return urlsplit(str(url)).hostname or str(url)
+        except Exception:
+            return str(url)
+
+    @staticmethod
+    def _truncate_traceback(formatted) -> str:
+        try:
+            joined = "".join(formatted).rstrip()
+        except Exception:
+            return str(formatted)
+        lines = joined.splitlines()
+        if len(lines) > _MAX_TRACEBACK_LINES:
+            return "\n".join(lines[-_MAX_TRACEBACK_LINES:])
+        return joined
+
+    @staticmethod
+    def _system_context() -> dict:
+        """Rich, always-available system/user context for error payloads."""
+        context = {
+            "os": f"{platform.system()} {platform.release()}",
+            "user_name": "",
+            "app_version": __version__,
+        }
+        try:
+            context["user_name"] = getpass.getuser() or ""
+        except Exception:
+            context["user_name"] = ""
+        return context
+
+    @staticmethod
+    def _translation_mode(details: dict) -> str:
+        """Map user settings/CLI language preference to a canonical mode."""
+        mode = details.get("translation_mode") or details.get("sub_type")
+        if mode:
+            return str(mode)
+        try:
+            from .settings import SettingsManager
+            lang = str(SettingsManager().get('preferred_language', 'Arabic Sub'))
+            mapping = {
+                "Arabic Sub": "arabic_sub",
+                "English Sub": "sub",
+                "English Dub": "dub",
+            }
+            for key, value in mapping.items():
+                if key.lower() in lang.lower():
+                    return value
+        except Exception:
+            pass
+        return "sub"
+
+    def track_error(self, error_msg: str = "", context: dict = None,
+                    exception: BaseException = None, exc_info: tuple = None):
+        """Report a diagnostic error event.
+
+        All extraction is local and cheap; the network send happens on a
+        background thread and fails silently when offline.
+        """
+        details: dict = {}
+
+        exc_type = exc_val = exc_tb = None
+        if exception is not None:
+            exc_type = type(exception)
+            exc_val = exception
+            if getattr(exception, "__traceback__", None) is not None:
+                exc_tb = exception.__traceback__
+        elif exc_info is not None and isinstance(exc_info, tuple) and exc_info[0] is not None:
+            exc_type, exc_val, exc_tb = exc_info
+
+        if exc_type is not None:
+            details["exception_type"] = getattr(exc_type, "__name__", str(exc_type))
+            details["error_msg"] = error_msg or str(exc_val) or ""
+            if exc_tb is not None:
+                try:
+                    formatted = _traceback.format_exception(exc_type, exc_val, exc_tb)
+                except Exception:
+                    formatted = None
+                if formatted:
+                    details["traceback"] = self._truncate_traceback(formatted)
+        else:
+            details["error_msg"] = error_msg or ""
+
+        if isinstance(context, dict):
+            for key, value in context.items():
+                if value is not None and str(value) != "":
+                    details[key] = value
+
+        if exc_val is not None:
+            if details.get("http_status") is None:
+                status = getattr(exc_val, "status_code", None)
+                if status is None and getattr(exc_val, "response", None) is not None:
+                    status = exc_val.response.status_code
+                if status:
+                    details["http_status"] = int(status)
+
+            if not details.get("server_url") and not details.get("stream_url"):
+                url = getattr(exc_val, "url", None)
+                if url is None and getattr(exc_val, "request", None) is not None:
+                    url = exc_val.request.url
+                if url:
+                    details["server_url"] = self._host_of(url)
+
+        if not details.get("translation_mode") and not details.get("sub_type"):
+            details["translation_mode"] = self._translation_mode(details)
+
+        self._send_data("error", details)
+
+    def fetch_stats(self, limit: int = 500) -> Optional[dict]:
+        """Fetch aggregated streaming history from the remote telemetry endpoint.
+
+        Returns None if analytics are disabled, the endpoint is unreachable, or
+        no playback data is available for this device.
+        """
+        try:
+            from .settings import SettingsManager
+            settings = SettingsManager()
+            if not settings.get('analytics'):
+                return None
+        except Exception:
+            return None
+
+        try:
+            endpoint_url, auth_secret = _get_analytics_endpoint_config()
+
+            headers = {
+                'X-Auth-Key': auth_secret,
+                'User-Agent': 'AniCliAr-Monitor/1.0'
+            }
+
+            resp = requests.get(
+                f"{endpoint_url}/stats",
+                params={"fingerprint": self.user_fingerprint, "limit": limit},
+                headers=headers,
+                timeout=8,
+            )
+            if resp.status_code != 200:
+                return None
+            data = resp.json()
+            return data if isinstance(data, dict) else None
+        except Exception:
+            return None
+
+# Global instance
+monitor = MonitoringSystem()

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/ani_cli_arabic/player.py

@@ -316,6 +316,7 @@ class PlayerManager:
                 self._play_mpv(url, title, available_players['MPV'], headers, ipc_socket=ipc_socket)
             elif selected_player == 'MPC-HC':
                 self._play_mpc(url, title, available_players['MPC-HC'], headers)
+            return selected_player.lower() if selected_player else None
         except Exception as e:
             if self.console:
                 from rich.text import Text
@@ -324,6 +325,7 @@ class PlayerManager:
             else:
                 print(f"Error launching player: {str(e)}", file=sys.stderr)
                 input("Press Enter to continue...")
+            return None
 
     def _play_vlc(self, url: str, title: str, vlc_path: str = None, headers: dict = None, rc_port: Optional[int] = None):
         if not vlc_path:

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/ani_cli_arabic/scrapers/provider_manager.py

@@ -81,6 +81,13 @@ class ProviderManager:
 
         for name, scraper in self._get_ordered_providers(lang_clean, provider_clean):
             sys.stderr.write(f"[?] Attempting provider: {name}...\n")
+            context = {
+                "anime": anime_title,
+                "episode": str(episode_num),
+                "provider": name,
+                "mode": mode or "sub",
+                "translation_mode": (mode or "sub").lower(),
+            }
             try:
                 result = await asyncio.wait_for(
                     asyncio.to_thread(
@@ -95,16 +102,34 @@ class ProviderManager:
                 sys.stderr.write(f"[✗] {name} returned no stream.\n")
             except asyncio.TimeoutError:
                 sys.stderr.write(f"[✗] {name} timed out after {_PROVIDER_TIMEOUT}s.\n")
+                self._report_error(f"{name} timed out after {_PROVIDER_TIMEOUT}s", context)
             except Exception:
                 sys.stderr.write(f"[✗] {name} errored, skipping to next provider.\n")
+                self._report_error(f"{name} raised an unexpected error", context,
+                                   exc_info=sys.exc_info())
 
         if lang_clean == "english":
             sys.stderr.write(
                 f"No working English streams found for '{anime_title}' ep {episode_num}. "
                 "Please try another provider or check your network.\n"
             )
+        self._report_error(
+            "No working stream found after trying all providers",
+            {"anime": anime_title, "episode": str(episode_num), "language": lang_clean,
+             "providers": ",".join(name for name, _ in self._get_ordered_providers(lang_clean, provider_clean))},
+        )
         return None, {}, None
 
+    @staticmethod
+    def _report_error(error_msg: str, context: dict, exception: BaseException = None,
+                      exc_info: tuple = None):
+        """Report a scraper-stage failure to telemetry without blocking the caller."""
+        try:
+            from ..monitoring import monitor
+            monitor.track_error(error_msg, context, exception=exception, exc_info=exc_info)
+        except Exception:
+            pass
+
     @staticmethod
     def _try_provider(
         scraper: BaseScraper, anime_title: str, episode_num, mode: str = "sub"
@@ -113,11 +138,22 @@ class ProviderManager:
         if mode_clean not in ("sub", "dub"):
             mode_clean = "sub"
 
+        context = {
+            "anime": anime_title,
+            "episode": str(episode_num),
+            "provider": scraper.name,
+            "mode": mode_clean,
+            "translation_mode": mode_clean,
+        }
+
         try:
             results = scraper.search(anime_title)
         except Exception:
+            ProviderManager._report_error("Scraper search failed", context,
+                                          exc_info=sys.exc_info())
             return None
         if not results:
+            ProviderManager._report_error("Scraper search returned no results", context)
             return None
 
         anime_id = results[0]["id"]
@@ -127,8 +163,13 @@ class ProviderManager:
                 scraper.preferred_category = mode_clean
             eps = scraper.get_episodes(anime_id)
         except Exception:
+            ProviderManager._report_error("Scraper episode list failed",
+                                          dict(context, anime_id=str(anime_id)),
+                                          exc_info=sys.exc_info())
             return None
         if not eps:
+            ProviderManager._report_error("Scraper episode list returned no results",
+                                          dict(context, anime_id=str(anime_id)))
             return None
 
         target = str(int(float(episode_num)))
@@ -153,7 +194,12 @@ class ProviderManager:
         try:
             stream = scraper.get_stream_url(ep_id)
         except Exception:
+            ProviderManager._report_error("Scraper stream resolution failed",
+                                          dict(context, episode_id=str(ep_id)),
+                                          exc_info=sys.exc_info())
             return None
         if stream.get("stream_url"):
             return stream["stream_url"], stream.get("headers", {})
+        ProviderManager._report_error("Scraper returned no stream URL",
+                                      dict(context, episode_id=str(ep_id)))
         return None

ani_cli_ar-1.9.3/ani_cli_arabic/stats.py

@@ -0,0 +1,114 @@
+from typing import Dict, Tuple
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from .config import COLOR_BORDER
+from .history import HistoryManager
+from .monitoring import monitor
+
+
+def fetch_remote_stats(limit: int = 500):
+    """Fetch aggregated streaming history from the remote telemetry endpoint."""
+    try:
+        return monitor.fetch_stats(limit)
+    except Exception:
+        return None
+
+
+def build_local_stats() -> Dict:
+    """Build a stats summary from the local last-watched history file."""
+    items = HistoryManager().get_history()
+    total = len(items)
+    unique_titles = len({it['title'] for it in items})
+    top_titles = [
+        {"title": it['title'], "count": 1, "episode": it['episode']}
+        for it in items[:10]
+    ]
+    return {
+        "source": "local",
+        "total_plays": total,
+        "unique_titles": unique_titles,
+        "recent_7d": 0,
+        "last_played": items[0]['last_updated'] if items else None,
+        "top_titles": top_titles,
+        "by_player": {},
+        "by_provider": {},
+        "by_quality": {},
+        "note": "Local history tracks the last watched episode per anime. Enable analytics in settings for full playback stats (every video play, player, provider and quality).",
+    }
+
+
+def get_stats() -> Tuple[str, Dict]:
+    """Return (source, stats) preferring remote telemetry, falling back to local history."""
+    remote = fetch_remote_stats()
+    if remote is not None and remote.get("total_plays", 0) > 0:
+        return "remote", remote
+    return "local", build_local_stats()
+
+
+def _fmt_count(breakdown: Dict) -> str:
+    if not breakdown:
+        return "—"
+    items = sorted(breakdown.items(), key=lambda kv: kv[1], reverse=True)
+    return ", ".join(f"{k} ({v})" for k, v in items[:5])
+
+
+def render_stats() -> None:
+    source, stats = get_stats()
+    console = Console()
+
+    header = "Your Streaming History"
+
+    summary = Table.grid(expand=False)
+    summary.add_column(style="bold", justify="left")
+    summary.add_column(justify="left")
+    summary.add_row("Source:", "Remote telemetry" if source == "remote" else "Local history")
+    summary.add_row("Total plays:", str(stats.get("total_plays", 0)))
+    summary.add_row("Unique titles:", str(stats.get("unique_titles", 0)))
+    summary.add_row("Last 7 days:", str(stats.get("recent_7d", 0)))
+    last = stats.get("last_played")
+    if last:
+        try:
+            from datetime import datetime
+            dt = datetime.fromisoformat(str(last).replace("Z", "+00:00"))
+            last = dt.strftime("%Y-%m-%d %H:%M")
+        except Exception:
+            pass
+    last_title = stats.get("last_title")
+    if last_title:
+        last = f"{last_title} (ep {stats.get('last_episode') or '?'}) — {last}"
+    summary.add_row("Last played:", last or "—")
+
+    table = Table(title="Most Watched", box=None, show_header=True, header_style="bold")
+    table.add_column("#", justify="right", style="dim", width=4)
+    table.add_column("Anime")
+    table.add_column("Plays", justify="right")
+    table.add_column("Last episode", justify="right")
+    for idx, item in enumerate(stats.get("top_titles", []), start=1):
+        table.add_row(
+            str(idx),
+            str(item.get("title", "Unknown")),
+            str(item.get("count", 0)),
+            str(item.get("episode", "—")),
+        )
+
+    breakdown = Panel(
+        Text.from_markup(
+            "[bold]Player:[/] " + _fmt_count(stats.get("by_player", {})) + "\n"
+            "[bold]Provider:[/] " + _fmt_count(stats.get("by_provider", {})) + "\n"
+            "[bold]Quality:[/] " + _fmt_count(stats.get("by_quality", {}))
+        ),
+        title="Breakdown",
+        border_style=COLOR_BORDER,
+        padding=(1, 2),
+    )
+
+    note = stats.get("note")
+    if note:
+        console.print(Panel(note, border_style="dim", padding=(0, 2)))
+    console.print(Panel(summary, title=header, border_style=COLOR_BORDER, padding=(1, 2)))
+    console.print(table)
+    console.print(breakdown)

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/ani_cli_arabic/version.py

@@ -2,7 +2,7 @@
 # THIS IS THE SINGLE SOURCE OF VERSION
 # All other files (pyproject.toml, workflows, etc.) read from here
 
-__version__ = "1.9.2"
+__version__ = "1.9.3"
 
 APP_VERSION = f"v{__version__}"
 GITHUB_REPO = "np4abdou1/ani-cli-arabic"

{ani_cli_ar-1.9.2 → ani_cli_ar-1.9.3}/ani_cli_arabic/watch_together.py

@@ -672,7 +672,12 @@ class WatchGuest:
                 break
         if selected is None:
             selected = eps[0]
-        server_data = api.get_streaming_servers(anime.id, str(selected.number), anime.type)
+        ctx = {
+            "anime": title,
+            "episode": str(selected.display_num),
+            "provider": "arabic_api",
+        }
+        server_data = api.get_streaming_servers(anime.id, str(selected.number), anime.type, ctx)
         if not server_data:
             return "", {}, ""
         quality = SettingsManager().get("default_quality", "1080p")
@@ -686,7 +691,7 @@ class WatchGuest:
         if not server_id:
             return "", {}, ""
         mf_url = api.build_mediafire_url(server_id)
-        direct = api.extract_mediafire_direct(mf_url)
+        direct = api.extract_mediafire_direct(mf_url, ctx)
         return direct or "", {}, "arabic_api"
 
     def _handle_load(self, payload: dict):
@@ -697,6 +702,29 @@ class WatchGuest:
                 url, headers, provider = self._resolve_stream(payload)
             except Exception:
                 url, headers, provider = "", {}, ""
+                exc_type, exc_val, exc_tb = sys.exc_info()
+                lang = str(payload.get("language", ""))
+                if "dub" in lang.lower():
+                    mode = "dub"
+                elif "arabic" in lang.lower():
+                    mode = "arabic_sub"
+                else:
+                    mode = "sub"
+                try:
+                    from .monitoring import monitor
+                    monitor.track_error(
+                        "Guest stream resolution failed",
+                        {
+                            "anime": payload.get("title", ""),
+                            "episode": payload.get("episode", ""),
+                            "language": lang,
+                            "provider": "arabic_api" if "arabic" in lang.lower() else "",
+                            "translation_mode": mode,
+                        },
+                        exc_info=(exc_type, exc_val, exc_tb),
+                    )
+                except Exception:
+                    pass
             if not url:
                 self._pending = {}
                 return
@@ -706,6 +734,18 @@ class WatchGuest:
         threading.Thread(target=worker, daemon=True).start()
 
     def _launch_player(self, url: str, headers: Dict[str, str]):
+        self._watch_start = time.time()
+        with self._state_lock:
+            self._watch_meta = dict(self._pending)
+        try:
+            from .monitoring import monitor
+            monitor.set_activity(
+                "watching",
+                self._watch_meta.get("title", ""),
+                self._watch_meta.get("episode"),
+            )
+        except Exception:
+            pass
         if self.player_kind == "vlc":
             vlc_path = self._player.get_available_players().get("VLC") or "vlc"
             args = self._player.build_vlc_args(
@@ -737,7 +777,17 @@ class WatchGuest:
                 stdin=subprocess.DEVNULL,
             )
         except Exception:
+            exc_type, exc_val, exc_tb = sys.exc_info()
             self._player_proc = None
+            try:
+                from .monitoring import monitor
+                monitor.track_error(
+                    "Failed to launch guest player",
+                    {"player": self.player_kind, "stream_url": url},
+                    exc_info=(exc_type, exc_val, exc_tb),
+                )
+            except Exception:
+                pass
             return
         threading.Thread(target=self._watch_player_exit, daemon=True).start()
         threading.Thread(target=self._apply_pending, daemon=True).start()
@@ -751,6 +801,24 @@ class WatchGuest:
             self._ipc.close()
             self._player_proc = None
         self._player.cleanup_guest_input_conf()
+        try:
+            from .monitoring import monitor
+            monitor.set_activity("idle")
+            start = getattr(self, "_watch_start", None)
+            if start is not None:
+                meta = getattr(self, "_watch_meta", {}) or {}
+                lang = str(meta.get("language", ""))
+                from .monitoring import monitor
+                monitor.track_video_play(
+                    meta.get("title", "") or "",
+                    meta.get("episode", "") or "",
+                    player=self.player_kind,
+                    provider="arabic_api" if "arabic" in lang.lower() else "",
+                    watch_start=start,
+                    watch_end=time.time(),
+                )
+        except Exception:
+            pass
 
     def _apply_pending(self):
         if not self._ipc.connect(timeout=20.0):

ani_cli_ar-1.9.2/ani_cli_arabic/monitoring.py

@@ -1,92 +0,0 @@
-import platform
-import hashlib
-import threading
-import requests
-from datetime import datetime, timezone
-from .api import _get_analytics_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_analytics_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()