Download bot/stats.py from luci18/animebot: direct link, hf CLI and curl.
- Browser
- Download file 9.9 kB
-
https://huggingface.co/luci18/animebot/resolve/main/bot/stats.py
- Command line
-
hf download hf://luci18/animebot/bot/stats.py
-
curl -L -o stats.py https://huggingface.co/luci18/animebot/resolve/main/bot/stats.py
9.9 kB
| """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() | |