Update app.py

app.py

@@ -1,7 +1,6 @@
 import streamlit as st
 import streamlit_authenticator as stauth
-import yaml
-from yaml.loader import SafeLoader
+import sqlite3
 import os
 from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
 import torch
@@ -28,55 +27,66 @@ 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"""
+# Configurar banco de dados SQLite
+def init_db():
+    """Inicializa o banco de dados SQLite com tabela de usuários"""
+    db_path = os.getenv('DB_PATH', 'users.db')
+    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
+        )
+    ''')
+    
+    # Adicionar usuários de exemplo (remover ou personalizar em produção)
     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
+        hashed_password = stauth.Hasher(['senha123']).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))
+        conn.commit()
+    except Exception as e:
+        logging.error(f"Erro ao inicializar banco de dados: {e}")
+        st.error(f"Erro ao inicializar banco de dados: {str(e)}")
+    
+    conn.close()
+
+def load_users_from_db():
+    """Carrega usuários do banco de dados SQLite"""
+    try:
+        db_path = os.getenv('DB_PATH', '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()}
+        conn.close()
         
-        # 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': []
-            }
+            'credentials': {'usernames': users},
+            '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}")
+        st.error(f"Erro ao carregar usuários do banco de dados: {str(e)}")
+        logging.error(f"Erro ao carregar usuários: {e}")
         return None
 
 # Cache para evitar recarregar modelos a cada execução
 @st.cache_resource(show_spinner=False)
 def load_models():
     """Carrega todos os modelos com cache para melhor performance"""
-    device = torch.device("cpu")
+    device = torch.device("cpu")  # Use 'cuda' se GPU estiver disponível
     logging.info(f"Usando dispositivo: {device}")
     models = {}
     
@@ -442,8 +452,11 @@ 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():
+    # Inicializar banco de dados
+    init_db()
+    
     # Carregar configuração de autenticação
-    config = load_auth_config()
+    config = load_users_from_db()
     if not config:
         st.error("Falha ao carregar autenticação. Contate o administrador.")
         return
@@ -639,154 +652,4 @@ def handle_text_models(models, model_key, model_name):
         else:
             st.warning("⚠️ Por favor, insira um texto válido.")
 
-def handle_qa_model(models, model_key):
-    """Manipula modelo de Q&A"""
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        context = st.text_area(
-            "Contexto:", 
-            height=200,
-            placeholder="Cole o texto que contém a informação...",
-            key="qa_context"
-        )
-    
-    with col2:
-        question = st.text_area(
-            "Pergunta:", 
-            height=150,
-            placeholder="Faça sua pergunta sobre o contexto...",
-            key="qa_question"
-        )
-    
-    with st.expander("⚙️ Parâmetros Avançados"):
-        confidence_threshold = st.slider("Limite de confiança", 0.0, 1.0, 0.5, 0.01)
-    
-    if st.button("🚀 Executar Pergunta e Resposta", type="primary", key="btn_qa"):
-        if context.strip() and question.strip():
-            with st.spinner("Buscando resposta..."):
-                try:
-                    result = models[model_key](question=question, context=context)
-                    
-                    if result['score'] < confidence_threshold:
-                        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%}")
-                    
-                except Exception as e:
-                    st.error(f"Erro ao processar Q&A: {str(e)}")
-                    logging.error(f"Erro no modelo Q&A: {e}")
-        else:
-            st.warning("⚠️ Por favor, forneça tanto o contexto quanto a pergunta.")
-
-def handle_image_models(models, model_key, model_name):
-    """Manipula modelos de imagem"""
-    uploaded_file = st.file_uploader(
-        "Carregue uma imagem", 
-        type=["jpg", "png", "jpeg", "bmp"],
-        help="Formatos suportados: JPG, PNG, JPEG, BMP",
-        key=f"img_upload_{model_key}"
-    )
-    
-    if uploaded_file is not None:
-        if not validate_image_file(uploaded_file):
-            st.error("⚠️ Formato de arquivo inválido ou arquivo corrompido.")
-            return
-            
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.subheader("🖼️ Imagem Original")
-            image = process_image_file(uploaded_file)
-            if image:
-                st.image(image)
-        
-        with col2:
-            st.subheader("📊 Resultados")
-            if st.button(f"🚀 Executar {model_name}", type="primary", key=f"btn_img_{model_key}"):
-                if image:
-                    with st.spinner("Analisando imagem..."):
-                        try:
-                            result = models[model_key](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}")
-
-def handle_audio_models(models, model_key):
-    """Manipula modelos de áudio"""
-    model_name = "Transcrição de Áudio" if model_key == 'speech_to_text' else "Classificação de Áudio"
-    
-    uploaded_file = st.file_uploader(
-        f"Carregue um arquivo de áudio para {model_name}", 
-        type=["wav", "mp3", "flac", "m4a"],
-        help="Formatos suportados: WAV, MP3, FLAC, M4A",
-        key=f"audio_upload_{model_key}"
-    )
-    
-    if uploaded_file is not None:
-        if not validate_audio_file(uploaded_file):
-            st.error("⚠️ Formato de arquivo inválido ou não suportado.")
-            return
-            
-        st.audio(uploaded_file, format="audio/wav")
-        
-        if st.button(f"🚀 Executar {model_name}", type="primary", key=f"btn_audio_{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)
-                        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}")
-
-def handle_generative_models(models, model_key):
-    """Manipula modelos generativos"""
-    prompt = st.text_area(
-        "Descrição da imagem:",
-        height=150,
-        placeholder="Descreva a imagem que deseja gerar...",
-        key="text_to_image_prompt"
-    )
-    
-    with st.expander("⚙️ Parâmetros Avançados"):
-        cols = st.columns(2)
-        with cols[0]:
-            width = st.slider("Largura", 256, 1024, 512, 64)
-        with cols[1]:
-            height = st.slider("Altura", 256, 1024, 512, 64)
-        num_images = st.slider("Número de imagens", 1, 4, 1)
-        guidance_scale = st.slider("Escala de orientação", 1.0, 20.0, 7.5)
-    
-    if st.button("🚀 Gerar Imagem", type="primary", key="btn_text_to_image"):
-        if prompt.strip():
-            with st.spinner("Criando imagem..."):
-                try:
-                    result = models[model_key](
-                        prompt,
-                        height=height,
-                        width=width,
-                        num_images_per_prompt=num_images,
-                        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}")
-        else:
-            st.warning("⚠️ Por favor, insira uma descrição para a imagem.")
-
-if __name__ == "__main__":
-    main()
+def handle