Update app.py

app.py

@@ -2,11 +2,61 @@ import gradio as gr
 from sentence_transformers import SentenceTransformer
 from sklearn.metrics.pairwise import cosine_similarity
 import numpy as np
+import plotly.graph_objects as go
 
 # Initialize model
 model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
 
-# Enhanced knowledge base with more detailed descriptions and combinations
+# Questionário DISC
+DISC_QUESTIONS = [
+    {
+        "pergunta": "Em situações de trabalho em equipe, você geralmente:",
+        "opcoes": [
+            ("D", "Assume a liderança e toma decisões rápidas"),
+            ("I", "Motiva o grupo e mantém o ambiente animado"),
+            ("S", "Apoia os colegas e mantém a harmonia"),
+            ("C", "Analisa detalhadamente antes de agir")
+        ]
+    },
+    {
+        "pergunta": "Quando enfrenta um desafio no trabalho, você:",
+        "opcoes": [
+            ("D", "Enfrenta diretamente e busca soluções imediatas"),
+            ("I", "Discute com outros e busca diferentes perspectivas"),
+            ("S", "Mantém a calma e segue um processo estabelecido"),
+            ("C", "Pesquisa todas as informações disponíveis primeiro")
+        ]
+    },
+    {
+        "pergunta": "Em reuniões profissionais, você costuma:",
+        "opcoes": [
+            ("D", "Ir direto ao ponto e focar em resultados"),
+            ("I", "Participar ativamente e compartilhar ideias"),
+            ("S", "Ouvir atentamente e contribuir quando solicitado"),
+            ("C", "Tomar notas e questionar os detalhes")
+        ]
+    },
+    {
+        "pergunta": "Ao lidar com mudanças no ambiente de trabalho, você:",
+        "opcoes": [
+            ("D", "Abraça a mudança e lidera a implementação"),
+            ("I", "Entusiasma os outros sobre as novas possibilidades"),
+            ("S", "Adapta-se gradualmente seguindo o processo"),
+            ("C", "Analisa os impactos antes de aceitar")
+        ]
+    },
+    {
+        "pergunta": "Sob pressão no trabalho, você tende a:",
+        "opcoes": [
+            ("D", "Tornar-se mais direto e focado em resultados"),
+            ("I", "Buscar apoio e interação com a equipe"),
+            ("S", "Manter a calma e seguir metodicamente"),
+            ("C", "Concentrar-se em detalhes e procedimentos")
+        ]
+    }
+]
+
+# Enhanced knowledge base
 DISC_PROFILES = {
     'D': {
         'nome': 'Dominância',
@@ -244,16 +294,61 @@ def get_profile_description(perfil, percentual):
         'recomendacoes': recomendacoes
     }
 
+def calcular_perfil(respostas):
+    """Calcula os percentuais de cada perfil DISC."""
+    contagem = {'D': 0, 'I': 0, 'S': 0, 'C': 0}
+    
+    for resposta in respostas:
+        if resposta:
+            perfil = resposta.split()[0]
+            contagem[perfil] += 1
+    
+    total = sum(contagem.values())
+    if total > 0:
+        percentuais = {k: (v/total) * 100 for k, v in contagem.items()}
+    else:
+        percentuais = {k: 0 for k in contagem.keys()}
+    
+    return percentuais
+
+def create_disc_plot(percentuais):
+    """Cria um gráfico de barras para visualização do perfil DISC."""
+    colors = {
+        'D': '#FF4B4B',
+        'I': '#FFD700',
+        'S': '#4CAF50',
+        'C': '#2196F3'
+    }
+    
+    fig = go.Figure(data=[
+        go.Bar(
+            x=list(percentuais.keys()),
+            y=list(percentuais.values()),
+            marker_color=[colors[k] for k in percentuais.keys()],
+            text=[f'{v:.1f}%' for v in percentuais.values()],
+            textposition='auto',
+        )
+    ])
+    
+    fig.update_layout(
+        title='Distribuição do Perfil DISC',
+        yaxis_title='Percentual (%)',
+        yaxis_range=[0, 100],
+        showlegend=False,
+        template='plotly_white',
+        height=400
+    )
+    
+    return fig
+
 def gerar_relatorio_personalizado(percentuais):
     """Gera relatório detalhado e personalizado baseado nos percentuais DISC."""
     perfis_ordenados = dict(sorted(percentuais.items(), key=lambda x: x[1], reverse=True))
     perfis_desc = {k: get_profile_description(k, v) for k, v in perfis_ordenados.items()}
     
-    # Perfil dominante e secundário
     perfil_dominante = list(perfis_ordenados.keys())[0]
     perfil_secundario = list(perfis_ordenados.keys())[1]
     
-    # Gerar relatório
     relatorio = f"""ANÁLISE DE PERFIL COMPORTAMENTAL DISC
 
 VISÃO GERAL
@@ -281,21 +376,6 @@ OBSERVAÇÃO: Este perfil representa suas tendências comportamentais naturais.
 
     return relatorio
 
-# Atualizar a função de processamento do questionário
-def processar_questionario(*args):
-    """Processa as respostas do questionário e gera o relatório personalizado."""
-    respostas = list(args)
-    percentuais = calcular_perfil(respostas)
-    return gerar_relatorio_personalizado(percentuais)
-
-# Manter o resto do código original (interface Gradio) como está...
-
-import gradio as gr
-from sentence_transformers import SentenceTransformer
-import numpy as np
-
-# Manter a base DISC_PROFILES do código anterior...
-
 # Temas e estilos personalizados
 CUSTOM_CSS = """
 .container {
@@ -315,8 +395,21 @@ CUSTOM_CSS = """
     background-color: #ffffff;
     box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
 }
+.progress-bar {
+    margin: 20px 0;
+    padding: 10px;
+    background: #eef2ff;
+    border-radius: 8px;
+}
+.footer {
+    margin-top: 30px;
+    text-align: center;
+    font-size: 0.9em;
+    color: #666;
+}
 """
 
+# Configuração do tema
 THEME = gr.themes.Soft(
     primary_hue="blue",
     secondary_hue="gray",
@@ -330,12 +423,21 @@ THEME = gr.themes.Soft(
     block_title_text_size="xl",
 )
 
-# Componente de progresso
 def update_progress(progress, total_questions=5):
     """Atualiza a barra de progresso."""
     answered = sum(1 for p in progress if p is not None)
     return f"{answered}/{total_questions} questões respondidas", answered / total_questions
 
+def reset_interface():
+    """Reinicia a interface para um novo teste."""
+    return [None] * 5 + [
+        gr.update(visible=False),
+        gr.update(interactive=True),
+        None, None, None, None,
+        "0/5 questões respondidas",
+        0
+    ]
+
 def create_interface():
     """Cria interface moderna do Gradio."""
     with gr.Blocks(theme=THEME, css=CUSTOM_CSS) as iface:
@@ -344,14 +446,22 @@ def create_interface():
             with gr.Column():
                 gr.Markdown("""
                 # 🎯 Análise de Perfil Comportamental DISC
-                Descubra seu perfil comportamental respondendo às questões abaixo.
-                Escolha as opções que melhor representam seu comportamento natural.
+                
+                ### Descubra seu perfil comportamental único!
+                
+                Este teste ajudará você a entender melhor seu estilo de comportamento natural
+                e como você pode aproveitar seus pontos fortes no ambiente profissional.
+                
+                #### Instruções:
+                - Responda todas as questões pensando em seu comportamento mais natural
+                - Não existe resposta certa ou errada
+                - Escolha a opção que melhor representa como você normalmente age
                 """)
         
         # Container principal
         with gr.Column(elem_classes="container"):
             # Barra de progresso
-            with gr.Row():
+            with gr.Row(elem_classes="progress-bar"):
                 progress_text = gr.Markdown("0/5 questões respondidas")
                 progress_bar = gr.Progress()
             
@@ -360,18 +470,19 @@ def create_interface():
             for i, questao in enumerate(DISC_QUESTIONS, 1):
                 with gr.Box(elem_classes="question-card"):
                     gr.Markdown(f"### Questão {i}: {questao['pergunta']}")
-                    radio = gr.Radio(
-                        choices=[f"{perfil} - {desc}" for perfil, desc in questao['opcoes']],
-                        label="Selecione a opção mais adequada",
-                        scale=0,
-                        interactive=True
-                    )
-                    radio_components.append(radio)
+                    with gr.Column():
+                        radio = gr.Radio(
+                            choices=[f"{perfil} - {desc}" for perfil, desc in questao['opcoes']],
+                            label="Selecione a opção mais adequada:",
+                            scale=0,
+                            interactive=True
+                        )
+                        radio_components.append(radio)
             
             # Botão de análise
-            with gr.Row():
+            with gr.Row(elem_classes="center"):
                 analyze_btn = gr.Button(
-                    "Analisar Perfil",
+                    "📊 Analisar Perfil",
                     variant="primary",
                     scale=0,
                     min_width=200
@@ -379,7 +490,7 @@ def create_interface():
             
             # Área de resultados
             with gr.Box(visible=False, elem_classes="result-card") as result_box:
-                gr.Markdown("### 📊 Resultado da Análise")
+                gr.Markdown("## 📊 Resultado da Análise")
                 
                 with gr.Row():
                     # Gráfico de distribuição
@@ -387,16 +498,18 @@ def create_interface():
                     
                     # Métricas principais
                     with gr.Column():
-                        perfil_dominante = gr.Textbox(
-                            label="Perfil Dominante",
-                            show_label=True,
-                            interactive=False
-                        )
-                        perfil_secundario = gr.Textbox(
-                            label="Perfil Secundário",
-                            show_label=True,
-                            interactive=False
-                        )
+                        with gr.Box():
+                            gr.Markdown("### Perfis Principais")
+                            perfil_dominante = gr.Textbox(
+                                label="Perfil Dominante",
+                                show_label=True,
+                                interactive=False
+                            )
+                            perfil_secundario = gr.Textbox(
+                                label="Perfil Secundário",
+                                show_label=True,
+                                interactive=False
+                            )
                 
                 # Relatório detalhado
                 with gr.Accordion("📝 Relatório Detalhado", open=True):
@@ -404,95 +517,83 @@ def create_interface():
                 
                 # Botões de ação
                 with gr.Row():
-                    reset_btn = gr.Button("🔄 Reiniciar", variant="secondary")
-                    download_btn = gr.Button("⬇️ Download PDF", variant="secondary")
+                    download_btn = gr.Button("⬇️ Baixar Relatório PDF", variant="secondary")
+                    reset_btn = gr.Button("🔄 Fazer Novo Teste", variant="secondary")
+                    share_btn = gr.Button("📤 Compartilhar Resultado", variant="secondary")
 
-            # Lógica de atualização da interface
-            def update_display(*answers):
-                if all(a is not None for a in answers):
-                    return {
-                        result_box: gr.update(visible=True),
-                        analyze_btn: gr.update(interactive=False)
-                    }
-                return {
-                    result_box: gr.update(visible=False),
-                    analyze_btn: gr.update(interactive=True)
-                }
-            
-            # Funções de processamento
-            def process_and_visualize(*answers):
-                """Processa respostas e gera visualizações."""
-                percentuais = calcular_perfil(answers)
-                
-                # Criar gráfico
-                fig = create_disc_plot(percentuais)
-                
-                # Gerar relatório
-                report = gerar_relatorio_personalizado(percentuais)
-                
-                # Identificar perfis principais
-                sorted_profiles = dict(sorted(percentuais.items(), key=lambda x: x[1], reverse=True))
-                main_profile = list(sorted_profiles.keys())[0]
-                secondary_profile = list(sorted_profiles.keys())[1]
-                
+            # Footer
+            with gr.Row(elem_classes="footer"):
+                gr.Markdown("""
+                    💡 **Observação:** Este é um teste comportamental indicativo. 
+                    Os resultados representam tendências naturais de comportamento,
+                    que podem variar dependendo do contexto e situação.
+                """)
+
+        # Event handlers
+        def update_display(*answers):
+            """Atualiza a visibilidade dos componentes baseado nas respostas."""
+            if all(a is not None for a in answers):
                 return {
-                    plot: fig,
-                    perfil_dominante: f"{main_profile} ({sorted_profiles[main_profile]:.1f}%)",
-                    perfil_secundario: f"{secondary_profile} ({sorted_profiles[secondary_profile]:.1f}%)",
-                    output: report
+                    result_box: gr.update(visible=True),
+                    analyze_btn: gr.update(interactive=False)
                 }
-            
-            def reset_interface():
-                """Reinicia a interface."""
-                return [None] * len(radio_components) + [
-                    gr.update(visible=False),
-                    gr.update(interactive=True),
-                    None, None, None, None,
-                    "0/5 questões respondidas"
-                ]
-            
-            # Event listeners
-            for radio in radio_components:
-                radio.change(
-                    lambda *args: update_progress(args),
-                    inputs=radio_components,
-                    outputs=[progress_text, progress_bar]
-                )
-                radio.change(
-                    update_display,
-                    inputs=radio_components,
-                    outputs=[result_box, analyze_btn]
-                )
-            
-            analyze_btn.click(
-                process_and_visualize,
+            return {
+                result_box: gr.update(visible=False),
+                analyze_btn: gr.update(interactive=True)
+            }
+
+        # Event bindings
+        for radio in radio_components:
+            radio.change(
+                lambda *args: update_progress(args),
                 inputs=radio_components,
-                outputs=[plot, perfil_dominante, perfil_secundario, output]
+                outputs=[progress_text, progress_bar]
             )
-            
-            reset_btn.click(
-                reset_interface,
-                outputs=radio_components + [
-                    result_box,
-                    analyze_btn,
-                    plot,
-                    perfil_dominante,
-                    perfil_secundario,
-                    output,
-                    progress_text
-                ]
-            )
-            
-            # Download handler (exemplo simples)
-            download_btn.click(
-                lambda x: f"disc_report_{x}.pdf",
-                inputs=[perfil_dominante],
-                outputs=gr.File()
+            radio.change(
+                update_display,
+                inputs=radio_components,
+                outputs=[result_box, analyze_btn]
             )
+        
+        analyze_btn.click(
+            process_and_visualize,
+            inputs=radio_components,
+            outputs=[plot, perfil_dominante, perfil_secundario, output]
+        )
+        
+        reset_btn.click(
+            reset_interface,
+            outputs=radio_components + [
+                result_box,
+                analyze_btn,
+                plot,
+                perfil_dominante,
+                perfil_secundario,
+                output,
+                progress_text,
+                progress_bar
+            ]
+        )
+        
+        # Exemplo simples de geração de PDF (você precisará implementar a função real)
+        def generate_pdf(report_text):
+            # Implementar geração real de PDF aqui
+            return "report.pdf"
+        
+        download_btn.click(
+            generate_pdf,
+            inputs=[output],
+            outputs=gr.File()
+        )
+        
+        # Função de compartilhamento (exemplo)
+        def share_results():
+            return gr.Info("Link de compartilhamento copiado!")
+        
+        share_btn.click(share_results)
 
     return iface
 
-# Criar e lançar a interface
 if __name__ == "__main__":
     iface = create_interface()
-    iface.launch(share=True)
+    iface.launch(show_error=True)