animebot / bot /stats.py
luci18's picture
Re-upload fresh bot files
7cb306b verified
Raw History Blame Contribute Delete
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()