Update app.py

app.py

@@ -1,4 +1,8 @@
 import streamlit as st
+import streamlit_authenticator as stauth
+import yaml
+from yaml.loader import SafeLoader
+import os
 from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
 import torch
 from PIL import Image
@@ -7,7 +11,6 @@ import librosa
 import numpy as np
 import logging
 import tempfile
-import os
 from streamlit.runtime.uploaded_file_manager import UploadedFile
 from diffusers import StableDiffusionPipeline
 
@@ -25,6 +28,50 @@ logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 
+# Configurar autenticação
+def load_auth_config():
+    """Carrega configuração de autenticação de variável de ambiente ou arquivo"""
+    try:
+        # Tenta carregar da variável de ambiente (Hugging Face Secrets)
+        config_yaml = os.getenv('AUTH_CONFIG')
+        if config_yaml:
+            config = yaml.load(config_yaml, Loader=SafeLoader)
+            return config
+        
+        # Alternativa: carregar de um arquivo externo
+        config_path = os.getenv('AUTH_CONFIG_PATH', '~/.streamlit/config.yaml')
+        config_path = os.path.expanduser(config_path)
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as file:
+                config = yaml.load(file, Loader=SafeLoader)
+            return config
+        
+        # Configuração padrão para testes (remover em produção)
+        st.warning("⚠️ Nenhuma configuração de autenticação encontrada. Usando credenciais padrão (inseguro).")
+        config = {
+            'credentials': {
+                'usernames': {
+                    'cliente': {
+                        'name': 'Cliente',
+                        'password': '$2b$12$6r1z.7zM7kL9vJ8K2Qf3Ce7V8Z9Qz3q0zXzY7W8K9vJ8K2Qf3Ce7'  # Senha: senha123
+                    }
+                }
+            },
+            'cookie': {
+                'name': 'ai_app_cookie',
+                'key': 'random_key_123',
+                'expiry_days': 30
+            },
+            'preauthorized': {
+                'emails': []
+            }
+        }
+        return config
+    except Exception as e:
+        st.error(f"Erro ao carregar configuração de autenticação: {str(e)}")
+        logging.error(f"Erro na configuração de autenticação: {e}")
+        return None
+
 # Cache para evitar recarregar modelos a cada execução
 @st.cache_resource(show_spinner=False)
 def load_models():
@@ -185,10 +232,14 @@ def process_image_file(image_file):
         logging.error(f"Erro no processamento de imagem: {e}")
         return None
 
-def display_results(result, model_key):
+def display_results(result, model_key, input_text=None):
     """Exibe resultados formatados de acordo com o tipo de modelo"""
     if model_key == 'summarization':
         st.subheader("📝 Resumo Gerado")
+        if input_text:
+            st.markdown("**Texto Original:**")
+            st.write(input_text)
+            st.markdown("**Resumo:**")
         st.info(result[0]['summary_text'])
     
     elif model_key == 'translation':
@@ -310,7 +361,7 @@ def get_use_cases():
             'description': "Identifica defeitos ou classifica produtos em linhas de produção com base em imagens.",
             'example': "Uma fábrica de eletrônicos classifica imagens de circuitos como 'Defeituoso' ou 'Aprovado' para controle de qualidade.",
             'benefit': "Redução de erros humanos e aumento da eficiência na inspeção.",
-            'demo_input': None,  # Imagens não podem ser pré-carregadas diretamente no código
+            'demo_input': None,
             'demo_type': 'image'
         },
         'object_detection': {
@@ -374,7 +425,7 @@ def handle_use_case_demo(models, use_case_key, use_case):
         if use_case['demo_type'] == 'text':
             with st.spinner("Processando demonstração..."):
                 result = models[use_case_key](use_case['demo_input'])
-                display_results(result, use_case_key)
+                display_results(result, use_case_key, input_text=use_case['demo_input'])
         elif use_case['demo_type'] == 'qa':
             with st.spinner("Processando demonstração..."):
                 result = models[use_case_key](
@@ -382,6 +433,8 @@ def handle_use_case_demo(models, use_case_key, use_case):
                     context=use_case['demo_input']['context']
                 )
                 st.success("🔍 Resposta encontrada:")
+                st.markdown(f"**Contexto:** {use_case['demo_input']['context']}")
+                st.markdown(f"**Pergunta:** {use_case['demo_input']['question']}")
                 st.markdown(f"**Resposta:** {result['answer']}")
                 st.markdown(f"**Confiança:** {result['score']:.2%}")
     except Exception as e:
@@ -389,132 +442,153 @@ def handle_use_case_demo(models, use_case_key, use_case):
         logging.error(f"Erro na demonstração do caso de uso {use_case_key}: {e}")
 
 def main():
-    st.title("🤖 Aplicação de IA Multi-Modal Avançada")
-    st.markdown("---")
-    
-    # Carregar modelos
-    with st.spinner("Carregando modelos de IA... (Isso pode levar alguns minutos na primeira execução)"):
-        models = load_models()
-    
-    if not models:
-        st.error("Falha crítica ao carregar os modelos. Verifique os logs para mais detalhes.")
+    # Carregar configuração de autenticação
+    config = load_auth_config()
+    if not config:
+        st.error("Falha ao carregar autenticação. Contate o administrador.")
         return
     
-    # Abas para navegação
-    tab1, tab2 = st.tabs(["Explorar Modelos", "Casos de Uso"])
-    
-    with tab1:
-        # Sidebar para seleção de modelo
-        st.sidebar.title("⚙️ Configurações")
-        model_categories = {
-            "📝 Processamento de Texto": [
-                ("Análise de Sentimento", "sentiment_analysis"),
-                ("Classificação de Texto", "text_classification"),
-                ("Resumo de Texto", "summarization"),
-                ("Perguntas e Respostas", "question_answering"),
-                ("Tradução (EN→PT)", "translation"),
-                ("Reconhecimento de Entidades", "ner"),
-                ("Geração de Texto", "text_generation")
-            ],
-            "🖼️ Processamento de Imagem": [
-                ("Classificação de Imagem", "image_classification"),
-                ("Detecção de Objetos", "object_detection"),
-                ("Segmentação de Imagem", "image_segmentation"),
-                ("Reconhecimento Facial", "facial_recognition")
-            ],
-            "🎵 Processamento de Áudio": [
-                ("Transcrição de Áudio", "speech_to_text"),
-                ("Classificação de Emoções", "audio_classification")
-            ],
-            "✨ Modelos Generativos": [
-                ("Texto para Imagem", "text_to_image")
-            ]
-        }
-        
-        selected_category = st.sidebar.selectbox(
-            "Categoria",
-            list(model_categories.keys()),
-            index=0
-        )
+    authenticator = stauth.Authenticate(
+        config['credentials'],
+        config['cookie']['name'],
+        config['cookie']['key'],
+        config['cookie']['expiry_days'],
+        config['preauthorized']
+    )
+
+    # Tela de login
+    name, authentication_status, username = authenticator.login('Login', 'main')
+
+    if authentication_status:
+        st.write(f"Bem-vindo, {name}!")
+        authenticator.logout('Logout', 'sidebar')
+
+        st.title("🤖 Aplicação de IA Multi-Modal Avançada")
+        st.markdown("---")
         
-        selected_model = st.sidebar.selectbox(
-            "Modelo", 
-            [name for name, key in model_categories[selected_category]],
-            format_func=lambda x: x,
-            index=0
-        )
+        # Carregar modelos
+        with st.spinner("Carregando modelos de IA... (Isso pode levar alguns minutos na primeira execução)"):
+            models = load_models()
         
-        # Obter chave do modelo selecionado
-        model_key = next(key for name, key in model_categories[selected_category] if name == selected_model)
+        if not models:
+            st.error("Falha crítica ao carregar os modelos. Verifique os logs para mais detalhes.")
+            return
         
-        # Interface principal
-        st.header(f"{selected_model}")
+        # Abas para navegação
+        tab1, tab2 = st.tabs(["Explorar Modelos", "Casos de Uso"])
         
-        # Accordion para informações do modelo
-        with st.expander("ℹ️ Sobre este modelo"):
-            model_info = {
-                'sentiment_analysis': "Analisa o sentimento expresso em um texto (positivo/negativo/neutro).",
-                'text_classification': "Classifica textos em categorias pré-definidas.",
-                'summarization': "Gera um resumo conciso de um texto longo.",
-                'question_answering': "Responde perguntas baseadas em um contexto fornecido.",
-                'translation': "Traduz texto de inglês para português.",
-                'ner': "Identifica e classifica entidades nomeadas (pessoas, lugares, organizações).",
-                'text_generation': "Gera texto criativo continuando a partir de um prompt.",
-                'image_classification': "Identifica objetos e cenas em imagens.",
-                'object_detection': "Detecta e localiza múltiplos objetos em uma imagem.",
-                'image_segmentation': "Segmenta diferentes elementos em uma imagem.",
-                'facial_recognition': "Reconhece características faciais e emoções.",
-                'speech_to_text': "Transcreve fala em texto.",
-                'audio_classification': "Classifica emoções em arquivos de áudio.",
-                'text_to_image': "Gera imagens a partir de descrições textuais."
+        with tab1:
+            # Sidebar para seleção de modelo
+            st.sidebar.title("⚙️ Configurações")
+            model_categories = {
+                "📝 Processamento de Texto": [
+                    ("Análise de Sentimento", "sentiment_analysis"),
+                    ("Classificação de Texto", "text_classification"),
+                    ("Resumo de Texto", "summarization"),
+                    ("Perguntas e Respostas", "question_answering"),
+                    ("Tradução (EN→PT)", "translation"),
+                    ("Reconhecimento de Entidades", "ner"),
+                    ("Geração de Texto", "text_generation")
+                ],
+                "🖼️ Processamento de Imagem": [
+                    ("Classificação de Imagem", "image_classification"),
+                    ("Detecção de Objetos", "object_detection"),
+                    ("Segmentação de Imagem", "image_segmentation"),
+                    ("Reconhecimento Facial", "facial_recognition")
+                ],
+                "🎵 Processamento de Áudio": [
+                    ("Transcrição de Áudio", "speech_to_text"),
+                    ("Classificação de Emoções", "audio_classification")
+                ],
+                "✨ Modelos Generativos": [
+                    ("Texto para Imagem", "text_to_image")
+                ]
             }
-            st.info(model_info.get(model_key, "Informações detalhadas sobre este modelo."))
-        
-        # Processamento baseado no tipo de modelo
-        try:
-            if model_key in ['sentiment_analysis', 'text_classification', 'summarization', 
-                            'translation', 'text_generation', 'ner']:
-                handle_text_models(models, model_key, selected_model)
             
-            elif model_key == 'question_answering':
-                handle_qa_model(models, model_key)
+            selected_category = st.sidebar.selectbox(
+                "Categoria",
+                list(model_categories.keys()),
+                index=0
+            )
             
-            elif model_key in ['image_classification', 'object_detection', 
-                              'image_segmentation', 'facial_recognition']:
-                handle_image_models(models, model_key, selected_model)
+            selected_model = st.sidebar.selectbox(
+                "Modelo", 
+                [name for name, key in model_categories[selected_category]],
+                format_func=lambda x: x,
+                index=0
+            )
             
-            elif model_key in ['speech_to_text', 'audio_classification']:
-                handle_audio_models(models, model_key)
+            # Obter chave do modelo selecionado
+            model_key = next(key for name, key in model_categories[selected_category] if name == selected_model)
             
-            elif model_key == 'text_to_image':
-                handle_generative_models(models, model_key)
-        
-        except Exception as e:
-            st.error(f"Erro inesperado durante a execução: {str(e)}")
-            logging.exception("Erro durante a execução do modelo")
-    
-    with tab2:
-        st.header("Casos de Uso")
-        st.markdown("Explore casos práticos de aplicação dos modelos para resolver problemas reais.")
-        
-        use_cases = get_use_cases()
-        selected_use_case = st.selectbox(
-            "Selecione um caso de uso",
-            list(use_cases.keys()),
-            format_func=lambda x: use_cases[x]['title']
-        )
-        
-        use_case = use_cases[selected_use_case]
-        
-        st.subheader(use_case['title'])
-        with st.expander("ℹ️ Detalhes do Caso de Uso"):
-            st.markdown(f"**Descrição**: {use_case['description']}")
-            st.markdown(f"**Exemplo Prático**: {use_case['example']}")
-            st.markdown(f"**Benefício**: {use_case['benefit']}")
+            # Interface principal
+            st.header(f"{selected_model}")
+            
+            # Accordion para informações do modelo
+            with st.expander("ℹ️ Sobre este modelo"):
+                model_info = {
+                    'sentiment_analysis': "Analisa o sentimento expresso em um texto (positivo/negativo/neutro).",
+                    'text_classification': "Classifica textos em categorias pré-definidas.",
+                    'summarization': "Gera um resumo conciso de um texto longo.",
+                    'question_answering': "Responde perguntas baseadas em um contexto fornecido.",
+                    'translation': "Traduz texto de inglês para português.",
+                    'ner': "Identifica e classifica entidades nomeadas (pessoas, lugares, organizações).",
+                    'text_generation': "Gera texto criativo continuando a partir de um prompt.",
+                    'image_classification': "Identifica objetos e cenas em imagens.",
+                    'object_detection': "Detecta e localiza múltiplos objetos em uma imagem.",
+                    'image_segmentation': "Segmenta diferentes elementos em uma imagem.",
+                    'facial_recognition': "Reconhece características faciais e emoções.",
+                    'speech_to_text': "Transcreve fala em texto.",
+                    'audio_classification': "Classifica emoções em arquivos de áudio.",
+                    'text_to_image': "Gera imagens a partir de descrições textuais."
+                }
+                st.info(model_info.get(model_key, "Informações detalhadas sobre este modelo."))
+            
+            # Processamento baseado no tipo de modelo
+            try:
+                if model_key in ['sentiment_analysis', 'text_classification', 'summarization', 
+                                'translation', 'text_generation', 'ner']:
+                    handle_text_models(models, model_key, selected_model)
+                
+                elif model_key == 'question_answering':
+                    handle_qa_model(models, model_key)
+                
+                elif model_key in ['image_classification', 'object_detection', 
+                                  'image_segmentation', 'facial_recognition']:
+                    handle_image_models(models, model_key, selected_model)
+                
+                elif model_key in ['speech_to_text', 'audio_classification']:
+                    handle_audio_models(models, model_key)
+                
+                elif model_key == 'text_to_image':
+                    handle_generative_models(models, model_key)
+            
+            except Exception as e:
+                st.error(f"Erro inesperado durante a execução: {str(e)}")
+                logging.exception("Erro durante a execução do modelo")
         
-        if use_case['demo_input'] is not None:
-            if st.button("🚀 Executar Demonstração", key=f"demo_{selected_use_case}"):
-                handle_use_case_demo(models, selected_use_case, use_case)
+        with tab2:
+            st.header("Casos de Uso")
+            st.markdown("Explore casos práticos de aplicação dos modelos para resolver problemas reais.")
+            
+            use_cases = get_use_cases()
+            selected_use_case = st.selectbox(
+                "Selecione um caso de uso",
+                list(use_cases.keys()),
+                format_func=lambda x: use_cases[x]['title']
+            )
+            
+            use_case = use_cases[selected_use_case]
+            
+            st.subheader(use_case['title'])
+            with st.expander("ℹ️ Detalhes do Caso de Uso"):
+                st.markdown(f"**Descrição**: {use_case['description']}")
+                st.markdown(f"**Exemplo Prático**: {use_case['example']}")
+                st.markdown(f"**Benefício**: {use_case['benefit']}")
+            
+            if use_case['demo_input'] is not None:
+                if st.button("🚀 Executar Demonstração", key=f"demo_{selected_use_case}"):
+                    handle_use_case_demo(models, selected_use_case, use_case)
 
 def handle_text_models(models, model_key, model_name):
     """Manipula modelos de texto"""
@@ -557,7 +631,7 @@ def handle_text_models(models, model_key, model_name):
                     else:
                         result = models[model_key](input_text, **advanced_params)
                     
-                    display_results(result, model_key)
+                    display_results(result, model_key, input_text=input_text)
                     
                 except Exception as e:
                     st.error(f"Erro ao processar texto: {str(e)}")
@@ -598,6 +672,8 @@ def handle_qa_model(models, model_key):
                         st.warning(f"⚠️ Confiança baixa na resposta ({result['score']:.2%})")
                     
                     st.success("🔍 Resposta encontrada:")
+                    st.markdown(f"**Contexto:** {context}")
+                    st.markdown(f"**Pergunta:** {question}")
                     st.markdown(f"**Resposta:** {result['answer']}")
                     st.markdown(f"**Confiança:** {result['score']:.2%}")