app.py

import gradio as gr
from transformers import pipeline
import numpy as np
from typing import List, Dict

class SimpleTemperamentAnalyzer:
    def __init__(self):
        # Modelo para análise de sentimentos em português
        self.model = pipeline(
            "text-classification",
            model="neuralmind/bert-base-portuguese-cased",
            return_all_scores=True
        )
        
        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']
        }

        # Descrições para análise do modelo
        self.descricoes_temperamentos = {
            'SANGUÍNEO': 'pessoa extrovertida, social, otimista e comunicativa',
            'COLÉRICO': 'pessoa determinada, prática, líder e independente',
            'MELANCÓLICO': 'pessoa perfeccionista, sensível, detalhista e artística',
            'FLEUMÁTICO': 'pessoa calma, pacífica, objetiva e organizada'
        }

    def analisar_texto_caracteristicas(self, caracteristicas: List[str]) -> Dict[str, float]:
        """Usa o modelo NLP para analisar o texto das características selecionadas"""
        # Junta as características em um texto para análise
        texto_analise = " ".join(caracteristicas)
        
        # Análise para cada temperamento
        scores_temp = {}
        for temp, desc in self.descricoes_temperamentos.items():
            # Analisa a similaridade entre as características selecionadas e a descrição do temperamento
            resultado = self.model(f"Características: {texto_analise}. Descrição: {desc}")
            scores_temp[temp] = resultado[0][0]['score']  # Pega o score principal
            
        return scores_temp

    def analisar_respostas(self, respostas_marcadas: List[str]) -> Dict[str, float]:
        """Combina análise tradicional com NLP para gerar pontuações"""
        # Pontuações baseadas em contagem
        pontuacoes_contagem = {}
        for temp, caracteristicas in self.temperamentos.items():
            marcadas = sum(1 for c in caracteristicas if c in respostas_marcadas)
            pontuacoes_contagem[temp] = marcadas
        
        # Pontuações baseadas em NLP
        pontuacoes_nlp = self.analisar_texto_caracteristicas(respostas_marcadas)
        
        # Combina as pontuações (média ponderada)
        pontuacoes_finais = {}
        for temp in self.temperamentos:
            # Peso 0.6 para contagem e 0.4 para NLP
            pond_contagem = pontuacoes_contagem[temp] * 0.6
            pond_nlp = pontuacoes_nlp[temp] * 0.4
            pontuacoes_finais[temp] = pond_contagem + pond_nlp
        
        # Normaliza para 100%
        total = sum(pontuacoes_finais.values())
        if total > 0:
            for temp in pontuacoes_finais:
                pontuacoes_finais[temp] = (pontuacoes_finais[temp] / total) * 100
        
        return pontuacoes_finais

    def interpretar_combinacao(self, temp_ordenados: List[tuple]) -> str:
        """Usa o modelo para interpretar a combinação de temperamentos"""
        combinacao = f"{temp_ordenados[0][0]} com {temp_ordenados[1][0]}"
        interpretacao = self.model(
            f"Combinação de temperamentos: {combinacao}. "
            f"Características principais: {self.descricoes_temperamentos[temp_ordenados[0][0]]} "
            f"com aspectos de {self.descricoes_temperamentos[temp_ordenados[1][0]]}"
        )
        return interpretacao[0][0]['label']

    def gerar_analise(self, temperamento_dominante: str, pontuacoes: Dict[str, float]) -> Dict:
        """Gera uma análise detalhada usando o modelo NLP"""
        descricoes = {
            'SANGUÍNEO': {
                'positivo': ['sociabilidade', 'entusiasmo', 'carisma', 'energia positiva', 'facilidade de comunicação'],
                'desafios': ['tendência à dispersão', 'dificuldade com rotinas', 'pode ser superficial'],
                'profissional': 'Tende a se destacar em áreas que envolvem interação social, vendas, comunicação e trabalho em equipe.',
                'relacionamentos': 'Faz amizades facilmente e mantém um círculo social ativo. Precisa desenvolver maior profundidade nas relações.'
            },
            'COLÉRICO': {
                'positivo': ['liderança', 'determinação', 'praticidade', 'foco em resultados', 'iniciativa'],
                'desafios': ['impaciência', 'autoritarismo', 'dificuldade em demonstrar empatia'],
                'profissional': 'Excelente em posições de liderança, gestão de projetos e empreendedorismo.',
                'relacionamentos': 'Direto e objetivo nas relações, precisa desenvolver mais sensibilidade e paciência.'
            },
            'MELANCÓLICO': {
                'positivo': ['profundidade analítica', 'criatividade', 'atenção aos detalhes', 'sensibilidade', 'perfeccionismo'],
                'desafios': ['autocrítica excessiva', 'tendência à introspecção', 'dificuldade com mudanças'],
                'profissional': 'Se destaca em áreas que exigem análise detalhada, planejamento e criatividade.',
                'relacionamentos': 'Valoriza relações profundas e significativas, mas pode ter dificuldade em se abrir.'
            },
            'FLEUMÁTICO': {
                'positivo': ['equilíbrio emocional', 'diplomacia', 'organização', 'confiabilidade', 'paciência'],
                'desafios': ['passividade', 'resistência a mudanças', 'dificuldade em tomar iniciativa'],
                'profissional': 'Eficiente em funções que requerem mediação, organização e trabalho metódico.',
                'relacionamentos': 'Estável e confiável nas relações, mas pode parecer distante ou pouco expressivo.'
            }
        }

        temp_ordenados = sorted(pontuacoes.items(), key=lambda x: x[1], reverse=True)
        
        # Usa o modelo para interpretar a combinação
        interpretacao_combinacao = self.interpretar_combinacao(temp_ordenados)
        
        analise = {
            'perfil_principal': f"Seu perfil predominante é {temperamento_dominante} ({pontuacoes[temperamento_dominante]:.1f}%), ",
            'combinacao': f"com influências significativas de {' e '.join([f'{temp} ({pont:.1f}%)' for temp, pont in temp_ordenados[1:3]])}.",
            'interpretacao': interpretacao_combinacao,
            'caracteristicas': [],
            'areas_desenvolvimento': [],
            'perfil_profissional': "",
            'relacionamentos': ""
        }
        
        # Análise das características principais usando o modelo
        for temp, pont in temp_ordenados[:2]:
            if pont > 20:
                caract_temp = " ".join(descricoes[temp]['positivo'])
                analise_caract = self.model(f"Características principais: {caract_temp}")
                analise['caracteristicas'].extend(descricoes[temp]['positivo'][:3])
                analise['areas_desenvolvimento'].extend(descricoes[temp]['desafios'][:2])
                analise['perfil_profissional'] += descricoes[temp]['profissional'] + " "
                analise['relacionamentos'] += descricoes[temp]['relacionamentos'] + " "
        
        return analise

def criar_interface():
    analisador = SimpleTemperamentAnalyzer()
    
    def validar_selecao(selecoes):
        if len(selecoes) > 5:
            # Retorna apenas as primeiras 5 seleções
            return selecoes[:5], "Por favor, selecione apenas 5 características."
        return selecoes, "" if selecoes else "Selecione até 5 características que mais combinam com você."
    
    def processar_selecao(selecoes):
        selecoes_validadas, mensagem = validar_selecao(selecoes)
        if mensagem and "apenas" in mensagem:  # Se excedeu o limite
            return f"⚠️ {mensagem}\n\nPor favor, desmarque algumas opções para continuar."
        
        if not selecoes_validadas:
            return "Selecione algumas características para realizar a análise."
            
        pontuacoes = analisador.analisar_respostas(selecoes_validadas)
        temperamento_dominante = max(pontuacoes.items(), key=lambda x: x[1])[0]
        analise = analisador.gerar_analise(temperamento_dominante, pontuacoes)
        
        resultado = "### Resultados da Análise de Temperamento\n\n"
        resultado += "**Características Selecionadas:**\n"
        for caract in selecoes_validadas:
            resultado += f"- {caract}\n"
            
        resultado += "\n**Pontuações:**\n"
        for temp, pont in pontuacoes.items():
            resultado += f"- {temp}: {pont:.1f}%\n"
        
        resultado += f"\n**Análise Detalhada:**\n"
        resultado += f"{analise['perfil_principal']}{analise['combinacao']}\n"
        resultado += f"**Interpretação:** {analise['interpretacao']}\n\n"
        
        resultado += "**Principais Características:**\n"
        for caract in analise['caracteristicas']:
            resultado += f"- {caract}\n"
            
        resultado += "\n**Áreas para Desenvolvimento:**\n"
        for area in analise['areas_desenvolvimento']:
            resultado += f"- {area}\n"
            
        resultado += f"\n**Perfil Profissional:**\n{analise['perfil_profissional']}\n\n"
        resultado += f"**Relacionamentos:**\n{analise['relacionamentos']}\n"
        
        return resultado

    with gr.Blocks(theme=gr.themes.Soft()) as interface:
        gr.Markdown("## Análise de Temperamento Simplificada")
        gr.Markdown("### Selecione exatamente 5 características que mais combinam com você")
        
        todas_caracteristicas = []
        for temp, caract in analisador.temperamentos.items():
            todas_caracteristicas.extend(caract)
        
        selecoes = gr.CheckboxGroup(
            choices=todas_caracteristicas,
            label="Escolha 5 características:",
            info="Limite: 5 características"
        )
        
        btn = gr.Button("Analisar")
        saida = gr.Markdown()
        
        # Atualiza em tempo real para validar seleções
        selecoes.change(
            fn=validar_selecao,
            inputs=selecoes,
            outputs=[selecoes, saida]
        )
        
        # Processa a análise quando o botão é clicado
        btn.click(
            fn=processar_selecao,
            inputs=selecoes,
            outputs=saida
        )
    
    return interface

if __name__ == "__main__":
    interface = criar_interface()
    interface.launch()