twisted_audio / firebase_service.py
codebydante's picture
Upload 42 files
8ce9e44 verified
Raw History Blame Contribute Delete
25.5 kB
import firebase_admin
from firebase_admin import credentials, firestore
import os
import json
import asyncio
# Variable global para el cliente de Firestore
db = None
def init_firebase():
global db
if db is not None:
return db
try:
# 1. Intentar cargar desde variable de entorno (JSON RAW)
firebase_json = os.environ.get("FIREBASE_JSON")
# 2. Si no es JSON raw, intentar ruta de archivo
if not firebase_json:
cred_path = os.environ.get("FIREBASE_CREDENTIALS", "firebase_credentials.json")
if os.path.exists(cred_path):
cred = credentials.Certificate(cred_path)
else:
print("⚠️ [Firebase] No se encontraron credenciales (FIREBASE_JSON ni archivo).")
return None
else:
# Parsear el JSON del string
try:
cred_dict = json.loads(firebase_json)
cred = credentials.Certificate(cred_dict)
except Exception as e:
print(f"❌ [Firebase] Error parseando FIREBASE_JSON: {e}")
return None
# Inicializar App
if not firebase_admin._apps:
firebase_admin.initialize_app(cred)
db = firestore.client()
print("🔥 [Firebase] Conectado exitosamente a Firestore.")
return db
except Exception as e:
print(f"❌ [Firebase] Error inicializando: {e}")
return None
# Inicializar al importar (o llamar explícitamente en main)
init_firebase()
from config import BOT_TOKEN
# Segregar cache por Bot ID para evitar conflictos al cambiar de bot
BOT_ID = BOT_TOKEN.split(":")[0] if ":" in BOT_TOKEN else "global"
CACHE_COLLECTION = f"media_cache_{BOT_ID}"
async def get_cached_file(video_id, quality):
"""
Busca en la colección del bot actual si existe el file_id.
Retorna el file_id o None.
"""
if not db: return None
try:
# Usamos el video_id como ID del documento para búsqueda rápida O(1)
doc_ref = db.collection(CACHE_COLLECTION).document(str(video_id))
loop = asyncio.get_running_loop()
# FIX: Añadir timeout de 5s para evitar hanging si Firebase falla
try:
doc = await asyncio.wait_for(loop.run_in_executor(None, doc_ref.get), timeout=5.0)
except asyncio.TimeoutError:
print(f"⚠️ [Firebase] Cache Read Timeout ({video_id}) - Saltando cache.")
return None
if doc.exists:
data = doc.to_dict()
# data estructura: {'mp3': 'file_id_1', '720': 'file_id_2', ...}
return data.get(quality)
return None
except Exception as e:
print(f"⚠️ [Firebase] Error leyendo cache: {e}")
return None
async def get_cached_data(video_id):
"""
Retorna el documento completo del cache (incluyendo meta y todos los formatos).
"""
if not db: return None
try:
doc_ref = db.collection(CACHE_COLLECTION).document(str(video_id))
loop = asyncio.get_running_loop()
doc = await loop.run_in_executor(None, doc_ref.get)
if doc.exists: return doc.to_dict()
except Exception as e:
print(f"⚠️ [Firebase] Error leyendo data cache: {e}")
return None
async def save_cached_file(video_id, quality, file_id, meta=None):
"""
Guarda o actualiza el file_id para una calidad dada.
"""
if not db: return
try:
doc_ref = db.collection(CACHE_COLLECTION).document(str(video_id))
# Usamos set con merge=True para no borrar otras calidades
update_data = {
quality: file_id,
'last_updated': firestore.SERVER_TIMESTAMP
}
if meta:
update_data['meta'] = meta # Título, duración, etc si queremos guardar info extra
loop = asyncio.get_running_loop()
await loop.run_in_executor(None, lambda: doc_ref.set(update_data, merge=True))
print(f"🔥 [Firebase] Cache guardado: {video_id} [{quality}]")
except Exception as e:
print(f"❌ [Firebase] Error guardando cache: {e}")
# --- STRICT CACHE LOGIC (URL + Quality + DocMode) ---
import hashlib
def _compute_variant_key(url, quality, is_doc):
"""Genera un hash único basado en los parámetros estrictos."""
# Eporner Direct Link Normalization:
# URL style: https://www.eporner.com/dload/VIDEO_ID/QUALITY/TOKEN-filename.mp4
# We want to key ONLY by VIDEO_ID + QUALITY to allow cache hits even if token changes.
if "eporner.com/dload/" in url:
try:
# Extract ID usually after /dload/
parts = url.split('/dload/')
if len(parts) > 1:
# Part 1 is video_id: 2pBe2ZZDqtG
vid_id_clean = parts[1].split('/')[0]
# Use this clean ID as the 'url' for the key
url = f"eporner_{vid_id_clean}"
except: pass
raw = f"{url}|{quality}|{str(is_doc).lower()}"
return hashlib.sha256(raw.encode()).hexdigest()
async def get_cached_file_strict(video_id, url, quality, is_doc):
"""
Busca una variante exacta en el documento del video.
"""
if not db: return None
try:
doc_ref = db.collection(CACHE_COLLECTION).document(str(video_id))
loop = asyncio.get_running_loop()
try:
doc = await asyncio.wait_for(loop.run_in_executor(None, doc_ref.get), timeout=5.0)
except asyncio.TimeoutError:
return None
if doc.exists:
data = doc.to_dict()
variants = data.get('variants', {})
v_key = _compute_variant_key(url, quality, is_doc)
# DEBUG
print(f"🔍 [Firebase Debug] Key: {v_key} | Variants: {list(variants.keys())}")
variant = variants.get(v_key)
if variant:
print(f"✨ [Firebase] Cache Estricto ENCONTRADO: {video_id}")
return variant.get('file_id')
return None
except Exception as e:
print(f"⚠️ [Firebase] Error leyendo cache estricto: {e}")
return None
async def save_cached_file_strict(video_id, url, quality, is_doc, file_id, meta=None):
"""
Guarda una variante estricta en el documento.
"""
if not db: return
try:
doc_ref = db.collection(CACHE_COLLECTION).document(str(video_id))
v_key = _compute_variant_key(url, quality, is_doc)
variant_data = {
'file_id': file_id,
'url': url,
'quality': quality,
'is_doc': is_doc,
'saved_at': firestore.SERVER_TIMESTAMP
}
# Validar meta
if meta and isinstance(meta, dict):
# Limpiar meta para evitar recursión o datos corruptos
safe_meta = {k: v for k, v in meta.items() if isinstance(v, (str, int, float, bool))}
variant_data['meta'] = safe_meta
# Update map inside map: {'variants': {hash: {...}}}
loop = asyncio.get_running_loop()
# 1. Leer data actual para no sobreescribir otras variantes si set(merge=True) no es suficiente para deep merges de maps
# Firestore merge de mapas reemplaza todo el mapa si no usas notación de puntos.
# FIX: Usar diccionario anidado para set(merge=True) en Python para asegurar merge correcto
update_payload = {
'variants': {
v_key: variant_data
},
'last_updated': firestore.SERVER_TIMESTAMP
}
if meta:
update_payload['global_meta'] = meta # Meta general (ej titulo) solo lo último
await loop.run_in_executor(None, lambda: doc_ref.set(update_payload, merge=True))
print(f"🔥 [Firebase] Cache Estricto Guardado: {video_id} [Q:{quality} D:{is_doc}]")
except Exception as e:
print(f"❌ [Firebase] Error guardando cache estricto: {e}")
async def delete_cached_file(video_id):
"""
Elimina un archivo del cache (útil si el link expira o es inválido).
"""
if not db: return
try:
doc_ref = db.collection(CACHE_COLLECTION).document(str(video_id))
loop = asyncio.get_running_loop()
await loop.run_in_executor(None, doc_ref.delete)
print(f"🗑 [Firebase] Cache eliminado: {video_id}")
except Exception as e:
print(f"⚠️ [Firebase] Error eliminando cache: {e}")
async def get_bot_config():
"""
Obtiene la configuración global del bot (ej: canal de backup).
Retorna un dict con las keys.
"""
if not db: return {}
try:
doc_ref = db.collection('bot_settings').document('global_config')
loop = asyncio.get_running_loop()
doc = await loop.run_in_executor(None, doc_ref.get)
if doc.exists:
return doc.to_dict()
return {}
except Exception as e:
print(f"⚠️ [Firebase] Error leyendo config global: {e}")
return {}
async def save_bot_config(key, value):
"""
Guarda una key especifica en la configuración global.
"""
if not db: return False
try:
doc_ref = db.collection('bot_settings').document('global_config')
loop = asyncio.get_running_loop()
await loop.run_in_executor(None, lambda: doc_ref.set({key: value}, merge=True))
print(f"🔥 [Firebase] Config guardada: {key} = {value}")
return True
except Exception as e:
print(f"❌ [Firebase] Error guardando config global: {e}")
return False
async def load_all_user_configs():
"""Carga todas las configs de usuarios desde Firestore."""
if not db: return {}
try:
# Ejecutar en thread pool para no bloquear
loop = asyncio.get_running_loop()
docs = await loop.run_in_executor(None, lambda: db.collection('user_configs').stream())
# Stream devuelve un generador, iterarlo puede bloquear si son muchos,
# pero es necesario para poblar la RAM inicial.
data = {}
for doc in docs:
try:
data[int(doc.id)] = doc.to_dict()
except: pass
print(f"🔥 [Firebase] Configs cargadas: {len(data)} usuarios.")
return data
except Exception as e:
print(f"⚠️ [Firebase] Config Load Error: {e}")
return {}
async def save_user_config_fb(chat_id, config_data):
"""Guarda/Actualiza la config de un usuario."""
if not db: return
try:
# Fire-and-forget sync wrapper
loop = asyncio.get_running_loop()
await loop.run_in_executor(None, lambda: db.collection('user_configs').document(str(chat_id)).set(config_data, merge=True))
except Exception as e:
print(f"❌ [Firebase] Save Config Error: {e}")
async def load_all_hashtags():
"""Carga todos los hashtags."""
if not db: return {}
try:
loop = asyncio.get_running_loop()
docs = await loop.run_in_executor(None, lambda: db.collection('hashtags').stream())
data = {}
for doc in docs:
data[doc.id] = doc.to_dict().get('msgs', [])
print(f"🔥 [Firebase] Hashtags cargados: {len(data)} tags.")
return data
except Exception as e:
print(f"⚠️ [Firebase] Tags Load Error: {e}")
return {}
async def save_hashtag_fb(tag, msgs_list):
if not db: return
try:
loop = asyncio.get_running_loop()
await loop.run_in_executor(None, lambda: db.collection('hashtags').document(tag).set({'msgs': msgs_list}, merge=True))
except Exception as e:
print(f"❌ [Firebase] Save Tag Error: {e}")
async def register_user(user_id, first_name, username):
"""
Registra al usuario, cuenta el total y detecta cambio de nombre.
Retorna: (is_new, count, name_changed)
"""
if not db: return (False, 0, False) # Fallback
try:
# Referencias
user_ref = db.collection('user_configs').document(str(user_id))
stats_ref = db.collection('bot_settings').document('stats')
# Ejecutar transacción (pseudo-transacción para simplificar en async wrapper)
# Nota: Firestore async de python no soporta transactions con await facil dentro de lambda
# Haremos una logica optimista/separada por simplicidad y velocidad
# 1. Obtener User
loop = asyncio.get_running_loop()
doc = await loop.run_in_executor(None, user_ref.get)
if not doc.exists:
# --- NUEVO USUARIO ---
# 1. Incrementar contador global
try:
# Lectura + Escritura (Riesgo bajo de colision en low traffic)
st_doc = await loop.run_in_executor(None, stats_ref.get)
current_count = st_doc.to_dict().get('user_count', 0) if st_doc.exists else 0
new_count = current_count + 1
await loop.run_in_executor(None, lambda: stats_ref.set({'user_count': new_count}, merge=True))
except:
new_count = 1 # Fallback
# 2. Guardar Usuario
user_data = {
'first_name': first_name,
'username': username,
'joined_at': firestore.SERVER_TIMESTAMP,
'user_id': user_id
}
await loop.run_in_executor(None, lambda: user_ref.set(user_data, merge=True))
return (True, new_count, False)
else:
# --- USUARIO EXISTENTE ---
data = doc.to_dict()
old_name = data.get('first_name', '')
# Detectar cambio de nombre
if old_name != first_name:
await loop.run_in_executor(None, lambda: user_ref.set({'first_name': first_name, 'username': username}, merge=True))
return (False, 0, True)
return (False, 0, False)
except Exception as e:
print(f"⚠️ [Firebase] Register Error: {e}")
return (False, 0, False)
async def get_global_stats():
"""Retorna el diccionario de stats (ej: user_count)."""
if not db: return {}
try:
doc_ref = db.collection('bot_settings').document('stats')
loop = asyncio.get_running_loop()
doc = await loop.run_in_executor(None, doc_ref.get)
if doc.exists: return doc.to_dict()
return {}
except: return {}
# --- USER RULES (Memoria a largo plazo) ---
async def get_user_rules_fb(user_id, persona_id="nsfw"):
"""Retorna la lista de reglas de un usuario para una personalidad específica."""
if not db: return []
try:
doc_ref = db.collection('user_rules').document(str(user_id))
loop = asyncio.get_running_loop()
doc = await loop.run_in_executor(None, doc_ref.get)
if doc.exists:
data = doc.to_dict()
# MIGRATION CHECK: If 'rules' is at top level, it's legacy
if 'rules' in data and isinstance(data['rules'], list):
# Assume legacy rules belong to 'nsfw' or default
legacy = data.pop('rules')
if 'nsfw' not in data: data['nsfw'] = {'rules': legacy}
else: data['nsfw']['rules'].extend(legacy)
# Save migration async
await loop.run_in_executor(None, lambda: doc_ref.set(data, merge=True))
# Retrieve persona rules
p_data = data.get(persona_id, {})
return p_data.get('rules', [])
return []
except Exception as e:
print(f"⚠️ [Firebase] Error leyendo reglas ({persona_id}): {e}")
return []
async def save_user_rule_fb(user_id, rule_text, action="add", persona_id="nsfw"):
"""Guarda, elimina o limpia reglas de un usuario (Scoped by Persona)."""
if not db: return False
try:
doc_ref = db.collection('user_rules').document(str(user_id))
loop = asyncio.get_running_loop()
# Leemos primero para modificar la lista
doc = await loop.run_in_executor(None, doc_ref.get)
data = doc.to_dict() if doc.exists else {}
# MIGRATION ON SAVE
if 'rules' in data and isinstance(data['rules'], list):
legacy = data.pop('rules')
if 'nsfw' not in data: data['nsfw'] = {'rules': legacy}
else: data['nsfw']['rules'].extend(legacy)
# Get target list
if persona_id not in data: data[persona_id] = {'rules': []}
current_rules = data[persona_id].get('rules', [])
changed = False
if action == "add":
if rule_text not in current_rules:
current_rules.append(rule_text)
changed = True
elif action == "remove":
# Loose match or exact? Exact for now
if rule_text in current_rules:
current_rules = [r for r in current_rules if r != rule_text]
changed = True
elif action == "clear":
current_rules = []
changed = True
if changed:
data[persona_id]['rules'] = current_rules
await loop.run_in_executor(None, lambda: doc_ref.set(data, merge=True))
print(f"🔥 [Firebase] Reglas actualizadas user {user_id} [{persona_id}]: {action}")
return True
return True
except Exception as e:
print(f"❌ [Firebase] Error guardando regla ({persona_id}): {e}")
return False
# --- GLOBAL PERSONAS (SHARED) ---
async def save_global_persona(pid, data):
"""Guarda una personalidad global (Nombre, Prompt, Imágenes)."""
if not db: return
try:
# Use a separate collection for scalable global personas
doc_ref = db.collection('global_personas').document(str(pid))
loop = asyncio.get_running_loop()
await loop.run_in_executor(None, lambda: doc_ref.set(data, merge=True))
print(f"🌍 [Firebase] Personalidad Global Guardada: {pid}")
except Exception as e:
print(f"❌ [Firebase] Error guardando global persona: {e}")
async def get_all_global_personas():
"""Retorna todas las personalidades globales {pid: data}."""
if not db: return {}
try:
loop = asyncio.get_running_loop()
docs = await loop.run_in_executor(None, lambda: db.collection('global_personas').stream())
data = {}
for doc in docs:
data[doc.id] = doc.to_dict()
return data
except Exception as e:
print(f"⚠️ [Firebase] Global Personas Load Error: {e}")
return {}
async def delete_global_persona_fb(pid):
"""Elimina una personalidad global."""
if not db: return
try:
doc_ref = db.collection('global_personas').document(str(pid))
loop = asyncio.get_running_loop()
await loop.run_in_executor(None, doc_ref.delete)
print(f"🗑 [Firebase] Personalidad Global Eliminada: {pid}")
except Exception as e:
print(f"❌ [Firebase] Error eliminando global persona: {e}")
# --- CLOUD BODY (AVATARS) ---
async def save_persona_image(persona_id, outfit_id, emotion_id, file_id):
"""
Guarda un File ID de Telegram en la colección de avatares.
Estructura: avatars/{persona_id} -> {outfit_id}: {emotion_id: [file_ids]}
"""
if not db: return False
try:
doc_ref = db.collection('avatars').document(str(persona_id))
loop = asyncio.get_running_loop()
doc = await loop.run_in_executor(None, doc_ref.get)
data = doc.to_dict() if doc.exists else {}
# Estructura profunda: data[outfit][emotion] = list
if outfit_id not in data: data[outfit_id] = {}
if emotion_id not in data[outfit_id]: data[outfit_id][emotion_id] = []
# Evitar duplicados exactos
if file_id not in data[outfit_id][emotion_id]:
data[outfit_id][emotion_id].append(file_id)
# Guardar
await loop.run_in_executor(None, lambda: doc_ref.set(data, merge=True))
print(f"🔥 [Firebase] Avatar Saved: {persona_id}/{outfit_id}/{emotion_id}")
return True
return True # Ya existía
except Exception as e:
print(f"❌ [Firebase] Avatar Save Error: {e}")
return False
async def get_persona_images(persona_id, outfit_id, emotion_id):
"""
Retorna la lista de File IDs para una combinación específica.
"""
if not db: return []
try:
doc_ref = db.collection('avatars').document(str(persona_id))
loop = asyncio.get_running_loop()
doc = await loop.run_in_executor(None, doc_ref.get)
if doc.exists:
data = doc.to_dict()
outfit_data = data.get(outfit_id, {})
images = outfit_data.get(emotion_id, [])
return images
return []
except Exception as e:
print(f"⚠️ [Firebase] Avatar Read Error: {e}")
return []
async def get_all_avatars(persona_id):
"""Retorna toda la estructura de avatares de una persona."""
if not db: return {}
try:
doc_ref = db.collection('avatars').document(str(persona_id))
loop = asyncio.get_running_loop()
doc = await loop.run_in_executor(None, doc_ref.get)
return doc.to_dict() if doc.exists else {}
except: return {}
async def delete_persona_image(persona_id, outfit_id, emotion_id, file_id_target):
"""
Elimina una imagen específica (por file_id) de la lista.
file_id_target puede ser string o dict {'id':...}
"""
if not db: return False
try:
doc_ref = db.collection('avatars').document(str(persona_id))
loop = asyncio.get_running_loop()
doc = await loop.run_in_executor(None, doc_ref.get)
if not doc.exists: return False
data = doc.to_dict()
if outfit_id not in data or emotion_id not in data[outfit_id]:
return False
current_list = data[outfit_id][emotion_id]
# Filtrar
new_list = []
found = False
target_str = file_id_target
if isinstance(file_id_target, dict): target_str = file_id_target.get('id')
for item in current_list:
item_id = item
if isinstance(item, dict): item_id = item.get('id')
if item_id == target_str:
found = True
else:
new_list.append(item)
if found:
data[outfit_id][emotion_id] = new_list
await loop.run_in_executor(None, lambda: doc_ref.set(data))
print(f"🗑 [Firebase] Avatar Deleted: {target_str}")
return True
return False
except Exception as e:
print(f"❌ [Firebase] Avatar Delete Error: {e}")
return False
# --- VIRAL SHORTS PERSISTENCE ---
async def save_viral_item_fb(item):
"""Guarda un item viral en la colección 'viral_shorts'."""
if not db: return False
try:
# Usa el ID del item como ID del documento
doc_ref = db.collection('viral_shorts').document(str(item['id']))
loop = asyncio.get_running_loop()
await loop.run_in_executor(None, lambda: doc_ref.set(item, merge=True))
print(f"🔥 [Firebase] Viral Item Saved: {item['id']}")
return True
except Exception as e:
print(f"❌ [Firebase] Viral Save Error: {e}")
return False
async def delete_viral_item_fb(item_id):
"""Elimina un item viral de la colección."""
if not db: return False
try:
doc_ref = db.collection('viral_shorts').document(str(item_id))
loop = asyncio.get_running_loop()
await loop.run_in_executor(None, doc_ref.delete)
print(f"🗑 [Firebase] Viral Item Deleted: {item_id}")
return True
except Exception as e:
print(f"❌ [Firebase] Viral Delete Error: {e}")
return False
async def load_all_viral_items_fb():
"""Carga todos los items virales en una lista."""
if not db: return []
try:
loop = asyncio.get_running_loop()
docs = await loop.run_in_executor(None, lambda: db.collection('viral_shorts').stream())
items = []
for doc in docs:
try:
items.append(doc.to_dict())
except: pass
print(f"🔥 [Firebase] Viral Items Loaded: {len(items)}")
return items
except Exception as e:
print(f"⚠️ [Firebase] Viral Load Error: {e}")
return []