Update app.py

app.py

@@ -135,18 +135,11 @@ class EnhancedCoach:
     def analisar_tom(self, texto: str) -> Tuple[str, float]:
         """Analisa o tom predominante na resposta usando TextBlob e padrões lexicais."""
         texto_lower = texto.lower()
-        
-        # Análise de sentimento com TextBlob
         blob = TextBlob(texto)
-        
-        # Contagem de padrões de tom
         tone_scores = {}
         for tone, patterns in TONE_PATTERNS.items():
             score = sum(texto_lower.count(pattern) for pattern in patterns)
-            # Normalize with TextBlob polarity
             tone_scores[tone] = score * (1 + abs(blob.sentiment.polarity))
-            
-        # Get predominant tone
         predominant_tone = max(tone_scores.items(), key=lambda x: x[1])
         return predominant_tone[0], predominant_tone[1]
 
@@ -154,11 +147,9 @@ class EnhancedCoach:
         """Analisa o sentimento geral da resposta."""
         positive_words = ["consegui", "superei", "aprendi", "melhorei", "efetivo"]
         negative_words = ["difícil", "desafiador", "complicado", "problema", "falha"]
-        
         texto_lower = texto.lower()
         positive_count = sum(1 for word in positive_words if word in texto_lower)
         negative_count = sum(1 for word in negative_words if word in texto_lower)
-        
         if positive_count > negative_count:
             return "positive"
         elif negative_count > positive_count:
@@ -176,186 +167,59 @@ class EnhancedCoach:
     def encontrar_melhor_resposta(self, texto_usuario: str, categoria: str) -> str:
         sentimento = self.analisar_sentimento(texto_usuario)
         acao_especifica = self.extrair_acao_especifica(texto_usuario)
-        
         respostas_categoria = RESPOSTAS_COACH[categoria][sentimento]
         user_embedding = model.encode(texto_usuario)
-        
         melhor_resposta = None
         maior_similaridade = -1
-        
         for template in respostas_categoria:
             context_embedding = model.encode(template["context"])
             similaridade = np.dot(user_embedding, context_embedding)
-            
             if similaridade > maior_similaridade:
                 maior_similaridade = similaridade
                 melhor_resposta = template["response"]
-        
         return melhor_resposta.format(specific_action=acao_especifica.lower())
     
     def gerar_resposta(self, texto_usuario: str) -> str:
         if self.sessao_completa:
             self.__init__()
-            
         if self.pergunta_atual >= len(PERGUNTAS):
             tempo = (datetime.now() - self.inicio).seconds // 60
             return self.gerar_sumario_final(tempo)
-            
-        # Analyze tone
         tom_predominante, intensidade = self.analisar_tom(texto_usuario)
         self.tone_history.append(tom_predominante)
-        
         pergunta_atual = PERGUNTAS[self.pergunta_atual]
-        self.historico_respostas.append(texto_usuario)
-        
-        feedback = self.encontrar_melhor_resposta(
-            texto_usuario, 
-            pergunta_atual["categoria"]
-        )
-        
-        # Add tone-specific insights
-        tom_insight = self._gerar_insight_tom(tom_predominante, intensidade)
-        padrao_identificado = self._analisar_padroes()
-        
-        resposta = f"""### Feedback Personalizado 💭\n\n{feedback}{padrao_identificado}\n\n{tom_insight}"""
-        resposta += self._gerar_pontos_aprofundamento()
-        
         self.pergunta_atual += 1
-        if self.pergunta_atual < len(PERGUNTAS):
-            resposta += self._gerar_proxima_pergunta()
-        else:
-            self.sessao_completa = True
-            tempo = (datetime.now() - self.inicio).seconds // 60
-            resposta += self.gerar_sumario_final(tempo)
-        
-        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:
-        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:
-        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:
-        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 gerar_sumario_final(self, tempo: int) -> str:
-        # Analyze patterns in responses
-        sentimentos = [self.analisar_sentimento(resp) for resp in self.historico_respostas]
-        predominante = max(set(sentimentos), key=sentimentos.count)
-        
-        # Add tone pattern analysis
-        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)}"
-        
-        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}
-
-#### 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 significado do padrão de tom predominante."""
-        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 primeira_pergunta(self):
-        return f"""### 👋 Bem-vindo à sua Jornada de Desenvolvimento!
+        self.historico_respostas.append({
+            "pergunta": pergunta_atual["pergunta"],
+            "resposta": texto_usuario,
+            "sentimento": self.analisar_sentimento(texto_usuario),
+            "tom": tom_predominante
+        })
+        feedback = self.encontrar_melhor_resposta(texto_usuario, pergunta_atual["categoria"])
+        return f"Resposta analisada: {feedback}\n\nPróxima pergunta: {PERGUNTAS[self.pergunta_atual]['pergunta']}" if self.pergunta_atual < len(PERGUNTAS) else feedback
+    
+    def gerar_sumario_final(self, tempo_total: int) -> str:
+        summary = [f"Tonalidade predominante da sessão: {max(set(self.tone_history), key=self.tone_history.count)}."]
+        for resposta in self.historico_respostas:
+            summary.append(f"- Pergunta: {resposta['pergunta']}\n  Resposta: {resposta['resposta']}\n  Sentimento: {resposta['sentimento']}\n  Tom: {resposta['tom']}\n")
+        summary.append(f"Tempo total da sessão: {tempo_total} minutos.")
+        self.sessao_completa = True
+        return "\n".join(summary)
 
-Vamos explorar aspectos importantes da sua liderança através de reflexões guiadas.
 
-{PERGUNTAS[0]['pergunta']}
+# Interface Gradio
+coach = EnhancedCoach()
 
-Tome um momento para conectar com suas experiências e compartilhe sua perspectiva..."""
+def interface_chat(texto_usuario):
+    return coach.gerar_resposta(texto_usuario)
 
-def criar_interface():
-    coach = EnhancedCoach()
-    
-    with gr.Blocks(title="Coach de Liderança") as app:
-        gr.Markdown("""
-        # 🚀 Coach de Liderança
-
-        Desenvolva sua liderança através de reflexão guiada e feedback personalizado.
-        """)
-        
-        chat = gr.Chatbot(
-            value=[[None, coach.primeira_pergunta()]],
-            height=600,
-            show_label=False
-        )
-        
-        with gr.Row():
-            txt = gr.Textbox(
-                placeholder="Compartilhe sua reflexão aqui...",
-                lines=4,
-                label="Sua Resposta"
-            )
-            btn = gr.Button("Enviar")
-        
-        def responder(mensagem, historico):
-            if not mensagem.strip():
-                return "", historico
-            
-            resposta = coach.gerar_resposta(mensagem)
-            historico.append([mensagem, resposta])
-            return "", historico
-        
-        txt.submit(responder, [txt, chat], [txt, chat])
-        btn.click(responder, [txt, chat], [txt, chat])
-    
-    return app
+demo = gr.Interface(
+    fn=interface_chat,
+    inputs="text",
+    outputs="text",
+    title="Coaching Inteligente",
+    description="Receba perguntas personalizadas e feedback em tempo real para desenvolvimento pessoal e profissional."
+)
 
 if __name__ == "__main__":
-    app = criar_interface()
-    app.launch()
+    demo.launch()