KudoBot / bot /database.py
saske560's picture
Upload 11 files
4a456cc verified
Raw History Blame Contribute Delete
39.9 kB
from __future__ import annotations
import asyncio
import hashlib
import json
from copy import deepcopy
from datetime import datetime, timedelta, timezone
from pathlib import Path
from typing import Any
from .mongo_store import MongoSnapshotStore
from .permissions import AccessProfile, synthetic_plan
from .utils import iso_now, normalize_text, score_match, today_key, to_item_id
class JsonDatabase:
def __init__(
self,
path: Path,
owner_ids: list[int] | None = None,
storage_chat_ids: list[int] | None = None,
*,
mongodb_uri: str = "",
mongodb_db_name: str = "media_archive_bot",
mongodb_collection: str = "snapshots",
mongodb_server_selection_timeout_ms: int = 5000,
) -> None:
self.path = path
self.owner_ids = sorted({int(x) for x in (owner_ids or [])})
self.default_storage_chat_ids = sorted({int(x) for x in (storage_chat_ids or [])})
self._lock = asyncio.Lock()
self.mongo = MongoSnapshotStore(
mongodb_uri,
mongodb_db_name,
mongodb_collection,
server_selection_timeout_ms=mongodb_server_selection_timeout_ms,
)
self.path.parent.mkdir(parents=True, exist_ok=True)
if not self.path.exists():
self._bootstrap()
local_data = self._read_sync() if self.path.exists() else None
merged = self.mongo.merge_prefer_latest(local_data) if self.mongo.enabled else local_data
if merged:
self._write_sync(merged, sync_mongo=False)
if self.mongo.enabled:
self.mongo.save_snapshot(merged)
def _bootstrap(self) -> None:
now = iso_now()
base = {
"meta": {"schema_version": 3, "created_at": now, "updated_at": now},
"config": {
"maintenance": False,
"storage_chat_ids": self.default_storage_chat_ids,
"not_found_chat_id": None,
"legal_notice": "Usa este bot solo con archivos que te pertenezcan o que tengas derecho a distribuir.",
"ai_enabled": False,
"db_backend": "json+mongo" if self.mongo.enabled else "json",
},
"plans_catalog": {
"free": {
"name": "Free",
"emoji": "🆓",
"daily_search_limit": 30,
"daily_download_limit": 8,
"favorites_limit": 0,
"priority": 0,
},
"vip": {
"name": "VIP",
"emoji": "💎",
"daily_search_limit": 200,
"daily_download_limit": 60,
"favorites_limit": 200,
"priority": 1,
},
"premium": {
"name": "Premium",
"emoji": "👑",
"daily_search_limit": 999999,
"daily_download_limit": 999999,
"favorites_limit": 1000,
"priority": 2,
},
},
"admins": self.owner_ids,
"users": {},
"library": {},
"requests": [],
"audit": [],
}
self._write_sync(base)
def _normalize_sync(self, data: dict[str, Any]) -> dict[str, Any]:
now_iso = iso_now()
data.setdefault("meta", {})
data["meta"].setdefault("schema_version", 3)
data["meta"].setdefault("created_at", now_iso)
data["meta"].setdefault("updated_at", now_iso)
config = data.setdefault("config", {})
config.setdefault("maintenance", False)
config.setdefault("storage_chat_ids", [])
config.setdefault("not_found_chat_id", None)
config.setdefault("ai_enabled", False)
config.setdefault("db_backend", "json+mongo" if self.mongo.enabled else "json")
storage_ids = {int(x) for x in config.get("storage_chat_ids", [])} | set(self.default_storage_chat_ids)
config["storage_chat_ids"] = sorted(storage_ids)
if config.get("not_found_chat_id") not in (None, ""):
config["not_found_chat_id"] = int(config["not_found_chat_id"])
plans = data.setdefault("plans_catalog", {})
free = plans.setdefault("free", {})
free.setdefault("name", "Free")
free.setdefault("emoji", "🆓")
free.setdefault("daily_search_limit", 30)
free.setdefault("daily_download_limit", 8)
free.setdefault("favorites_limit", 0)
free.setdefault("priority", 0)
vip = plans.setdefault("vip", {})
vip.setdefault("name", "VIP")
vip.setdefault("emoji", "💎")
vip.setdefault("daily_search_limit", 200)
vip.setdefault("daily_download_limit", 60)
vip.setdefault("favorites_limit", 200)
vip.setdefault("priority", 1)
premium = plans.setdefault("premium", {})
premium.setdefault("name", "Premium")
premium.setdefault("emoji", "👑")
premium.setdefault("daily_search_limit", 999999)
premium.setdefault("daily_download_limit", 999999)
premium.setdefault("favorites_limit", 1000)
premium.setdefault("priority", 2)
data.setdefault("users", {})
data.setdefault("library", {})
data.setdefault("requests", [])
requests = []
for req in data.get("requests", []):
if not isinstance(req, dict):
continue
req.setdefault("id", hashlib.sha1(f"{req.get('query', '')}:{req.get('created_at', now_iso)}".encode("utf-8")).hexdigest()[:10])
req.setdefault("query", "")
req.setdefault("normalized_query", normalize_text(req.get("query")))
req.setdefault("status", "open")
req.setdefault("count", 1)
req.setdefault("source", "manual")
req.setdefault("created_at", now_iso)
req.setdefault("last_requested_at", req.get("created_at", now_iso))
requesters = []
seen_requesters = set()
for requester in req.get("requesters", []):
if not isinstance(requester, dict):
continue
rid = int(requester.get("id") or 0)
if rid and rid in seen_requesters:
continue
if rid:
seen_requesters.add(rid)
requester["id"] = rid
requester.setdefault("first_name", "")
requester.setdefault("username", "")
requester.setdefault("requested_at", req.get("created_at", now_iso))
requesters.append(requester)
req["requesters"] = requesters
requests.append(req)
data["requests"] = requests[-5000:]
admins = {int(x) for x in data.get("admins", [])} | set(self.owner_ids)
data["admins"] = sorted(admins)
now = datetime.now(timezone.utc)
for record in data["users"].values():
record.setdefault("favorites", [])
record.setdefault("stats", {})
stats = record["stats"]
stats.setdefault("searches_total", 0)
stats.setdefault("downloads_total", 0)
stats.setdefault("searches_today", 0)
stats.setdefault("downloads_today", 0)
stats.setdefault("last_search_date", today_key())
stats.setdefault("last_download_date", today_key())
record.setdefault("downloads", [])
record.setdefault("plan", "free")
record.setdefault("plan_expires_at", None)
record.setdefault("notes", "")
expires = record.get("plan_expires_at")
if expires:
try:
expires_dt = datetime.fromisoformat(expires)
if expires_dt.tzinfo is None:
expires_dt = expires_dt.replace(tzinfo=timezone.utc)
if expires_dt <= now:
record["plan"] = "free"
record["plan_expires_at"] = None
except ValueError:
record["plan_expires_at"] = None
return data
def _read_sync(self) -> dict[str, Any]:
if not self.path.exists():
self._bootstrap()
with self.path.open("r", encoding="utf-8") as handle:
data = json.load(handle)
return self._normalize_sync(data)
def _write_sync(self, data: dict[str, Any], *, sync_mongo: bool = True) -> None:
data["meta"]["updated_at"] = iso_now()
temp = self.path.with_suffix(".tmp")
with temp.open("w", encoding="utf-8") as handle:
json.dump(data, handle, ensure_ascii=False, indent=2)
temp.replace(self.path)
if sync_mongo and self.mongo.enabled:
self.mongo.save_snapshot(data)
async def read(self) -> dict[str, Any]:
async with self._lock:
return deepcopy(self._read_sync())
async def write(self, data: dict[str, Any]) -> None:
async with self._lock:
self._write_sync(data)
async def mutate(self, callback):
async with self._lock:
data = self._normalize_sync(self._read_sync())
result = callback(data)
self._write_sync(data)
return result
async def get_backend_info(self) -> dict[str, Any]:
return {
"json_path": str(self.path),
"mongo": self.mongo.info(),
}
async def ensure_user(self, user) -> dict[str, Any]:
user_id = str(user.id)
def _mut(data: dict[str, Any]):
users = data.setdefault("users", {})
if user_id not in users:
users[user_id] = {
"id": user.id,
"first_name": user.first_name or "",
"last_name": user.last_name or "",
"username": user.username or "",
"joined_at": iso_now(),
"last_seen_at": iso_now(),
"plan": "free",
"plan_expires_at": None,
"banned": False,
"notes": "",
"favorites": [],
"downloads": [],
"stats": {
"searches_total": 0,
"downloads_total": 0,
"searches_today": 0,
"downloads_today": 0,
"last_search_date": today_key(),
"last_download_date": today_key(),
},
}
record = users[user_id]
record["first_name"] = user.first_name or record.get("first_name", "")
record["last_name"] = user.last_name or record.get("last_name", "")
record["username"] = user.username or record.get("username", "")
record["last_seen_at"] = iso_now()
return deepcopy(record)
return await self.mutate(_mut)
async def get_user(self, user_id: int) -> dict[str, Any] | None:
data = await self.read()
user = data.get("users", {}).get(str(user_id))
return deepcopy(user) if user else None
async def is_owner(self, user_id: int) -> bool:
return int(user_id) in set(self.owner_ids)
async def is_admin(self, user_id: int) -> bool:
data = await self.read()
return int(user_id) in {int(x) for x in data.get("admins", [])} or int(user_id) in self.owner_ids
async def is_banned(self, user_id: int) -> bool:
record = await self.get_user(user_id)
return bool(record and record.get("banned"))
async def get_maintenance(self) -> bool:
data = await self.read()
return bool(data.get("config", {}).get("maintenance", False))
async def set_maintenance(self, actor_id: int, value: bool) -> None:
def _mut(data: dict[str, Any]):
data.setdefault("config", {})["maintenance"] = value
await self.mutate(_mut)
await self.add_audit(actor_id, "set_maintenance", {"value": value})
async def list_admin_ids(self) -> list[int]:
data = await self.read()
return sorted({int(x) for x in data.get("admins", [])} | set(self.owner_ids))
async def add_admin(self, actor_id: int, target_id: int) -> None:
if actor_id not in self.owner_ids:
raise PermissionError("Solo el owner puede agregar admins.")
def _mut(data: dict[str, Any]):
admins = {int(x) for x in data.get("admins", [])}
admins.add(int(target_id))
data["admins"] = sorted(admins | set(self.owner_ids))
await self.mutate(_mut)
await self.add_audit(actor_id, "add_admin", {"target_id": target_id})
async def remove_admin(self, actor_id: int, target_id: int) -> None:
if actor_id not in self.owner_ids:
raise PermissionError("Solo el owner puede quitar admins.")
if int(target_id) in self.owner_ids:
raise PermissionError("No se puede quitar un owner.")
def _mut(data: dict[str, Any]):
admins = {int(x) for x in data.get("admins", [])}
admins.discard(int(target_id))
data["admins"] = sorted(admins | set(self.owner_ids))
await self.mutate(_mut)
await self.add_audit(actor_id, "remove_admin", {"target_id": target_id})
async def set_ban(self, actor_id: int, target_id: int, value: bool) -> None:
def _mut(data: dict[str, Any]):
user = data.get("users", {}).get(str(target_id))
if not user:
raise KeyError("Usuario no encontrado en la base")
user["banned"] = value
await self.mutate(_mut)
await self.add_audit(actor_id, "set_ban", {"target_id": target_id, "value": value})
async def get_plan_catalog(self) -> dict[str, Any]:
data = await self.read()
return deepcopy(data.get("plans_catalog", {}))
async def create_plan(self, actor_id: int, key: str, name: str, daily_search_limit: int, daily_download_limit: int, favorites_limit: int, emoji: str = "⭐") -> None:
key = normalize_text(key).replace(" ", "_")
if not key:
raise ValueError("Clave de plan inválida.")
def _mut(data: dict[str, Any]):
plans = data.setdefault("plans_catalog", {})
priority = max((int(v.get("priority", 0)) for v in plans.values()), default=0) + 1
plans[key] = {
"name": name,
"emoji": emoji,
"daily_search_limit": int(daily_search_limit),
"daily_download_limit": int(daily_download_limit),
"favorites_limit": int(favorites_limit),
"priority": priority,
}
await self.mutate(_mut)
await self.add_audit(actor_id, "create_plan", {"plan": key})
async def delete_plan(self, actor_id: int, key: str) -> None:
key = normalize_text(key).replace(" ", "_")
if key in {"free", "vip", "premium"}:
raise PermissionError("No puedes borrar planes base.")
def _mut(data: dict[str, Any]):
plans = data.setdefault("plans_catalog", {})
if key not in plans:
raise KeyError("Plan no existe")
del plans[key]
for user in data.get("users", {}).values():
if user.get("plan") == key:
user["plan"] = "free"
user["plan_expires_at"] = None
await self.mutate(_mut)
await self.add_audit(actor_id, "delete_plan", {"plan": key})
async def get_access_profile(self, user_id: int) -> AccessProfile:
data = await self.read()
user = data.get("users", {}).get(str(user_id))
plans = data.get("plans_catalog", {})
admins = {int(x) for x in data.get("admins", [])} | set(self.owner_ids)
if int(user_id) in self.owner_ids:
plan = synthetic_plan("owner")
return AccessProfile(
role="owner",
plan_key="owner",
plan=plan,
unlimited=True,
protect_content=False,
can_favorites=True,
can_admin=True,
)
if int(user_id) in admins:
plan = synthetic_plan("admin")
return AccessProfile(
role="admin",
plan_key="admin",
plan=plan,
unlimited=True,
protect_content=False,
can_favorites=True,
can_admin=True,
)
plan_key = (user or {}).get("plan", "free")
plan = deepcopy(plans.get(plan_key, plans.get("free", {})))
return AccessProfile(
role="user",
plan_key=plan_key,
plan=plan,
unlimited=False,
protect_content=(plan_key == "free"),
can_favorites=(plan_key != "free"),
can_admin=False,
)
async def get_user_plan_data(self, user_id: int) -> tuple[str, dict[str, Any], dict[str, Any] | None]:
data = await self.read()
user = data.get("users", {}).get(str(user_id))
access = await self.get_access_profile(user_id)
return access.plan_key, deepcopy(access.plan), deepcopy(user) if user else None
async def can_use_favorites(self, user_id: int) -> bool:
access = await self.get_access_profile(user_id)
return access.can_favorites
async def set_user_plan(self, actor_id: int, target_id: int, plan_key: str, days: int | None = None) -> None:
plan_key = normalize_text(plan_key).replace(" ", "_")
def _mut(data: dict[str, Any]):
plans = data.setdefault("plans_catalog", {})
if plan_key not in plans:
raise KeyError("Plan no existe")
users = data.setdefault("users", {})
user = users.get(str(target_id))
if not user:
raise KeyError("Usuario no encontrado en la base")
user["plan"] = plan_key
if days and days > 0:
user["plan_expires_at"] = (datetime.now(timezone.utc) + timedelta(days=days)).isoformat()
else:
user["plan_expires_at"] = None
await self.mutate(_mut)
await self.add_audit(actor_id, "set_plan", {"target_id": target_id, "plan": plan_key, "days": days})
async def _daily_allowance(self, user_id: int, kind: str) -> tuple[bool, int, int]:
data = await self.read()
user = data.get("users", {}).get(str(user_id), {})
access = await self.get_access_profile(user_id)
plan = access.plan
stats = user.get("stats", {})
today = today_key()
if kind == "search":
last_key = "last_search_date"
today_key_name = "searches_today"
limit_key = "daily_search_limit"
else:
last_key = "last_download_date"
today_key_name = "downloads_today"
limit_key = "daily_download_limit"
count = int(stats.get(today_key_name, 0)) if stats.get(last_key) == today else 0
limit = int(plan.get(limit_key, 0))
if access.unlimited:
return True, count, limit
return count < limit, count, limit
async def can_search(self, user_id: int) -> tuple[bool, int, int]:
return await self._daily_allowance(user_id, "search")
async def can_download(self, user_id: int) -> tuple[bool, int, int]:
return await self._daily_allowance(user_id, "download")
async def _increment_counter(self, user_id: int, kind: str) -> None:
user_id_str = str(user_id)
def _mut(data: dict[str, Any]):
user = data["users"][user_id_str]
stats = user.setdefault("stats", {})
today = today_key()
last_key = f"last_{kind}_date"
if kind == "search":
today_key_name = "searches_today"
total_key = "searches_total"
else:
today_key_name = "downloads_today"
total_key = "downloads_total"
if stats.get(last_key) != today:
stats[today_key_name] = 0
stats[last_key] = today
stats[total_key] = int(stats.get(total_key, 0)) + 1
stats[today_key_name] = int(stats.get(today_key_name, 0)) + 1
await self.mutate(_mut)
async def increment_search(self, user_id: int) -> None:
await self._increment_counter(user_id, "search")
async def increment_download(self, user_id: int) -> None:
await self._increment_counter(user_id, "download")
async def toggle_favorite(self, user_id: int, item_id: str) -> tuple[str, int]:
def _mut(data: dict[str, Any]):
user = data.get("users", {}).get(str(user_id))
if not user:
raise KeyError("Usuario no encontrado")
favorites = user.setdefault("favorites", [])
if item_id in favorites:
favorites.remove(item_id)
return "removed", len(favorites)
plan_key = user.get("plan", "free")
if plan_key == "free":
return "upgrade", len(favorites)
plans = data.get("plans_catalog", {})
plan = plans.get(plan_key, plans.get("free", {}))
limit = int(plan.get("favorites_limit", 25))
if len(favorites) >= limit:
return "limit", len(favorites)
favorites.append(item_id)
return "added", len(favorites)
return await self.mutate(_mut)
async def get_favorites(self, user_id: int) -> list[dict[str, Any]]:
data = await self.read()
user = data.get("users", {}).get(str(user_id), {})
library = data.get("library", {})
results = []
for item_id in user.get("favorites", []):
item = library.get(item_id)
if item:
results.append(deepcopy(item))
return results
async def add_download_log(self, user_id: int, item_id: str) -> None:
def _mut(data: dict[str, Any]):
user = data.get("users", {}).get(str(user_id))
if not user:
return
downloads = user.setdefault("downloads", [])
downloads.append({"item_id": item_id, "at": iso_now()})
if len(downloads) > 50:
del downloads[:-50]
await self.mutate(_mut)
async def get_recent_downloads(self, user_id: int) -> list[dict[str, Any]]:
data = await self.read()
user = data.get("users", {}).get(str(user_id), {})
library = data.get("library", {})
results = []
for event in reversed(user.get("downloads", [])[-20:]):
item = library.get(event.get("item_id"))
if item:
enriched = deepcopy(item)
enriched["downloaded_at"] = event.get("at")
results.append(enriched)
return results
async def export_copy(self, export_dir: Path) -> Path:
export_dir.mkdir(parents=True, exist_ok=True)
target = export_dir / f"database_export_{today_key()}.json"
data = await self.read()
with target.open("w", encoding="utf-8") as handle:
json.dump(data, handle, ensure_ascii=False, indent=2)
return target
async def import_from_path(self, path: Path, actor_id: int) -> None:
with path.open("r", encoding="utf-8") as handle:
incoming = json.load(handle)
incoming = self._normalize_sync(incoming)
incoming["admins"] = sorted({int(x) for x in incoming.get("admins", [])} | set(self.owner_ids))
incoming.setdefault("config", {}).setdefault("storage_chat_ids", [])
incoming["config"]["storage_chat_ids"] = sorted(
{int(x) for x in incoming["config"].get("storage_chat_ids", [])} | set(self.default_storage_chat_ids)
)
await self.write(incoming)
await self.add_audit(actor_id, "import_db", {"path": str(path)})
async def get_storage_chat_ids(self) -> list[int]:
data = await self.read()
return [int(x) for x in data.get("config", {}).get("storage_chat_ids", [])]
async def add_storage_chat(self, actor_id: int, chat_id: int) -> None:
def _mut(data: dict[str, Any]):
config = data.setdefault("config", {})
values = {int(x) for x in config.get("storage_chat_ids", [])}
values.add(int(chat_id))
config["storage_chat_ids"] = sorted(values)
await self.mutate(_mut)
await self.add_audit(actor_id, "add_storage_chat", {"chat_id": chat_id})
async def remove_storage_chat(self, actor_id: int, chat_id: int) -> None:
if int(chat_id) in self.default_storage_chat_ids:
raise PermissionError("Ese chat viene fijado por entorno y no se puede quitar desde el bot.")
def _mut(data: dict[str, Any]):
config = data.setdefault("config", {})
values = {int(x) for x in config.get("storage_chat_ids", [])}
values.discard(int(chat_id))
config["storage_chat_ids"] = sorted(values)
await self.mutate(_mut)
await self.add_audit(actor_id, "remove_storage_chat", {"chat_id": chat_id})
async def get_not_found_chat_id(self) -> int | None:
data = await self.read()
value = data.get("config", {}).get("not_found_chat_id")
return int(value) if value not in (None, "") else None
async def set_not_found_chat(self, actor_id: int, chat_id: int | None) -> None:
def _mut(data: dict[str, Any]):
config = data.setdefault("config", {})
config["not_found_chat_id"] = int(chat_id) if chat_id not in (None, "") else None
await self.mutate(_mut)
await self.add_audit(actor_id, "set_not_found_chat", {"chat_id": chat_id})
async def upsert_library_item(self, actor_id: int | None, item: dict[str, Any]) -> dict[str, Any]:
item = deepcopy(item)
item_id = to_item_id(int(item["chat_id"]), int(item["message_id"]))
item["item_id"] = item_id
item["indexed_at"] = iso_now()
item["search_blob"] = item.get("search_blob") or ""
item["normalized_title"] = item.get("normalized_title") or normalize_text(item.get("title"))
def _mut(data: dict[str, Any]):
library = data.setdefault("library", {})
item["created_at"] = library.get(item_id, {}).get("created_at", iso_now())
library[item_id] = item
return deepcopy(item)
stored = await self.mutate(_mut)
if actor_id is not None:
await self.add_audit(actor_id, "upsert_library_item", {"item_id": item_id, "title": item.get("title")})
return stored
async def remove_library_item(self, actor_id: int | None, chat_id: int, message_id: int) -> None:
item_id = to_item_id(chat_id, message_id)
def _mut(data: dict[str, Any]):
data.setdefault("library", {}).pop(item_id, None)
for user in data.get("users", {}).values():
if item_id in user.get("favorites", []):
user["favorites"] = [x for x in user.get("favorites", []) if x != item_id]
await self.mutate(_mut)
if actor_id is not None:
await self.add_audit(actor_id, "remove_library_item", {"item_id": item_id})
async def get_library_item(self, item_id: str) -> dict[str, Any] | None:
data = await self.read()
item = data.get("library", {}).get(item_id)
return deepcopy(item) if item else None
async def list_library_items(self) -> list[dict[str, Any]]:
data = await self.read()
items = list(data.get("library", {}).values())
return sorted((deepcopy(x) for x in items), key=lambda item: (item.get("normalized_title", ""), item.get("season") or 0, item.get("episode") or 0, item.get("part") or 0))
async def search_library(self, query: str, limit: int = 80) -> list[dict[str, Any]]:
data = await self.read()
items = list(data.get("library", {}).values())
ranked = []
for item in items:
score = score_match(query, item.get("search_blob", ""), item.get("title", ""))
if score > 20:
ranked.append((score, item))
ranked.sort(key=lambda pair: (pair[0], pair[1].get("indexed_at", "")), reverse=True)
return [deepcopy(item) for _, item in ranked[:limit]]
def _group_key_for_item(self, item: dict[str, Any]) -> str:
return "|".join([
item.get("content_type") or "movie",
item.get("category") or item.get("content_type") or "movie",
item.get("normalized_title") or normalize_text(item.get("title")),
str(item.get("year") or ""),
])
def _group_items(self, items: list[dict[str, Any]], *, score_query: str | None = None) -> list[dict[str, Any]]:
grouped: dict[str, dict[str, Any]] = {}
for item in items:
group_key = self._group_key_for_item(item)
bucket = grouped.setdefault(group_key, {
"group_key": group_key,
"title": item.get("title") or "Sin título",
"normalized_title": item.get("normalized_title") or normalize_text(item.get("title")),
"content_type": item.get("content_type") or "movie",
"category": item.get("category") or item.get("content_type") or "movie",
"year": item.get("year"),
"quality": item.get("quality"),
"language": item.get("language"),
"language_flag": item.get("language_flag"),
"items": [],
"best_score": 0.0,
"total_items": 0,
"seasons": set(),
"episodes_count": 0,
"parts": set(),
"total_size": 0,
"downloads_total": 0,
})
score = score_match(score_query or item.get("title", ""), item.get("search_blob", ""), item.get("title", "")) if score_query else 0.0
bucket["best_score"] = max(bucket["best_score"], score)
bucket["items"].append(item)
bucket["total_items"] += 1
bucket["total_size"] += int(item.get("file_size") or 0)
bucket["downloads_total"] += int(item.get("downloads_count") or 0)
if item.get("season") is not None:
bucket["seasons"].add(int(item.get("season") or 1))
if item.get("episode") is not None:
bucket["episodes_count"] += 1
if item.get("part") is not None:
bucket["parts"].add(int(item["part"]))
groups = []
for bucket in grouped.values():
bucket["items"].sort(key=lambda it: (
int(it.get("season") or 0),
int(it.get("episode") or 0),
int(it.get("part") or 0),
it.get("indexed_at", ""),
))
bucket["seasons"] = sorted(bucket["seasons"])
bucket["parts"] = sorted(bucket["parts"])
groups.append(bucket)
return groups
async def search_library_groups(self, query: str, limit_items: int = 160, limit_groups: int = 40) -> list[dict[str, Any]]:
results = await self.search_library(query, limit=limit_items)
groups = self._group_items(results, score_query=query)
groups.sort(key=lambda group: (group["best_score"], group["total_items"]), reverse=True)
return [deepcopy(group) for group in groups[:limit_groups]]
async def catalog_groups(self, kind: str = "all", limit_groups: int = 500) -> list[dict[str, Any]]:
data = await self.read()
items = list(data.get("library", {}).values())
kind = normalize_text(kind or "all")
filtered: list[dict[str, Any]] = []
for item in items:
category = item.get("category") or item.get("content_type") or "movie"
content_type = item.get("content_type") or "movie"
if kind in {"all", "catalogo"}:
pass
elif kind in {"movies", "peliculas", "pelicula", "movie"} and content_type != "movie":
continue
elif kind in {"series", "serie"} and content_type != "series":
continue
elif kind == "anime" and category != "anime":
continue
filtered.append(item)
groups = self._group_items(filtered)
groups.sort(key=lambda group: (group.get("normalized_title", ""), group.get("year") or 0))
return [deepcopy(group) for group in groups[:limit_groups]]
async def get_group_items(self, group_key: str) -> list[dict[str, Any]]:
data = await self.read()
library = data.get("library", {})
parts = group_key.split("|", 3)
while len(parts) < 4:
parts.append("")
content_type, category, normalized_title, year_text = parts
year_value = int(year_text) if year_text.isdigit() else None
results = []
for item in library.values():
if (item.get("content_type") or "movie") != content_type:
continue
if (item.get("category") or item.get("content_type") or "movie") != category:
continue
if (item.get("normalized_title") or normalize_text(item.get("title"))) != normalized_title:
continue
if (item.get("year") or None) != year_value:
continue
results.append(deepcopy(item))
results.sort(key=lambda it: (
int(it.get("season") or 0),
int(it.get("episode") or 0),
int(it.get("part") or 0),
it.get("indexed_at", ""),
))
return results
async def bump_item_downloads(self, item_id: str, amount: int = 1) -> None:
def _mut(data: dict[str, Any]):
item = data.get("library", {}).get(item_id)
if not item:
return
item["downloads_count"] = int(item.get("downloads_count") or 0) + int(amount)
await self.mutate(_mut)
async def add_missing_request(self, user, query: str, *, source: str = "manual") -> dict[str, Any]:
query = " ".join((query or "").split()).strip()
if not query:
raise ValueError("Petición vacía")
normalized = normalize_text(query)
if not normalized:
raise ValueError("Petición inválida")
def _mut(data: dict[str, Any]):
requests = data.setdefault("requests", [])
now_iso = iso_now()
requester = {
"id": int(user.id),
"first_name": user.first_name or "",
"username": user.username or "",
"requested_at": now_iso,
}
existing = None
for req in requests:
if req.get("normalized_query") == normalized and req.get("status", "open") == "open":
existing = req
break
if existing is None:
request_id = hashlib.sha1(f"{normalized}:{now_iso}".encode("utf-8")).hexdigest()[:10]
existing = {
"id": request_id,
"query": query,
"normalized_query": normalized,
"status": "open",
"count": 0,
"source": source,
"created_at": now_iso,
"last_requested_at": now_iso,
"requesters": [],
}
requests.append(existing)
existing["last_requested_at"] = now_iso
existing["count"] = int(existing.get("count") or 0) + 1
requesters = existing.setdefault("requesters", [])
requester_ids = {int(item.get("id") or 0) for item in requesters if isinstance(item, dict)}
if int(user.id) not in requester_ids:
requesters.append(requester)
else:
for item in requesters:
if int(item.get("id") or 0) == int(user.id):
item["requested_at"] = now_iso
item["first_name"] = user.first_name or item.get("first_name", "")
item["username"] = user.username or item.get("username", "")
break
if len(requests) > 5000:
del requests[:-5000]
return deepcopy(existing)
request = await self.mutate(_mut)
await self.add_audit(int(user.id), "add_missing_request", {"request_id": request.get("id"), "query": query, "source": source})
return request
async def list_recent_requests(self, limit: int = 20) -> list[dict[str, Any]]:
data = await self.read()
requests = list(data.get("requests", []))
requests.sort(key=lambda item: item.get("last_requested_at", item.get("created_at", "")), reverse=True)
return [deepcopy(item) for item in requests[:limit]]
async def get_stats(self) -> dict[str, Any]:
data = await self.read()
users = data.get("users", {})
library = data.get("library", {})
requests = data.get("requests", [])
requests_open = sum(1 for req in requests if req.get("status", "open") == "open")
plans_count: dict[str, int] = {}
searches = 0
downloads = 0
banned = 0
admins_set = {int(x) for x in data.get("admins", [])} | set(self.owner_ids)
for user_id_str, user in users.items():
user_id = int(user_id_str)
if user_id in self.owner_ids:
plan_key = "owner"
elif user_id in admins_set:
plan_key = "admin"
else:
plan_key = user.get("plan", "free")
plans_count[plan_key] = plans_count.get(plan_key, 0) + 1
stats = user.get("stats", {})
searches += int(stats.get("searches_total", 0))
downloads += int(stats.get("downloads_total", 0))
banned += 1 if user.get("banned") else 0
return {
"users": len(users),
"admins": len(set(data.get("admins", [])) | set(self.owner_ids)),
"banned": banned,
"library_items": len(library),
"storage_chats": len(data.get("config", {}).get("storage_chat_ids", [])),
"not_found_chat_id": data.get("config", {}).get("not_found_chat_id"),
"searches": searches,
"downloads": downloads,
"requests_total": len(requests),
"requests_open": requests_open,
"maintenance": bool(data.get("config", {}).get("maintenance", False)),
"plans": plans_count,
"ai_enabled": bool(data.get("config", {}).get("ai_enabled", False)),
"db_backend": data.get("config", {}).get("db_backend", "json+mongo" if self.mongo.enabled else "json"),
"mongo_enabled": self.mongo.enabled,
"mongo_ready": self.mongo.ready,
"mongo_last_error": self.mongo.last_error,
}
async def add_audit(self, actor_id: int, action: str, payload: dict[str, Any] | None = None) -> None:
payload = payload or {}
def _mut(data: dict[str, Any]):
audit = data.setdefault("audit", [])
audit.append({"at": iso_now(), "actor_id": actor_id, "action": action, "payload": payload})
if len(audit) > 1000:
del audit[:-1000]
await self.mutate(_mut)