Programa para vaculhar pastas e encontrar distancia entre cidades utilizando OSRM

[coordenacaoprojetoslz7-pixel]

import os
import re
import pandas as pd
from datetime import datetime, date # Adicionado date para data atual
import time
import requests # Para chamadas HTTP ao OSRM

Tentar importar bibliotecas de geolocalização

try:
from geopy.geocoders import Nominatim
from geopy.exc import GeocoderTimedOut, GeocoderUnavailable
GEO_LIBS_AVAILABLE = True
except ImportError:
GEO_LIBS_AVAILABLE = False
print("⚠️ Biblioteca geopy não encontrada. A funcionalidade de cálculo de distância não estará disponível.")
print(" Para habilitar, instale-a com: pip install geopy requests")

--- Configurações para Cálculo de Distância ---

CIDADE_ORIGEM_NOME = "Wenceslau Braz, Paraná, Brasil"
OSRM_SERVER_URL = "http://router.project-osrm.org" # Servidor público do OSRM

Cache para coordenadas e distâncias

coordenadas_cache = {}
distancias_cache_osrm = {}

def obter_coordenadas_osm(localizador, cidade_estado_base, tentativas_adicionais=None):
"""Tenta obter coordenadas, primeiro com cidade_estado_base, depois com tentativas_adicionais."""
tentativas = [cidade_estado_base]
if tentativas_adicionais:
tentativas.extend(tentativas_adicionais)

for tentativa_local in tentativas:
    if tentativa_local in coordenadas_cache:
        if coordenadas_cache[tentativa_local] is not None: # Se já temos uma coordenada válida, retorna
            return coordenadas_cache[tentativa_local]
        # Se foi None antes, não tenta de novo com o mesmo nome, mas permite outras tentativas
        continue 

    try:
        print(f"   🌍 Geocodificando (OSM): {tentativa_local}")
        location = localizador.geocode(tentativa_local, timeout=10)
        time.sleep(1.1) # Nominatim público tem limite de 1 req/s
        if location:
            coordenadas_cache[tentativa_local] = (location.latitude, location.longitude)
            return coordenadas_cache[tentativa_local]
        else:
            # Marcamos como None para esta tentativa específica, mas não impede outras
            coordenadas_cache[tentativa_local] = None 
            print(f"   ❌ Coordenadas (OSM) não encontradas para: {tentativa_local}")
    except GeocoderTimedOut:
        print(f"   ⏳ Timeout ao geocodificar (OSM): {tentativa_local}")
        # Não retorna None imediatamente, permite outras tentativas se houver
    except GeocoderUnavailable:
        print(f"   🔌 Serviço de geocodificação (OSM) indisponível ao tentar: {tentativa_local}")
        # Não retorna None imediatamente, permite outras tentativas se houver
    except Exception as e:
        print(f"   💥 Erro inesperado ao geocodificar (OSM) {tentativa_local}: {e}")
        # Não retorna None imediatamente, permite outras tentativas se houver

# Se todas as tentativas falharem para este conjunto de nomes
return None

def calcular_distancia_osrm(coords_origem, coords_destino):
cache_key = (coords_origem, coords_destino)
if cache_key in distancias_cache_osrm:
return distancias_cache_osrm[cache_key]

if not coords_origem or not coords_destino:
    return None

url = f"{OSRM_SERVER_URL}/route/v1/driving/{coords_origem[1]},{coords_origem[0]};{coords_destino[1]},{coords_destino[0]}?overview=false&alternatives=false"

try:
    print(f"   🚗 Calculando rota OSRM de {coords_origem} para {coords_destino}")
    response = requests.get(url, timeout=15)
    time.sleep(0.5) 
    response.raise_for_status()
    data = response.json()
    
    if data.get("code") == "Ok" and data.get("routes"):
        distancia_m = data["routes"][0]["distance"]
        distancia_km = round(distancia_m / 1000, 2)
        distancias_cache_osrm[cache_key] = distancia_km
        return distancia_km
    else:
        print(f"   ❌ Rota OSRM não encontrada ou resposta inválida: {data.get("code")} para {coords_origem} -> {coords_destino}")
        distancias_cache_osrm[cache_key] = None
        return None
except requests.exceptions.Timeout:
    print(f"   ⏳ Timeout ao consultar OSRM para rota: {coords_origem} -> {coords_destino}")
    return None
except requests.exceptions.RequestException as e:
    print(f"   💥 Erro na requisição OSRM: {e}")
    return None
except Exception as e:
    print(f"   💥 Erro inesperado ao processar resposta OSRM: {e}")
    return None

def extrair_nome_cidade(texto_municipio_orgao):
try:
partes = texto_municipio_orgao.upper().split(" DE ", 1)
if len(partes) > 1:
nome_cidade_extraido = partes[1].strip()
return ' '.join(word.capitalize() for word in nome_cidade_extraido.split())
else:
return ' '.join(word.capitalize() for word in texto_municipio_orgao.strip().split())
except Exception:
return texto_municipio_orgao.strip()

def extrair_dados_pastas_osrm_filtrado(diretorio_base, arquivo_saida, cidade_origem_ref_nome):
dados_extraidos = []
padrao_pasta_edital = r"^([A-Z]+(?:\s[A-Z]+)*)\s+(\S+)\s+(.+?)\s+LZ7(?:\s+(\d{2}-\d{2}-\d{4})|\s+-\s+(\d{2}[.-]\d{2}(?:[.-]\d{4})?))?$"
data_hoje = date.today()

localizador = None
coords_cidade_origem = None
calculo_distancia_habilitado = False

if GEO_LIBS_AVAILABLE:
    try:
        localizador = Nominatim(user_agent="licitacao_extrator_manus_osrm_v5/1.0") 
        coords_cidade_origem = obter_coordenadas_osm(localizador, cidade_origem_ref_nome)
        if coords_cidade_origem:
            print(f"📍 Coordenadas da cidade de origem ({cidade_origem_ref_nome}): {coords_cidade_origem}")
            calculo_distancia_habilitado = True
        else:
            print(f"❌ Não foi possível obter coordenadas para a cidade de origem: {cidade_origem_ref_nome}. Cálculo de distância desabilitado.")
    except Exception as e:
        print(f"💥 Erro ao inicializar Nominatim: {e}. Cálculo de distância desabilitado.")
else:
    print("\n--- Bibliotecas de geolocalização não disponíveis. Cálculo de distância desabilitado. ---")

print(f"\n🔍 Iniciando varredura em: {diretorio_base}")

for raiz, pastas, _ in os.walk(diretorio_base, topdown=True):
    if os.path.samefile(raiz, diretorio_base):
        pastas_originais = len(pastas)
        pastas[:] = [p for p in pastas if p in ["2024", "2025"] and os.path.isdir(os.path.join(raiz, p))]
        if len(pastas) < pastas_originais:
            print(f"   ↪ Filtrando anos. Processando apenas: {pastas} em {diretorio_base}")
        if not pastas:
            print(f"   ⚠️ Nenhuma pasta de ano (")

    pastas[:] = [p for p in pastas if not p.startswith(".")]
    
    for nome_pasta_edital in pastas:
        match = re.match(padrao_pasta_edital, nome_pasta_edital)
        if match:
            modalidade = match.group(1).strip()
            num_ano = match.group(2).strip()
            municipio_licitacao_raw = match.group(3).strip()
            data_str_g4 = match.group(4)
            data_str_g5 = match.group(5)

            data_str_final = ""
            data_licitacao_obj = pd.NaT

            if data_str_g4:
                data_str_final = data_str_g4
                try: data_licitacao_obj = datetime.strptime(data_str_final, "%d-%m-%Y").date()
                except ValueError: print(f"⚠️ Data (G4) inválida: {data_str_final} na pasta {nome_pasta_edital}.")
            elif data_str_g5:
                data_str_final = data_str_g5
                data_str_normalizada = data_str_final.replace(".", "-")
                try:
                    if len(data_str_normalizada) == 10: data_licitacao_obj = datetime.strptime(data_str_normalizada, "%d-%m-%Y").date()
                    elif len(data_str_normalizada) == 5: print(f"ℹ️ Data (G5) em formato DD-MM: {data_str_final} na pasta {nome_pasta_edital}.")
                    else: print(f"⚠️ Data (G5) em formato não suportado: {data_str_final} na pasta {nome_pasta_edital}.")
                except ValueError: print(f"⚠️ Data (G5) inválida: {data_str_final} na pasta {nome_pasta_edital}.")
            
            distancia_calculada_km = None
            cidade_destino_processada = extrair_nome_cidade(municipio_licitacao_raw)

            if calculo_distancia_habilitado and coords_cidade_origem and localizador and pd.notna(data_licitacao_obj) and data_licitacao_obj >= data_hoje:
                print(f"   -> Licitação futura ({data_licitacao_obj}), calculando distância para {cidade_destino_processada} (original: {municipio_licitacao_raw}).")
                
                # Prioriza Paraná, depois São Paulo, depois Brasil geral
                tentativas_geocoding = [
                    f"{cidade_destino_processada}, Paraná, Brasil",
                    f"{cidade_destino_processada}, São Paulo, Brasil",
                    f"{cidade_destino_processada}, Brasil"
                ]
                coords_destino = obter_coordenadas_osm(localizador, tentativas_geocoding[0], tentativas_adicionais=tentativas_geocoding[1:])

                # Se ainda falhar e o nome processado for diferente do raw, tenta o raw como último recurso
                if not coords_destino and cidade_destino_processada.lower() != municipio_licitacao_raw.lower():
                    print(f"   -> Tentando geocodificar com original: {municipio_licitacao_raw}, Brasil")
                    coords_destino = obter_coordenadas_osm(localizador, f"{municipio_licitacao_raw}, Brasil")

                if coords_destino:
                    distancia_calculada_km = calcular_distancia_osrm(coords_cidade_origem, coords_destino)
                else:
                    print(f"   ❌ Não foi possível obter coordenadas para o destino: {cidade_destino_processada} (original: {municipio_licitacao_raw})")
            elif pd.notna(data_licitacao_obj) and data_licitacao_obj < data_hoje:
                print(f"   -> Licitação passada ({data_licitacao_obj}), distância não será calculada para {cidade_destino_processada}.")
            
            dados_extraidos.append({
                "Nome da Pasta do Edital": nome_pasta_edital,
                "Modalidade": modalidade,
                "Número/Ano": num_ano,
                "Município/Órgão (Original)": municipio_licitacao_raw,
                "Cidade para Distância": cidade_destino_processada,
                "Data da Licitação": data_licitacao_obj if pd.notna(data_licitacao_obj) else None,
                f"Distância de {cidade_origem_ref_nome.split(",")[0]} (km)": distancia_calculada_km
            })
            print(f"✔️ Dados extraídos: {cidade_destino_processada} - {data_licitacao_obj if pd.notna(data_licitacao_obj) else 'Sem data'} - Dist: {distancia_calculada_km if distancia_calculada_km is not None else 'N/A'} km")

if not dados_extraidos:
    print("❌ Nenhuma pasta de edital com o padrão esperado foi encontrada nos anos 2024 e 2025.")
    return pd.DataFrame()

df = pd.DataFrame(dados_extraidos)
colunas_desejadas = ["Nome da Pasta do Edital", "Modalidade", "Número/Ano", "Município/Órgão (Original)", "Cidade para Distância", "Data da Licitação",
                       f"Distância de {cidade_origem_ref_nome.split(",")[0]} (km)"]
df = df[colunas_desejadas]

if "Data da Licitação" in df.columns:
    df["Data da Licitação"] = pd.to_datetime(df["Data da Licitação"], errors="coerce")
    df = df.sort_values(by="Data da Licitação", na_position="last")

try:
    df.to_excel(arquivo_saida, index=False, engine="openpyxl")
    print(f"\n✅ Dados salvos com sucesso em: {arquivo_saida}")
except Exception as e:
    print(f"\n❌ Erro ao salvar o arquivo Excel: {e}")
return df

--- Configuração Principal ---

diretorio_licitacoes_usuario = "C:/Users/danie/Desktop/LZ7/1 - Editais Licitação"
diretorio_saida_excel = "C:/Users/danie/Desktop/LZ7/1 - Editais Licitação/Organizados"
nome_arquivo_excel_base = "levantamento_editais_osrm_filtrado_v5"

--- Execução ---

if name == "main":
# Gerar timestamp para execução e nome do arquivo
timestamp_execucao = datetime.now().strftime("%Y%m%d_%H%M%S")
print(f"\n🕒 Execução iniciada em: {datetime.now().strftime('%d/%m/%Y %H:%M:%S')}")

# Adicionar timestamp ao nome do arquivo de saída
nome_arquivo_excel_saida = f"{nome_arquivo_excel_base}_{timestamp_execucao}.xlsx"
if not GEO_LIBS_AVAILABLE:
    print("\n--- Processamento interrompido pois bibliotecas de geolocalização não estão disponíveis. ---")
    print("--- Instale com: pip install geopy requests pandas openpyxl ---")
else:
    diretorio_alvo = diretorio_licitacoes_usuario
    
    # Verificar se o diretório de saída existe, se não, criar
    if not os.path.exists(diretorio_saida_excel):
        try:
            os.makedirs(diretorio_saida_excel)
            print(f"📁 Diretório de saída criado: {diretorio_saida_excel}")
        except Exception as e:
            print(f"❌ Erro ao criar diretório de saída: {e}")
            print(f"⚠️ Usando diretório atual como alternativa.")
            diretorio_saida_excel = os.getcwd()
    
    caminho_completo_saida_excel = os.path.join(diretorio_saida_excel, nome_arquivo_excel_saida)

    if not os.path.isdir(diretorio_alvo):
        print(f"❌ Erro: O diretório base especificado não existe ou não é um diretório válido: {diretorio_alvo}")
        print(f"➡️ Por favor, verifique o caminho na variável \"diretorio_licitacoes_usuario\" no script.")
    else:
        print(f"Iniciando processo com OSRM (filtrado, com extração de cidade e geocodificação priorizada PR/SP).")
        print(f"🕒 Timestamp: {timestamp_execucao}")
        print(f"📊 O arquivo Excel será salvo como: {caminho_completo_saida_excel}")
        df_resultado = extrair_dados_pastas_osrm_filtrado(diretorio_alvo, caminho_completo_saida_excel, CIDADE_ORIGEM_NOME)
        if not df_resultado.empty:
            print("\nResumo do DataFrame gerado:")
            print(df_resultado.head())
        else:
            print("\nNenhum dado foi extraído para gerar o DataFrame.")
        
        # Registrar timestamp de finalização
        print(f"\n🕒 Execução finalizada em: {datetime.now().strftime('%d/%m/%Y %H:%M:%S')}")