"""Statistics module for user and bot analytics.""" import logging from datetime import datetime, timedelta from typing import Dict, List, Any, Optional from collections import defaultdict from bot.database import db logger = logging.getLogger(__name__) class StatsManager: """Manage statistics for users and bot.""" def get_user_stats(self, user_id: int) -> Dict[str, Any]: """Get statistics for a specific user.""" # Get download stats total_downloads = db.downloads.count_documents({"user_id": user_id}) completed_downloads = db.downloads.count_documents( {"user_id": user_id, "status": "completed"} ) failed_downloads = db.downloads.count_documents( {"user_id": user_id, "status": "failed"} ) # Get encode stats total_encodes = db.encodes.count_documents({"user_id": user_id}) completed_encodes = db.encodes.count_documents( {"user_id": user_id, "status": "completed"} ) failed_encodes = db.encodes.count_documents( {"user_id": user_id, "status": "failed"} ) # Get recent activity (last 7 days) week_ago = datetime.utcnow() - timedelta(days=7) recent_downloads = db.downloads.count_documents({ "user_id": user_id, "created_at": {"$gte": week_ago} }) recent_encodes = db.encodes.count_documents({ "user_id": user_id, "created_at": {"$gte": week_ago} }) # Get favorite anime (most downloaded) pipeline = [ {"$match": {"user_id": user_id}}, {"$group": {"_id": "$anime_id", "count": {"$sum": 1}}}, {"$sort": {"count": -1}}, {"$limit": 5} ] favorite_anime = list(db.downloads.aggregate(pipeline)) return { "user_id": user_id, "downloads": { "total": total_downloads, "completed": completed_downloads, "failed": failed_downloads, "success_rate": self._calc_rate(completed_downloads, total_downloads), "recent_7d": recent_downloads }, "encodes": { "total": total_encodes, "completed": completed_encodes, "failed": failed_encodes, "success_rate": self._calc_rate(completed_encodes, total_encodes), "recent_7d": recent_encodes }, "favorite_anime": favorite_anime, "last_updated": datetime.utcnow() } def get_bot_stats(self) -> Dict[str, Any]: """Get overall bot statistics (admin only).""" # Total counts total_downloads = db.downloads.count_documents({}) total_encodes = db.encodes.count_documents({}) total_users = db.users.count_documents({}) # Status breakdown download_status = self._get_status_breakdown("downloads") encode_status = self._get_status_breakdown("encodes") # Activity over time (last 30 days) daily_stats = self._get_daily_stats(days=30) # Top active users top_users_pipeline = [ { "$group": { "_id": "$user_id", "downloads": {"$sum": 1} } }, {"$sort": {"downloads": -1}}, {"$limit": 10} ] top_users = list(db.downloads.aggregate(top_users_pipeline)) # Popular anime popular_anime_pipeline = [ {"$group": {"_id": "$anime_id", "downloads": {"$sum": 1}}}, {"$sort": {"downloads": -1}}, {"$limit": 10} ] popular_anime = list(db.downloads.aggregate(popular_anime_pipeline)) # Storage usage estimate storage_stats = self._estimate_storage() return { "overview": { "total_users": total_users, "total_downloads": total_downloads, "total_encodes": total_encodes, "active_downloads": download_status.get("downloading", 0), "active_encodes": encode_status.get("encoding", 0) }, "download_status": download_status, "encode_status": encode_status, "daily_activity": daily_stats, "top_users": top_users, "popular_anime": popular_anime, "storage": storage_stats, "last_updated": datetime.utcnow() } def get_leaderboard(self, period: str = "all") -> List[Dict[str, Any]]: """Get user leaderboard by activity. Args: period: "all", "week", or "month" """ match_filter = {} if period == "week": match_filter["created_at"] = { "$gte": datetime.utcnow() - timedelta(days=7) } elif period == "month": match_filter["created_at"] = { "$gte": datetime.utcnow() - timedelta(days=30) } # Combine downloads and encodes download_pipeline = [ {"$match": match_filter}, {"$group": {"_id": "$user_id", "downloads": {"$sum": 1}}} ] downloads_by_user = list(db.downloads.aggregate(download_pipeline)) encode_pipeline = [ {"$match": match_filter}, {"$group": {"_id": "$user_id", "encodes": {"$sum": 1}}} ] encodes_by_user = list(db.encodes.aggregate(encode_pipeline)) # Merge results user_scores = defaultdict(lambda: {"downloads": 0, "encodes": 0}) for item in downloads_by_user: user_scores[item["_id"]]["downloads"] = item["downloads"] for item in encodes_by_user: user_scores[item["_id"]]["encodes"] = item["encodes"] # Calculate total score and sort leaderboard = [] for user_id, scores in user_scores.items(): leaderboard.append({ "user_id": user_id, "downloads": scores["downloads"], "encodes": scores["encodes"], "total": scores["downloads"] + scores["encodes"] }) leaderboard.sort(key=lambda x: x["total"], reverse=True) return leaderboard[:20] # Top 20 def _get_status_breakdown(self, collection: str) -> Dict[str, int]: """Get status breakdown for a collection.""" coll = db.downloads if collection == "downloads" else db.encodes pipeline = [ {"$group": {"_id": "$status", "count": {"$sum": 1}}} ] results = list(coll.aggregate(pipeline)) return {item["_id"]: item["count"] for item in results} def _get_daily_stats(self, days: int = 30) -> List[Dict[str, Any]]: """Get daily activity stats.""" start_date = datetime.utcnow() - timedelta(days=days) # Daily downloads download_pipeline = [ {"$match": {"created_at": {"$gte": start_date}}}, { "$group": { "_id": { "$dateToString": {"format": "%Y-%m-%d", "date": "$created_at"} }, "count": {"$sum": 1} } }, {"$sort": {"_id": 1}} ] daily_downloads = list(db.downloads.aggregate(download_pipeline)) # Daily encodes encode_pipeline = [ {"$match": {"created_at": {"$gte": start_date}}}, { "$group": { "_id": { "$dateToString": {"format": "%Y-%m-%d", "date": "$created_at"} }, "count": {"$sum": 1} } }, {"$sort": {"_id": 1}} ] daily_encodes = list(db.encodes.aggregate(encode_pipeline)) # Merge dates = set() for d in daily_downloads + daily_encodes: dates.add(d["_id"]) result = [] for date in sorted(dates): dl_count = next((d["count"] for d in daily_downloads if d["_id"] == date), 0) enc_count = next((e["count"] for e in daily_encodes if e["_id"] == date), 0) result.append({ "date": date, "downloads": dl_count, "encodes": enc_count, "total": dl_count + enc_count }) return result def _estimate_storage(self) -> Dict[str, Any]: """Estimate storage usage (rough approximation).""" # This is a rough estimate based on average file sizes # In production, you'd want to actually scan directories avg_download_size_mb = 200 # Average anime episode avg_encode_size_mb = 150 # Average encoded file total_downloads = db.downloads.count_documents({"status": "completed"}) total_encodes = db.encodes.count_documents({"status": "completed"}) downloads_mb = total_downloads * avg_download_size_mb encodes_mb = total_encodes * avg_encode_size_mb return { "downloads_mb": downloads_mb, "encodes_mb": encodes_mb, "total_mb": downloads_mb + encodes_mb, "total_gb": round((downloads_mb + encodes_mb) / 1024, 2), "note": "Estimated based on average file sizes" } def _calc_rate(self, completed: int, total: int) -> float: """Calculate success rate percentage.""" if total == 0: return 0.0 return round((completed / total) * 100, 1) # Global instance stats_manager = StatsManager()