Update modules/contexto.py

modules/contexto.py

@@ -1,315 +1,94 @@
 """
-API wrapper for Akira service - VERSÃO FINAL INDESTRUTÍVEL
-- Proteção TOTAL contra JSON malformado
-- data SEMPRE dict → NUNCA MAIS 'str' object has no attribute 'get'
-- Gírias REMOVIDAS do prompt/retorno
-- Simples, rápido, inquebrável
+Contexto de conversa por usuário
+================================
+- Memória afetiva
+- Análise de emoção (retorna str)
+- Gírias aprendidas (sempre lista de dict)
+- Integração com banco
+- SEM MÉTODOS INEXISTENTES
 """
-from typing import Any, Dict, Optional
-import time
-import re
-import datetime
-import random
 import json
-from flask import Flask, Blueprint, request, jsonify
+from typing import List, Tuple, Dict
 from loguru import logger
 import modules.config as config
-from .contexto import Contexto
-from .database import Database
-from .treinamento import Treinamento
-from .web_search import WebSearch
-from .local_llm import LlamaLLM
-
-# Verifica disponibilidade
-try:
-    from mistralai import Mistral
-    mistral_available = True
-except ImportError:
-    mistral_available = False
-    logger.warning("mistralai não instalado")
-
-try:
-    import google.generativeai as genai
-    gemini_available = True
-except ImportError:
-    gemini_available = False
-    logger.warning("google-generativeai não instalado")
-
-
-class LLMManager:
-    def __init__(self, config):
-        self.config = config
-        self.llama = LlamaLLM()
-        self.mistral_client = None
-        self.gemini_model = None
-        self._setup_providers()
-
-    def _setup_providers(self):
-        if mistral_available and self.config.MISTRAL_API_KEY:
-            try:
-                self.mistral_client = Mistral(api_key=self.config.MISTRAL_API_KEY)
-                logger.info("Mistral API inicializado (principal)")
-            except Exception as e:
-                logger.warning(f"Mistral falhou: {e}")
-                self.mistral_client = None
-
-        if gemini_available and self.config.GEMINI_API_KEY:
-            try:
-                genai.configure(api_key=self.config.GEMINI_API_KEY)
-                self.gemini_model = genai.GenerativeModel(self.config.GEMINI_MODEL)
-                logger.info("Gemini inicializado (fallback)")
-            except Exception as e:
-                logger.warning(f"Gemini falhou: {e}")
-                self.gemini_model = None
-
-    def _limpar_resposta(self, texto: str) -> str:
-        if not texto:
-            return ""
-        texto = re.sub(r'[\*\_\`\[\]\"\<\>]', '', texto)
-        texto = re.sub(r'\s+', ' ', texto.replace('\n', ' ')).strip()
-        if len(texto) > 280:
-            frases = [f.strip() for f in texto.split('. ') if f.strip()]
-            curto = ""
-            for f in frases:
-                if len(curto + f + ". ") <= 280:
-                    curto += f + ". "
-                else:
-                    break
-            texto = curto.strip()
-            if not texto.endswith(('.', '!', '?')):
-                texto += "..."
-        return texto.strip()
-
-    def generate(self, prompt: str, max_tokens: int = 500, temperature: float = 0.8) -> str:
-        max_attempts = 6
-        for attempt in range(1, max_attempts + 1):
-            if self.mistral_client:
-                try:
-                    resp = self.mistral_client.chat.complete(
-                        model=self.config.MISTRAL_MODEL,
-                        messages=[{"role": "user", "content": prompt}],
-                        max_tokens=max_tokens,
-                        temperature=temperature,
-                        top_p=self.config.TOP_P,
-                    )
-                    text = resp.choices[0].message.content
-                    if text:
-                        logger.info(f"Mistral OK (tentativa {attempt})")
-                        return self._limpar_resposta(text)
-                except Exception as e:
-                    if "401" in str(e) or "Unauthorized" in str(e):
-                        logger.error("MISTRAL: Chave inválida!")
-                    elif "429" in str(e):
-                        time.sleep(2 ** (attempt % 3))
-                    logger.warning(f"Mistral erro {attempt}: {e}")
-
-            if self.llama.model:
-                try:
-                    resp = self.llama.generate(prompt, max_tokens)
-                    if resp.strip():
-                        logger.info(f"Llama OK (tentativa {attempt})")
-                        return self._limpar_resposta(resp)
-                except Exception as e:
-                    logger.warning(f"Llama erro {attempt}: {e}")
-
-            if self.gemini_model:
-                try:
-                    resp = self.gemini_model.generate_content(
-                        prompt,
-                        generation_config={
-                            "max_output_tokens": max_tokens,
-                            "temperature": temperature,
-                            "top_p": self.config.TOP_P,
-                        }
-                    )
-                    text = resp.text
-                    if text:
-                        logger.info(f"Gemini OK (tentativa {attempt})")
-                        return self._limpar_resposta(text)
-                except Exception as e:
-                    if "429" in str(e) or "quota" in str(e):
-                        time.sleep(2 ** (attempt % 3))
-                    logger.warning(f"Gemini erro {attempt}: {e}")
-
-        logger.error("Todos LLMs falharam")
-        return self.config.FALLBACK_RESPONSE
-
-
-class AkiraAPI:
-    def __init__(self, cfg_module):
-        self.config = cfg_module
-        self.app = Flask(__name__)
-        self.api = Blueprint("akira_api", __name__)
-        self.db = Database(getattr(self.config, 'DB_PATH', '/app/data/akira.db'))
-        self.contexto_cache = {}
-        self.providers = LLMManager(self.config)
-        self.treinador = Treinamento(self.db)
-        self.web_search = WebSearch()
-        self._setup_routes()
-
-        # REGISTRO DUPLO COM NOMES ÚNICOS → SEM CONFLITO
-        self.app.register_blueprint(self.api, url_prefix="/api", name="akira_api_prefixed")
-        self.app.register_blueprint(self.api, url_prefix="", name="akira_api_root")
-
-        if getattr(self.config, 'START_PERIODIC_TRAINER', False):
-            self.treinador.start_periodic_training()
-
-    def _get_user_context(self, usuario: str, numero: str) -> Contexto:
-        key = numero or usuario
-        if key not in self.contexto_cache:
-            # RETIFICAÇÃO FINAL: Contexto(db, user_key=key)
-            ctx = Contexto(self.db, user_key=key)
-            ctx.atualizar_aprendizados_do_banco()
-            self.contexto_cache[key] = ctx
-        return self.contexto_cache[key]
-
-    def _get_pronomes_por_tom(self, tom: str) -> str:
-        result = self.db._execute_with_retry(
-            "SELECT pronomes FROM pronomes_por_tom WHERE tom=?", (tom.lower(),)
-        )
-        return result[0][0] if result else ""
-
-    def _build_prompt(self, usuario: str, numero: str, mensagem: str, emocao: str,
-                      contexto: Contexto, is_privileged: bool, is_reply: bool, mensagem_original: str) -> str:
-        data_hora = datetime.datetime.now().strftime("%d/%m/%Y %H:%M")
-        noticias = self.web_search.pesquisar_noticias_angola()
-        tom_usuario = contexto.ton_predominante or "neutro"
-        pronomes = self._get_pronomes_por_tom(tom_usuario)
-
-        strict = f"""
-REGRAS OBRIGATÓRIAS:
-- FALE COMO GENTE, NUNCA COMO IA
-- 1-2 FRASES CURTAS
-- GÍRIAS: bué, fixe, puto, oroh, mwangolé, kota
-- SARCASMO OK
-- USE kkk, rsrs, aff
-- SEM markdown, negrito
-- USE NOME ~40% DAS VEZES
-- DATA: {data_hora}
-# NOTÍCIAS ANGOLA:
-{noticias}
-# PRONOMES ({tom_usuario}):
-{pronomes}
-# EMOÇÃO ATUAL:
-{emocao}
-"""
-        if is_privileged:
-            strict += "- TOM FORMAL COM ISAAC: Sr., boss, maior\n"
-        else:
-            strict += "- TOM NORMAL: fala de Luanda\n"
-
-        hist = contexto.obter_historico()[-3:]
-        hist_txt = "\n".join([f"U: {h[0]}\nA: {h[1]}" for h in hist]) if hist else ""
-
-        user_info = f"""
-USUÁRIO:
-- Nome: {usuario}
-- Número: {numero}
-- Tom: {tom_usuario}
-- Privilégio: {'sim' if is_privileged else 'não'}
-"""
-
-        prompt = f"[SYSTEM]\n{strict}\n{self.config.SYSTEM_PROMPT}\n{self.config.PERSONA}\n[/SYSTEM]\n"
-        prompt += f"[CONTEXTO]\n{hist_txt}\n{user_info}\n[/CONTEXTO]\n"
-        prompt += f"[MENSAGEM]\n{mensagem}\n[/MENSAGEM]\nAkira:"
-        return prompt
-
-    def _setup_routes(self):
-        @self.api.route('/akira', methods=['POST'])
-        @self.api.route('/', methods=['POST'])
-        def akira_endpoint():
-            try:
-                # --- PROTEÇÃO JSON + EXTRAÇÃO ---
-                raw_data = request.get_data(as_text=True)
-                data = {}
-
-                try:
-                    data = request.get_json(force=True, silent=True) or {}
-                except Exception as e:
-                    logger.warning(f"Erro ao parsear JSON: {e}")
-
-                if isinstance(data, str):
-                    try:
-                        data = json.loads(data)
-                    except Exception as e:
-                        logger.warning(f"Erro ao json.loads(string): {e}")
-                        data = {}
-
-                if not isinstance(data, dict):
-                    data = {}
-
-                if not data:
-                    logger.warning(f"Corpo vazio: {raw_data[:200]}")
-
-                usuario = data.get('usuario', 'anonimo') if isinstance(data, dict) else 'anonimo'
-                numero = data.get('numero', '') if isinstance(data, dict) else ''
-                mensagem = data.get('mensagem', '') if isinstance(data, dict) else ''
-                is_privileged = (usuario.lower() == 'isaac' or '244937035662' in numero)
-                is_reply = bool(data.get('is_reply') or data.get('mensagem_original')) if isinstance(data, dict) else False
-                mensagem_original = (data.get('mensagem_original') or data.get('quoted_message') or '') if isinstance(data, dict) else ''
-
-                if not mensagem.strip():
-                    return jsonify({'error': 'mensagem obrigatória'}), 400
-
-                logger.info(f"{usuario} ({numero}): {mensagem[:120]}")
-
-                # --- PROCESSAMENTO ---
-                contexto = self._get_user_context(usuario, numero)
-                emocao = contexto.analisar_emocoes_mensagem(mensagem)
-                prompt = self._build_prompt(usuario, numero, mensagem, emocao, contexto, is_privileged, is_reply, mensagem_original)
-                resposta = self.providers.generate(prompt, max_tokens=500, temperature=0.8)
-
-                if random.random() < getattr(self.config, 'USAR_NOME_PROBABILIDADE', 0.4):
-                    if random.random() < 0.5:
-                        resposta = f"{usuario}, {resposta.lower()}"
-                    else:
-                        resposta = f"{resposta} {usuario}"
-
-                # --- ATUALIZAÇÃO ---
-                contexto.atualizar_contexto(mensagem, resposta)
-                self.treinador.registrar_interacao(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
-
-                # --- RETORNO BLINDADO ---
+from .database import Database  # IMPORT CORRETO: database.py
+
+class Contexto:
+    def __init__(self, db: Database, user_key: str):
+        self.db = db
+        self.user_key = user_key
+        self.historico: List[Tuple[str, str]] = []
+        self.emocao_atual: str = config.HUMOR_INICIAL
+        self.termo_contexto: List[str] = []
+        self.girias_aprendidas: List[Dict[str, str]] = []
+        self.ton_predominante: str = "neutro"
+        self._carregar_do_banco()
+
+    def _carregar_do_banco(self):
+        try:
+            dados = self.db.carregar_contexto(self.user_key)
+            if dados:
+                self.historico = json.loads(dados.get("historico", "[]"))
+                self.emocao_atual = dados.get("emocao_atual", config.HUMOR_INICIAL)
+                self.termo_contexto = json.loads(dados.get("termos", "[]"))
+                girias_raw = dados.get("girias", "[]")
                 try:
-                    termo_contexto = contexto.termo_contexto
-                    if isinstance(termo_contexto, str):
-                        try:
-                            termo_contexto = json.loads(termo_contexto)
-                        except:
-                            termo_contexto = []
-                    if not isinstance(termo_contexto, list):
-                        termo_contexto = []
-
-                    girias_lista = getattr(contexto, 'girias_aprendidas', [])
-                    if isinstance(girias_lista, str):
-                        try:
-                            girias_lista = json.loads(girias_lista)
-                        except:
-                            girias_lista = []
-                    if not isinstance(girias_lista, list):
-                        girias_lista = []
-                    girias_seguras = [
-                        g.get('giria', '') for g in girias_lista[:3]
-                        if isinstance(g, dict)
+                    girias = json.loads(girias_raw) if isinstance(girias_raw, str) else girias_raw
+                    self.girias_aprendidas = [
+                        g for g in girias
+                        if isinstance(g, dict) and "giria" in g
                     ]
                 except Exception as e:
-                    logger.warning(f"Erro ao processar aprendizados: {e}")
-                    termo_contexto = []
-                    girias_seguras = []
-
-                return jsonify({
-                    'resposta': resposta,
-                    'aprendizados': {
-                        'emocao_atual': contexto.emocao_atual,
-                        'termos': termo_contexto,
-                        'gírias': girias_seguras
-                    }
-                })
-
-            except Exception as e:
-                logger.error(f"Erro fatal: {e}", exc_info=True)
-                return jsonify({'resposta': 'tive erro, puto. tenta depois.'}), 500
-
-    def run(self, host='0.0.0.0', port=7860, debug=False):
-        logger.info(f"Iniciando Flask na porta {port}")
-        self.app.run(host=host, port=port, debug=debug, threaded=True)
+                    logger.warning(f"Erro ao parsear gírias: {e}")
+                    self.girias_aprendidas = []
+                self.ton_predominante = dados.get("tom", "neutro")
+        except Exception as e:
+            logger.warning(f"Erro ao carregar contexto: {e}")
+            self.historico = []
+            self.girias_aprendidas = []
+            self.termo_contexto = []
+
+    def salvar_no_banco(self):
+        try:
+            self.db.salvar_contexto(
+                self.user_key,
+                json.dumps(self.historico[-config.MEMORIA_MAX:]),
+                self.emocao_atual,
+                json.dumps(self.termo_contexto),
+                json.dumps(self.girias_aprendidas),
+                self.ton_predominante
+            )
+        except Exception as e:
+            logger.error(f"Erro ao salvar contexto: {e}")
+
+    def atualizar_aprendizados_do_banco(self):
+        try:
+            girias = self.db.listar_girias_aprendidas(self.user_key)
+            self.girias_aprendidas = [
+                {"giria": g[0], "significado": g[1]} for g in girias
+            ]
+        except Exception as e:
+            logger.warning(f"Erro ao atualizar gírias: {e}")
+            self.girias_aprendidas = []
+
+    def analisar_emocoes_mensagem(self, mensagem: str) -> str:
+        msg = mensagem.lower()
+        if any(p in msg for p in ["feliz", "fixe", "bué bom", "adoro", "rsrs", "kkk"]):
+            return "feliz"
+        if any(p in msg for p in ["triste", "chateado", "merda", "puto", "caralho"]):
+            return "triste"
+        if any(p in msg for p in ["irritada", "foda-se", "vsf", "burro"]):
+            return "irritada"
+        if any(p in msg for p in ["curioso", "o que", "como", "porquê"]):
+            return "curiosa"
+        return "neutra"
+
+    def obter_historico(self) -> List[Tuple[str, str]]:
+        return self.historico[-3:]
+
+    def atualizar_contexto(self, mensagem: str, resposta: str):
+        self.historico.append((mensagem, resposta))
+        if len(self.historico) > config.MEMORIA_MAX:
+            self.historico.pop(0)
+        self.emocao_atual = self.analisar_emocoes_mensagem(mensagem)
+        self.salvar_no_banco()