Update app.py

app.py

@@ -2,6 +2,9 @@ import streamlit as st
 import streamlit_authenticator as stauth
 import sqlite3
 import os
+import psycopg2
+import jwt
+from datetime import datetime, timedelta
 from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
 import torch
 from PIL import Image
@@ -12,6 +15,8 @@ import logging
 import tempfile
 from streamlit.runtime.uploaded_file_manager import UploadedFile
 from diffusers import StableDiffusionPipeline
+import sentry_sdk
+from streamlit_tour import st_tour
 
 # Configurar página
 st.set_page_config(
@@ -20,43 +25,42 @@ st.set_page_config(
     layout="wide"
 )
 
-# Configurar logging
+# Configurar logging e Sentry
+sentry_sdk.init(os.getenv('SENTRY_DSN', ''), traces_sample_rate=1.0)
 logging.basicConfig(
-    filename='app_errors.log',
+    filename='/home/user/app/private/app_errors.log',
     level=logging.ERROR,
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 
-# Configurar banco de dados SQLite
+# Configurar banco de dados
 def init_db():
     """Inicializa o banco de dados SQLite com tabela de usuários"""
-    db_path = os.getenv('DB_PATH', 'users.db')
+    db_path = os.getenv('DB_PATH', '/home/user/app/private/users.db')
+    os.makedirs(os.path.dirname(db_path), exist_ok=True)
     conn = sqlite3.connect(db_path)
     cursor = conn.cursor()
     
-    # Criar tabela de usuários se não existir
     cursor.execute('''
         CREATE TABLE IF NOT EXISTS users (
             username TEXT PRIMARY KEY,
             name TEXT NOT NULL,
-            password TEXT NOT NULL
+            password TEXT NOT NULL,
+            role TEXT NOT NULL DEFAULT 'user'
         )
     ''')
     
-    # Adicionar usuários de exemplo (remover ou personalizar em produção)
+    # Adicionar admin padrão (remover em produção)
     try:
-        hashed_password = stauth.Hasher(['senha123']).generate()[0]
+        hashed_password = stauth.Hasher(['admin123']).generate()[0]
         cursor.execute('''
-            INSERT OR IGNORE INTO users (username, name, password)
-            VALUES (?, ?, ?)
-        ''', ('cliente', 'Cliente', hashed_password))
-        cursor.execute('''
-            INSERT OR IGNORE INTO users (username, name, password)
-            VALUES (?, ?, ?)
-        ''', ('empresa1', 'Empresa Um', hashed_password))
+            INSERT OR IGNORE INTO users (username, name, password, role)
+            VALUES (?, ?, ?, ?)
+        ''', ('admin', 'Administrador', hashed_password, 'admin'))
         conn.commit()
     except Exception as e:
         logging.error(f"Erro ao inicializar banco de dados: {e}")
+        sentry_sdk.capture_exception(e)
         st.error(f"Erro ao inicializar banco de dados: {str(e)}")
     
     conn.close()
@@ -64,11 +68,11 @@ def init_db():
 def load_users_from_db():
     """Carrega usuários do banco de dados SQLite"""
     try:
-        db_path = os.getenv('DB_PATH', 'users.db')
+        db_path = os.getenv('DB_PATH', '/home/user/app/private/users.db')
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
-        cursor.execute("SELECT username, name, password FROM users")
-        users = {row[0]: {'name': row[1], 'password': row[2]} for row in cursor.fetchall()}
+        cursor.execute("SELECT username, name, password, role FROM users")
+        users = {row[0]: {'name': row[1], 'password': row[2], 'role': row[3]} for row in cursor.fetchall()}
         conn.close()
         
         config = {
@@ -78,130 +82,64 @@ def load_users_from_db():
         }
         return config
     except Exception as e:
-        st.error(f"Erro ao carregar usuários do banco de dados: {str(e)}")
+        st.error(f"Erro ao carregar usuários: {str(e)}")
         logging.error(f"Erro ao carregar usuários: {e}")
+        sentry_sdk.capture_exception(e)
         return None
 
-# Cache para evitar recarregar modelos a cada execução
+# Cache para modelos
 @st.cache_resource(show_spinner=False)
-def load_models():
-    """Carrega todos os modelos com cache para melhor performance"""
-    device = torch.device("cpu")  # Use 'cuda' se GPU estiver disponível
-    logging.info(f"Usando dispositivo: {device}")
-    models = {}
+def load_model(model_key):
+    """Carrega modelo específico com cache persistente"""
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    cache_dir = "/home/user/app/model_cache"
+    os.makedirs(cache_dir, exist_ok=True)
+    logging.info(f"Carregando modelo {model_key} em {device} com cache em {cache_dir}")
     
     try:
-        # Modelos de texto
-        models['sentiment_analysis'] = pipeline(
-            "sentiment-analysis", 
-            model="cardiffnlp/twitter-roberta-base-sentiment-latest",
-            device=device
-        )
-        
-        models['text_classification'] = pipeline(
-            "text-classification", 
-            model="distilbert-base-uncased-finetuned-sst-2-english",
-            device=device
-        )
-        
-        models['summarization'] = pipeline(
-            "summarization", 
-            model="facebook/bart-large-cnn",
-            device=device,
-            max_length=150,
-            min_length=30
-        )
-        
-        models['question_answering'] = pipeline(
-            "question-answering", 
-            model="deepset/roberta-base-squad2",
-            device=device
-        )
-        
-        models['translation'] = pipeline(
-            "translation", 
-            model="Helsinki-NLP/opus-mt-tc-big-en-pt",
-            device=device
-        )
-
-        tokenizer_gpt2 = AutoTokenizer.from_pretrained("gpt2")
-        model_gpt2 = AutoModelForCausalLM.from_pretrained("gpt2")
-        model_gpt2.config.pad_token_id = model_gpt2.config.eos_token_id
-        
-        models['text_generation'] = pipeline(
-            "text-generation",
-            model=model_gpt2,
-            tokenizer=tokenizer_gpt2,
-            device=device
-        )
-        
-        models['ner'] = pipeline(
-            "ner",
-            model="dbmdz/bert-large-cased-finetuned-conll03-english",
-            device=device,
-            aggregation_strategy="simple"
-        )
-        
-        # Modelos de imagem
-        models['image_classification'] = pipeline(
-            "image-classification",
-            model="google/vit-base-patch16-224",
-            device=device
-        )
-        
-        models['object_detection'] = pipeline(
-            "object-detection",
-            model="facebook/detr-resnet-50",
-            device=device
-        )
-        
-        models['image_segmentation'] = pipeline(
-            "image-segmentation",
-            model="facebook/detr-resnet-50-panoptic",
-            device=device
-        )
-        
-        models['facial_recognition'] = pipeline(
-            "image-classification",
-            model="mo-thecreator/vit-Facial-Expression-Recognition",
-            device=device
-        )
-        
-        # Modelos de áudio
-        models['speech_to_text'] = pipeline(
-            "automatic-speech-recognition",
-            model="openai/whisper-base",
-            device=device
-        )
-        
-        models['audio_classification'] = pipeline(
-            "audio-classification",
-            model="superb/hubert-base-superb-er",
-            device=device
-        )
-        
-        # Modelos generativos
-        models['text_to_image'] = StableDiffusionPipeline.from_pretrained(
-            "runwayml/stable-diffusion-v1-5",
-            torch_dtype=torch.float16,
-            use_safetensors=True,
-            safety_checker=None,
-            variant="fp16"
-        )
-        
+        if model_key == 'sentiment_analysis':
+            return pipeline("sentiment-analysis", model="cardiffnlp/twitter-roberta-base-sentiment-latest", device=device, cache_dir=cache_dir)
+        elif model_key == 'text_classification':
+            return pipeline("text-classification", model="distilbert-base-uncased-finetuned-sst-2-english", device=device, cache_dir=cache_dir)
+        elif model_key == 'summarization':
+            return pipeline("summarization", model="facebook/bart-large-cnn", device=device, max_length=150, min_length=30, cache_dir=cache_dir)
+        elif model_key == 'question_answering':
+            return pipeline("question-answering", model="deepset/roberta-base-squad2", device=device, cache_dir=cache_dir)
+        elif model_key == 'translation':
+            return pipeline("translation", model="Helsinki-NLP/opus-mt-tc-big-en-pt", device=device, cache_dir=cache_dir)
+        elif model_key == 'text_generation':
+            tokenizer = AutoTokenizer.from_pretrained("gpt2", cache_dir=cache_dir)
+            model = AutoModelForCausalLM.from_pretrained("gpt2", cache_dir=cache_dir)
+            model.config.pad_token_id = model.config.eos_token_id
+            return pipeline("text-generation", model=model, tokenizer=tokenizer, device=device)
+        elif model_key == 'ner':
+            return pipeline("ner", model="dbmdz/bert-large-cased-finetuned-conll03-english", device=device, aggregation_strategy="simple", cache_dir=cache_dir)
+        elif model_key == 'image_classification':
+            return pipeline("image-classification", model="google/vit-base-patch16-224", device=device, cache_dir=cache_dir)
+        elif model_key == 'object_detection':
+            return pipeline("object-detection", model="facebook/detr-resnet-50", device=device, cache_dir=cache_dir)
+        elif model_key == 'image_segmentation':
+            return pipeline("image-segmentation", model="facebook/detr-resnet-50-panoptic", device=device, cache_dir=cache_dir)
+        elif model_key == 'facial_recognition':
+            return pipeline("image-classification", model="mo-thecreator/vit-Facial-Expression-Recognition", device=device, cache_dir=cache_dir)
+        elif model_key == 'speech_to_text':
+            return pipeline("automatic-speech-recognition", model="openai/whisper-base", device=device, cache_dir=cache_dir)
+        elif model_key == 'audio_classification':
+            return pipeline("audio-classification", model="superb/hubert-base-superb-er", device=device, cache_dir=cache_dir)
+        elif model_key == 'text_to_image':
+            return StableDiffusionPipeline.from_pretrained(
+                "runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16, use_safetensors=True, safety_checker=None, variant="fp16", cache_dir=cache_dir
+            )
     except Exception as e:
-        st.error(f"Erro crítico ao carregar modelos: {str(e)}")
-        logging.exception("Erro ao carregar modelos")
-        return {}
-    
-    return models
+        st.error(f"Erro ao carregar modelo {model_key}: {str(e)}")
+        logging.error(f"Erro ao carregar modelo {model_key}: {e}")
+        sentry_sdk.capture_exception(e)
+        return None
 
 def validate_audio_file(file: UploadedFile) -> bool:
     """Valida o arquivo de áudio"""
     valid_extensions = ['.wav', '.mp3', '.flac', '.m4a']
-    if not any(file.name.lower().endswith(ext) for ext in valid_extensions):
-        return False
-    return True
+    return any(file.name.lower().endswith(ext) for ext in valid_extensions)
 
 def validate_image_file(file: UploadedFile) -> bool:
     """Valida o arquivo de imagem"""
@@ -223,11 +161,11 @@ def process_audio_file(audio_file):
         
         audio_array, sample_rate = librosa.load(tmp_file_path, sr=16000)
         os.unlink(tmp_file_path)
-        
         return audio_array
     except Exception as e:
         st.error(f"Erro ao processar áudio: {str(e)}")
         logging.error(f"Erro no processamento de áudio: {e}")
+        sentry_sdk.capture_exception(e)
         return None
 
 def process_image_file(image_file):
@@ -240,6 +178,7 @@ def process_image_file(image_file):
     except Exception as e:
         st.error(f"Erro ao processar imagem: {str(e)}")
         logging.error(f"Erro no processamento de imagem: {e}")
+        sentry_sdk.capture_exception(e)
         return None
 
 def display_results(result, model_key, input_text=None):
@@ -304,6 +243,61 @@ def display_results(result, model_key, input_text=None):
         st.subheader("🎨 Imagem Gerada")
         st.image(result[0], caption="Imagem gerada a partir do texto")
 
+def load_branding(username):
+    """Carrega branding personalizado por usuário"""
+    branding = {
+        'admin': {'logo': '/home/user/app/logos/admin_logo.png', 'title': 'Bem-vindo, Administrador!'},
+        'cliente': {'logo': '/home/user/app/logos/cliente_logo.png', 'title': 'Bem-vindo, Cliente!'},
+        'empresa1': {'logo': '/home/user/app/logos/empresa1_logo.png', 'title': 'Bem-vindo, Empresa Um!'}
+    }
+    return branding.get(username, {'logo': None, 'title': 'Bem-vindo!'})
+
+def admin_panel(authenticator):
+    """Painel administrativo para gerenciar usuários"""
+    if st.session_state.get('role') == 'admin':
+        st.sidebar.subheader("Painel Admin")
+        with st.sidebar.form("add_user_form"):
+            username = st.text_input("Username")
+            name = st.text_input("Nome")
+            password = st.text_input("Senha", type="password")
+            role = st.selectbox("Role", ["user", "admin"])
+            if st.form_submit_button("Adicionar Usuário"):
+                hashed_password = stauth.Hasher([password]).generate()[0]
+                db_path = os.getenv('DB_PATH', '/home/user/app/private/users.db')
+                conn = sqlite3.connect(db_path)
+                cursor = conn.cursor()
+                try:
+                    cursor.execute('INSERT INTO users (username, name, password, role) VALUES (?, ?, ?, ?)', 
+                                 (username, name, hashed_password, role))
+                    conn.commit()
+                    st.success(f"Usuário {username} adicionado!")
+                except sqlite3.IntegrityError:
+                    st.error("Usuário já existe.")
+                except Exception as e:
+                    st.error(f"Erro ao adicionar usuário: {str(e)}")
+                    logging.error(f"Erro ao adicionar usuário: {e}")
+                    sentry_sdk.capture_exception(e)
+                conn.close()
+        
+        with st.sidebar.form("remove_user_form"):
+            username_to_remove = st.text_input("Username para Remover")
+            if st.form_submit_button("Remover Usuário"):
+                db_path = os.getenv('DB_PATH', '/home/user/app/private/users.db')
+                conn = sqlite3.connect(db_path)
+                cursor = conn.cursor()
+                try:
+                    cursor.execute('DELETE FROM users WHERE username = ?', (username_to_remove,))
+                    conn.commit()
+                    if cursor.rowcount > 0:
+                        st.success(f"Usuário {username_to_remove} removido!")
+                    else:
+                        st.error("Usuário não encontrado.")
+                except Exception as e:
+                    st.error(f"Erro ao remover usuário: {str(e)}")
+                    logging.error(f"Erro ao remover usuário: {e}")
+                    sentry_sdk.capture_exception(e)
+                conn.close()
+
 def get_use_cases():
     """Retorna os casos de uso para cada modelo"""
     return {
@@ -315,6 +309,7 @@ def get_use_cases():
             'demo_input': "A entrega foi super rápida, adorei!",
             'demo_type': 'text'
         },
+        # Outros casos de uso mantidos idênticos ao original
         'text_classification': {
             'title': "Classificação de Texto",
             'description': "Classifica e-mails recebidos como positivos ou negativos para priorizar respostas ou identificar reclamações.",
@@ -432,13 +427,14 @@ def handle_use_case_demo(models, use_case_key, use_case):
     
     st.subheader("📊 Demonstração")
     try:
+        model = models.get(use_case_key) or load_model(use_case_key)
         if use_case['demo_type'] == 'text':
             with st.spinner("Processando demonstração..."):
-                result = models[use_case_key](use_case['demo_input'])
+                result = model(use_case['demo_input'])
                 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](
+                result = model(
                     question=use_case['demo_input']['question'],
                     context=use_case['demo_input']['context']
                 )
@@ -450,6 +446,7 @@ def handle_use_case_demo(models, use_case_key, use_case):
     except Exception as e:
         st.error(f"Erro ao executar demonstração: {str(e)}")
         logging.error(f"Erro na demonstração do caso de uso {use_case_key}: {e}")
+        sentry_sdk.capture_exception(e)
 
 def main():
     # Inicializar banco de dados
@@ -473,51 +470,62 @@ def main():
     name, authentication_status, username = authenticator.login('Login', 'main')
 
     if authentication_status:
-        st.write(f"Bem-vindo, {name}!")
+        # Gerenciar sessão
+        if "user_id" not in st.session_state:
+            st.session_state.user_id = username
+            st.session_state.role = config['credentials']['usernames'][username]['role']
+        
+        # Carregar branding
+        branding = load_branding(username)
+        if branding['logo'] and os.path.exists(branding['logo']):
+            st.image(branding['logo'], width=150)
+        st.title(branding['title'])
+        
         authenticator.logout('Logout', 'sidebar')
-
-        st.title("🤖 Aplicação de IA Multi-Modal Avançada")
-        st.markdown("---")
+        admin_panel(authenticator)
         
-        # Carregar modelos
-        with st.spinner("Carregando modelos de IA... (Isso pode levar alguns minutos na primeira execução)"):
-            models = load_models()
+        # Tour guiado
+        if st.sidebar.button("Iniciar Tour"):
+            st_tour([
+                {"element": "#login", "title": "Login", "description": "Faça login com suas credenciais."},
+                {"element": "#tab1", "title": "Explorar Modelos", "description": "Teste modelos de IA."},
+                {"element": "#tab2", "title": "Casos de Uso", "description": "Explore aplicações práticas."}
+            ])
         
-        if not models:
-            st.error("Falha crítica ao carregar os modelos. Verifique os logs para mais detalhes.")
-            return
+        st.markdown("---")
+        
+        # Carregar modelos sob demanda
+        models = {}
+        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")
+            ]
+        }
         
         # 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()),
@@ -531,13 +539,17 @@ def main():
                 index=0
             )
             
-            # Obter chave do modelo selecionado
             model_key = next(key for name, key in model_categories[selected_category] if name == selected_model)
             
-            # Interface principal
+            # Carregar modelo com barra de progresso
+            if model_key not in models:
+                with st.spinner(f"Carregando modelo {selected_model}..."):
+                    progress = st.progress(0)
+                    models[model_key] = load_model(model_key)
+                    progress.progress(100)
+            
             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).",
@@ -557,7 +569,6 @@ def main():
                 }
                 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']:
@@ -578,7 +589,8 @@ def main():
             
             except Exception as e:
                 st.error(f"Erro inesperado durante a execução: {str(e)}")
-                logging.exception("Erro durante a execução do modelo")
+                logging.error(f"Erro durante a execução do modelo {model_key}: {e}")
+                sentry_sdk.capture_exception(e)
         
         with tab2:
             st.header("Casos de Uso")
@@ -612,7 +624,6 @@ def handle_text_models(models, model_key, model_name):
         key=f"text_input_{model_key}"
     )
     
-    # Parâmetros adicionais para alguns modelos
     advanced_params = {}
     if model_key == 'summarization':
         with st.expander("⚙️ Parâmetros Avançados"):
@@ -629,10 +640,11 @@ def handle_text_models(models, model_key, model_name):
         if input_text.strip():
             with st.spinner("Processando..."):
                 try:
+                    model = models.get(model_key) or load_model(model_key)
                     if model_key == 'ner':
-                        result = models[model_key](input_text)
+                        result = model(input_text)
                     elif model_key == 'text_generation':
-                        result = models[model_key](
+                        result = model(
                             input_text,
                             max_new_tokens=advanced_params.get('max_length', 100),
                             do_sample=True,
@@ -642,13 +654,14 @@ def handle_text_models(models, model_key, model_name):
                             num_return_sequences=advanced_params.get('num_return_sequences', 1)
                         )
                     else:
-                        result = models[model_key](input_text, **advanced_params)
+                        result = model(input_text, **advanced_params)
                     
                     display_results(result, model_key, input_text=input_text)
                     
                 except Exception as e:
                     st.error(f"Erro ao processar texto: {str(e)}")
                     logging.error(f"Erro no modelo {model_key}: {e}")
+                    sentry_sdk.capture_exception(e)
         else:
             st.warning("⚠️ Por favor, insira um texto válido.")
 
@@ -679,7 +692,8 @@ def handle_qa_model(models, model_key):
         if context.strip() and question.strip():
             with st.spinner("Buscando resposta..."):
                 try:
-                    result = models[model_key](question=question, context=context)
+                    model = models.get(model_key) or load_model(model_key)
+                    result = model(question=question, context=context)
                     
                     if result['score'] < confidence_threshold:
                         st.warning(f"⚠️ Confiança baixa na resposta ({result['score']:.2%})")
@@ -693,6 +707,7 @@ def handle_qa_model(models, model_key):
                 except Exception as e:
                     st.error(f"Erro ao processar Q&A: {str(e)}")
                     logging.error(f"Erro no modelo Q&A: {e}")
+                    sentry_sdk.capture_exception(e)
         else:
             st.warning("⚠️ Por favor, forneça tanto o contexto quanto a pergunta.")
 
@@ -724,12 +739,13 @@ def handle_image_models(models, model_key, model_name):
                 if image:
                     with st.spinner("Analisando imagem..."):
                         try:
-                            result = models[model_key](image)
+                            model = models.get(model_key) or load_model(model_key)
+                            result = model(image)
                             display_results(result, model_key)
-                                
                         except Exception as e:
                             st.error(f"Erro ao processar imagem: {str(e)}")
                             logging.error(f"Erro no modelo {model_key}: {e}")
+                            sentry_sdk.capture_exception(e)
 
 def handle_audio_models(models, model_key):
     """Manipula modelos de áudio"""
@@ -753,16 +769,16 @@ def handle_audio_models(models, model_key):
             with st.spinner("Processando áudio..."):
                 try:
                     audio_array = process_audio_file(uploaded_file)
-                    
                     if audio_array is not None:
-                        result = models[model_key](audio_array)
+                        model = models.get(model_key) or load_model(model_key)
+                        result = model(audio_array)
                         display_results(result, model_key)
                     else:
                         st.error("Não foi possível processar o arquivo de áudio.")
-                        
                 except Exception as e:
                     st.error(f"Erro ao processar áudio: {str(e)}")
                     logging.error(f"Erro no modelo {model_key}: {e}")
+                    sentry_sdk.capture_exception(e)
 
 def handle_generative_models(models, model_key):
     """Manipula modelos generativos"""
@@ -786,7 +802,8 @@ def handle_generative_models(models, model_key):
         if prompt.strip():
             with st.spinner("Criando imagem..."):
                 try:
-                    result = models[model_key](
+                    model = models.get(model_key) or load_model(model_key)
+                    result = model(
                         prompt,
                         height=height,
                         width=width,
@@ -794,10 +811,10 @@ def handle_generative_models(models, model_key):
                         guidance_scale=guidance_scale
                     )
                     display_results(result, model_key)
-                    
                 except Exception as e:
                     st.error(f"Erro ao gerar imagem: {str(e)}")
                     logging.error(f"Erro no modelo text-to-image: {e}")
+                    sentry_sdk.capture_exception(e)
         else:
             st.warning("⚠️ Por favor, insira uma descrição para a imagem.")