Update app.py

app.py

@@ -1,116 +1,139 @@
 import gradio as gr
-from temperament_analyzer import TemperamentAnalyzer
+from transformers import pipeline
+import numpy as np
 
-def create_interface():
-    analyzer = TemperamentAnalyzer()
-    
-    def process_selections(
-        sang_strengths, sang_weaknesses,
-        col_strengths, col_weaknesses,
-        mel_strengths, mel_weaknesses,
-        fleu_strengths, fleu_weaknesses
-    ):
-        # Organize responses
-        responses = {
-            'SANGUÍNEO': {
-                'strengths': sang_strengths,
-                'weaknesses': sang_weaknesses
-            },
-            'COLÉRICO': {
-                'strengths': col_strengths,
-                'weaknesses': col_weaknesses
-            },
-            'MELANCÓLICO': {
-                'strengths': mel_strengths,
-                'weaknesses': mel_weaknesses
-            },
-            'FLEUMÁTICO': {
-                'strengths': fleu_strengths,
-                'weaknesses': fleu_weaknesses
-            }
+class SimpleTemperamentAnalyzer:
+    def __init__(self):
+        # Usando um modelo leve de sentiment analysis em português
+        self.model = pipeline(
+            "text-classification",
+            model="neuralmind/bert-base-portuguese-cased",
+            return_all_scores=True
+        )
+        
+        # Definições básicas dos temperamentos
+        self.temperamentos = {
+            'SANGUÍNEO': ['Alegre', 'Extrovertido', 'Social', 'Otimista', 'Comunicativo'],
+            'COLÉRICO': ['Líder', 'Determinado', 'Prático', 'Produtivo', 'Independente'],
+            'MELANCÓLICO': ['Perfeccionista', 'Detalhista', 'Artístico', 'Sensível', 'Idealista'],
+            'FLEUMÁTICO': ['Calmo', 'Pacífico', 'Objetivo', 'Diplomático', 'Organizado']
+        }
+
+    def analisar_respostas(self, respostas_marcadas):
+        """Analisa as respostas e retorna os percentuais de cada temperamento"""
+        total_possiveis = {temp: len(caract) for temp, caract in self.temperamentos.items()}
+        pontuacoes = {}
+        
+        for temp, caracteristicas in self.temperamentos.items():
+            marcadas = sum(1 for c in caracteristicas if c in respostas_marcadas)
+            pontuacoes[temp] = (marcadas / total_possiveis[temp]) * 100
+            
+        return pontuacoes
+
+    def gerar_analise(self, temperamento_dominante, pontuacoes):
+        """Gera uma análise simplificada baseada no temperamento dominante"""
+        descricoes = {
+            'SANGUÍNEO': 'pessoa sociável e entusiasmada, que se relaciona facilmente',
+            'COLÉRICO': 'pessoa determinada e prática, com forte capacidade de liderança',
+            'MELANCÓLICO': 'pessoa profunda e analítica, com sensibilidade artística',
+            'FLEUMÁTICO': 'pessoa calma e objetiva, que mantém o equilíbrio em situações difíceis'
+        }
+        
+        recomendacoes = {
+            'SANGUÍNEO': [
+                'Desenvolver mais foco e disciplina',
+                'Estabelecer rotinas diárias',
+                'Praticar conclusão de tarefas'
+            ],
+            'COLÉRICO': [
+                'Cultivar mais paciência',
+                'Ouvir mais as pessoas',
+                'Desenvolver empatia'
+            ],
+            'MELANCÓLICO': [
+                'Ser mais flexível',
+                'Evitar perfeccionismo excessivo',
+                'Desenvolver otimismo'
+            ],
+            'FLEUMÁTICO': [
+                'Tomar mais iniciativa',
+                'Expressar mais os sentimentos',
+                'Estabelecer metas pessoais'
+            ]
+        }
+        
+        return {
+            'descricao': descricoes[temperamento_dominante],
+            'recomendacoes': recomendacoes[temperamento_dominante]
         }
+
+def criar_interface():
+    analisador = SimpleTemperamentAnalyzer()
+    
+    def processar_selecao(selecoes):
+        # Calcula pontuações
+        pontuacoes = analisador.analisar_respostas(selecoes)
         
-        # Calculate scores
-        scores = analyzer.analyze_responses(responses)
+        # Identifica temperamento dominante
+        temperamento_dominante = max(pontuacoes.items(), key=lambda x: x[1])[0]
         
-        # Identify dominant temperament
-        dominant = max(scores.items(), key=lambda x: x[1])[0]
+        # Gera análise
+        analise = analisador.gerar_analise(temperamento_dominante, pontuacoes)
         
-        # Format result
-        result = f"""
-        # Análise de Temperamento
+        # Formata resultado
+        resultado = f"""
+        ### Resultados da Análise de Temperamento
+
+        **Pontuações:**
+        {' '.join([f'- {temp}: {pont:.1f}%\n' for temp, pont in pontuacoes.items()])}
+
+        **Temperamento Predominante:** {temperamento_dominante}
 
-        ## Pontuações
-        {'-' * 50}
-        """ + '\n'.join([f"**{temp}**: {score:.1f}%" for temp, score in scores.items()]) + f"""
+        **Análise:**
+        Você demonstra ser uma {analise['descricao']}.
 
-        ## Temperamento Dominante
-        {'-' * 50}
-        **{dominant}**
+        **Recomendações para Desenvolvimento:**
+        {"".join([f'- {rec}\n' for rec in analise['recomendacoes']])}
         """
         
-        return result
+        return resultado
 
-    # Gradio Interface
-    with gr.Blocks(theme=gr.themes.Soft()) as iface:
-        gr.Markdown("# Análise de Temperamento e Necessidades Espirituais")
+    # Interface Gradio
+    with gr.Blocks(theme=gr.themes.Soft()) as interface:
+        gr.Markdown("## Análise de Temperamento Simplificada")
         
-        with gr.Tab("SANGUÍNEO"):
-            sang_str = gr.CheckboxGroup(
-                choices=analyzer.questionnaire['SANGUÍNEO']['strengths'],
-                label="Pontos Fortes"
-            )
-            sang_weak = gr.CheckboxGroup(
-                choices=analyzer.questionnaire['SANGUÍNEO']['weaknesses'],
-                label="Pontos Fracos"
-            )
-            
-        with gr.Tab("COLÉRICO"):
-            col_str = gr.CheckboxGroup(
-                choices=analyzer.questionnaire['COLÉRICO']['strengths'],
-                label="Pontos Fortes"
-            )
-            col_weak = gr.CheckboxGroup(
-                choices=analyzer.questionnaire['COLÉRICO']['weaknesses'],
-                label="Pontos Fracos"
-            )
-            
-        with gr.Tab("MELANCÓLICO"):
-            mel_str = gr.CheckboxGroup(
-                choices=analyzer.questionnaire['MELANCÓLICO']['strengths'],
-                label="Pontos Fortes"
-            )
-            mel_weak = gr.CheckboxGroup(
-                choices=analyzer.questionnaire['MELANCÓLICO']['weaknesses'],
-                label="Pontos Fracos"
-            )
-            
-        with gr.Tab("FLEUMÁTICO"):
-            fleu_str = gr.CheckboxGroup(
-                choices=analyzer.questionnaire['FLEUMÁTICO']['strengths'],
-                label="Pontos Fortes"
-            )
-            fleu_weak = gr.CheckboxGroup(
-                choices=analyzer.questionnaire['FLEUMÁTICO']['weaknesses'],
-                label="Pontos Fracos"
-            )
-
-        analyze_btn = gr.Button("Analisar Temperamento", variant="primary")
-        output = gr.Markdown()
-
-        analyze_btn.click(
-            fn=process_selections,
-            inputs=[
-                sang_str, sang_weak,
-                col_str, col_weak,
-                mel_str, mel_weak,
-                fleu_str, fleu_weak
-            ],
-            outputs=output
+        # Cria uma lista única com todas as características
+        todas_caracteristicas = []
+        for temp, caract in analisador.temperamentos.items():
+            todas_caracteristicas.extend(caract)
+        
+        # Checkbox para seleção
+        selecoes = gr.CheckboxGroup(
+            choices=todas_caracteristicas,
+            label="Selecione as características que mais combinam com você:"
         )
+        
+        # Botão e saída
+        btn = gr.Button("Analisar")
+        saida = gr.Markdown()
+        
+        # Evento
+        btn.click(
+            fn=processar_selecao,
+            inputs=selecoes,
+            outputs=saida
+        )
+    
+    return interface
 
-    return iface
+# Arquivo requirements.txt simplificado
+"""
+gradio==4.19.2
+transformers==4.37.2
+numpy==1.26.3
+torch==2.1.2
+"""
 
 if __name__ == "__main__":
-    iface = create_interface()
-    iface.launch()
+    interface = criar_interface()
+    interface.launch()