App Custo

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+BP[[:space:]]-[[:space:]]Analítico-App-Custo-v2[[:space:]](1).png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,19 @@
+# 1. Pega um "computador" Linux com Python 3.11 já instalado
+FROM python:3.11-slim
+
+# 2. Cria uma pasta chamada /app lá dentro e entra nela
+WORKDIR /app
+
+# 3. Copia a nossa lista de compras e manda o Python instalar tudo
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 4. Copia TODO o resto dos seus arquivos para dentro da nuvem
+# (Isso vai copiar o main.py, suas imagens PNG, o Login.py, etc)
+COPY . .
+
+# 5. Avisa o Hugging Face que o nosso sistema vai sair pela porta 7860
+EXPOSE 7860
+
+# 6. O comando final: Dá o play no sistema!
+CMD ["python", "main.py"]

Google_Sheets.py

@@ -0,0 +1,94 @@
+from dotenv import load_dotenv
+import os
+import gspread
+from google.oauth2.service_account import Credentials
+import pandas as pd
+import json  # <-- NOVO IMPORT OBRIGATÓRIO
+
+# Abrindo o cofre .env para pegar as chaves (funciona no PC, é ignorado no Hugging Face)
+load_dotenv()
+
+# --- 1. CONFIGURAÇÕES ---
+ID_PLANILHA = os.getenv("ID_PLANILHA")
+
+# Escopos (permissões) que o robô vai pedir
+ESCOPOS = [
+    "https://www.googleapis.com/auth/spreadsheets",
+    "https://www.googleapis.com/auth/drive"
+]
+
+def conectar_sheets():
+    """Lê as credenciais (da nuvem ou local) e abre a conexão definitiva com o Google"""
+    try:
+        # Tenta puxar o JSON gigante direto do cofre (Hugging Face)
+        segredo_google = os.environ.get("GOOGLE_JSON")
+
+        if segredo_google:
+            # --- MODO NUVEM (Hugging Face) ---
+            print("Tentando conectar pelo MODO NUVEM...")
+            credenciais_dict = json.loads(segredo_google)
+            # Usa o from_service_account_info em vez do _file
+            credenciais = Credentials.from_service_account_info(credenciais_dict, scopes=ESCOPOS)
+        else:
+            # --- MODO LOCAL (Seu Computador) ---
+            print("Tentando conectar pelo MODO LOCAL...")
+            CAMINHO_JSON = os.getenv("CAMINHO_JSON")
+            credenciais = Credentials.from_service_account_file(CAMINHO_JSON, scopes=ESCOPOS)
+
+        # Autoriza e cria o cliente final
+        cliente = gspread.authorize(credenciais)
+        print("✅ Conectado ao Google com sucesso!")
+        return cliente
+
+    except Exception as e:
+        print(f"❌ Erro ao conectar: {e}")
+        return None
+
+# ==============================================================================
+# AS FUNÇÕES ABAIXO NÃO PRECISARAM DE MUDANÇAS, POIS A LÓGICA ACIMA RESOLVE TUDO!
+# ==============================================================================
+
+def adicionar_linha_sheets(historico):
+    cliente = conectar_sheets()
+    if not cliente:
+        return
+
+    try:
+        print("1. Abrindo a planilha...")
+        # Abre a planilha pelo ID e seleciona a primeira aba (Página1)
+        planilha = cliente.open_by_key(ID_PLANILHA)
+        aba = planilha.sheet1
+
+        print("3. Preparando a nova linha...")
+        # Convertemos o dic em list pegamos seus valroes e enviamos como uma nova linha
+        linha_formato_lista = list(historico.values())
+        aba.append_row(linha_formato_lista)
+
+        aviso='1'
+
+        return aviso
+
+    except Exception as e:
+        aviso=e
+        return aviso
+
+def ler_historico():
+    print("Baixando registros do Google Sheets...")
+    cliente = conectar_sheets()
+    planilha = cliente.open_by_key(ID_PLANILHA)
+    aba = planilha.sheet1
+
+    # O COMANDO MÁGICO AQUI:
+    dados = aba.get_all_records()
+    df = pd.DataFrame(dados)
+    return df
+
+def senhas():
+    cliente = conectar_sheets()
+    planilha = cliente.open_by_key(ID_PLANILHA)
+    aba = planilha.worksheet("acessos")
+
+    # O COMANDO MÁGICO AQUI:
+    dados = aba.get_all_records()
+    df = pd.DataFrame(dados)
+    return df

Login.py

@@ -0,0 +1,153 @@
+import flet as ft
+import Google_Sheets
+def montar_tela_login(funcao_entrar_no_sistema):
+
+
+    texto_aviso = ft.TextField(
+        label=None,
+        width=0,
+        height=0,
+        border_radius=10,
+        border_color="white",
+
+
+    )
+
+    # 1. Campos de Texto
+    campo_usuario = ft.TextField(
+        label="Usuário",
+        width=280,
+        height=50,
+        border_radius=10,
+        prefix_icon=ft.Icons.PERSON,
+        border_color="green",
+        focused_border_color="#2E7D32",
+    )
+
+    campo_senha = ft.TextField(
+        label="Senha",
+        width=280,
+        height=50,
+        border_radius=10,
+        password=True,
+        can_reveal_password=True,
+        prefix_icon=ft.Icons.LOCK,
+        border_color="green",
+        focused_border_color="#2E7D32",
+    )
+
+    # Chama a planilha para verificar o login e senha
+    retorno = Google_Sheets.senhas()
+    print(f'Retorno da planilha se senhas:{retorno}')
+
+
+    # 3. A Lógica de Validação
+    def fazer_login(e):
+        user_digitado = (campo_usuario.value or "").strip()
+        senha_digitada = (campo_senha.value or "").strip()
+
+
+        # Filtra os user e senhas do excel
+        tabela_filtrada = retorno[
+            (retorno['Usuário'].astype(str) == user_digitado) &
+            (retorno['Senha'].astype(str) == senha_digitada)
+            ]
+
+
+
+
+
+        # Validação Básica: Deixou em branco?
+        if not user_digitado or not senha_digitada:
+            print("Preencha os campos!")
+            texto_aviso.value=f"❌ Preencha os campos! "
+            texto_aviso.bgcolor="yellow"
+            texto_aviso.border_color="black"
+            texto_aviso.height=50
+            texto_aviso.width=290
+            return
+
+        # Se o Pandas achou uma linha, ele entra! Se a tabela vier vazia, credencial inválida.
+        if  not tabela_filtrada.empty:
+            print("Login com sucesso!")
+
+            e.page.session.store.set("user",user_digitado)
+            funcao_entrar_no_sistema(e)  # Libera a passagem para o main.py!
+        else:
+            print("Tentativa de acesso negada.")
+            texto_aviso.value = f"❌ Acesso Incorreto ! "
+            texto_aviso.bgcolor = "orange"
+            texto_aviso.border_color = "black"
+            texto_aviso.height = 50
+            texto_aviso.width = 290
+
+
+
+    # 2. Botão de Entrar
+    btn_entrar = ft.ElevatedButton(
+        content=ft.Text("ACESSAR SISTEMA", color="white"),
+        width=280,
+        height=40,
+        style=ft.ButtonStyle(
+            bgcolor="#2E7D32",
+            shape=ft.RoundedRectangleBorder(radius=10),
+            elevation=5,
+        ),
+        on_click=fazer_login
+    )
+
+    # 3. Definimos o Formulário Branco
+    formulario_branco = ft.Container(
+        content=ft.Column(
+            controls=[
+                # Colocando o texto de aviso na tela
+                texto_aviso,
+
+                ft.Divider(height=10, color="transparent"),
+
+                ft.Icon(ft.Icons.ACCOUNT_CIRCLE, size=80, color="#2E7D32"),
+                ft.Text("Bem-vindo", size=24, weight="bold", color="black"),
+                ft.Text("Faça login para continuar", size=14, color="grey"),
+                ft.Divider(height=20, color="transparent"),
+
+                campo_usuario,
+                ft.Divider(height=10, color="transparent"),
+                campo_senha,
+                ft.Divider(height=30, color="transparent"),
+                btn_entrar
+            ],
+            horizontal_alignment=ft.CrossAxisAlignment.CENTER,
+            spacing=5
+        ),
+        width=380,  # Aumentei um pouco para caber os inputs (280) + o padding (80)
+        height=500,
+        padding=40,
+        bgcolor="white",
+        border_radius=20,
+        shadow=ft.BoxShadow(
+            spread_radius=1,
+            blur_radius=15,
+            color=ft.Colors.BLACK45,
+            offset=ft.Offset(0, 0),
+            blur_style=ft.BlurStyle.OUTER,
+        ),
+    )
+
+    # ==============================================================================
+    # 4. LAYOUT FINAL (Totalmente Responsivo)
+    # ==============================================================================
+    layout = ft.Container(
+        # Coloca a imagem de fundo perfeitamente ajustada
+        image=ft.DecorationImage(
+            src="login fundo.webp",
+            fit="cover"  # Faz a imagem cobrir toda a tela
+        ),
+        expand=True,  # Força o container a ocupar a tela inteira do navegador/monitor
+
+        # A MÁGICA ESTÁ AQUI: Alinha o conteúdo (o formulário) exatamente no centro de tudo!
+        alignment=ft.Alignment.CENTER,
+
+        content=formulario_branco
+    )
+
+    return layout

Qlik_sense.py

@@ -0,0 +1,147 @@
+from dotenv import load_dotenv
+import os
+import requests  # NOVO: Biblioteca nativa para requisições na web
+from qlik_sdk import AuthType, Config, Apps
+import pandas as pd
+import Google_Sheets
+
+
+# Abrindo o cofre.env para pegar as chaves
+load_dotenv()
+
+# --- 1. CONFIGURAÇÕES ---
+TENANT_URL = os.getenv("TENANT_URL")
+APP_ID = os.getenv("APP_ID")
+CLIENT_ID = os.getenv("CLIENT_ID")
+CLIENT_SECRET = os.getenv("CLIENT_SECRET")
+
+# --- 2. A AUTENTICAÇÃO BLINDADA (BUSCA MANUAL DO TOKEN) ---
+print("Buscando autorização M2M no Qlik...")
+
+# Fazemos o pedido oficial do Token direto na "porta" do Qlik Cloud
+resposta = requests.post(
+    f"{TENANT_URL}/oauth/token",
+    json={
+        "client_id": CLIENT_ID,
+        "client_secret": CLIENT_SECRET,
+        "grant_type": "client_credentials"
+    },
+    headers={"Accept": "application/json", "Content-Type": "application/json"}
+)
+
+# Se der erro de senha/ID ou de permissão, ele avisa na hora
+if resposta.status_code != 200:
+    print(f"❌ Erro na autenticação com o Qlik: {resposta.text}")
+    exit()
+
+# Extraímos o código do token que acabamos de receber!
+token_seguro = resposta.json().get("access_token")
+print("✔️ Token gerado com sucesso!")
+
+
+# O PULO DO GATO: Agora nós enganamos o SDK!
+# Nós passamos o 'auth_type' como APIKey, e colocamos o token fresquinho ali dentro.
+config = Config(
+    host=TENANT_URL,
+    auth_type=AuthType.APIKey,
+    api_key=token_seguro
+)
+
+# Instanciamos a classe Apps normalmente. O SDK vai achar que é uma chave normal e abrir!
+apps = Apps(config)
+
+# =========================================================
+
+def extrair_dados_engine():
+    print("Conectando ao App do Qlik...")
+
+    # Pega a referência do Aplicativo
+    app = apps.get(APP_ID)
+    try:
+        # Abre a sessão com a Engine (memória RAM do Qlik)
+        with app.open():
+            print(f"App '{app.attributes.name}' aberto! Montando a tabela virtual...")
+
+            # --- 3. DEFINA AS COLUNAS AQUI ---
+            campos_desejados = ["SAFRA","UF","CÓDIGO DO PRODUTO","DERIVAÇÃO","DESCRIÇÃO PRODUTO","MARCA","CUSTO ATUAL","DATA VENC ATUAL","DATA DE VENC NOVA","NOVO CUSTO","% BARTER","QUANTIDADE"]
+
+            limite_linhas = int(10000 / len(campos_desejados))
+
+            qDimensions = [{"qDef": {"qFieldDefs": [campo]}} for campo in campos_desejados]
+
+            properties = {
+                "qInfo": {"qType": "StraightTable"},
+                "qHyperCubeDef": {
+                    "qDimensions": qDimensions,
+                    "qInitialDataFetch": [{
+                        "qTop": 0,
+                        "qLeft": 0,
+                        "qHeight": limite_linhas,
+                        "qWidth": len(campos_desejados)
+                    }]
+                }
+            }
+
+            # Cria o objeto na sessão e puxa o layout
+            obj = app.create_session_object(properties)
+            layout = obj.get_layout()
+
+            # Acessa a matriz de dados que a Engine devolveu
+            matriz_dados = layout.qHyperCube.qDataPages[0].qMatrix
+
+            # --- 4. CONVERTE PARA PANDAS ---
+            dados_limpos = []
+            for linha in matriz_dados:
+                registro = {}
+                for i, campo in enumerate(campos_desejados):
+                    registro[campo] = linha[i].qText
+                dados_limpos.append(registro)
+
+            df = pd.DataFrame(dados_limpos)
+
+            #Crio uma nova coluna onde add a opção de salvar o registro
+            df["Salvar alteração"]=""
+
+            #Chamando a leitura do google sheets para colocar os valores na tela
+            hist=Google_Sheets.ler_historico()
+
+            # 2. Só faz a mágica se tiver dados no Sheets
+            if not hist.empty:
+                print("Cruzando dados do Qlik com o Google Sheets...")
+
+                # Passo A: Transforma a coluna de texto em DATA DE VERDADE para o Python saber quem é mais novo
+                hist['DATA REGISTRADA'] = pd.to_datetime(hist['DATA REGISTRADA'], format="%d/%m/%Y %H:%M:%S")
+
+                #Vou forçar as 2 colunas de produto tanto do excel quanto do qlik a serem textos sem espaços
+                hist['PRODUTO']=hist['PRODUTO'].astype(str).str.strip()
+                df['CÓDIGO DO PRODUTO']=df['CÓDIGO DO PRODUTO'].astype(str).str.strip()
+
+                # Passo B: Ordena do mais novo pro mais velho, e remove produtos repetidos (fica só o último salvo!)
+                hist_recente = hist.sort_values(by='DATA REGISTRADA', ascending=False).drop_duplicates(subset=['PRODUTO'],keep='first')
+
+                # Passo C: Transforma o 'Cod Produto' na chave de busca (como se fosse a 1ª coluna do PROCV no Excel)
+                hist_recente.set_index('PRODUTO', inplace=True)
+
+                # Passo D: Faz o PROCV mapeando o Código do Produto do Qlik com o do Sheets
+                # Se não achar nada (.fillna("")), deixa a caixinha em branco ("")
+                df["DATA DE VENC NOVA"] = df['CÓDIGO DO PRODUTO'].map(hist_recente['DATA VENC NOVA']).fillna("")
+                df["NOVO CUSTO"] = df['CÓDIGO DO PRODUTO'].map(hist_recente['NOVO CUSTO']).fillna("")
+                df["% BARTER"] = df['CÓDIGO DO PRODUTO'].map(hist_recente['BARTER %']).fillna("")
+                df["QUANTIDADE"] = df['CÓDIGO DO PRODUTO'].map(hist_recente['QUANTIDADE']).fillna("")
+
+            # 3. Se a planilha do Sheets estiver totalmente vazia (primeiro dia de uso)
+            else:
+                print("Planilha vazia. Criando colunas em branco.")
+                df["DATA DE VENC NOVA"] = ""
+                df["NOVO CUSTO"] = ""
+                df["% BARTER"] = ""
+                df["QUANTIDADE"] = ""
+
+
+            print(f"Sucesso! Extraídas {df} linhas do Qlik.")
+            return df,hist
+
+    except Exception as e:
+        print(f"Erro ao extrair dados do Qlik: {e}")
+        return None
+

Registros.py

@@ -0,0 +1,251 @@
+import flet as ft
+import Google_Sheets
+
+#Cria uma variavel global para atualziar a base quando atualizada
+upd=None
+
+def montar_tela_registros(loogof,retorno,base):
+    print('Iniciando modulo registros (Lendo direto do Sheets)')
+
+    #Recebe a base lida no inicio do código
+    global upd
+
+    upd=base
+
+    #Logica para retroanr a tela de login
+    def ir_para_login(e=None):
+
+        loogof()
+
+   #Função para voltar a tela principal
+    def tela_principal(e=None):
+
+        retorno()
+
+   #Função para atualizar a tela de registros
+    def atualizar(e):
+        global upd
+        upd = Google_Sheets.ler_historico()
+
+        preencher_tabela(upd)
+
+
+    # 2. SE A PLANILHA ESTIVER VAZIA
+    if upd.empty:
+        conteudo_tabela = ft.Text("Nenhuma alteração realizada.", color="black", size=20)
+
+    # 3. SE TIVER DADOS, MONTA A TABELA
+    else:
+        print('Lendo os registros e montando a tela...')
+
+
+        # Pega os nomes das colunas da Linha 1 do Sheets
+        nomes_colunas = upd.columns.tolist()
+        colunas_flet = [ft.DataColumn(ft.Text(str(nome), weight="bold", color="black")) for nome in nomes_colunas]
+
+        tabela_obj = ft.DataTable(
+            columns=colunas_flet,
+            rows=[],  # Deixamos vazio para a função abaixo preencher
+            heading_row_color="#C8E6C9",
+            column_spacing=20,
+            data_row_min_height=40,
+        )
+        conteudo_tabela = ft.Column([tabela_obj], scroll=ft.ScrollMode.AUTO, expand=True)
+
+        # --- FUNÇÃO DE PREENCHER A TABELA (TOTALMENTE CONVERTIDA PARA PANDAS) ---
+        def preencher_tabela(dataframe,precisa_atualizar=True):
+            linhas_flet = []
+
+            # O jeito certo de ler um DataFrame linha a linha:
+            for index, row in dataframe.iterrows():
+                celulas = []
+
+                # Para cada nome de coluna, pega o valor exato daquela célula
+                for col in nomes_colunas:
+                    valor = row[col]
+                    celulas.append(ft.DataCell(ft.Text(str(valor), color="black", size=12)))
+
+                linhas_flet.append(ft.DataRow(cells=celulas,
+
+                                        #Criamos uma configuração de cores para ele ter o visual de houver na tela
+                                         color={
+                                             #Cor quando ele passa o moouse por cima
+                                             ft.ControlState.HOVERED:"#a7d498",
+
+                                             # Cor para o exato momento do clique
+                                             ft.ControlState.PRESSED: "#a7d498",
+
+                                             # Cor de quando você está com o cursor piscando lá dentro digitando
+                                             ft.ControlState.FOCUSED: "#a7d498",
+
+                                             # Outra cor para quando ele clica
+                                             ft.ControlState.SELECTED:"#a7d498",
+
+                                             #Outra cor para quando ele não passa o mouse nem clica
+                                             ft.ControlState.DEFAULT:ft.Colors.TRANSPARENT,
+
+                                         },
+                                         #Essa função serve apenas para avisar ao flet que essa linha deve ser ativa, assim o hover funciona
+                                         on_select_change=lambda e: print('Acordando a linha')
+
+
+                                         ))
+                tabela_obj.rows = linhas_flet
+
+            if precisa_atualizar:
+                tabela_obj.update()
+                conteudo_tabela.update()
+
+            # --- A SUPER BUSCA GLOBAL (ESTILO GOOGLE) ---
+
+        def filtrar_tudo(e):
+
+            print('iniciando filtro')
+            # 1. Pega o texto, deixa minúsculo e tira espaços sobrando nas pontas
+            texto = e.control.value.lower().strip()
+
+            # 2. Se apagou tudo, devolve a tabela original
+            if texto == "" or texto == " ":
+                preencher_tabela(upd.head(50))
+                print('sem dados para filtrar')
+                return
+
+            # 3. O SEGREDO: Corta o texto nos espaços!
+            # Se ele digitou "AGRO 3000", vira uma lista: ["agro", "3000"]
+            palavras_digitadas = texto.split()
+
+            # Fazemos uma cópia da tabela inteira para ir "espremendo" ela
+            df_filtrado = upd.copy()
+
+            # 4. O Loop do Afunilamento
+            for palavra in palavras_digitadas:
+                print(f'Filtrando as palavras:{palavra}')
+                # Para CADA palavra, ele procura na tabela e joga fora o que não bater
+                mascara_busca = df_filtrado.astype(str).apply(
+                    lambda col: col.str.lower().str.contains(palavra, na=False))
+                df_filtrado = df_filtrado[mascara_busca.any(axis=1)]
+
+            # No final do loop, só sobram as linhas que têm TODAS as palavras digitadas!
+            preencher_tabela(df_filtrado.head(50))
+
+         # Campo de busca inteligente
+        campo_busca = ft.TextField(
+            label="Filtrar qualquer campo...",
+            prefix_icon=ft.Icons.SEARCH,
+            width=250,
+            height=40,
+            text_size=14,
+            border_color="white24",
+            focused_border_color="green",
+            label_style=ft.TextStyle(color="white70"),
+            on_submit=filtrar_tudo  # Chama a função quando clicamos no enter
+        )
+
+        # ==============================================================================
+        # --- O CABEÇALHO RESPONSIVO (Mesma lógica da tela principal) ---
+        # ==============================================================================
+        linha_cabecalho = ft.Row(
+            controls=[
+                # 1. TEXTO DA ESQUERDA
+                ft.Text("App Custo de Produtos - Setor Compras", color="white", weight="bold", size=18),
+
+                # 2. PRIMEIRA MOLA: Empurra o centro
+                ft.Container(expand=True),
+
+                # 3. O "PACOTE" CENTRAL: Busca, Botões e Linhas Divisórias
+                ft.Row(
+                    controls=[
+                        campo_busca,
+
+                        # Linha Divisória 1
+                        ft.Container(width=1, height=30, bgcolor="white54", margin=ft.margin.symmetric(horizontal=10)),
+
+                        ft.TextButton("Lista De Produtos", on_click=tela_principal, style=ft.ButtonStyle(
+                            color={ft.ControlState.DEFAULT: ft.Colors.WHITE,
+                                   ft.ControlState.HOVERED: ft.Colors.BLACK})),
+
+                        # Linha Divisória 2
+                        ft.Container(width=1, height=30, bgcolor="white54", margin=ft.margin.symmetric(horizontal=10)),
+
+                        ft.TextButton("Meus Registros", style=ft.ButtonStyle(
+                            color={ft.ControlState.DEFAULT: ft.Colors.WHITE,
+                                   ft.ControlState.HOVERED: ft.Colors.BLACK})),
+                    ],
+                    spacing=5,
+                    vertical_alignment=ft.CrossAxisAlignment.CENTER,
+                ),
+
+                # 4. SEGUNDA MOLA: Empurra os botões de ação lá pro canto direito
+                ft.Container(expand=True),
+
+                # 5. PACOTE DA DIREITA: Agrupa o botão Atualizar e o Sair lado a lado
+                ft.Row(
+                    controls=[
+                        # Botão Atualizar (Azul)
+                        ft.Container(
+                            content=ft.Icon(icon=ft.Icons.UPDATE_ROUNDED, color="white", size=20),
+                            on_click=atualizar,
+                            tooltip="Atualizar a tela!",
+                            bgcolor="blue", width=35, height=35, border_radius=5, alignment=ft.Alignment.CENTER,
+                            ink=True
+                        ),
+
+                        # Botão Sair (Vermelho)
+                        ft.Container(
+                            content=ft.Icon(icon=ft.Icons.POWER_SETTINGS_NEW, color="white", size=20),
+                            on_click=ir_para_login,
+                            tooltip="Sair do Sistema!",
+                            bgcolor="red", width=35, height=35, border_radius=5, alignment=ft.Alignment.CENTER, ink=True
+                        )
+                    ],
+                    spacing=10  # Pequeno espaço entre o botão azul e o vermelho
+                )
+            ],
+            alignment=ft.MainAxisAlignment.START,
+            vertical_alignment=ft.CrossAxisAlignment.CENTER,
+        )
+
+        # ==============================================================================
+        # --- A ÁREA DA TABELA RESPONSIVA ---
+        # ==============================================================================
+        area_tabela = ft.Container(
+            content=ft.Column(
+                controls=[
+                    ft.Text("Histórico de Alterações", size=25, weight="bold", color="black"),
+                    ft.Divider(),
+                    conteudo_tabela  # Aqui entra a tabela que foi montada lá em cima
+                ],
+                expand=True  # Garante que a coluna ocupe tudo
+            ),
+            bgcolor="white",
+            border_radius=10,
+            padding=10,
+            expand=True  # Faz a caixa branca esticar até o fim da tela
+        )
+
+        # ==============================================================================
+        # --- O LAYOUT PRINCIPAL DA TELA ---
+        # ==============================================================================
+        layout = ft.Container(
+            image=ft.DecorationImage(
+                src="BP - Analítico-App-Custo-v2 (1).png",
+                fit="cover"
+            ),
+            expand=True,
+            padding=ft.Padding(top=20, left=30, right=30, bottom=20),
+            content=ft.Column(
+                controls=[
+                    linha_cabecalho,
+                    area_tabela
+                ],
+                expand=True,
+                spacing=20
+            )
+        )
+    # Preenche a tabela com todos os dados logo que a tela carregar
+    if not upd.empty:
+        # Passamos False para ele NÃO tentar desenhar antes da hora!
+        preencher_tabela(upd, precisa_atualizar=False)
+
+
+    return layout

main.py

@@ -0,0 +1,559 @@
+#Funções de bibliotecas exportadas
+from datetime import datetime
+
+#Bibliotecas interas
+import flet as ft
+import asyncio
+
+#Importa modulos e suas funções
+import Registros
+import Login
+import Qlik_sense
+import Google_Sheets
+
+#Var global para receber os dados do qlik
+df=None
+
+#Var de global para buscar o historico
+df_hist=None
+
+
+
+#Função mae, na qual chamamos as demais e oraganizamos a logica
+def main(page: ft.Page):
+
+    #Definindo tamanho e parametos da pagina, nome etc
+    page.padding = 0
+    page.spacing = 0
+    page.bgcolor = ft.Colors.BLACK
+    page.window_maximized = True
+    page.title = "Sistema de Precificação"
+
+
+    # 2. FUNÇÃO QUE RODA ESCONDIDA NO FUNDO
+    async def carregar_no_fundo():
+        global df, df_hist
+
+        await asyncio.sleep(2)
+        print("Iniciando download silencioso do Qlik... e sheets")
+        df, df_hist = Qlik_sense.extrair_dados_engine()
+
+
+        print("Download do Qlik e sheets concluído com sucesso!")
+
+
+
+    # 3. TELA DE LOGIN
+    def ir_para_login(e=None):
+
+
+        page.clean()
+        tela = Login.montar_tela_login(ir_para_principal)
+        page.add(tela)
+        page.update()
+
+
+        #Elimino toda a configuração atual de espaçamento da tela para eu poder configurar como desejar abaixo com flet
+        page.padding=0
+        page.spacing=0
+        page.expand=True
+
+
+
+
+
+        # --- FUNÇÃO 1: CONSTRÓI A TELA DE REGISTROS ---
+    def ir_para_registros(e):
+            page.clean()  # 1. Limpa a tela principal
+            global df_hist
+            print('Iniciado outro modulo')
+
+            # 2. Chama o módulo para desenhar a tela nova
+            # Passamos a função 'ir_para_principal' para ele saber como voltar
+            tela = Registros.montar_tela_registros(ir_para_login,ir_para_principal,df_hist)
+
+            page.add(tela)  # 3. Adiciona a tela nova
+            page.update()
+
+   # Dic que define tamanho das colunas
+    larguras_colunas = {
+        "SAFRA":100,
+        "CÓDIGO DO PRODUTO": 150,
+        "DERIVAÇÃO":80,
+        "DESCRIÇÃO PRODUTO": 200,
+        "MARCA": 180,
+        "CUSTO ATUAL": 120,  # Maior porque tem muito texto
+        "DATA VENC ATUAL": 180,
+        "DATA DE VENC NOVA":180,
+        "NOVO CUSTO":100,
+        "% BARTER":100,
+        "QUANTIDADE":100,
+        "Salvar alteração":100
+
+    }
+
+    def get_largura(nome_coluna):
+        return larguras_colunas.get(nome_coluna, 120)
+
+    #Essa def cria o esqueleto da pagina com a informações retornadas
+    def ir_para_principal(e=None):
+        page.clean()
+        print('Iniciando tela principal')
+
+        #Uso a var globar para extrari o retorno do qlik
+        global df
+
+        # Criamos a tabela de dados como um objeto global dentro do main para podermos atualizar depois
+        tabela_dados_obj = ft.DataTable(
+            columns=[ft.DataColumn(ft.Text("")) for _ in df.columns],
+            rows=[],  # Começa vazia, vamos preencher na função
+            column_spacing=50,
+            data_row_max_height=float("inf"),
+            data_row_min_height=60,
+
+
+
+        )
+
+        #Empacoto a tabela acima que tem só colunas em uma coluna do flet
+        container_colum = ft.Column(
+            controls=[tabela_dados_obj],  # Apenas a tabela diretamente!
+            scroll=ft.ScrollMode.AUTO,
+            expand=True,
+
+        )
+
+
+        # Cabeçalho Fixo (seu código atual) AQUI COLOCAMOS O CABEÇALHO EM NEGRITO COM LETRA PRETA
+        colunas_cabecalho = [
+            ft.DataColumn(
+                ft.Container(
+                    content=ft.Text(col, weight="bold", color="black"),
+                    width=get_largura(col),
+
+
+
+                )
+            ) for col in df.columns
+        ]
+
+        #AQUI LEMOS O CABEÇALHO ACIMA COLOCAMOS UM FUNDO TRAPARENTE E UM TAMANHO E ALTURA
+        tabela_cabecalho = ft.DataTable(
+
+            columns=colunas_cabecalho,
+
+            heading_row_color=ft.Colors.TRANSPARENT,
+            column_spacing=50,
+            heading_row_height=50,
+
+        )
+
+        # Colunas editavel listadas para usarmos em outras defs
+        COLUNA_EDITAVEL = ["DATA DE VENC NOVA","NOVO CUSTO","QUANTIDADE","% BARTER"]
+
+        #Cria uma def para fechar nosso banner imporovisado
+        def fechar_banner_custom(e):
+            banner_customizado.visible = False
+            page.update()
+
+        #Cria um campo de texto vazio
+        texto_banner = ft.Text("", color="black", size=16, weight="bold")
+
+        #Cria nosso banner e recebe o texto vazio
+        banner_customizado = ft.Container(
+            content=ft.Row(
+                controls=[
+                    texto_banner,
+                    ft.Container(expand=True),
+                    ft.TextButton("OK, ENTENDI", on_click=fechar_banner_custom, style=ft.ButtonStyle(color="black"))
+                ]
+            ),
+            bgcolor="green",
+            top=0, left=0, right=0,
+            padding=15,
+            visible=False,
+        )
+
+
+
+        # --- FUNÇÃO QUE SALVA A LINHA TODA ---
+        def salvar_edicao(df_index, caixas_da_linha):
+
+            print("Iniciando verificação da linha completa...")
+
+            valores_validados = {}  # Vamos guardar aqui os valores que passarem no teste
+
+            # 1. VALIDAÇÃO: Vamos olhar cada caixinha daquela linha
+            for nome_coluna, campo_texto in caixas_da_linha.items():
+                valor_digitado = campo_texto.value
+
+                # Se o campo estiver vazio, pula e não altera nada
+                if valor_digitado == "" or valor_digitado == "-":
+                    continue
+
+                    # Testa os números
+                if nome_coluna in ["NOVO CUSTO", "% BARTER", "QUANTIDADE"]:
+                    try:
+                        valor_limpo = valor_digitado.replace('.', '').replace(',', '.')
+                        valores_validados[nome_coluna] = float(valor_limpo)
+                        print('Salvo valor numerico com sucesso')
+                    except ValueError:
+                        print('deu erro na hora de validar campos de valor')
+
+                        banner_customizado.bgcolor = "orange"
+                        texto_banner.value = f" ❌ O campo NOVO CUSTO, % BARTER, QUANTIDADE , precisa ser valor númerico valido "
+                        banner_customizado.visible = True
+                        page.update()
+                        return  # Aborta o salvamento da linha inteira!
+
+                # Testa as datas
+                elif nome_coluna in ["DATA DE VENC NOVA"]:
+                    try:
+                        datetime.strptime(valor_digitado, "%d/%m/%Y")
+                        valores_validados[nome_coluna] = valor_digitado
+
+                    except ValueError:
+
+                        print('Deu erro no momento de validar data')
+
+                        banner_customizado.bgcolor = "orange"
+                        texto_banner.value = f" ❌ O campo DATA DE VENC NOVA , precisa ser uma data valida "
+                        banner_customizado.visible = True
+                        page.update()
+                        return # Aborta o salvamento da linha inteira!
+
+
+            # 2. SE PASSOU EM TUDO SEM ERROS, ATUALIZA O PANDAS
+            for nome_coluna, valor_novo in valores_validados.items():
+                if df[nome_coluna].dtype == 'string' or df[nome_coluna].dtype.name == 'string':
+                    df[nome_coluna] = df[nome_coluna].astype('object')
+
+                df.at[df_index, nome_coluna] = valor_novo
+                print(f'Resposta salva no df:{df[nome_coluna]}')
+
+            # 3. Tira a foto da linha atualizada com TUDO o que foi digitado
+            linha_atualizada = df.loc[df_index]
+
+            # 4. Monta o Dicionário mestre para o Google Sheets
+            data_hora = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
+            registro = {
+                "Data/Hora": data_hora,
+                "User": page.session.store.get("user") or "Desconhecido",
+                "Safra": linha_atualizada['SAFRA'],
+                "Produto": linha_atualizada['CÓDIGO DO PRODUTO'],
+                "Derv": linha_atualizada['DERIVAÇÃO'],
+                "desc prod": linha_atualizada['DESCRIÇÃO PRODUTO'],
+                "Marca": linha_atualizada['MARCA'],
+                "Nv custo": linha_atualizada['CUSTO ATUAL'],
+                "Data venc atual": linha_atualizada['DATA VENC ATUAL'],
+                "Data de venc nv": linha_atualizada['DATA DE VENC NOVA'],
+                "Novo custo": linha_atualizada['NOVO CUSTO'],
+                "Barter": linha_atualizada['% BARTER'],
+                "qtd": linha_atualizada['QUANTIDADE'],
+
+            }
+
+
+            # 5. Envia para o Google Sheets UMA única vez
+            retorno=Google_Sheets.adicionar_linha_sheets(registro)
+            print(f'Retorno do mod sheets {retorno}')
+            if retorno =='1':
+                print('Tentando atualizar tela sucesso')
+
+                banner_customizado.bgcolor = "white"
+                texto_banner.value = "✔️ Registro salvo com sucesso 💾!"
+                banner_customizado.visible = True
+                page.update()
+
+            else:
+
+                print('Tentando atualizar tela com erro (Banner)')
+
+                banner_customizado.bgcolor = "orange"
+                texto_banner.value = f"❌ Ops! Ocorreu um erro: {retorno}"
+                banner_customizado.visible = True
+                page.update()
+
+
+
+        # --- FUNÇÃO DE PREENCHER A TABELA (MODIFICADA) ELA QUE VAI SEMPRE ATUALZIAR A TABELA COM OS DADOS RETORNADOS DO QLIK E FILTROS ---
+        def preencher_tabela(dataframe):
+            linhas = []
+
+
+            # iterrows() agora nos dá o 'index' real da linha no DataFrame (fundamental para atualizar o dado correto)
+            for index, row in dataframe.iterrows():
+                celulas = []
+
+                # um dic para guardar al alterações
+                cx_tx_linha = {}
+
+                for col_name in dataframe.columns:
+                    valor = row[col_name]
+                    if col_name == 'CÓDIGO DO PRODUTO':
+                        texto_formatado=str(valor)
+
+                    else:
+                       texto_formatado = f"{valor:.2f}"  if isinstance(valor, (int, float)) else str(valor)
+
+
+                    #Verifico se estou olhando para a coluna botão
+                    if col_name == "Salvar alteração":
+
+                        botao_salvar= ft.IconButton(
+                            icon=ft.Icons.SAVE,
+                            icon_color="green",
+                            tooltip="Salvar registro",
+
+                            # Aqui damos o poder par ao botão enviar para a def que mnd para o sheets
+                            on_click=lambda e, idx=index, cx=cx_tx_linha: salvar_edicao(idx, cx)
+
+
+
+                        )
+                        celulas.append(ft.DataCell(ft.Container(content=botao_salvar, width=get_largura(col_name))))
+                    # SE FOR A COLUNA EDITÁVEL, COLOCA UM TEXTFIELD
+                    elif col_name in COLUNA_EDITAVEL:
+                        campo_editavel = ft.TextField(
+                            value=texto_formatado,
+                            text_size=12,
+                            height=35,
+                            content_padding=5,
+                            border_color="transparent",  # Deixa invisível até focar
+                            focused_border_color="blue",
+
+                        )
+
+                        # Guarda essa caixinha no nosso dicionário para o botão ler depois!
+                        cx_tx_linha[col_name] = campo_editavel
+
+                        celulas.append(ft.DataCell(ft.Container(content=campo_editavel,width=get_largura(col_name))))
+
+                    # SE FOR OUTRA COLUNA, COLOCA TEXTO NORMAL (Bloqueado)
+                    else:
+                        texto_visual = ft.Text(texto_formatado, color="black", size=12)
+                        # Envolvemos no Container
+                        celulas.append(ft.DataCell(ft.Container(content=texto_visual, width=get_largura(col_name), padding=ft.Padding.symmetric(vertical=10, horizontal=0))))
+
+                #Adicionamos os valores na lsita declarada no topo da def adicionams um hover nele
+                linhas.append(ft.DataRow(cells=celulas,
+
+                                        #Criamos uma configuração de cores para ele ter o visual de houver na tela
+                                         color={
+                                             #Cor quando ele passa o moouse por cima
+                                             ft.ControlState.HOVERED:"#a7d498",
+
+                                             # Cor para o exato momento do clique
+                                             ft.ControlState.PRESSED: "#a7d498",
+
+                                             # Cor de quando você está com o cursor piscando lá dentro digitando
+                                             ft.ControlState.FOCUSED: "#a7d498",
+
+                                             # Outra cor para quando ele clica
+                                             ft.ControlState.SELECTED:"#a7d498",
+
+                                             #Outra cor para quando ele não passa o mouse nem clica
+                                             ft.ControlState.DEFAULT:ft.Colors.TRANSPARENT,
+
+                                         },
+                                         #Essa função serve apenas para avisar ao flet que essa linha deve ser ativa, assim o hover funciona
+                                         on_select_change=lambda e: print('Acordando a linha')
+
+
+                                         ))
+
+            #Add na tabelas essas linhs configuradas
+            tabela_dados_obj.rows = linhas
+            tabela_dados_obj.update()
+
+            # 2. NOVO: Força a barra de rolagem a recalcular o tamanho correto!
+            container_colum.update()
+            page.update()
+
+            # --- A SUPER BUSCA GLOBAL (ESTILO GOOGLE) ---
+        def filtrar_tudo(e):
+
+                print('iniciando filtro')
+                # 1. Pega o texto, deixa minúsculo e tira espaços sobrando nas pontas
+                texto = e.control.value.lower().strip()
+
+                # 2. Se apagou tudo, devolve a tabela original
+                if texto == "" or texto== " ":
+                    preencher_tabela(df.head(50))
+                    print('sem dados para filtrar')
+                    return
+
+                # 3. O SEGREDO: Corta o texto nos espaços!
+                # Se ele digitou "AGRO 3000", vira uma lista: ["agro", "3000"]
+                palavras_digitadas = texto.split()
+
+                # Fazemos uma cópia da tabela inteira para ir "espremendo" ela
+                df_filtrado = df.copy()
+
+                # 4. O Loop do Afunilamento
+                for palavra in palavras_digitadas:
+
+                    print(f'Filtrando as palavras:{palavra}')
+                    # Para CADA palavra, ele procura na tabela e joga fora o que não bater
+                    mascara_busca = df_filtrado.astype(str).apply(
+                        lambda col: col.str.lower().str.contains(palavra, na=False))
+                    df_filtrado = df_filtrado[mascara_busca.any(axis=1)]
+
+                # No final do loop, só sobram as linhas que têm TODAS as palavras digitadas!
+                preencher_tabela(df_filtrado.head(50))
+
+        # Campo de busca inteligente
+        campo_busca = ft.TextField(
+            label="Filtrar qualquer campo...",
+            prefix_icon=ft.Icons.SEARCH,
+            width=250,
+            height=40,
+            text_size=14,
+            border_color="white24",
+            focused_border_color="green",
+            label_style=ft.TextStyle(color="white70"),
+            on_submit=filtrar_tudo  # Chama a função quando clicamos no enter
+        )
+
+
+
+
+       #Etapa onde definimos valores fora da tabela principal, como botões de atualizar, abrir novas abas etc
+
+        # --- O CABEÇALHO RESPONSIVO ---
+        # --- O CABEÇALHO RESPONSIVO ---
+        linha_cabecalho = ft.Row(
+            controls=[
+
+                # 1. O TEXTO DO APLICATIVO (O jeito certo de colocar texto)
+                # Remova o texto da sua imagem PNG e deixe o Flet desenhar ele aqui,
+                # assim ele NUNCA mais será cortado em telas menores!
+                ft.Text("App Custo de Produtos - Setor Compras", color="white", weight="bold", size=18),
+
+                # 2. PRIMEIRA MOLA: Fica entre o título e o grupo central
+                ft.Container(expand=True),
+
+                # 3. O "PACOTE" CENTRAL: Agrupamos a busca e os botões juntos aqui
+                # 3. O "PACOTE" CENTRAL: Busca, Botões e Linhas Divisórias
+                ft.Row(
+                    controls=[
+                        # O Campo de busca fica de um lado
+                        campo_busca,
+
+                        # --- LINHA DIVISÓRIA 1 (Feita pelo Flet) ---
+                        ft.Container(
+                            width=1,  # Espessura da linha
+                            height=30,  # Altura da linha
+                            bgcolor="white54",  # Branco com um pouco de transparência
+                            margin=ft.margin.symmetric(horizontal=10)  # Dá um respiro para os lados
+                        ),
+
+                        # O primeiro botão fica no meio
+                        ft.TextButton("Lista De Produtos", style=ft.ButtonStyle(
+                            color={ft.ControlState.DEFAULT: ft.Colors.WHITE,
+                                   ft.ControlState.HOVERED: ft.Colors.BLACK})),
+
+                        # --- LINHA DIVISÓRIA 2 (Feita pelo Flet) ---
+                        ft.Container(
+                            width=1,
+                            height=30,
+                            bgcolor="white54",
+                            margin=ft.margin.symmetric(horizontal=10)
+                        ),
+
+                        # O segundo botão fica do outro lado
+                        ft.TextButton("Meus Registros", on_click=ir_para_registros, style=ft.ButtonStyle(
+                            color={ft.ControlState.DEFAULT: ft.Colors.WHITE,
+                                   ft.ControlState.HOVERED: ft.Colors.BLACK})),
+                    ],
+                    spacing=5,  # O spacing pode ser menor agora, pois a margem das linhas já afasta os itens
+                    vertical_alignment=ft.CrossAxisAlignment.CENTER,
+                ),
+
+                # 4. SEGUNDA MOLA: Fica entre o grupo central e o botão de sair
+                ft.Container(expand=True),
+
+                # 5. BOTÃO DE SAIR (A segunda mola empurra ele lá pro canto direito)
+                ft.Container(
+                    content=ft.Icon(icon=ft.Icons.POWER_SETTINGS_NEW, color="white", size=20),
+                    on_click=ir_para_login,
+                    tooltip="Sair do Sistema!",
+                    bgcolor="red",
+                    width=35,
+                    height=35,
+                    border_radius=5,
+                    alignment=ft.Alignment.CENTER,
+                    ink=True,
+                )
+            ],
+            alignment=ft.MainAxisAlignment.START,
+            vertical_alignment=ft.CrossAxisAlignment.CENTER,
+        )
+
+        # --- A ÁREA DA TABELA RESPONSIVA ---
+        area_tabela = ft.Container(
+            content=ft.Row(
+                controls=[
+                    ft.Column(
+                        controls=[
+                            tabela_cabecalho,
+                            container_colum
+                        ],
+                        spacing=0,
+                        expand=True  # Permite que a coluna da tabela cresça verticalmente
+                    )
+                ],
+                scroll=ft.ScrollMode.AUTO,  # Mantém o scroll horizontal essencial para tabelas grandes
+                expand=True,
+                vertical_alignment=ft.CrossAxisAlignment.START
+            ),
+            bgcolor="white",
+            border_radius=10,
+            padding=10,
+            expand=True  # Faz a caixa branca da tabela ocupar todo o espaço restante da tela
+        )
+
+        # --- O LAYOUT PRINCIPAL (Substitui o Stack) ---
+        # --- O LAYOUT PRINCIPAL (Atualizado Flet 0.22+) ---
+        conteudo = ft.Container(
+            # NOVA FORMA DE COLOCAR IMAGEM DE FUNDO:
+            image=ft.DecorationImage(
+                src="BP - Analítico-App-Custo-v2 (1).png",
+                fit="cover"
+            ),
+            expand=True,
+            # NOVA FORMA DE FAZER O PADDING (Resolve o aviso amarelo):
+            padding=ft.Padding(top=20, left=30, right=30, bottom=20),
+            content=ft.Column(
+                controls=[
+                    linha_cabecalho,
+                    area_tabela  # A tabela vai preencher todo o resto do espaço
+                ],
+                expand=True,
+                spacing=20  # Espaçamento dinâmico entre o cabeçalho e a tabela
+            )
+        )
+
+        # Como tiramos o Stack, o banner agora vai na "camada superior" da página (Overlay)
+        # Isso garante que ele sempre flutue no topo da tela, independente do tamanho!
+        page.overlay.append(banner_customizado)
+
+        page.add(conteudo)
+
+
+        preencher_tabela(df.head(50))
+
+        # Assim que abrir a tela de login chamamos a def que irá buscar os dados do QLik
+    page.run_task(carregar_no_fundo)
+    ir_para_login()
+
+#ft.run(main, view=ft.AppView.WEB_BROWSER, assets_dir=".")  # Removido o modo browser para rodar como App Desktop nativo
+
+
+ft.run(
+    main,
+    view=ft.WEB_BROWSER,
+    assets_dir=".",     # <--- Mantém as suas imagens funcionando!
+    host="0.0.0.0",     # <--- Libera o acesso externo
+    port=7860           # <--- A porta obrigatória do Hugging Face
+)

requirements.txt

@@ -0,0 +1,7 @@
+flet
+pandas
+python-dotenv
+google-auth
+gspread
+qlik-sdk
+requests