Update app.py

app.py

@@ -4,6 +4,11 @@ from sentence_transformers import SentenceTransformer
 import numpy as np
 from typing import Dict, List, Tuple
 from textblob import TextBlob
+import nltk
+from nltk.tokenize import sent_tokenize
+
+# Download required NLTK data
+nltk.download('punkt')
 
 # Load embeddings model
 model = SentenceTransformer('all-MiniLM-L6-v2')
@@ -131,15 +136,66 @@ class EnhancedCoach:
         self.historico_respostas = []
         self.sessao_completa = False
         self.tone_history = []
+        self.response_quality_metrics = []
+        
+    def analyze_response_quality(self, text: str) -> Dict[str, float]:
+        """Analyzes response quality based on multiple dimensions."""
+        sentences = sent_tokenize(text)
         
+        metrics = {
+            "depth": self._calculate_depth(text),
+            "clarity": self._calculate_clarity(sentences),
+            "specificity": self._calculate_specificity(text),
+            "actionability": self._calculate_actionability(sentences)
+        }
+        
+        self.response_quality_metrics.append(metrics)
+        return metrics
+    
+    def _calculate_depth(self, text: str) -> float:
+        """Measures response depth based on length and unique word usage."""
+        words = text.lower().split()
+        unique_words = len(set(words))
+        return min(1.0, (len(words) * unique_words) / 1000)
+    
+    def _calculate_clarity(self, sentences: List[str]) -> float:
+        """Measures clarity based on sentence structure."""
+        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) -> float:
+        """Measures specificity based on concrete details."""
+        specific_indicators = ["exemplo", "especificamente", "concretamente", 
+                             "situação", "caso", "quando", "onde", "como"]
+        return min(1.0, sum(text.lower().count(ind) for ind in specific_indicators) / 5)
+    
+    def _calculate_actionability(self, sentences: List[str]) -> float:
+        """Measures actionability based on action verbs and concrete steps."""
+        action_verbs = ["implementar", "fazer", "criar", "desenvolver", "estabelecer", 
+                       "planejar", "executar", "medir", "avaliar"]
+        if not sentences:
+            return 0.0
+        actionable = sum(1 for s in sentences 
+                        if any(verb in s.lower() for verb in action_verbs))
+        return min(1.0, actionable / len(sentences))
+
     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]
 
@@ -147,9 +203,11 @@ 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:
@@ -167,59 +225,212 @@ 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:
+        # First, analyze response quality
+        quality_metrics = self.analyze_response_quality(texto_usuario)
+        
+        if quality_metrics["depth"] < 0.3 or quality_metrics["specificity"] < 0.2:
+            return """### Feedback Inicial 💭
+
+Para oferecer um feedback mais valioso, poderia compartilhar mais detalhes específicos sobre sua experiência? 
+Alguns aspectos que enriqueceriam sua reflexão:
+- Exemplos concretos da situação
+- Ações específicas tomadas
+- Resultados observados"""
+
         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
-        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)
+        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)}"
+        
+        # Analyze overall response quality metrics
+        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)}
 
-# Interface Gradio
-coach = EnhancedCoach()
+#### Perfil de Liderança Observado:
+{perfil}{tone_insight}{quality_insights}
 
-def interface_chat(texto_usuario):
-    return coach.gerar_resposta(texto_usuario)
+#### 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
 
-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."
-)
+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!
+
+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 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
 
 if __name__ == "__main__":
-    demo.launch()
+    app = criar_interface()
+    app.launch()