Update app.py

app.py

@@ -6,30 +6,41 @@ from typing import Dict, List, Tuple
 from textblob import TextBlob
 import json
 import os
+from pathlib import Path
 
-# Load embeddings model
-model = SentenceTransformer('all-MiniLM-L6-v2')
-
-# Load data from JSON
-def load_coach_data():
+# Configuração inicial
+def setup_environment():
+    """Configura o ambiente inicial e carrega os dados necessários."""
+    # Verifica se o arquivo JSON existe
+    if not Path("coach_data.json").exists():
+        raise FileNotFoundError("O arquivo coach_data.json não foi encontrado")
+    
     try:
+        # Carrega os dados do JSON
         with open('coach_data.json', 'r', encoding='utf-8') as f:
             data = json.load(f)
-            return data['perguntas'], data['tone_patterns'], data['respostas_coach']
-    except FileNotFoundError:
-        print("Error: coach_data.json not found")
-        raise
+            return (
+                data['perguntas'],
+                data['tone_patterns'],
+                data['respostas_coach']
+            )
     except json.JSONDecodeError:
-        print("Error: Invalid JSON format in coach_data.json")
-        raise
+        raise ValueError("Erro ao decodificar o arquivo JSON")
     except KeyError as e:
-        print(f"Error: Missing required key in JSON data: {e}")
-        raise
+        raise KeyError(f"Chave obrigatória não encontrada no JSON: {e}")
+
+# Carrega o modelo de embeddings
+try:
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+except Exception as e:
+    raise RuntimeError(f"Erro ao carregar o modelo de embeddings: {e}")
 
-PERGUNTAS, TONE_PATTERNS, RESPOSTAS_COACH = load_coach_data()
+# Carrega os dados do coach
+PERGUNTAS, TONE_PATTERNS, RESPOSTAS_COACH = setup_environment()
 
 class EnhancedCoach:
     def __init__(self):
+        """Inicializa o coach com os estados necessários."""
         self.pergunta_atual = 0
         self.inicio = datetime.now()
         self.historico_respostas = []
@@ -38,6 +49,7 @@ class EnhancedCoach:
         self.response_quality_metrics = []
     
     def analyze_response_quality(self, text: str) -> Dict[str, float]:
+        """Analisa a qualidade da resposta do usuário."""
         sentences = [s.strip() for s in text.split('.') if s.strip()]
         words = text.lower().split()
         
@@ -52,6 +64,7 @@ class EnhancedCoach:
         return metrics
     
     def _calculate_depth(self, text: str, words: List[str]) -> float:
+        """Calcula a profundidade da resposta."""
         if not words:
             return 0.0
             
@@ -70,12 +83,14 @@ class EnhancedCoach:
         return min(1.0, depth_score)
     
     def _calculate_clarity(self, sentences: List[str]) -> float:
+        """Calcula a clareza da resposta."""
         if not sentences:
             return 0.0
         avg_length = sum(len(s.split()) for s in sentences) / len(sentences)
         return 1.0 if 10 <= avg_length <= 20 else 0.7
     
     def _calculate_specificity(self, text: str, words: List[str]) -> float:
+        """Calcula a especificidade da resposta."""
         specific_indicators = [
             "exemplo", "especificamente", "concretamente", 
             "situação", "caso", "quando", "onde", "como",
@@ -91,6 +106,7 @@ class EnhancedCoach:
         return min(1.0, (indicator_count * 0.7 + response_length_factor * 0.3))
     
     def _calculate_actionability(self, sentences: List[str]) -> float:
+        """Calcula a acionabilidade da resposta."""
         action_verbs = [
             "implementar", "fazer", "criar", "desenvolver", "estabelecer", 
             "planejar", "executar", "medir", "avaliar", "iniciar",
@@ -103,6 +119,7 @@ class EnhancedCoach:
         return min(1.0, actionable / len(sentences))
 
     def analisar_tom(self, texto: str) -> Tuple[str, float]:
+        """Analisa o tom predominante da resposta."""
         texto_lower = texto.lower()
         blob = TextBlob(texto)
         
@@ -115,6 +132,7 @@ class EnhancedCoach:
         return predominant_tone[0], predominant_tone[1]
 
     def analisar_sentimento(self, texto: str) -> str:
+        """Analisa o sentimento geral da resposta."""
         positive_words = [
             "consegui", "superei", "aprendi", "melhorei", "efetivo",
             "cresci", "evoluí", "realizei", "alcancei", "progresso"
@@ -135,6 +153,7 @@ class EnhancedCoach:
         return "neutral"
 
     def extrair_acao_especifica(self, texto: str) -> str:
+        """Extrai uma ação específica da resposta do usuário."""
         sentences = texto.split('.')
         for sentence in sentences:
             if any(action in sentence.lower() for action in ["eu", "minha", "realizei", "fiz"]):
@@ -142,6 +161,7 @@ class EnhancedCoach:
         return texto.split('.')[0].strip()
 
     def encontrar_melhor_resposta(self, texto_usuario: str, categoria: str) -> str:
+        """Encontra a melhor resposta do coach baseada no texto do usuário."""
         sentimento = self.analisar_sentimento(texto_usuario)
         acao_especifica = self.extrair_acao_especifica(texto_usuario)
         
@@ -162,6 +182,7 @@ class EnhancedCoach:
         return melhor_resposta.format(specific_action=acao_especifica.lower())
     
     def gerar_resposta(self, texto_usuario: str) -> str:
+        """Gera uma resposta completa do coach."""
         quality_metrics = self.analyze_response_quality(texto_usuario)
         
         if quality_metrics["depth"] < 0.15 and quality_metrics["specificity"] < 0.1:
@@ -205,9 +226,117 @@ Alguns aspectos que enriqueceriam sua reflexão:
             tempo = (datetime.now() - self.inicio).seconds // 60
             resposta += self.gerar_sumario_final(tempo)
         
-        return
+        return resposta
+
+    def _gerar_insight_tom(self, tom: str, intensidade: float) -> str:
+        """Gera insights baseados no tom da resposta."""
+        insights = {
+            "confiante": "Sua confiança ao abordar este tema é notável. Como você construiu esta segurança?",
+            "reflexivo": "Sua abordagem reflexiva traz profundidade à análise. Continue explorando diferentes perspectivas.",
+            "hesitante": "Percebo algumas incertezas naturais do processo. Que apoio ajudaria a fortalecer sua confiança?",
+            "pragmatico": "Seu foco em resultados práticos é valioso. Como você equilibra isso com visão de longo prazo?",
+            "emocional": "Sua conexão emocional com a liderança demonstra comprometimento genuíno."
+        }
         
+        if intensidade > 2:
+            return f"\n\n💡 {insights[tom]} Sua expressão é particularmente intensa neste aspecto."
+        return f"\n\n💡 {insights[tom]}"
+
+    def _analisar_padroes(self) -> str:
+        """Analisa padrões nas respostas do usuário."""
+        if len(self.historico_respostas) <= 1:
+            return ""
+            
+        sentimento_atual = self.analisar_sentimento(self.historico_respostas[-1])
+        sentimento_anterior = self.analisar_sentimento(self.historico_respostas[-2])
+        
+        if sentimento_atual == sentimento_anterior == "positive":
+            return "\n\n💡 Observo um padrão consistente de confiança em suas respostas. Continue desenvolvendo esses pontos fortes!"
+        elif sentimento_atual == sentimento_anterior == "improvement":
+            return "\n\n💡 Percebo que você está identificando áreas de desenvolvimento. Vamos focar em estratégias práticas para esses desafios."
+        return ""
+
+    def _gerar_pontos_aprofundamento(self) -> str:
+        """Gera pontos para aprofundamento da reflexão."""
+        return """
+
+#### Pontos para Aprofundamento:
+1. Como essa experiência se conecta com seus valores de liderança?
+2. Que recursos específicos você identificou como necessários?
+3. Qual seria o próximo marco de desenvolvimento nessa área?"""
+
+    def _gerar_proxima_pergunta(self) -> str:
+        """Gera a próxima pergunta da sequência."""
+        proxima = PERGUNTAS[self.pergunta_atual]
+        return f"""\n\n### Próxima Reflexão: {proxima['categoria'].title()} 🎯\n\n{proxima['pergunta']}\n\nTome um momento para refletir e conectar com suas experiências..."""
+
+    def primeira_pergunta(self) -> str:
+        """Gera a mensagem inicial e primeira pergunta do coach."""
+        return f"""### 👋 Bem-vindo à sua Jornada de Desenvolvimento!
+
+Vamos explorar aspectos importantes da sua liderança através de reflexões guiadas.
+
+{PERGUNTAS[0]['pergunta']}
+
+Tome um momento para conectar com suas experiências e compartilhe sua perspectiva..."""
+
+    def gerar_sumario_final(self, tempo: int) -> str:
+        """Gera o sumário final da sessão."""
+        sentimentos = [self.analisar_sentimento(resp) for resp in self.historico_respostas]
+        predominante = max(set(sentimentos), key=sentimentos.count)
+        
+        tone_pattern = max(set(self.tone_history), key=self.tone_history.count)
+        tone_insight = f"\n\n#### Padrão de Comunicação:\nSeu estilo predominante é {tone_pattern}, o que sugere {self._interpretar_padrao_tom(tone_pattern)}"
+        
+        avg_metrics = {
+            key: sum(m[key] for m in self.response_quality_metrics) / len(self.response_quality_metrics)
+            for key in ["depth", "clarity", "specificity", "actionability"]
+        }
+        
+        quality_insights = "\n\n#### Insights de Qualidade das Respostas:"
+        if avg_metrics["depth"] > 0.7:
+            quality_insights += "\n- Suas reflexões demonstram profundidade significativa"
+        if avg_metrics["specificity"] > 0.7:
+            quality_insights += "\n- Você fornece exemplos concretos e detalhados"
+        if avg_metrics["actionability"] > 0.7:
+            quality_insights += "\n- Suas respostas são orientadas para ação"
+        
+        if predominante == "positive":
+            perfil = "Você demonstra forte autoconhecimento e confiança em sua liderança."
+        elif predominante == "improvement":
+            perfil = "Você demonstra excelente capacidade de identificar oportunidades de desenvolvimento."
+        else:
+            perfil = "Você demonstra uma abordagem equilibrada entre conquistas e desafios."
+        
+        return f"""
+### 🎉 Jornada de Desenvolvimento Concluída!
+
+⏱️ Tempo de reflexão: {tempo} minutos
+📝 Temas explorados: {len(PERGUNTAS)}
+
+#### Perfil de Liderança Observado:
+{perfil}{tone_insight}{quality_insights}
+
+#### Recomendações Personalizadas:
+1. Implemente uma ação específica mencionada em suas reflexões esta semana
+2. Mantenha um diário de liderança focado nos temas discutidos
+3. Estabeleça checkpoints mensais para revisar seu progresso
+
+Deseja iniciar uma nova jornada de desenvolvimento com outros temas?"""
+
+    def _interpretar_padrao_tom(self, tom: str) -> str:
+        """Interpreta o padrão de tom identificado nas respostas."""
+        interpretacoes = {
+            "confiante": "uma base sólida para influenciar e liderar equipes.",
+            "reflexivo": "uma capacidade valiosa de considerar múltiplas perspectivas.",
+            "hesitante": "uma oportunidade para fortalecer sua confiança através da prática.",
+            "pragmatico": "um foco valioso em resultados e implementação.",
+            "emocional": "uma forte conexão com o impacto humano da liderança."
+        }
+        return interpretacoes.get(tom, "um estilo único de liderança.")
+
 def criar_interface():
+    """Cria a interface do usuário usando Gradio."""
     coach = EnhancedCoach()
     
     with gr.Blocks(title="Coach de Liderança", theme=gr.themes.Soft()) as app:
@@ -241,6 +370,14 @@ def criar_interface():
     
     return app
 
+def main():
+    """Função principal para iniciar a aplicação."""
+    try:
+        app = criar_interface()
+        app.launch()
+    except Exception as e:
+        print(f"Erro ao iniciar a aplicação: {e}")
+        raise
+
 if __name__ == "__main__":
-    app = criar_interface()
-    app.launch()
+    main()