ollama.py

"""Integración con Ollama LLM local para análisis inteligente del mercado.

Ollama corre en el mismo servidor (localhost:11434) con GPU RTX 3070 Ti.
Solo un modelo en GPU a la vez (8GB VRAM).
Si Ollama no está disponible, todas las funciones retornan None gracefully.
"""
import hashlib
import logging
import time
from typing import Optional

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

from config import OLLAMA_URL, OLLAMA_MODEL_FAST, OLLAMA_MODEL_REASONING, OLLAMA_TIMEOUT

logger = logging.getLogger(__name__)

# --- Response cache ---
_cache: dict[str, tuple[float, str]] = {}
CACHE_TTL = 900  # 15 minutos

# --- Circuit breaker ---
_circuit_open = False
_circuit_open_since = 0.0
CIRCUIT_RESET_SECONDS = 300  # 5 min antes de reintentar

# --- Connection pool ---
_session: Optional[requests.Session] = None


def _get_session() -> requests.Session:
    """Session con connection pooling y reintentos."""
    global _session
    if _session is None:
        _session = requests.Session()
        retry = Retry(total=2, backoff_factor=0.5, status_forcelist=[502, 503, 504])
        adapter = HTTPAdapter(max_retries=retry, pool_connections=2, pool_maxsize=4)
        _session.mount("http://", adapter)
    return _session


def _is_available() -> bool:
    """Comprueba si Ollama está disponible (respeta circuit breaker)."""
    global _circuit_open, _circuit_open_since

    if _circuit_open:
        if time.time() - _circuit_open_since < CIRCUIT_RESET_SECONDS:
            return False
        # Intentar reconectar
        _circuit_open = False

    try:
        resp = _get_session().get(f"{OLLAMA_URL}/api/tags", timeout=3)
        return resp.status_code == 200
    except Exception:
        _circuit_open = True
        _circuit_open_since = time.time()
        return False


def _cache_key(prompt: str, model: str) -> str:
    return hashlib.md5((model + prompt).encode()).hexdigest()


def _get_cached(key: str) -> Optional[str]:
    if key in _cache:
        ts, response = _cache[key]
        if time.time() - ts < CACHE_TTL:
            return response
        del _cache[key]
    return None


def _set_cached(key: str, response: str):
    _cache[key] = (time.time(), response)
    # Limitar cache a 100 entradas
    if len(_cache) > 100:
        oldest = min(_cache, key=lambda k: _cache[k][0])
        del _cache[oldest]


def generate(prompt: str, model: str = None, timeout: int = None) -> Optional[str]:
    """Genera texto con Ollama. Retorna None si no disponible."""
    global _circuit_open, _circuit_open_since

    model = model or OLLAMA_MODEL_FAST
    timeout = timeout or OLLAMA_TIMEOUT

    key = _cache_key(prompt, model)
    cached = _get_cached(key)
    if cached:
        return cached

    if not _is_available():
        return None

    try:
        resp = _get_session().post(
            f"{OLLAMA_URL}/api/generate",
            json={"model": model, "prompt": prompt, "stream": False},
            timeout=timeout,
        )
        resp.raise_for_status()
        text = resp.json().get("response", "").strip()
        if text:
            _set_cached(key, text)
            return text
        return None
    except Exception as e:
        logger.warning(f"Ollama error ({model}): {e}")
        _circuit_open = True
        _circuit_open_since = time.time()
        return None


def analyze_should_buy(
    ticker: str, score: int, reasons_pro: list, reasons_con: list,
    ml_prob: float, trend: str, rsi: float, sentiment: str
) -> Optional[str]:
    """Análisis narrativo para la decisión de compra. Usa modelo de razonamiento."""
    pros = "\n".join(f"  - {r}" for r in reasons_pro) or "  (ninguna)"
    cons = "\n".join(f"  - {r}" for r in reasons_con) or "  (ninguna)"

    prompt = (
        f"Eres un asesor financiero que explica las cosas de forma sencilla a alguien "
        f"sin experiencia en bolsa. Nada de jerga técnica. Habla como si le explicaras "
        f"a un amigo si merece la pena invertir en esta empresa.\n\n"
        f"Empresa: {ticker}\n"
        f"Puntuación general: {score} (positivo = buena oportunidad, negativo = mala)\n"
        f"Probabilidad de subida según IA: {ml_prob:.0%}\n"
        f"La acción está: {trend}\n"
        f"¿Está cara o barata? RSI {rsi:.0f} (por encima de 70 = cara, por debajo de 30 = barata)\n\n"
        f"Puntos a favor:\n{pros}\n\n"
        f"Puntos en contra:\n{cons}\n\n"
        f"Noticias: {sentiment}\n\n"
        f"Explica en 2-3 párrafos cortos y claros:\n"
        f"1. ¿Qué está pasando con esta empresa?\n"
        f"2. ¿Es buen momento para comprar? ¿Por qué sí o por qué no?\n"
        f"3. ¿Qué riesgos hay?\n\n"
        f"Usa lenguaje cotidiano. Nada de siglas ni indicadores técnicos. "
        f"Máximo 3 párrafos cortos."
    )
    return generate(prompt, model=OLLAMA_MODEL_REASONING, timeout=45)


def analyze_sentiment_headlines(ticker: str, headlines: list[dict]) -> Optional[str]:
    """Análisis de sentimiento profundo a partir de titulares. Usa modelo rápido."""
    if not headlines:
        return None

    titles = "\n".join(
        f"  {i+1}. {h.get('title', 'Sin título')}"
        for i, h in enumerate(headlines[:5])
    )
    prompt = (
        f"Eres un analista financiero. Analiza estas noticias sobre {ticker} "
        f"y determina el sentimiento general en 1 párrafo en español. Sé conciso.\n\n"
        f"Noticias:\n{titles}\n\n"
        f"¿El sentimiento es alcista, bajista o neutral? ¿Por qué? Máximo 3 frases."
    )
    return generate(prompt, model=OLLAMA_MODEL_FAST)


def summarize_signal(
    ticker: str, action: str, score: float, strategy: str, reasons: list[str]
) -> Optional[str]:
    """Resumen de 1 línea para notificaciones de scan. Usa modelo rápido."""
    reasons_text = "; ".join(reasons[:3])
    prompt = (
        f"Resume en UNA sola frase en español por qué {action} {ticker} es interesante ahora. "
        f"Score: {score:.1f}/10. Estrategia: {strategy}. Razones: {reasons_text}. "
        f"Solo una frase, máximo 100 caracteres."
    )
    result = generate(prompt, model=OLLAMA_MODEL_FAST, timeout=15)
    if result and len(result) > 200:
        result = result[:200].rsplit(" ", 1)[0] + "..."
    return result


def generate_premarket_briefing(
    regime: str, calendar_events: list, spy_change: float, vix: float
) -> Optional[str]:
    """Briefing pre-mercado. Usa modelo de razonamiento."""
    events_text = "\n".join(
        f"  - {e.get('event', e) if isinstance(e, dict) else str(e)}"
        for e in (calendar_events or [])[:5]
    ) or "  Sin eventos relevantes"

    prompt = (
        f"Eres un analista de mercados. Genera un briefing pre-mercado breve en español.\n\n"
        f"Régimen actual: {regime}\n"
        f"SPY cambio overnight: {'+' if spy_change >= 0 else ''}{spy_change:.1f}%\n"
        f"VIX: {vix:.1f}\n\n"
        f"Eventos económicos hoy:\n{events_text}\n\n"
        f"Genera un briefing de 2-3 párrafos cortos: qué esperar, sectores clave, "
        f"qué vigilar. Sé directo y práctico."
    )
    return generate(prompt, model=OLLAMA_MODEL_REASONING, timeout=45)


def enhance_daily_summary(
    positions_summary: str, daily_pnl: float, win_rate: float, regime: str
) -> Optional[str]:
    """Resumen diario narrativo. Usa modelo de razonamiento."""
    pnl_sign = "+" if daily_pnl >= 0 else ""
    prompt = (
        f"Eres un analista financiero personal. Resume el día de trading en 2 párrafos "
        f"en español.\n\n"
        f"Posiciones:\n{positions_summary}\n\n"
        f"P&L del día: {pnl_sign}{daily_pnl:.2f}€\n"
        f"Win rate global: {win_rate:.0%}\n"
        f"Régimen de mercado: {regime}\n\n"
        f"Resume qué pasó, qué salió bien/mal, y qué vigilar mañana. Sé breve y directo."
    )
    return generate(prompt, model=OLLAMA_MODEL_REASONING, timeout=45)


def analyze_earnings_call(ticker: str, transcript_text: str) -> Optional[str]:
    """Analiza una transcripción de earnings call. Usa modelo de razonamiento.

    Busca: tono del management, sorpresas, cambios de estrategia, señales.
    """
    # Truncar transcripción para que quepa en contexto del modelo
    max_chars = 6000
    if len(transcript_text) > max_chars:
        transcript_text = transcript_text[:max_chars] + "\n[...truncado]"

    prompt = (
        f"Eres un analista financiero experto. Analiza esta transcripción de earnings call "
        f"de {ticker} y genera un análisis en español.\n\n"
        f"TRANSCRIPCIÓN (extracto):\n{transcript_text}\n\n"
        f"Responde con:\n"
        f"1. Resumen ejecutivo en 2-3 frases\n"
        f"2. Señal: BULLISH, BEARISH o NEUTRAL (con 1 frase de justificación)\n"
        f"3. Confianza: HIGH, MEDIUM o LOW\n"
        f"4. Tono del management (optimista, cauteloso, confiado, evasivo)\n"
        f"5. Puntos clave (3-5 bullets con -)\n\n"
        f"Sé directo y práctico. Máximo 200 palabras."
    )
    return generate(prompt, model=OLLAMA_MODEL_REASONING, timeout=60)


def extract_guidance(ticker: str, transcript_text: str) -> Optional[str]:
    """Extrae guidance forward-looking de la transcripción. Usa modelo de razonamiento."""
    max_chars = 6000
    if len(transcript_text) > max_chars:
        transcript_text = transcript_text[:max_chars] + "\n[...truncado]"

    prompt = (
        f"Eres un analista financiero. Extrae SOLO la guidance forward-looking "
        f"de esta transcripción de earnings call de {ticker}.\n\n"
        f"TRANSCRIPCIÓN (extracto):\n{transcript_text}\n\n"
        f"Responde con:\n"
        f"1. Guidance de revenue/ingresos (si mencionan proyecciones)\n"
        f"2. Guidance de EPS/beneficios (si mencionan proyecciones)\n"
        f"3. Outlook general: RAISED, MAINTAINED, LOWERED o UNKNOWN\n"
        f"4. Detalles relevantes en 2-3 frases\n\n"
        f"Si no hay guidance clara, di 'No se menciona guidance específica'.\n"
        f"Sé breve. Máximo 150 palabras."
    )
    return generate(prompt, model=OLLAMA_MODEL_REASONING, timeout=60)


def get_status() -> dict:
    """Estado del servicio Ollama."""
    available = _is_available()
    return {
        "available": available,
        "circuit_open": _circuit_open,
        "cache_size": len(_cache),
        "model_fast": OLLAMA_MODEL_FAST,
        "model_reasoning": OLLAMA_MODEL_REASONING,
        "url": OLLAMA_URL,
    }