refact: v2.1.0

Dockerfile

@@ -0,0 +1,28 @@
+# Use a imagem base do Python
+FROM python:3.9-slim
+
+# Defina um diretório de trabalho padrão dentro do container
+WORKDIR /app
+
+# Copie os arquivos necessários para o container
+COPY requirements.txt /app/requirements.txt
+COPY . /app
+
+# Instale as dependências do sistema e do Python
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# Exponha a porta onde o Streamlit será executado
+EXPOSE 8501
+
+# Adicione uma verificação de saúde (healthcheck)
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health || exit 1
+
+# Comando para iniciar o Streamlit
+ENTRYPOINT ["streamlit", "run", "main.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -1,12 +1,83 @@
----
-title: GeoCosmos 2.0 - Banco de Dados
-emoji: 🏔
-colorFrom: gray
-colorTo: green
-sdk: streamlit
-sdk_version: 1.37.0
-app_file: Início.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# GeoCosmos
+
+GeoCosmos é uma plataforma desenvolvida pela Kukac para a Future Mining, especializada em extração de dados de artigos científicos de geologia utilizando Inteligência Artificial. O objetivo deste projeto é proporcionar uma interface amigável para acesso e manipulação dos dados extraídos de artigos, incluindo a possibilidade de filtrar, visualizar e excluir registros diretamente de um banco de dados SQL.
+
+## Getting Started
+
+Para começar a utilizar o projeto, siga as etapas abaixo:
+
+1. **Clone o repositório**
+
+   Clone este repositório para sua máquina local:
+
+   ```bash
+   git clone https://gitlab.kukac.com.br/kukac/future-mining/geocosmos.git
+   ```
+
+2. **Configuração de ambiente**
+
+   Certifique-se de que você tem o Python 3.8+ instalado em sua máquina. Em seguida, instale as dependências necessárias utilizando o `pip`:
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Configuração das variáveis de ambiente**
+
+   O projeto utiliza o arquivo `.env` para carregar as variáveis de ambiente, como credenciais de acesso ao banco de dados. Certifique-se de configurar corretamente este arquivo com as variáveis `username`, `password` e `DATABASE_URL`.
+
+## Instalação
+
+Para rodar o projeto localmente, execute o seguinte comando:
+
+```bash
+streamlit run app.py
+```
+
+Isso iniciará o servidor do Streamlit e abrirá a interface no seu navegador.
+
+## Funcionalidades
+
+- **Autenticação de usuário**: Um sistema de login que protege o acesso à plataforma.
+- **Visualização de dados**: Exibição de artigos científicos de geologia extraídos de um banco de dados SQL.
+- **Filtros avançados**: Permite filtrar dados com base em colunas numéricas, categóricas ou de data.
+- **Edição de dados**: Interface para selecionar, visualizar e excluir registros do banco de dados.
+- **Download de dados**: Exporte os dados visualizados como arquivos CSV.
+
+## Como usar
+
+1. **Login**: Para acessar a plataforma, insira o nome de usuário e senha fornecidos.
+2. **Filtrar dados**: Escolha as colunas e os filtros que deseja aplicar aos dados.
+3. **Editar dados**: Selecione as linhas que deseja editar ou excluir e execute as ações necessárias.
+4. **Exportar dados**: Baixe os dados filtrados ou modificados como CSV.
+
+## Suporte
+
+Se precisar de ajuda, abra uma issue no repositório ou entre em contato com a equipe de suporte da Kukac.
+
+## Roadmap
+
+- **Próximas funcionalidades**:
+  - Integração com novos bancos de dados geológicos.
+  - Melhoria na interface de filtragem e visualização de dados.
+
+## Contribuindo
+
+Este projeto é mantido pela Kukac e está aberto a contribuições. Caso queira colaborar, siga os passos abaixo:
+
+1. Fork este repositório.
+2. Crie uma nova branch para suas alterações.
+3. Envie um pull request com suas melhorias.
+
+## Autores e Agradecimentos
+
+Este projeto foi desenvolvido pela equipe de inovação da Kukac, com o apoio da Future Mining.
+
+## Licença
+
+Este projeto é de propriedade da Future Mining.
+
+## Status do Projeto
+
+O desenvolvimento está ativo e contínuo.

Início.py → main.py

@@ -1,14 +1,17 @@
+from dotenv import load_dotenv
+load_dotenv()
+
 import streamlit as st
 import pandas as pd
 from sqlalchemy import create_engine, MetaData, Table, delete
 from sqlalchemy.orm import sessionmaker
-from filter import filter_dataframe
+from utils.filter import filter_dataframe
 import os
 import time
 
 # Dados de login
-USERNAME = os.getenv("username")
-PASSWORD = os.getenv("password")
+USERNAME = os.getenv('username')
+PASSWORD = os.getenv('password')
 
 # Configurações da página
 st.set_page_config(
@@ -25,6 +28,7 @@ def authenticate_user(username: str, password: str) -> bool:
 def login_screen():
     st.subheader('⛰️ Banco de Dados - GeoCosmos')
 
+
     with st.form(key='login_form'):
         username = st.text_input("Nome de usuário")
         password = st.text_input("Senha", type='password')
@@ -41,41 +45,27 @@ def login_screen():
 
 # Função para ler dados da tabela SQL a partir de um arquivo
 def load_data() -> pd.DataFrame:
-    # Acesse as variáveis de ambiente
-    dialect = os.getenv("DB_DIALECT")
-    driver = os.getenv("DB_DRIVER")
-    username = os.getenv("DB_USERNAME")
-    password = os.getenv("DB_PASSWORD")
-    host = os.getenv("DB_HOST")
-    port = os.getenv("DB_PORT")
-    database = os.getenv("DB_DATABASE")
-
-    connection_url = f"{dialect}+{driver}://{username}:{password}@{host}:{port}/{database}"
-
+    connection_url = os.getenv("DATABASE_URL")
     engine = create_engine(connection_url)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    
-    with open('query.sql', 'r', encoding='utf-8') as file:
-        query = file.read()
-    
-    df = pd.read_sql(query, engine)
-    
-    return df, engine, session
+    df = pd.read_sql_table(table_name=os.getenv("TABLE_NAME"), con=engine)
+    return df, engine  # Removido o retorno da sessão
 
 # Função para deletar linhas selecionadas
-def delete_selected_rows(selected_ids, engine, session):
+def delete_selected_rows(selected_ids, engine, table):
     meta = MetaData()
-    table = Table('Extraction', meta, autoload_with=engine, schema="public")
-    with session.begin():
-        for id_value in selected_ids:
-            stmt = delete(table).where(table.c.id == id_value)
-            session.execute(stmt)
-        session.commit()
+    table = Table(table, meta, autoload_with=engine, schema="public")
+    
+    Session = sessionmaker(bind=engine)
+    session = Session()
+    
+    try:
+        with session.begin():
+            for id_value in selected_ids:
+                stmt = delete(table).where(table.c.id == id_value)
+                session.execute(stmt)
+    finally:
+        session.close()  # Garante o fechamento da sessão
 
-# Função para download dos dados como CSV
-def convert_df_to_csv(df):
-    return df.to_csv(index=False).encode('utf-8')
 
 # Verificar o estado de login
 if 'logged_in' not in st.session_state:
@@ -86,55 +76,72 @@ if not st.session_state['logged_in']:
     login_screen()
 else:
     st.header('⛰️ Banco de Dados - GeoCosmos')
-
-    df, engine, session = load_data()
-    
+                    
+    placeholder = st.empty()
+
+    with st.spinner("Carregando dados..."):
+        # Carrega os dados apenas uma vez
+        if 'df' not in st.session_state:
+            df, engine = load_data()
+            st.session_state.df = df
+            st.session_state.engine = engine
+        else:
+            df = st.session_state.df
+            engine = st.session_state.engine
+            
     # Aplica o filtro ao dataframe
     filtered_df = filter_dataframe(df)
 
+
     all_columns = filtered_df.columns.tolist()
     selected_columns = st.multiselect(
         'Escolha as colunas para exibir:',
-        options=[column for column in all_columns if column != 'id'],
+        options=[col for col in all_columns if col not in ['id', 'Seleção']],
         placeholder="Selecione uma ou mais colunas",
-        default=[]
+        default=[],
+        key="column_selector"
     )
 
-    
-    
+
     if selected_columns:
-        if 'id' not in selected_columns:
-            selected_columns.append('id')
-        if 'Nome do documento' not in selected_columns:
-            selected_columns.append('Nome do documento')
-        displayed_df = filtered_df[selected_columns]
+        displayed_columns = selected_columns + ['id']
+        if 'Nome do documento' not in displayed_columns:
+            displayed_columns.insert(1, 'Nome do documento')
+        # Remove duplicatas e garante a ordem
+        displayed_columns = list(dict.fromkeys(displayed_columns))
+        displayed_df = filtered_df[displayed_columns]
     else:
         displayed_df = filtered_df
 
-    # Adiciona a coluna de seleção
-    displayed_df.insert(0, 'Seleção', False)
-    
-    # Exibe o dataframe filtrado com checkboxes para seleção
-    edited_df = st.data_editor(displayed_df, disabled=[col for col in displayed_df.columns if col != 'Seleção'], hide_index=False, column_order = [col for col in displayed_df.columns if col != 'id'])
+    if st.button("🔄", type="tertiary"):
+        del st.session_state["df"]
+        st.rerun()
 
-    # Verifica se há pelo menos um checkbox selecionado
-    selected_ids = edited_df.loc[edited_df['Seleção'], "id"].tolist()
 
-    # Pega os nomes dos documentos selecionados
-    selected_docs = edited_df.loc[edited_df['Seleção'], 'Nome do documento'].tolist()
+    # Exibe o editor com ordem fixa e key estável
+    selected_df = st.dataframe(
+        displayed_df,
+        column_order=[col for col in displayed_df.columns if col != 'Seleção'],
+        hide_index=False,
+        key="stable_data_editor",
+        on_select="rerun",
+        selection_mode="multi-row"
+    )
 
+    selected_rows = selected_df['selection']['rows']
+    selected_ids = displayed_df.iloc[selected_rows]["id"].tolist()
+    
+    # Pega os nomes dos documentos selecionados
+    selected_docs = displayed_df.iloc[selected_rows]["Nome do documento"].tolist()
     if selected_ids:
         with st.popover("APAGAR"):
             st.warning("Você está prestes a apagar dados. Esta ação não pode ser desfeita.")
             confirmation = st.text_input("Digite 'APAGAR' e pressione ENTER para confirmar a deleção:")
-
             if confirmation == "APAGAR":
                 if st.button("CONFIRMAR"):
                     with st.spinner('Deletando arquivos...'):
-                        delete_selected_rows(selected_ids, engine, session)
+                        delete_selected_rows(selected_ids, engine, os.getenv("TABLE_NAME"))
                     st.success(f'Os seguintes documentos foram apagados: {selected_docs}')
-                    selected_ids = []
-                    time.sleep(3)
+                    del st.session_state["df"]
                     st.rerun()
-                    
-                    
+    

query.sql

@@ -1,221 +0,0 @@
-SELECT
-	id,
-    e.id AS "Id da entrada no banco",
-    e."createdAt" AS "Data Criação",
-    e.name AS "Nome do documento",
-
-    -- Alvo ou depósito
-    COALESCE(data->'responseData'->0->'response'->>'target_or_deposit', 'Não especificado') AS "Alvo ou depósito",
-
-   -- Tipo de mineralização
-    COALESCE(
-        array_to_string(
-            ARRAY(
-				SELECT DISTINCT CONCAT(
-                    mineralization->>'type'
-                )
-                FROM jsonb_array_elements(data->'responseData'->0->'response'->'mineralizations') AS mineralization
-            ), ', '
-        ), 'Não especificado'
-    ) AS "Tipo de mineralização",
-	
-    -- cidade
-	COALESCE(data->'responseData'->0->'response'->'region'->>'city', 'Não especificado') AS "Cidades",
-	-- estado
-	COALESCE(data->'responseData'->0->'response'->'region'->>'state', 'Não especificado') AS "Estado",
-	-- país
-	COALESCE(data->'responseData'->0->'response'->'region'->>'country', 'Não especificado') AS "País",
-	-- região
-	COALESCE(data->'responseData'->0->'response'->'region'->>'region_name', 'Não especificado') AS "Região",
-	-- Consolidar quantidade, tipo de mineralização e minerais com concentração
-	-- Consolidar quantidade, tipo de mineralização e minerais com concentração
-	CASE
-	    WHEN jsonb_typeof(data->'responseData'->0->'response'->'mineralizations') = 'array' THEN
-	        array_to_string(
-	            ARRAY(
-	                SELECT CONCAT(
-	                    -- Mostra a quantidade e o tipo de mineralização
-	                    mineralization->>'quantity', ' de ',
-	                    mineralization->>'type',
-	                    
-	                    -- Condicional para incluir minerais apenas se existirem
-	                    CASE
-	                        WHEN jsonb_typeof(mineralization->'minerals') = 'array'
-	                             AND jsonb_array_length(mineralization->'minerals') > 0 THEN
-	                            ': ' || array_to_string(
-	                                ARRAY(
-	                                    SELECT CONCAT(
-	                                        mineral->>'name', 
-	                                        ' (', mineral->>'concentration', ')'
-	                                    )
-	                                    FROM jsonb_array_elements(mineralization->'minerals') AS mineral
-	                                    WHERE mineral IS NOT NULL -- Ignora nulos
-	                                ), ', '
-	                            )
-	                        ELSE '' -- Não mostra nada se não houver minerais
-	                    END
-	                )
-	                FROM jsonb_array_elements(data->'responseData'->0->'response'->'mineralizations') AS mineralization
-	                WHERE mineralization IS NOT NULL -- Ignora nulos
-	            ), '; '
-	        )
-	    ELSE NULL -- Retorna NULL se o array não existir
-	END AS "Quantidades e concentrações",
-
-
-	-- extra_info
-	COALESCE(data->'responseData'->0->'response'->'region'->>'extra_info', 'Não especificado') AS "Informações adicionais",
-	
-    COALESCE(NULLIF(data->'responseData'->4->'response'->>'mineralization_signatures', '[]'), 'Não especificado') AS "Assinaturas de mineralização", -- Foi decidido que este era melhor
-
-	COALESCE(NULLIF(data->'responseData'->0->'response'->'geological_context'->>'tectonic_context', ''), 'Não especificado') AS "Contexto tectônico", -- OK
-    COALESCE(NULLIF(data->'responseData'->0->'response'->'geological_context'->>'geological_context_description', ''), 'Não especificado') AS "Contexto geológico", -- OK
-    COALESCE(NULLIF(data->'responseData'->0->'response'->'geological_context'->>'context_of_present_rocks', ''), 'Não especificado') AS "Rochas presentes", -- OK
-
-	-- Rochas sedimentares
-	CASE
-	    WHEN jsonb_typeof(data->'responseData'->1->'response'->'rockTypes'->'sedimentares') = 'array' THEN
-	        array_to_string(
-	            ARRAY(
-	                SELECT CONCAT(
-	                    sedimentares->>'name',
-	                    ' (Tipo: ', sedimentares->>'type',
-	                    ', Relações de contato: ', COALESCE(sedimentares->>'contact_relations', 'ND'), ')'
-	                )
-	                FROM jsonb_array_elements(data->'responseData'->1->'response'->'rockTypes'->'sedimentares') AS sedimentares
-	                WHERE sedimentares IS NOT NULL -- Ignora elementos nulos
-	            ), '; '
-	        )
-	    ELSE '' -- Retorna vazio se o array não existir
-	END AS "Rochas sedimentares",
-	-- Rochas metamórficas
-	CASE
-	    WHEN jsonb_typeof(data->'responseData'->1->'response'->'rockTypes'->'metamórficas') = 'array' THEN
-	        array_to_string(
-	            ARRAY(
-	                SELECT CONCAT(
-	                    metam->>'name',
-	                    ' (Tipo: ', metam->>'type',
-	                    ', Relações de contato: ', COALESCE(metam->>'contact_relations', 'ND'), ')'
-	                )
-	                FROM jsonb_array_elements(data->'responseData'->1->'response'->'rockTypes'->'metamórficas') AS metam
-	                WHERE metam IS NOT NULL
-	            ), '; '
-	        )
-	    ELSE ''
-	END AS "Rochas metamórficas",
-	
-	-- Rochas ígneas intrusivas
-	CASE
-	    WHEN jsonb_typeof(data->'responseData'->1->'response'->'rockTypes'->'ígneas_intrusivas') = 'array' THEN
-	        array_to_string(
-	            ARRAY(
-	                SELECT CONCAT(
-	                    igneas_i->>'name',
-	                    ' (Tipo: ', igneas_i->>'type',
-	                    ', Relações de contato: ', COALESCE(igneas_i->>'contact_relations', 'ND'), ')'
-	                )
-	                FROM jsonb_array_elements(data->'responseData'->1->'response'->'rockTypes'->'ígneas_intrusivas') AS igneas_i
-	                WHERE igneas_i IS NOT NULL
-	            ), '; '
-	        )
-	    ELSE ''
-	END AS "Rochas ígneas intrusivas",
-	
-	-- Rochas ígneas extrusivas
-	CASE
-	    WHEN jsonb_typeof(data->'responseData'->1->'response'->'rockTypes'->'ígneas_extrusivas') = 'array' THEN
-	        array_to_string(
-	            ARRAY(
-	                SELECT CONCAT(
-	                    igneas_e->>'name',
-	                    ' (Tipo: ', igneas_e->>'type',
-	                    ', Relações de contato: ', COALESCE(igneas_e->>'contact_relations', 'ND'), ')'
-	                )
-	                FROM jsonb_array_elements(data->'responseData'->1->'response'->'rockTypes'->'ígneas_extrusivas') AS igneas_e
-	                WHERE igneas_e IS NOT NULL
-	            ), '; '
-	        )
-	    ELSE ''
-	END AS "Rochas ígneas extrusivas",
-	
-	-- Rochas ígneas subvulcânicas
-	CASE
-	    WHEN jsonb_typeof(data->'responseData'->1->'response'->'rockTypes'->'ígneas_subvulcânicas') = 'array' THEN
-	        array_to_string(
-	            ARRAY(
-	                SELECT CONCAT(
-	                    igneas_sv->>'name',
-	                    ' (Tipo: ', igneas_sv->>'type',
-	                    ', Relações de contato: ', COALESCE(igneas_sv->>'contact_relations', 'ND'), ')'
-	                )
-	                FROM jsonb_array_elements(data->'responseData'->1->'response'->'rockTypes'->'ígneas_subvulcânicas') AS igneas_sv
-	                WHERE igneas_sv IS NOT NULL
-	            ), '; '
-	        )
-	    ELSE ''
-	END AS "Rochas ígneas subvulcânicas",
-
-    -- Rochas hospedeiras
-    COALESCE(NULLIF(data->'responseData'->2->'response'->'host_rocks'->>'name', '[null]'), 'Não identificado') AS "Nomes de rochas hospedeiras",
-    COALESCE(NULLIF(data->'responseData'->2->'response'->'host_rocks'->>'geologicalEnvironments', '[null]'), 'Não identificado') AS "Ambiente geológico", 
-    
-	COALESCE(NULLIF(array_to_string(ARRAY(SELECT jsonb_array_elements_text(data->'responseData'->2->'response'->'mineralFabric')), ', '), ''), 'Não identificado') AS "Textura de mineralização",
-    COALESCE(NULLIF(array_to_string(ARRAY(
-        SELECT jsonb_extract_path_text(associatedMinerals, 'name') || ' (' || 'Cor: ' || jsonb_extract_path_text(associatedMinerals, 'color') || ', Textura: ' || jsonb_extract_path_text(associatedMinerals, 'textures') || ', Nível de Alteração: ' || jsonb_extract_path_text(associatedMinerals, 'alterationLevel') || ')'
-        FROM jsonb_array_elements(data->'responseData'->2->'response'->'associatedMinerals') AS associatedMinerals
-    ), ', '), ''), 'Não identificado') AS "Minerais associados",
-
-	-- Tipos de processos alterações 
-	COALESCE(
-	    NULLIF(
-	        array_to_string(
-	            ARRAY(
-	                SELECT alteration->>'alterationType'
-	                FROM jsonb_array_elements(data->'responseData'->2->'response'->'alteration_processes') AS alteration
-	            ), ', '
-	        ), ''
-	    ), 'Não identificado'
-	) AS "Tipos de processos de alterações",
-	
-	-- Minerais associados a alterações hidrotermais
-	COALESCE(
-	    NULLIF(
-	        array_to_string(
-	            ARRAY(
-	                SELECT jsonb_array_elements_text(alteration->'associatedMinerals')
-	                FROM jsonb_array_elements(data->'responseData'->2->'response'->'alteration_processes') AS alteration
-	            ), ', '
-	        ), ''
-	    ), 'Não identificado'
-	) AS "Minerais associados a processos de alteração",
-
-    COALESCE(NULLIF(data->'responseData'->2->'response'->>'chemical_pattern_analysis', '[]'), 'Não especificado') AS "Análise de padrão químico",
-	
-
-	COALESCE(NULLIF(data->'responseData'->3->'response'->>'stable_isotopes', '[]'), 'Não especificado') AS "Isótopos Estáveis e Radiogênicos",
-    COALESCE(NULLIF(data->'responseData'->3->'response'->>'trace_elements_and_rare_earths', '[]'), 'Não especificado') AS "Elementos traço e terras raras",
-
- --    COALESCE(NULLIF(data->'responseData'->3->'response'->>'structural_mapping', '[]'), 'Não especificado') AS "Geologia estrutural da região",
-	-- COALESCE(NULLIF(data->'responseData'->4->'response'->>'structureMineralizationRelation', '[]'), 'Não especificado') AS "Relação estrutura-mineralização",
-	
-    COALESCE(NULLIF(data->'responseData'->4->'response'->>'geophysical_signatures', '[]'), 'Não especificado') AS "Assinaturas geofísicas",
-
-	COALESCE(NULLIF(data->'responseData'->5->'response'->>'additional_information', '[]'), 'Não especificado') AS "Informações adicionais de mineralização",
-	COALESCE(NULLIF(data->'responseData'->6->'response'->>'estimates', '[]'), 'Não especificado') AS "Estimativas de quantidade de mineralização",
-
-    COALESCE(NULLIF(data->'responseData'->7->'response'->>'potential', '[]'), 'Não especificado') AS "Potencial de descoberta",
-    COALESCE(NULLIF(data->'responseData'->8->'response'->>'strengths', '[]'), 'Não especificado') AS "Pontos fortes",
-    COALESCE(NULLIF(data->'responseData'->8->'response'->>'investment_risk', '[]'), 'Não especificado') AS "Risco de investimento",
-    COALESCE(NULLIF(data->'responseData'->8->'response'->>'economic_potential', '[]'), 'Não especificado') AS "Potencial econômico",
-    COALESCE(NULLIF(data->'responseData'->9->'response'->>'explanation', '[]'), 'Não especificado') AS "Explicação da favorabilidade",
-    COALESCE(NULLIF(data->'responseData'->9->'response'->>'favorability', '[]'), 'Não especificado') AS "Favorabilidade"
-    
-
-FROM
-    public."Extraction" e
-
-ORDER BY
-	e."createdAt";
-	
-	

requirements.txt

@@ -2,4 +2,5 @@ pandas==2.2.2
 SQLAlchemy
 streamlit
 toml==0.10.2
-psycopg2
+psycopg2-binary
+python-dotenv

filter.py → utils/filter.py

@@ -7,37 +7,84 @@ from pandas.api.types import (
     is_object_dtype,
 )
 
+def make_hashable(x):
+    """
+    Converte recursivamente listas (e, se necessário, dicionários) em tipos hashable.
+    """
+    if isinstance(x, list):
+        return tuple(make_hashable(e) for e in x)
+    # Se precisar, trate dicionários também:
+    if isinstance(x, dict):
+        return tuple(sorted((k, make_hashable(v)) for k, v in x.items()))
+    return x
+
+def flatten_unique_values(series: pd.Series) -> list:
+    """
+    Achata os valores únicos de uma série.
+    Se um valor for uma tupla, extrai cada item individualmente.
+    """
+    unique_values_set = set()
+    for val in series.dropna().unique():
+        # Se o valor for uma tupla, adicione cada item separadamente
+        if isinstance(val, tuple):
+            unique_values_set.update(val)
+        else:
+            unique_values_set.add(val)
+    return list(unique_values_set)
+
 def filter_dataframe(df: pd.DataFrame) -> pd.DataFrame:
     df = df.copy()
 
-    # Tentar converter datas para um formato padrão (datetime, sem fuso horário)
+    # Primeiro, converta todos os valores da DataFrame para hashable
+    for col in df.columns:
+        df[col] = df[col].apply(make_hashable)
+
+    # Tenta converter strings para datetime e remover fuso horário
     for col in df.columns:
         if is_object_dtype(df[col]):
             try:
-                df[col] = pd.to_datetime(df[col])
+                df[col] = pd.to_datetime(df[col], format="%d-%m-%Y")
             except Exception:
                 pass
-
         if is_datetime64_any_dtype(df[col]):
             df[col] = df[col].dt.tz_localize(None)
 
     modification_container = st.container()
 
     with modification_container:
-        to_filter_columns = st.multiselect("Filtrar por valor", [column for column in df.columns if column != 'id'], placeholder="Selecione um ou mais itens para filtrar")
+        to_filter_columns = st.multiselect(
+            "Filtrar por valor",
+            [column for column in df.columns if column != 'id'],
+            placeholder="Selecione um ou mais itens para filtrar"
+        )
         for column in to_filter_columns:
             left, right = st.columns((1, 20))
             left.write("↳")
-            # Tratar colunas com < 10 valores únicos como categóricos
+            
+            # Para colunas categóricas ou com poucos valores únicos, use multiselect
             if is_categorical_dtype(df[column]) or df[column].nunique() < 5000:
+                raw_unique_values = df[column].dropna().unique()
+                # Verifica se há valores do tipo tupla (decorrentes de listas convertidas)
+                if any(isinstance(val, tuple) for val in raw_unique_values):
+                    unique_values = flatten_unique_values(df[column])
+                    is_flattened = True
+                else:
+                    unique_values = list(raw_unique_values)
+                    is_flattened = False
+
                 user_cat_input = right.multiselect(
                     f"Valores para {column}",
-                    df[column].unique(),
-                    default=[], # Lista vazia para não ter valores pré-selecionados
+                    unique_values,
+                    default=[],  # Sem valores pré-selecionados
                     placeholder="Escolha uma opção"  
                 )
                 if user_cat_input:  # Filtrar apenas se houver seleção
-                    df = df[df[column].isin(user_cat_input)]
+                    if is_flattened:
+                        df = df[df[column].apply(
+                            lambda x: any(item in x for item in user_cat_input) if isinstance(x, tuple) else x in user_cat_input
+                        )]
+                    else:
+                        df = df[df[column].isin(user_cat_input)]
             elif is_numeric_dtype(df[column]):
                 _min = float(df[column].min())
                 _max = float(df[column].max())
@@ -59,22 +106,33 @@ def filter_dataframe(df: pd.DataFrame) -> pd.DataFrame:
                     ),
                     format="YYYY-MM-DD",
                 )
-                if len(user_date_input) == 2:
-                    user_date_input = tuple(map(pd.to_datetime, user_date_input))
-                    start_date, end_date = user_date_input
-                    df = df.loc[df[column].between(start_date, end_date)]
+                if isinstance(user_date_input, tuple) and len(user_date_input) == 2:
+                    start_date, end_date = map(pd.to_datetime, user_date_input)
+                    df = df[df[column].between(start_date, end_date)]
             else:
-                # Para colunas de texto, mostre uma seleção múltipla se houver poucos valores únicos
-                unique_values = df[column].dropna().unique()
-                if len(unique_values) < 5000:  # Ajuste o limite conforme necessário
+                # Para colunas de texto
+                raw_unique_values = df[column].dropna().unique()
+                if any(isinstance(val, tuple) for val in raw_unique_values):
+                    unique_values = flatten_unique_values(df[column])
+                    is_flattened = True
+                else:
+                    unique_values = list(raw_unique_values)
+                    is_flattened = False
+
+                if len(unique_values) < 5000:
                     user_text_input = right.multiselect(
                         f"Valores para {column}",
                         unique_values,
                         default=[],
                         placeholder="Escolha uma opção",  
                     )
-                    if user_text_input:  # Filtrar apenas se houver seleção
-                        df = df[df[column].isin(user_text_input)]
+                    if user_text_input:
+                        if is_flattened:
+                            df = df[df[column].apply(
+                                lambda x: any(item in x for item in user_text_input) if isinstance(x, tuple) else x in user_text_input
+                            )]
+                        else:
+                            df = df[df[column].isin(user_text_input)]
                 else:
                     user_text_input = right.text_input(
                         f"Substring ou regex em {column}",