Update modules/contexto.py

modules/contexto.py

@@ -1,34 +1,34 @@
+# modules/contexto.py
 import logging
 import re
 import random
 import time
 import sqlite3
-import json 
-from typing import Optional, List, Dict, Tuple, Any 
+import json
+from typing import Optional, List, Dict, Tuple, Any
 import modules.config as config
 from .database import Database
-from .treinamento import Treinamento 
+from .treinamento import Treinamento
 
 try:
-    from sentence_transformers import SentenceTransformer  # type: ignore[reportMissingImports]
+    from sentence_transformers import SentenceTransformer
 except Exception as e:
     logging.warning(f"sentence_transformers não disponível: {e}")
     SentenceTransformer = None
-    
+
 try:
-    import psutil  # type: ignore[reportMissingImports]
+    import psutil
 except Exception:
     psutil = None
-    
+
 try:
-    import structlog  # type: ignore[reportMissingImports]
+    import structlog
 except Exception:
     structlog = None
 
 logger = logging.getLogger(__name__)
-
-# Configuração do logging (fallback se structlog ausente)
 logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
+
 if structlog:
     structlog.configure(
         processors=[
@@ -45,9 +45,10 @@ if structlog:
 PALAVRAS_POSITIVAS = ['bom', 'ótimo', 'incrível', 'feliz', 'adorei', 'top', 'fixe', 'bué', 'show', 'legal', 'bacana']
 PALAVRAS_NEGATIVAS = ['ruim', 'péssimo', 'triste', 'ódio', 'raiva', 'chateado', 'merda', 'porra', 'odeio']
 
+
 class Contexto:
     """
-    Classe para gerenciar o contexto da conversa, análise de intenções e aprendizado 
+    Classe para gerenciar o contexto da conversa, análise de intenções e aprendizado
     dinâmico de termos regionais/gírias para cada usuário.
     """
     def __init__(self, db: Database, usuario: Optional[str] = None):
@@ -56,30 +57,27 @@ class Contexto:
         self.model: Optional[SentenceTransformer] = None
         self.embeddings: Optional[Dict[str, Any]] = None
         self._treinador: Optional[Treinamento] = None
-        
+
         # Estado de conversa
         self.emocao_atual = "neutra"
         self.espírito_crítico = False
         self.base_conhecimento = {}
-        
+
         # Garante que termo_contexto seja sempre um dicionário
         self.termo_contexto: Dict[str, Dict] = {}
         self.atualizar_aprendizados_do_banco()
-        
-        logger.info("🟢 Inicializando Contexto (com NLP avançado, aprendizado de gírias e emoções) ...")
-        
+
+        logger.info("Inicializando Contexto (com NLP avançado, aprendizado de gírias e emoções) ...")
+
         # Cache para termos regionais e gírias
         self.cache_girias: Dict[str, Any] = {}
-        
+
     def atualizar_aprendizados_do_banco(self):
-        """
-        Carrega todos os dados de aprendizado persistentes (termos, gírias, etc.)
-        do banco de dados para a instância do Contexto.
-        """
+        """Carrega todos os dados de aprendizado persistentes do banco."""
         try:
             termos_aprendidos = self.db.recuperar_girias_usuario(self.usuario) if self.usuario else []
             self.termo_contexto = {
-                termo['giria']: {"significado": termo['significado'], "frequencia": termo['frequencia']} 
+                termo['giria']: {"significado": termo['significado'], "frequencia": termo['frequencia']}
                 for termo in termos_aprendidos
             }
         except Exception as e:
@@ -91,88 +89,62 @@ class Contexto:
             if emocao_salva:
                 emocao_dict = json.loads(emocao_salva)
                 if isinstance(emocao_dict, dict) and 'emocao' in emocao_dict:
-                     self.emocao_atual = emocao_dict['emocao']
+                    self.emocao_atual = emocao_dict['emocao']
                 elif isinstance(emocao_salva, str):
-                    self.emocao_atual = emocao_salva 
+                    self.emocao_atual = emocao_salva
         except Exception as e:
             logger.warning(f"Falha ao carregar emoção do DB: {e}")
-        
-        logger.info(f"Aprendizados de contexto carregados/recarregados para {self.usuario}.")
+
+        logger.info(f"Aprendizados carregados para {self.usuario}.")
 
     @property
     def ton_predominante(self) -> Optional[str]:
-        """
-        [CORREÇÃO DO BUG] Retorna o tom predominante do usuário, acessando o DB.
-        Adicionado para resolver o 'AttributeError: ton_predominante'.
-        """
+        """Retorna o tom predominante do usuário (acessa o DB)."""
         if self.usuario:
             return self.db.obter_tom_predominante(self.usuario)
         return None
 
     def get_or_create_treinador(self, interval_hours: int = 24) -> Treinamento:
-        """Retorna um treinador associado a este contexto, criando se necessário."""
+        """Retorna um treinador associado, criando se necessário."""
         if self._treinador is None:
             self._treinador = Treinamento(self.db, contexto=self, interval_hours=interval_hours)
         return self._treinador
 
     def _load_model(self):
-        """Carrega o modelo SentenceTransformer e embeddings sob demanda."""
+        """Carrega o modelo SentenceTransformer sob demanda."""
         if self.model is not None:
             return
-        
-        start_time = time.time()
-        
         if SentenceTransformer is None:
-            logger.warning({"event": "Modelo SentenceTransformer não será carregado", "reason": "Biblioteca não instalada"})
+            logger.warning("SentenceTransformer não instalado")
             return
-        
         try:
             self.model = SentenceTransformer('all-MiniLM-L6-v2')
-            logger.info({"event": "Modelo SentenceTransformer carregado com sucesso"})
+            logger.info("Modelo SentenceTransformer carregado")
         except Exception as e:
-            logger.error({"event": "Erro ao carregar modelo", "error": str(e)})
+            logger.error(f"Erro ao carregar modelo: {e}")
             self.model = None
-            
         self._check_embeddings()
-        duration = time.time() - start_time
-        logger.info({"event": "Modelo carregado", "duration_seconds": duration})
 
     def _check_embeddings(self):
-        """Verifica ou cria embeddings no banco de dados SQLite."""
+        """Verifica ou cria embeddings no banco."""
         if self.model and not self.embeddings:
-            try:
-                self.embeddings = {"conhecimento_base": "placeholder_embedding_data"} 
-            except Exception as e:
-                logger.warning(f"Não foi possível carregar embeddings: {e}")
+            self.embeddings = {"conhecimento_base": "placeholder"}
 
     def analisar_emocoes_mensagem(self, mensagem: str) -> Dict[str, Any]:
-        """
-        Analisa o sentimento e emoção da mensagem (Heurística simples).
-        MÉTODO ADICIONADO PARA RESOLVER O ERRO 'analisar_emocoes_mensagem'.
-        """
+        """Analisa sentimento e emoção da mensagem (heurística)."""
         mensagem_lower = mensagem.strip().lower()
-
-        # Análise de Sentimento (Tom Simples)
         pos_count = sum(mensagem_lower.count(w) for w in PALAVRAS_POSITIVAS)
         neg_count = sum(mensagem_lower.count(w) for w in PALAVRAS_NEGATIVAS)
-        
+
         sentimento = "neutro"
         if pos_count > neg_count:
             sentimento = "positivo"
         elif neg_count > pos_count:
             sentimento = "negativo"
-            
-        # Determinar Emoção Predominante (simples)
-        if sentimento == "positivo":
-            emocao_predominante = "alegria"
-        elif sentimento == "negativo":
-            emocao_predominante = "frustração"
-        else:
-            emocao_predominante = "neutra"
-            
-        # Atualiza o estado da classe
+
+        emocao_predominante = "alegria" if sentimento == "positivo" else "frustração" if sentimento == "negativo" else "neutra"
         self.emocao_atual = emocao_predominante
-            
+
         return {
             "sentimento_detectado": sentimento,
             "emocao_predominante": emocao_predominante,
@@ -180,166 +152,141 @@ class Contexto:
             "intensidade_negativa": neg_count,
             "tom_sugerido": "casual" if sentimento != "neutro" else "neutro"
         }
-    
+
     def analisar_intencao_e_normalizar(self, mensagem: str, historico: List[Tuple[str, str]]) -> Dict[str, Any]:
-        """Analisa a intenção, normaliza a mensagem e detecta sentimentos/estilo (Heurística)."""
+        """Analisa intenção, normaliza e detecta estilo."""
         self._load_model()
-        
         if not isinstance(mensagem, str):
             mensagem = str(mensagem)
         mensagem_lower = mensagem.strip().lower()
 
-        # 1. Análise de Intenção
+        # Intenção
         intencao = "pergunta"
-        if '?' not in mensagem_lower and ('porquê' not in mensagem_lower or 'porque' not in mensagem_lower):
+        if '?' not in mensagem_lower and 'porquê' not in mensagem_lower and 'porque' not in mensagem_lower:
             intencao = "afirmacao"
         if any(w in mensagem_lower for w in ['ola', 'oi', 'bom dia', 'boa tarde', 'boa noite', 'como vai']):
             intencao = "saudacao"
         if any(w in mensagem_lower for w in ['tchau', 'ate mais', 'adeus', 'fim', 'parar']):
             intencao = "despedida"
-        
-        # 2. Análise de Sentimento/Emoção
+
+        # Sentimento
         analise_emocional = self.analisar_emocoes_mensagem(mensagem_lower)
-            
-        # 3. Análise de Estilo
+
+        # Estilo
         estilo = "informal"
         if len(re.findall(r'[A-ZÀ-Ÿ]{3,}', mensagem)) >= 2 or re.search(r'\b(Senhor|Doutor|Atenciosamente)\b', mensagem, re.IGNORECASE):
             estilo = "formal"
-            
-        # 4. Outras bandeiras
-        ironia = False
-        meia_frase = False 
+
         usar_nome = random.random() < getattr(config, 'USAR_NOME_PROBABILIDADE', 0.7)
 
         return {
             "texto_normalizado": mensagem_lower,
             "intencao": intencao,
-            "sentimento": analise_emocional['sentimento_detectado'], 
+            "sentimento": analise_emocional['sentimento_detectado'],
             "estilo": estilo,
             "contexto_ajustado": self.substituir_termos_aprendidos(mensagem_lower),
-            "ironia": ironia,
-            "meia_frase": meia_frase,
+            "ironia": False,
+            "meia_frase": False,
             "usar_nome": usar_nome,
-            "emocao": self.emocao_atual 
+            "emocao": self.emocao_atual
         }
 
     def obter_historico(self, limite: int = 5) -> List[Tuple[str, str]]:
-        """Recupera o histórico de mensagens do banco de dados (Mensagem do Usuário, Resposta da IA)."""
+        """Recupera histórico do banco."""
         if not self.usuario:
             return []
-            
-        raw_result = self.db.recuperar_mensagens(self.usuario, limite=limite)
-        
-        return raw_result if raw_result else []
+        raw = self.db.recuperar_mensagens(self.usuario, limite=limite)
+        return raw if raw else []
+
+    def obter_historico_para_llm(self) -> List[Dict]:
+        """Formato esperado pelo LLMManager.generate()"""
+        raw = self.obter_historico(limite=10)
+        history = []
+        for user_msg, bot_msg in raw:
+            history.append({"role": "user", "content": user_msg})
+            history.append({"role": "assistant", "content": bot_msg})
+        return history
 
     def atualizar_contexto(self, mensagem: str, resposta: str, numero: Optional[str] = None):
-        """Salva a interação no banco de mensagens e aciona aprendizado de termos."""
-        if not self.usuario:
-            usuario = 'anonimo'
-        else:
-            usuario = self.usuario
-            
-        final_numero = numero if numero else self.usuario
-        
+        """Salva interação e aprende."""
+        usuario = self.usuario or 'anonimo'
+        final_numero = numero or self.usuario
+
         try:
             self.db.salvar_mensagem(usuario, mensagem, resposta, numero=final_numero)
-            
             historico = self.obter_historico(limite=10)
-            self.aprender_do_historico(mensagem, resposta, historico) 
-            
+            self.aprender_do_historico(mensagem, resposta, historico)
             self.salvar_estado_contexto_no_db(final_numero)
-
         except Exception as e:
-            logger.warning(f'Falha ao salvar mensagem no DB: {e}')
+            logger.warning(f'Falha ao salvar: {e}')
 
     def salvar_estado_contexto_no_db(self, user_key: str):
-        """Persiste o estado atual da classe Contexto no banco de dados."""
+        """Persiste estado no DB."""
         termos_json = json.dumps(self.termo_contexto)
-        emocao_str = self.emocao_atual
-        
         try:
-            self.db.salvar_aprendizado_detalhado(user_key, "emocao_atual", json.dumps({"emocao": emocao_str}))
-            
+            self.db.salvar_aprendizado_detalhado(user_key, "emocao_atual", json.dumps({"emocao": self.emocao_atual}))
             self.db.salvar_contexto(
                 user_key=user_key,
-                historico="[]", 
-                emocao_atual=emocao_str,
+                historico="[]",
+                emocao_atual=self.emocao_atual,
                 termos=termos_json,
                 girias=termos_json,
-                tom=emocao_str 
+                tom=self.emocao_atual
             )
-            logger.debug(f"Contexto do usuário {user_key} salvo no DB.")
         except Exception as e:
-            logger.error(f"Falha ao salvar estado do contexto no DB: {e}")
-
+            logger.error(f"Falha ao salvar contexto: {e}")
 
     def aprender_do_historico(self, mensagem: str, resposta: str, historico: List[Tuple[str, str]]):
-        """Aprende termos do histórico de conversas e salva na tabela 'girias_aprendidas' (Downgrade/Heurística)."""
+        """Aprende gírias do histórico."""
         if not self.usuario:
             return
-
         mensagem_lower = mensagem.lower()
-        
-        # Exemplo: Aprender gírias angolanas simples se usadas frequentemente
-        girias_angolanas_simples = ['ya', 'bué', 'fixe', 'puto']
-        
+        girias_angolanas_simples = ['ya', 'bué', 'fixe', 'puto', 'kota', 'mwangolé']
+
         for giria in girias_angolanas_simples:
             if giria in mensagem_lower:
                 try:
-                    significado_placeholder = f'termo regional para {giria}'
-                    
-                    self.db.salvar_giria_aprendida(
-                        self.usuario,
-                        giria, 
-                        significado_placeholder,
-                        mensagem[:50]
-                    )
-                    
-                    self.termo_contexto[giria] = {"significado": significado_placeholder, "frequencia": self.termo_contexto.get(giria, {}).get("frequencia", 0) + 1}
-                    
+                    significado = f'termo regional para {giria}'
+                    self.db.salvar_giria_aprendida(self.usuario, giria, significado, mensagem[:50])
+                    self.termo_contexto[giria] = {
+                        "significado": significado,
+                        "frequencia": self.termo_contexto.get(giria, {}).get("frequencia", 0) + 1
+                    }
                 except Exception as e:
-                    logger.warning(f"Erro ao salvar gíria no DB: {e}")
-    
+                    logger.warning(f"Erro ao salvar gíria: {e}")
+
     def substituir_termos_aprendidos(self, mensagem: str) -> str:
-        """Substitui termos aprendidos na mensagem (baseado no dicionário termo_contexto)."""
+        """Substitui termos aprendidos."""
         for termo, info in self.termo_contexto.items():
             if isinstance(info, dict) and "significado" in info:
-                # Usa regex para substituir apenas a palavra inteira (case insensitive)
                 mensagem = re.sub(r'\b' + re.escape(termo) + r'\b', info["significado"], mensagem, flags=re.IGNORECASE)
         return mensagem
-        
+
     def obter_aprendizado_detalhado(self, chave: str) -> Optional[Dict]:
-        """Recupera aprendizados detalhados do usuário (simulação simples)."""
+        """Recupera aprendizado detalhado."""
         try:
-            raw_data = self.db.recuperar_aprendizado_detalhado(self.usuario, chave)
-            if raw_data:
-                return json.loads(raw_data)
-            return None
+            raw = self.db.recuperar_aprendizado_detalhado(self.usuario, chave)
+            return json.loads(raw) if raw else None
         except Exception as e:
-            logger.warning(f"Erro ao obter aprendizado detalhado: {e}")
+            logger.warning(f"Erro ao obter aprendizado: {e}")
             return None
-            
+
     def obter_emocao_atual(self) -> str:
-        """Recupera a emoção atual do usuário."""
         return self.emocao_atual
 
     def ativar_espírito_crítico(self):
-        """Ativa o espírito crítico para respostas questionadoras."""
         self.espírito_crítico = True
 
     def obter_aprendizados(self) -> Dict[str, Any]:
-        """Retorna os aprendizados do usuário, incluindo termos e emoções."""
-        aprendizados = {
+        """Retorna todos os aprendizados."""
+        return {
             "termos": self.termo_contexto,
             "emocao_preferida": self.emocao_atual,
-            "ton_predominante": self.ton_predominante # Adicionado o novo campo de tom
+            "ton_predominante": self.ton_predominante
         }
-        return aprendizados
 
     def salvar_conhecimento_base(self, chave: str, valor: Any):
-        """Salva uma informação na base de conhecimento."""
         self.base_conhecimento[chave] = valor
 
     def obter_conhecimento_base(self, chave: str) -> Optional[Any]:
-        """Obtém uma informação da base de conhecimento."""
         return self.base_conhecimento.get(chave)