Improve portable geospatial fallbacks and pesquisa loading

backend/app/core/elaboracao/geocodificacao.py

@@ -11,6 +11,8 @@ import os
 import numpy as np
 import pandas as pd
 
+from app.core.shapefile_runtime import load_vector_dataframe
+from app.portable_runtime_log import append_runtime_log
 from app.runtime_config import resolve_core_path
 from .core import NOMES_LAT, NOMES_LON
 
@@ -64,18 +66,36 @@ def carregar_eixos():
     if _gdf_eixos is not None:
         return _gdf_eixos
 
+    if not os.path.exists(_SHAPEFILE):
+        print(f"[geocodificacao] AVISO: shapefile não encontrado em {_SHAPEFILE}")
+        return None
+
     try:
         import geopandas as gpd
     except ImportError:
-        print("[geocodificacao] AVISO: geopandas não instalado — geocodificação indisponível.")
+        gpd = None
+
+    if gpd is not None:
+        try:
+            gdf = gpd.read_file(_SHAPEFILE, engine="fiona")
+            gdf = gdf.to_crs("EPSG:4326")
+            _gdf_eixos = gdf
+            return _gdf_eixos
+        except Exception as exc:
+            append_runtime_log(f"[mesa] geocodificacao: falha no geopandas para eixos: {exc}")
+
+    try:
+        gdf = load_vector_dataframe(_SHAPEFILE, target_crs="EPSG:4326")
+    except Exception as exc:
+        print(f"[geocodificacao] AVISO: falha ao carregar eixos por fallback: {exc}")
+        append_runtime_log(f"[mesa] geocodificacao: fallback de eixos falhou: {exc}")
         return None
 
-    if not os.path.exists(_SHAPEFILE):
-        print(f"[geocodificacao] AVISO: shapefile não encontrado em {_SHAPEFILE}")
+    if gdf.empty:
+        append_runtime_log("[mesa] geocodificacao: fallback de eixos retornou base vazia")
         return None
 
-    gdf = gpd.read_file(_SHAPEFILE, engine="fiona")
-    gdf = gdf.to_crs("EPSG:4326")
+    append_runtime_log("[mesa] geocodificacao: usando fallback leve para eixos de logradouros")
     _gdf_eixos = gdf
     return _gdf_eixos
 

backend/app/core/map_layers.py

@@ -8,6 +8,8 @@ from typing import Any
 
 import folium
 from branca.element import Element
+from app.core.shapefile_runtime import load_vector_geojson
+from app.portable_runtime_log import append_runtime_log
 from app.runtime_config import resolve_core_path
 
 _BAIRROS_SHP_PATH = resolve_core_path("dados", "Bairros_LC12112_16.shp")
@@ -45,29 +47,43 @@ def _carregar_bairros_geojson() -> dict[str, Any] | None:
             return _BAIRROS_GEOJSON_CACHE
 
 
+    geojson = None
+
     try:
         import geopandas as gpd
     except Exception:
-        return None
+        gpd = None
 
-    try:
-        gdf = gpd.read_file(_BAIRROS_SHP_PATH, engine="fiona")
-        if gdf is None or gdf.empty:
+    if gpd is not None:
+        try:
+            gdf = gpd.read_file(_BAIRROS_SHP_PATH, engine="fiona")
+            if gdf is not None and not gdf.empty:
+                if gdf.crs is not None:
+                    gdf = gdf.to_crs("EPSG:4326")
+                campos = ["geometry"]
+                for campo in _TOOLTIP_FIELDS:
+                    if campo in gdf.columns:
+                        campos.insert(0, campo)
+                        break
+                gdf = gdf.loc[:, campos].copy()
+                if _SIMPLIFY_TOLERANCE > 0:
+                    gdf["geometry"] = gdf.geometry.simplify(_SIMPLIFY_TOLERANCE, preserve_topology=True)
+                geojson = json.loads(gdf.to_json(drop_id=True))
+        except Exception as exc:
+            append_runtime_log(f"[mesa] bairros: falha no geopandas para camada de bairros: {exc}")
+
+    if geojson is None:
+        try:
+            geojson = load_vector_geojson(
+                _BAIRROS_SHP_PATH,
+                target_crs="EPSG:4326",
+                property_fields=_TOOLTIP_FIELDS,
+                simplify_tolerance=_SIMPLIFY_TOLERANCE,
+            )
+            append_runtime_log("[mesa] bairros: usando fallback leve para camada de bairros")
+        except Exception as exc:
+            append_runtime_log(f"[mesa] bairros: fallback de bairros falhou: {exc}")
             geojson = None
-        else:
-            if gdf.crs is not None:
-                gdf = gdf.to_crs("EPSG:4326")
-            campos = ["geometry"]
-            for campo in _TOOLTIP_FIELDS:
-                if campo in gdf.columns:
-                    campos.insert(0, campo)
-                    break
-            gdf = gdf.loc[:, campos].copy()
-            if _SIMPLIFY_TOLERANCE > 0:
-                gdf["geometry"] = gdf.geometry.simplify(_SIMPLIFY_TOLERANCE, preserve_topology=True)
-            geojson = json.loads(gdf.to_json(drop_id=True))
-    except Exception:
-        geojson = None
 
     with _BAIRROS_CACHE_LOCK:
         if geojson is not None:

backend/app/core/shapefile_runtime.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+def _build_transformer(source_crs: Any, target_crs: str | None):
+    if not source_crs or not target_crs:
+        return None
+
+    try:
+        from pyproj import CRS, Transformer
+    except Exception:
+        return None
+
+    try:
+        source = CRS.from_user_input(source_crs)
+        target = CRS.from_user_input(target_crs)
+    except Exception:
+        return None
+
+    if source == target:
+        return None
+
+    try:
+        return Transformer.from_crs(source, target, always_xy=True)
+    except Exception:
+        return None
+
+
+def load_vector_dataframe(shapefile_path: str | Path, *, target_crs: str | None = "EPSG:4326") -> pd.DataFrame:
+    import fiona
+    from shapely.geometry import shape
+    from shapely.ops import transform as shapely_transform
+
+    path = Path(shapefile_path).expanduser().resolve()
+    if not path.exists():
+        raise FileNotFoundError(f"Shapefile nao encontrado: {path}")
+
+    rows: list[dict[str, Any]] = []
+    with fiona.open(path) as source:
+        transformer = _build_transformer(source.crs_wkt or source.crs, target_crs)
+        for feature in source:
+            properties = dict(feature.get("properties") or {})
+            geometry_raw = feature.get("geometry")
+            geometry = None
+            if geometry_raw:
+                geometry = shape(geometry_raw)
+                if transformer is not None:
+                    geometry = shapely_transform(transformer.transform, geometry)
+            properties["geometry"] = geometry
+            rows.append(properties)
+
+    return pd.DataFrame(rows)
+
+
+def load_vector_geojson(
+    shapefile_path: str | Path,
+    *,
+    target_crs: str | None = "EPSG:4326",
+    property_fields: tuple[str, ...] | list[str] | None = None,
+    simplify_tolerance: float = 0.0,
+) -> dict[str, Any]:
+    import fiona
+    from shapely.geometry import mapping, shape
+    from shapely.ops import transform as shapely_transform
+
+    path = Path(shapefile_path).expanduser().resolve()
+    if not path.exists():
+        raise FileNotFoundError(f"Shapefile nao encontrado: {path}")
+
+    feature_collection: dict[str, Any] = {
+        "type": "FeatureCollection",
+        "features": [],
+    }
+
+    wanted_fields = tuple(str(field).strip() for field in (property_fields or ()) if str(field).strip())
+    with fiona.open(path) as source:
+        transformer = _build_transformer(source.crs_wkt or source.crs, target_crs)
+        for feature in source:
+            properties_raw = dict(feature.get("properties") or {})
+            geometry_raw = feature.get("geometry")
+            if not geometry_raw:
+                continue
+
+            geometry = shape(geometry_raw)
+            if transformer is not None:
+                geometry = shapely_transform(transformer.transform, geometry)
+            if simplify_tolerance and geometry is not None:
+                geometry = geometry.simplify(float(simplify_tolerance), preserve_topology=True)
+
+            properties = (
+                {field: properties_raw.get(field) for field in wanted_fields if field in properties_raw}
+                if wanted_fields
+                else properties_raw
+            )
+            feature_collection["features"].append(
+                {
+                    "type": "Feature",
+                    "properties": properties,
+                    "geometry": mapping(geometry),
+                }
+            )
+
+    return feature_collection

backend/app/portable_launcher.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import socket
 import threading
 import time
@@ -92,6 +93,7 @@ def main() -> int:
         if settings.config_path is not None:
             _append_startup_log(f"[mesa] configuracao carregada de {settings.config_path}", log_path)
         _append_startup_log(f"[mesa] runtime local em {settings.runtime_dir}", log_path)
+        os.environ["MESA_STARTUP_LOG_FILE"] = str(log_path)
         server, url = _build_server(settings, log_path)
         _append_startup_log(f"[mesa] iniciando servidor local em {url}", log_path)
     except Exception:

backend/app/portable_runtime_log.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def _log_path() -> Path | None:
+    raw = str(os.getenv("MESA_STARTUP_LOG_FILE") or "").strip()
+    if not raw:
+        return None
+    try:
+        return Path(raw).expanduser().resolve()
+    except Exception:
+        return None
+
+
+def append_runtime_log(message: str) -> None:
+    text = str(message).rstrip()
+    print(text, flush=True)
+
+    path = _log_path()
+    if path is None:
+        return
+
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(f"{text}\n")
+    except Exception:
+        pass

backend/app/services/pesquisa_service.py

@@ -26,6 +26,7 @@ from app.core.map_layers import (
     add_trabalhos_tecnicos_markers,
     add_zoom_responsive_circle_markers,
 )
+from app.portable_runtime_log import append_runtime_log
 from app.services import model_repository, trabalhos_tecnicos_service
 from app.services.serializers import sanitize_value
 
@@ -2567,6 +2568,7 @@ def _carregar_catalogo_vias() -> list[dict[str, Any]]:
 
     gdf = geocodificacao.carregar_eixos()
     if gdf is None or gdf.empty:
+        append_runtime_log("[mesa] pesquisa: base de eixos indisponivel para catalogo de logradouros")
         raise HTTPException(status_code=500, detail="Base de eixos indisponivel para localizar o avaliando")
 
     cols = {str(col).upper(): col for col in gdf.columns}
@@ -2575,6 +2577,7 @@ def _carregar_catalogo_vias() -> list[dict[str, Any]]:
     prefixo_col = cols.get("NMIDEPRE")
     abreviado_col = cols.get("NMIDEABR")
     if cdlog_col is None or nome_col is None:
+        append_runtime_log("[mesa] pesquisa: colunas obrigatorias dos eixos nao foram encontradas")
         raise HTTPException(status_code=500, detail="Base de eixos sem colunas necessarias para localizar o avaliando")
 
     vistos: set[int] = set()
@@ -2597,6 +2600,7 @@ def _carregar_catalogo_vias() -> list[dict[str, Any]]:
             }
         )
     _CATALOGO_VIAS_CACHE = list(catalogo)
+    append_runtime_log(f"[mesa] pesquisa: catalogo de logradouros carregado com {len(catalogo)} vias")
     return list(catalogo)
 
 

build/windows/mesa_frame_portable.spec

@@ -2,7 +2,7 @@
 
 from pathlib import Path
 
-from PyInstaller.utils.hooks import collect_data_files, collect_submodules
+from PyInstaller.utils.hooks import collect_data_files, collect_dynamic_libs, collect_submodules
 
 
 PROJECT_ROOT = Path.cwd().resolve()
@@ -18,9 +18,19 @@ if LOCAL_DATA_DIR.exists():
 datas += collect_data_files("safehttpx")
 datas += collect_data_files("gradio")
 datas += collect_data_files("gradio_client")
+datas += collect_data_files("fiona")
+datas += collect_data_files("geopandas")
+datas += collect_data_files("pyproj")
+
+binaries = []
+binaries += collect_dynamic_libs("fiona")
+binaries += collect_dynamic_libs("pyproj")
 
 hiddenimports = []
 hiddenimports += collect_submodules("app")
+hiddenimports += collect_submodules("fiona")
+hiddenimports += collect_submodules("pyproj")
+hiddenimports += collect_submodules("shapely")
 hiddenimports += [
     "uvicorn.loops.auto",
     "uvicorn.protocols.http.auto",
@@ -31,7 +41,7 @@ hiddenimports += [
 a = Analysis(
     [str(PROJECT_ROOT / "backend" / "portable_app.py")],
     pathex=[str(BACKEND_DIR)],
-    binaries=[],
+    binaries=binaries,
     datas=datas,
     hiddenimports=hiddenimports,
     hookspath=[],

build/windows/smoke_test_portable.ps1

@@ -15,6 +15,8 @@ $rootUrl = "http://127.0.0.1:$Port"
 $healthUrl = "$rootUrl/api/health"
 $loginUrl = "$rootUrl/api/auth/login"
 $meUrl = "$rootUrl/api/auth/me"
+$logoUrl = "$rootUrl/logo_mesa.png"
+$logradourosUrl = "$rootUrl/api/pesquisa/logradouros-eixos?limite=50"
 
 New-Item -ItemType Directory -Force -Path $configDir | Out-Null
 New-Item -ItemType Directory -Force -Path $runtimeDir | Out-Null
@@ -78,6 +80,11 @@ try {
     throw "Smoke test failed: root path returned status $($rootResp.StatusCode)."
   }
 
+  $logoResp = Invoke-WebRequest -Uri $logoUrl -UseBasicParsing -TimeoutSec 5
+  if ($logoResp.StatusCode -ne 200) {
+    throw "Smoke test failed: logo path returned status $($logoResp.StatusCode)."
+  }
+
   $loginBody = @{
     usuario = "smoke"
     matricula = "123456"
@@ -93,6 +100,11 @@ try {
   if ($meResp.usuario.usuario -ne "smoke") {
     throw "Smoke test failed: /api/auth/me returned unexpected user."
   }
+
+  $logradourosResp = Invoke-RestMethod -Uri $logradourosUrl -Headers @{ "X-Auth-Token" = $token } -TimeoutSec 10
+  if (-not $logradourosResp.logradouros_eixos -or $logradourosResp.logradouros_eixos.Count -lt 1) {
+    throw "Smoke test failed: /api/pesquisa/logradouros-eixos returned no suggestions."
+  }
 }
 finally {
   if ($proc -and -not $proc.HasExited) {

frontend/src/components/PesquisaTab.jsx

@@ -2029,8 +2029,18 @@ export default function PesquisaTab({
         </div>
 
         <div className="row pesquisa-actions pesquisa-actions-primary">
-          <button type="button" onClick={() => void buscarModelos()} disabled={isPesquisaBusy}>
-            {searchLoading ? 'Pesquisando...' : 'Pesquisar'}
+          <button
+            type="button"
+            className={searchLoading ? 'is-loading' : ''}
+            onClick={() => void buscarModelos()}
+            disabled={isPesquisaBusy}
+          >
+            {searchLoading ? (
+              <>
+                <span className="repo-open-btn-spinner" aria-hidden="true" />
+                <span>Pesquisando...</span>
+              </>
+            ) : 'Pesquisar'}
           </button>
           <button type="button" onClick={() => void onLimparFiltros()} disabled={isPesquisaBusy}>
             Limpar filtros
@@ -2285,6 +2295,7 @@ export default function PesquisaTab({
         </SectionBlock>
       </div>
 
+      <LoadingOverlay show={searchLoading} label="Pesquisando modelos..." />
       <LoadingOverlay show={modeloAbertoLoading} label="Carregando modelo..." />
     </div>
   )

frontend/src/styles.css

@@ -2903,6 +2903,13 @@ button.pesquisa-coluna-remove:hover {
   justify-content: flex-end;
 }
 
+.pesquisa-actions-primary button.is-loading {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+}
+
 .pesquisa-mapa-actions {
   align-items: flex-end;
   gap: 12px;