De Script Caótico a App de IA

import json
import logging
from datetime import datetime, timezone
from pathlib import Path
from dataclasses import dataclass, field

import tiktoken

logger = logging.getLogger(__name__)

PRECIOS: dict[str, dict[str, float]] = {
"gpt-4o-mini": {"input": 0.15, "output": 0.60},
"gpt-4o": {"input": 2.50, "output": 10.00},
"gpt-4.1-mini": {"input": 0.40, "output": 1.60},
"gpt-4.1-nano": {"input": 0.10, "output": 0.40},
}

@dataclass
class LlamadaRegistro:
timestamp: str
modelo: str
tokens_input: int
tokens_output: int
costo_usd: float
prompt_nombre: str = ""

@dataclass
class CostTracker:

presupuesto_mensual_usd: float = 5.0
archivo_log: Path = field(default_factory=lambda: Path("costos_log.json"))
_registros: list[LlamadaRegistro] = field(default_factory=list)

def __post_init__(self):
self._cargar_registros()

def verificar_presupuesto(self):
disponible = self.presupuesto_mensual_usd - self.gasto_mes_actual()
if disponible <= 0:
raise PresupuestoExcedido(
f"Presupuesto mensual agotado. "
f"Gastado: ${self.gasto_mes_actual():.4f} / "
f"${self.presupuesto_mensual_usd:.2f}"
)
logger.info("Presupuesto disponible: $%.4f", disponible)

def registrar_llamada(
self,
modelo: str,
tokens_input: int,
tokens_output: int,
prompt_nombre: str = "",
) -> float:
costo = self._calcular_costo(modelo, tokens_input, tokens_output)

registro = LlamadaRegistro(
timestamp=datetime.now(timezone.utc).isoformat(),
modelo=modelo,
tokens_input=tokens_input,
tokens_output=tokens_output,
costo_usd=costo,
prompt_nombre=prompt_nombre,
)

self._registros.append(registro)
self._guardar_registros()

logger.info(
"Costo: $%.6f | Tokens: %d in / %d out | Total mes: $%.4f",
costo, tokens_input, tokens_output, self.gasto_mes_actual(),
)

return costo

def gasto_mes_actual(self) -> float:
mes = datetime.now(timezone.utc).strftime("%Y-%m")
return sum(r.costo_usd for r in self._registros if r.timestamp.startswith(mes))

def _calcular_costo(self, modelo: str, tokens_input: int, tokens_output: int) -> float:
precios = PRECIOS.get(modelo, PRECIOS["gpt-4o-mini"])
return (
(tokens_input / 1_000_000) * precios["input"] +
(tokens_output / 1_000_000) * precios["output"]
)

def _cargar_registros(self):
if self.archivo_log.exists():
data = json.loads(self.archivo_log.read_text(encoding="utf-8"))
self._registros = [LlamadaRegistro(**r) for r in data]

def _guardar_registros(self):
self.archivo_log.write_text(
json.dumps([r.__dict__ for r in self._registros], indent=2, ensure_ascii=False),
encoding="utf-8",
)

def resumen(self) -> str:
gasto = self.gasto_mes_actual()
total_llamadas = len([
r for r in self._registros
if r.timestamp.startswith(datetime.now(timezone.utc).strftime("%Y-%m"))
])
return (
f"📊 Resumen mes actual\n"
f" Llamadas: {total_llamadas}\n"
f" Gastado: ${gasto:.4f}\n"
f" Disponible: ${self.presupuesto_mensual_usd - gasto:.4f}\n"
f" Presupuesto: ${self.presupuesto_mensual_usd:.2f}"
)

def contar_tokens(texto: str, modelo: str = "gpt-4o-mini") -> int:
"""Cuenta tokens localmente antes de hacer la llamada, con tiktoken."""
try:
encoding = tiktoken.encoding_for_model(modelo)
except KeyError:
encoding = tiktoken.get_encoding("cl100k_base")
return len(encoding.encode(texto))

class PresupuestoExcedido(Exception):
pass