teste funcionalidade de autenticação

.streamlit/config.toml

@@ -0,0 +1,3 @@
+[theme]
+
+base = 'light'

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.11
+
+# Criação do diretório de trabalho
+WORKDIR /app
+
+# Instalação das dependências
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Criação de um novo usuário com UID 1000
+RUN useradd -m -u 1000 user
+
+# Mudança para o novo usuário
+USER user
+
+# Definição das variáveis de ambiente
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Definição do diretório de trabalho para o novo usuário
+WORKDIR $HOME/app
+
+# Cópia do código da aplicação com propriedade atribuída ao novo usuário
+COPY --chown=user . $HOME/app
+
+# Exposição da porta para o Streamlit
+EXPOSE 7860
+
+# Comando para iniciar o Flask em segundo plano e o Streamlit
+CMD ["sh", "-c", "python chatbot_server.py & streamlit run app.py --server.port 7860 --server.address 0.0.0.0"]

app.py

@@ -0,0 +1,140 @@
+import streamlit as st
+import requests
+from PIL import Image
+import base64
+
+import streamlit as st
+import streamlit_authenticator as stauth
+
+import yaml
+from yaml.loader import SafeLoader
+
+
+class ChatbotApp:
+    def __init__(self):
+        # URL do backend (Flask)
+        self.backend_url = "http://localhost:5001/chat"
+        self.title = "Chatbot Carômetro"
+        self.description = "Este assistente virtual pode te ajudar com informações sobre carômetros da Sicoob."
+
+    def stream_chat(self, user_input):
+        """
+        Faz a comunicação com o backend e retorna a resposta como streaming de tokens.
+        """
+        try:
+            response = requests.post(
+                self.backend_url,
+                json={"message": user_input},
+                stream=True  # Ativa o streaming
+            )
+            response.raise_for_status()
+
+            # Gera os tokens conforme chegam no streaming
+            for chunk in response.iter_content(chunk_size=512):
+                if chunk:
+                    yield chunk.decode("utf-8")
+        except Exception as e:
+            yield f"Erro ao conectar ao servidor: {e}"
+
+    def render_sidebar(self):
+        """
+        Exibe opções na barra lateral e renderiza a logo do Sicoob.
+        """
+        st.sidebar.title("Configuração de LLM")
+        sidebar_option = st.sidebar.radio("Selecione o LLM", ["gpt-3.5-turbo"])
+        if sidebar_option != "gpt-3.5-turbo":
+            raise Exception("Opção de LLM inválida!")
+
+        # Exibe a logo do Sicoob na barra lateral
+        with open("sicoob-logo.png", "rb") as f:
+            data = base64.b64encode(f.read()).decode("utf-8")
+            st.sidebar.markdown(
+                f"""
+                <div style="display:table;margin-top:-80%;margin-left:0%;">
+                    <img src="data:image/png;base64,{data}" width="250" height="70">
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+    def render(self):
+        """
+        Renderiza a interface do chatbot.
+        """
+        # Configura título, ícone e layout da página
+        im = Image.open("pngegg.png")
+        st.set_page_config(page_title="Chatbot Carômetro", page_icon=im, layout="wide")
+
+        with open('./config.yaml') as file:
+            config = yaml.load(file, Loader=SafeLoader)
+
+        # Pre-hashing all plain text passwords once
+        # stauth.Hasher.hash_passwords(config['credentials'])
+
+        authenticator = stauth.Authenticate(
+            config['credentials'],
+            config['cookie']['name'],
+            config['cookie']['key'],
+            config['cookie']['expiry_days']
+        )
+
+        #try:
+        #    authenticator.login()
+        #except Exception as e:
+        #    st.error(e)
+            
+        with open('./config.yaml', 'w', encoding='utf-8') as file:
+            yaml.dump(config, file, default_flow_style=False)
+
+
+        authentication_status = authenticator.login()
+
+        if st.session_state["authentication_status"]:
+            authenticator.logout('Logout', 'main')
+
+            # Renderiza a barra lateral
+            self.render_sidebar()
+
+            # Título e descrição
+            st.title(self.title)
+            st.write(self.description)
+
+            # Inicializa o histórico na sessão
+            if "chat_history" not in st.session_state:
+                st.session_state.chat_history = []
+
+            # Renderiza as mensagens do histórico
+            for message in st.session_state.chat_history:
+                role, text = message.split(":", 1)
+                with st.chat_message(role.strip().lower()):
+                    st.write(text.strip())
+
+            # Captura o input do usuário
+            user_input = st.chat_input("Digite sua pergunta")
+            if user_input:
+                # Exibe a mensagem do usuário
+                with st.chat_message("user"):
+                    st.write(user_input)
+                st.session_state.chat_history.append(f"user: {user_input}")
+
+                # Placeholder para a resposta do assistente
+                with st.chat_message("assistant"):
+                    message_placeholder = st.empty()
+                    assistant_message = ""
+
+                    # Executa o streaming de tokens enquanto o backend responde
+                    for token in self.stream_chat(user_input):
+                        assistant_message += token
+                        message_placeholder.markdown(assistant_message + "▌")
+
+                    # Atualiza o placeholder com a mensagem final
+                    message_placeholder.markdown(assistant_message)
+                    st.session_state.chat_history.append(f"assistant: {assistant_message}")
+        elif st.session_state["authentication_status"] == False:
+            st.error('Username/password is incorrect')
+        elif st.session_state["authentication_status"] == None:
+            st.warning('Please enter your username and password')
+
+if __name__ == "__main__":
+    chatbot_app = ChatbotApp()
+    chatbot_app.render()

chatbot_server.py

@@ -0,0 +1,131 @@
+import os
+import logging
+import sys
+
+from flask import Flask, request, jsonify, Response
+# Inicializa o Flask
+app = Flask(__name__)
+
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+from llama_index.llms.openai import OpenAI
+from llama_index.embeddings.openai import OpenAIEmbedding
+from llama_index.core import (
+    Settings,
+    SimpleDirectoryReader,
+    StorageContext,
+    Document,
+)
+
+Settings.llm = OpenAI(model="gpt-3.5-turbo")
+Settings.embed_model = OpenAIEmbedding(model_name="text-embedding-3-small")
+directory_path = "documentos"
+from llama_index.readers.file import PDFReader #concatenar todo o documento já vem nativo no pdfreader
+file_extractor = {".pdf": PDFReader(return_full_document = True)}
+from drive_downloader import GoogleDriveDownloader
+
+# ID da pasta no Drive e caminho local
+folder_id = "1n34bmh9rlbOtCvE_WPZRukQilKeabWsN"
+local_path = directory_path
+
+GoogleDriveDownloader().download_from_folder(folder_id, local_path)
+
+documents = SimpleDirectoryReader(
+    input_dir=directory_path,
+    file_extractor=file_extractor,
+    filename_as_id=True,
+    recursive=True
+).load_data()
+
+from document_creator import create_single_document_with_filenames
+document = create_single_document_with_filenames(directory_path = directory_path)
+documents.append(document)
+
+#from llama_index.core.ingestion import IngestionPipeline
+#ingestion pipeline vai entrar em uso quando adicionar o extrator de metadados
+from llama_index.core.node_parser import SentenceSplitter
+splitter = SentenceSplitter(chunk_size=1024, chunk_overlap=128)
+nodes = splitter.get_nodes_from_documents(documents)
+
+from llama_index.core.storage.docstore import SimpleDocumentStore
+docstore = SimpleDocumentStore()
+docstore.add_documents(nodes)
+
+from llama_index.core import VectorStoreIndex, StorageContext
+from llama_index.vector_stores.chroma import ChromaVectorStore
+import chromadb
+
+db = chromadb.PersistentClient(path="chroma_db")
+chroma_collection = db.get_or_create_collection("dense_vectors")
+vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
+storage_context = StorageContext.from_defaults(
+    docstore=docstore, vector_store=vector_store
+    )
+index = VectorStoreIndex(nodes = nodes, storage_context=storage_context, show_progress = True)
+
+storage_context.docstore.persist("./docstore.json")
+
+index_retriever = index.as_retriever(similarity_top_k=2)
+import nest_asyncio
+nest_asyncio.apply()
+from llama_index.retrievers.bm25 import BM25Retriever
+bm25_retriever = BM25Retriever.from_defaults(
+    docstore=index.docstore,
+    similarity_top_k=2,
+    language = "portuguese",
+    verbose=True,
+    )
+
+from llama_index.core.retrievers import QueryFusionRetriever
+
+retriever = QueryFusionRetriever(
+    [index_retriever, bm25_retriever],
+    num_queries=1, #desativado = 1
+    mode="reciprocal_rerank",
+    use_async=True,
+    verbose=True,
+)
+
+from llama_index.core.storage.chat_store import SimpleChatStore
+from llama_index.core.memory import ChatMemoryBuffer
+chat_store = SimpleChatStore()
+chat_memory = ChatMemoryBuffer.from_defaults(
+    token_limit=3000,
+    chat_store=chat_store,
+    chat_store_key="user1",
+)
+from llama_index.core.query_engine import RetrieverQueryEngine
+query_engine = RetrieverQueryEngine.from_args(retriever)
+from llama_index.core.chat_engine import CondensePlusContextChatEngine
+chat_engine = CondensePlusContextChatEngine.from_defaults(
+    query_engine,
+    memory=chat_memory,
+    context_prompt=(
+        "Você é um assistente virtual capaz de interagir normalmente, além de"
+        " fornecer informações sobre organogramas e listar funcionários."
+        " Aqui estão os documentos relevantes para o contexto:\n"
+        "{context_str}"
+        "\nInstrução: Use o histórico da conversa anterior, ou o contexto acima, para responder."
+    ),
+)
+
+
+
+@app.route("/chat", methods=["POST"])
+def chat():
+    user_input = request.json.get("message", "")
+    if not user_input:
+        return jsonify({"error": "Mensagem vazia"}), 400
+
+    def generate_response():
+        try:
+            response = chat_engine.stream_chat(user_input)
+            for token in response.response_gen:
+                yield token  # Envia cada token
+            chat_store.persist(persist_path="chat_store.json")
+        except Exception as e:
+            yield f"Erro: {str(e)}"
+
+    return Response(generate_response(), content_type="text/plain")
+if __name__ == "__main__":
+    app.run(port=5001, debug=False)

config.yaml

@@ -0,0 +1,38 @@
+cookie:
+  expiry_days: 30
+  key: some_signature_key
+  name: some_cookie_name
+credentials:
+  usernames:
+    akcit_root:
+      email: [email protected]
+      failed_login_attempts: 0
+      first_name: akcit
+      last_name: root
+      logged_in: false
+      password: $2b$12$wd1lg1DTs4qEDRmohdptDegeSJhGstxqgCaTitfRQ0IGN.rnr51aG
+      roles:
+      - admin
+      - editor
+      - viewer
+    sicoob_central:
+      email: [email protected]
+      failed_login_attempts: 0
+      first_name: sicoob
+      last_name: central
+      logged_in: false
+      password: $2b$12$Y5tHfGABzVP9dm510HuHHuUbeZvNqUibUgj4TYH40rglhZGLPZ8rK
+      roles:
+      - viewer
+    sicoob_unidade:
+      email: [email protected]
+      failed_login_attempts: 0
+      first_name: sicoob
+      last_name: unidade
+      logged_in: false
+      password: $2b$12$h8U7XrVfACkHJaqGqcwR0OzDO.YorKF21lHpG/9MVa4K/98AbXtG.
+      roles:
+      - viewer
+pre-authorized:
+  emails:
+  - [email protected]

document_creator.py

@@ -0,0 +1,133 @@
+import os
+import re
+from pathlib import Path
+from llama_index.core import Document
+
+def create_single_document_with_filenames(directory_path: str) -> Document:
+    """
+    Percorre a pasta informada, organiza os arquivos em estrutura de anos (YYYY) e meses (MM),
+    gera um texto descritivo semelhante ao código anterior (sem salvar em arquivo) e retorna
+    esse texto dentro de um objeto Document.
+
+    Uso:
+        directory_path = "documentos"
+        doc = create_single_document_with_filenames(directory_path)
+        documents.append(doc)
+    """
+
+    # Dicionário {ano: {mes: [arquivos]}}
+    estrutura_anos = {}
+    # Lista para arquivos fora do padrão YYYY-MM
+    docs_sem_data = []
+    # Conjunto para todos os arquivos (para listagem geral no final)
+    todos_arquivos = set()
+
+    # Percorre o diretório de forma recursiva
+    for root, dirs, files in os.walk(directory_path):
+        match_ano_mes = re.search(r"(\d{4})-(\d{2})", root)
+        if match_ano_mes:
+            ano = match_ano_mes.group(1)
+            mes = match_ano_mes.group(2)
+
+            if ano not in estrutura_anos:
+                estrutura_anos[ano] = {}
+            if mes not in estrutura_anos[ano]:
+                estrutura_anos[ano][mes] = []
+
+            for nome_arq in files:
+                estrutura_anos[ano][mes].append(nome_arq)
+                todos_arquivos.add(nome_arq)
+        else:
+            # Se a pasta não segue o padrão YYYY-MM, consideramos esses arquivos "sem data"
+            for nome_arq in files:
+                docs_sem_data.append(nome_arq)
+                todos_arquivos.add(nome_arq)
+
+    # Montamos o texto final, seguindo a lógica dos "casos"
+    descricao_final = []
+
+    # Organiza a lista de anos e percorre
+    for ano in sorted(estrutura_anos.keys()):
+        meses_ordenados = sorted(estrutura_anos[ano].keys())
+        qtd_meses = len(meses_ordenados)
+
+        # Caso 1: Apenas um mês e um arquivo
+        if qtd_meses == 1:
+            unico_mes = meses_ordenados[0]
+            arquivos_unico_mes = estrutura_anos[ano][unico_mes]
+            if len(arquivos_unico_mes) == 1:
+                nome_mes_extenso = mes_extenso(unico_mes)
+                arquivo_unico = arquivos_unico_mes[0]
+                descricao_final.append(
+                    f"No ano de {ano}, temos somente o mês de {nome_mes_extenso} (mês {unico_mes}), "
+                    f"outros meses não foram listados, e nessa pasta encontramos apenas "
+                    f"um manual chamado {arquivo_unico}."
+                )
+                # pula para o próximo ano
+                continue
+
+        # Caso 2: Mais meses ou mais arquivos em algum mês
+        frase_inicial = f"No ano de {ano}, temos os meses de "
+        meses_descricao = [f"{mes_extenso(m)} (mês {m})" for m in meses_ordenados]
+        frase_inicial += ", ".join(meses_descricao) + "."
+        descricao_final.append(frase_inicial)
+
+        for mes_ in meses_ordenados:
+            arquivos_mes = estrutura_anos[ano][mes_]
+            nome_mes_extenso = mes_extenso(mes_)
+            qtd_arquivos = len(arquivos_mes)
+            if qtd_arquivos == 1:
+                descricao_final.append(
+                    f"Em {nome_mes_extenso} temos somente o manual chamado {arquivos_mes[0]}."
+                )
+            else:
+                descricao_final.append(
+                    f"Em {nome_mes_extenso} temos {qtd_arquivos} manuais, chamados: {', '.join(arquivos_mes)}."
+                )
+
+    # Caso 3: Arquivos sem data
+    if docs_sem_data:
+        docs_sem_data_unicos = list(set(docs_sem_data))
+        if len(docs_sem_data_unicos) == 1:
+            descricao_final.append(
+                f"Em nossos documentos, fora de pastas de data, temos somente este arquivo: {docs_sem_data_unicos[0]}."
+            )
+        else:
+            descricao_final.append(
+                "Em nossos documentos, fora de pastas de data, encontramos estes arquivos: "
+                + ", ".join(docs_sem_data_unicos) + "."
+            )
+
+    # Lista global de todos os arquivos
+    lista_geral_ordenada = sorted(todos_arquivos)
+    descricao_final.append(
+        "Essas são as listas de todos os documentos, manuais e organogramas que podemos "
+        f"resolver, listar e usar para nossas respostas, esses documentos vão ser muito úteis: {', '.join(lista_geral_ordenada)}"
+    )
+
+    # Une o texto final
+    document_text = "\n".join(descricao_final)
+
+    # Cria e retorna um Document com esse texto
+    document = Document(
+        text=document_text,
+        metadata={
+            "description": "Lista de manuais, arquivos e documentos que podemos responder.",
+            "file_name": "Lista de documentos",
+            "summary": "Entre 2011 e 2024, há uma grande variedade de manuais e documentos organizados por ano e mês: alguns anos possuem apenas um mês e um único arquivo, enquanto outros registram diversos períodos, cada um com vários manuais. Adicionalmente, há alguns arquivos “soltos”, fora dessas pastas de data. No fim, existe uma listagem completa de todos os itens, cobrindo instruções bancárias, regulamentos internos e outros materiais de suporte."
+            }
+    )
+    return document
+
+def mes_extenso(mes_str: str) -> str:
+    """
+    Converte '07' em 'Julho', '09' em 'Setembro', etc.
+    """
+    meses_dict = {
+        "01": "Janeiro",   "02": "Fevereiro", "03": "Março",
+        "04": "Abril",     "05": "Maio",      "06": "Junho",
+        "07": "Julho",     "08": "Agosto",    "09": "Setembro",
+        "10": "Outubro",   "11": "Novembro",  "12": "Dezembro"
+    }
+    return meses_dict.get(mes_str, mes_str)
+

drive_downloader.py

@@ -0,0 +1,300 @@
+try:
+    import os
+    import io
+    import json
+    import hashlib
+    from googleapiclient.discovery import build
+    from googleapiclient.http import MediaIoBaseDownload
+    from google.auth.transport.requests import Request
+    from google.oauth2.credentials import Credentials
+    from tqdm import tqdm
+except ImportError as e:
+    # Se faltarem as bibliotecas necessárias, levantamos Exception
+    raise Exception(
+        "Faltam bibliotecas necessárias para o GoogleDriveDownloader. "
+        "Instale-as com:\n\n"
+        "  pip install google-api-python-client google-auth-httplib2 google-auth-oauthlib tqdm\n\n"
+        f"Detalhes do erro: {str(e)}"
+    )
+
+class GoogleDriveDownloader:
+    """
+    Classe para autenticar e baixar arquivos do Google Drive,
+    preservando a estrutura de pastas e evitando downloads redundantes.
+    - Nunca abrirá navegador se não encontrar token válido (apenas levanta exceção).
+    - Pode ler 'credentials.json' e 'token.json' do disco ou das variáveis de ambiente.
+    """
+
+    SCOPES = ['https://www.googleapis.com/auth/drive.readonly']
+    
+    def __init__(self, chunksize=100 * 1024 * 1024):
+        """
+        :param chunksize: Tamanho (em bytes) de cada chunk ao baixar arquivos.
+                          Ex.: 100MB = 100 * 1024 * 1024.
+        """
+        self.chunksize = chunksize
+        self.service = None
+
+    def _get_credentials_from_env_or_file(self):
+        """
+        Verifica se existem variáveis de ambiente para 'CREDENTIALS' e 'TOKEN'.
+        Caso contrário, tenta usar arquivos locais 'credentials.json' e 'token.json'.
+        
+        Se o token local/ambiente não existir ou for inválido (sem refresh),
+        levanta exceção (não abrimos navegador neste fluxo).
+        """
+        print("Procurando credentials na variavel de ambiente...")
+        env_credentials = os.environ.get("CREDENTIALS")  # Conteúdo JSON do client secrets
+        env_token = os.environ.get("TOKEN")              # Conteúdo JSON do token
+
+        creds = None
+
+        # 1) Carregar credenciais do ambiente, se houver
+        if env_credentials:
+            try:
+                creds_json = json.loads(env_credentials)
+            except json.JSONDecodeError:
+                raise ValueError("A variável de ambiente 'CREDENTIALS' não contém JSON válido.")
+            
+            # Validamos o "client_id" para garantir que seja um JSON de credenciais mesmo
+            client_id = (
+                creds_json.get("installed", {}).get("client_id") or
+                creds_json.get("web", {}).get("client_id")
+            )
+            if not client_id:
+                raise ValueError("Credenciais em memória não parecem válidas. Faltam campos 'client_id'.")
+
+        else:
+            # Se não há credenciais no ambiente, tentamos local
+            if not os.path.exists("credentials.json"):
+                raise FileNotFoundError(
+                    "Nenhuma credencial encontrada em ambiente ou no arquivo 'credentials.json'."
+                )
+            print("Variavel não encontrada, usando credentials.json")
+            with open("credentials.json", 'r', encoding='utf-8') as f:
+                creds_json = json.load(f)
+
+        print("Procurando tokens na variavel de ambiente...")
+        token_data = None
+        if env_token:
+            try:
+                token_data = json.loads(env_token)
+            except json.JSONDecodeError:
+                raise ValueError("A variável de ambiente 'TOKEN' não contém JSON válido.")
+        else:
+            # Se não há token no ambiente, checamos arquivo local
+            if os.path.exists("token.json"):
+                print("Variavel não encontrada, usando token.json")
+                with open("token.json", 'r', encoding='utf-8') as tf:
+                    token_data = json.load(tf)
+            else:
+                raise FileNotFoundError(
+                    "Não há token no ambiente nem em 'token.json'. "
+                    "Não é possível autenticar sem abrir navegador, então abortando."
+                )
+        
+        # 3) Criar credenciais a partir do token_data
+        creds = Credentials.from_authorized_user_info(token_data, self.SCOPES)
+
+        # 4) Se expirou, tenta refresh
+        if not creds.valid:
+            if creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+                # Salva token atualizado, se estiver usando arquivo local
+                if not env_token:  # só sobrescreve se está lendo do disco
+                    with open("token.json", 'w', encoding='utf-8') as token_file:
+                        token_file.write(creds.to_json())
+            else:
+                # Se não é válido e não há refresh token, não temos como renovar sem navegador
+                raise RuntimeError(
+                    "As credenciais de token são inválidas/expiradas e sem refresh token. "
+                    "Não é possível abrir navegador neste fluxo, abortando."
+                )
+
+        return creds
+
+    def authenticate(self):
+        """Cria e armazena o serviço do Drive API nesta instância."""
+        creds = self._get_credentials_from_env_or_file()
+        self.service = build("drive", "v3", credentials=creds)
+
+    def _list_files_in_folder(self, folder_id):
+        """Retorna a lista de itens (arquivos/pastas) diretamente em 'folder_id'."""
+        items = []
+        page_token = None
+        query = f"'{folder_id}' in parents and trashed=false"
+
+        while True:
+            response = self.service.files().list(
+                q=query,
+                spaces='drive',
+                fields='nextPageToken, files(id, name, mimeType)',
+                pageToken=page_token
+            ).execute()
+            items.extend(response.get('files', []))
+            page_token = response.get('nextPageToken', None)
+            if not page_token:
+                break
+        return items
+
+    def _get_file_metadata(self, file_id):
+        """
+        Retorna (size, md5Checksum, modifiedTime) de um arquivo no Drive.
+        Se algum campo não existir, retorna valor padrão.
+        """
+        data = self.service.files().get(
+            fileId=file_id,
+            fields='size, md5Checksum, modifiedTime'
+        ).execute()
+
+        size = int(data.get('size', 0))
+        md5 = data.get('md5Checksum', '')
+        modified_time = data.get('modifiedTime', '')
+        return size, md5, modified_time
+
+    def _get_all_items_recursively(self, folder_id, parent_path=''):
+        """
+        Percorre recursivamente a pasta (folder_id) no Drive,
+        retornando lista de dicts (id, name, mimeType, path).
+        """
+        results = []
+        items = self._list_files_in_folder(folder_id)
+
+        for item in items:
+            current_path = os.path.join(parent_path, item['name'])
+            if item['mimeType'] == 'application/vnd.google-apps.folder':
+                results.append({
+                    'id': item['id'],
+                    'name': item['name'],
+                    'mimeType': item['mimeType'],
+                    'path': current_path
+                })
+                sub = self._get_all_items_recursively(item['id'], current_path)
+                results.extend(sub)
+            else:
+                results.append({
+                    'id': item['id'],
+                    'name': item['name'],
+                    'mimeType': item['mimeType'],
+                    'path': parent_path
+                })
+        return results
+
+    def _needs_download(self, local_folder, file_info):
+        """
+        Verifica se o arquivo em 'file_info' precisa ser baixado.
+        - Se não existir localmente, retorna True.
+        - Se existir, compara tamanho e MD5 (quando disponível).
+        - Retorna True se for diferente, False se for idêntico.
+        """
+        file_id = file_info['id']
+        file_name = file_info['name']
+        rel_path = file_info['path']
+
+        drive_size, drive_md5, _ = self._get_file_metadata(file_id)
+        full_local_path = os.path.join(local_folder, rel_path, file_name)
+
+        if not os.path.exists(full_local_path):
+            return True  # Não existe localmente
+
+        local_size = os.path.getsize(full_local_path)
+        if local_size != drive_size:
+            return True
+
+        if drive_md5:
+            with open(full_local_path, 'rb') as f:
+                local_md5 = hashlib.md5(f.read()).hexdigest()
+            if local_md5 != drive_md5:
+                return True
+
+        return False
+
+    def _download_single_file(self, file_id, file_name, relative_path, progress_bar):
+        """
+        Faz download de um único arquivo do Drive, atualizando a barra de progresso global.
+        """
+        # Como fizemos 'os.chdir(local_folder)' antes, 'relative_path' pode ser vazio.
+        # Então concatenamos sem o local_folder:
+        file_path = os.path.join(relative_path, file_name)
+
+        # Se o path do diretório for vazio, cai no '.' para evitar WinError 3
+        dir_name = os.path.dirname(file_path) or '.'
+        os.makedirs(dir_name, exist_ok=True)
+
+        request = self.service.files().get_media(fileId=file_id)
+        with io.FileIO(file_path, 'wb') as fh:
+            downloader = MediaIoBaseDownload(fh, request, chunksize=self.chunksize)
+            done = False
+            previous_progress = 0
+
+            while not done:
+                status, done = downloader.next_chunk()
+                if status:
+                    current_progress = status.resumable_progress
+                    chunk_downloaded = current_progress - previous_progress
+                    previous_progress = current_progress
+                    progress_bar.update(chunk_downloaded)
+
+    def download_from_folder(self, drive_folder_id: str, local_folder: str):
+        """
+        Método principal para:
+         1. Autenticar sem abrir navegador (usa token local/ambiente).
+         2. Exibir "Iniciando verificação de documentos".
+         3. Listar recursivamente arquivos da pasta do Drive.
+         4. Verificar quais precisam de download.
+         5. Baixar apenas o necessário, com barra de progresso única.
+        """
+        print("Iniciando verificação de documentos")
+
+        if not self.service:
+            self.authenticate()
+
+        print("Buscando lista de arquivos no Drive...")
+        all_items = self._get_all_items_recursively(drive_folder_id)
+
+        # Filtra apenas arquivos (exclui subpastas)
+        all_files = [f for f in all_items if f['mimeType'] != 'application/vnd.google-apps.folder']
+
+        print("Verificando quais arquivos precisam ser baixados...")
+        files_to_download = []
+        total_size_to_download = 0
+        for info in all_files:
+            if self._needs_download(local_folder, info):
+                drive_size, _, _ = self._get_file_metadata(info['id'])
+                total_size_to_download += drive_size
+                files_to_download.append(info)
+
+        if not files_to_download:
+            print("Nenhum arquivo novo ou atualizado. Tudo sincronizado!")
+            return
+
+        print("Calculando total de bytes a serem baixados...")
+
+        # Ajusta a pasta local e cria se necessário
+        os.makedirs(local_folder, exist_ok=True)
+
+        # Muda diretório de trabalho para simplificar criação de subpastas
+        old_cwd = os.getcwd()
+        os.chdir(local_folder)
+
+        # Cria a barra de progresso global
+        progress_bar = tqdm(
+            total=total_size_to_download,
+            unit='B',
+            unit_scale=True,
+            desc='Baixando arquivos'
+        )
+
+        # Baixa só o que precisa
+        for file_info in files_to_download:
+            self._download_single_file(
+                file_id=file_info['id'],
+                file_name=file_info['name'],
+                relative_path=file_info['path'],
+                progress_bar=progress_bar
+            )
+
+        progress_bar.close()
+        os.chdir(old_cwd)
+
+        print("Download concluído com sucesso!")

requirements.txt

@@ -0,0 +1,8 @@
+llama-index==0.12.12
+llama-index-retrievers-bm25==0.5.2
+llama-index-vector-stores-chroma==0.4.1
+llama-index-readers-google==0.6.0
+openpyxl==3.1.5
+flask==3.1.0
+streamlit==1.41.1
+streamlit_authenticator