Speed up model search warmup and first map load

backend/app/core/map_layers.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from html import escape
 from pathlib import Path
-from threading import Lock
+from threading import Event, Lock
 from typing import Any
 
 import folium
@@ -19,6 +19,8 @@ _SIMPLIFY_TOLERANCE = 0.00005
 _BAIRROS_CACHE_LOCK = Lock()
 _BAIRROS_GEOJSON_CACHE: dict[str, Any] | None = None
 _BAIRROS_SOURCE_SIGNATURE: tuple[tuple[str, int, int], ...] | None = None
+_BAIRROS_INFLIGHT_SIGNATURE: tuple[tuple[str, int, int], ...] | None = None
+_BAIRROS_INFLIGHT_EVENT: Event | None = None
 
 
 def _assinatura_bairros_source() -> tuple[tuple[str, int, int], ...] | None:
@@ -38,61 +40,84 @@ def _assinatura_bairros_source() -> tuple[tuple[str, int, int], ...] | None:
 
 def _carregar_bairros_geojson() -> dict[str, Any] | None:
     global _BAIRROS_GEOJSON_CACHE, _BAIRROS_SOURCE_SIGNATURE
+    global _BAIRROS_INFLIGHT_SIGNATURE, _BAIRROS_INFLIGHT_EVENT
     assinatura = _assinatura_bairros_source()
     if assinatura is None or not _BAIRROS_SHP_PATH.exists():
         return None
 
-    with _BAIRROS_CACHE_LOCK:
-        if _BAIRROS_SOURCE_SIGNATURE == assinatura and _BAIRROS_GEOJSON_CACHE is not None:
-            return _BAIRROS_GEOJSON_CACHE
-
-
-    geojson = None
-
-    try:
-        import geopandas as gpd
-    except Exception:
-        gpd = None
+    while True:
+        with _BAIRROS_CACHE_LOCK:
+            if _BAIRROS_SOURCE_SIGNATURE == assinatura and _BAIRROS_GEOJSON_CACHE is not None:
+                return _BAIRROS_GEOJSON_CACHE
+
+            if _BAIRROS_INFLIGHT_SIGNATURE == assinatura and _BAIRROS_INFLIGHT_EVENT is not None:
+                inflight = _BAIRROS_INFLIGHT_EVENT
+                is_builder = False
+            else:
+                inflight = Event()
+                _BAIRROS_INFLIGHT_SIGNATURE = assinatura
+                _BAIRROS_INFLIGHT_EVENT = inflight
+                is_builder = True
+
+        if not is_builder:
+            inflight.wait()
+            continue
 
-    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
 
-    with _BAIRROS_CACHE_LOCK:
-        if geojson is not None:
-            _BAIRROS_GEOJSON_CACHE = geojson
-            _BAIRROS_SOURCE_SIGNATURE = assinatura
-        else:
-            _BAIRROS_GEOJSON_CACHE = None
-            _BAIRROS_SOURCE_SIGNATURE = None
-    return geojson
+            try:
+                import geopandas as gpd
+            except Exception:
+                gpd = None
+
+            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
+
+            with _BAIRROS_CACHE_LOCK:
+                if geojson is not None:
+                    _BAIRROS_GEOJSON_CACHE = geojson
+                    _BAIRROS_SOURCE_SIGNATURE = assinatura
+                else:
+                    _BAIRROS_GEOJSON_CACHE = None
+                    _BAIRROS_SOURCE_SIGNATURE = None
+            return geojson
+        finally:
+            with _BAIRROS_CACHE_LOCK:
+                waiter = _BAIRROS_INFLIGHT_EVENT if _BAIRROS_INFLIGHT_SIGNATURE == assinatura else None
+                if _BAIRROS_INFLIGHT_SIGNATURE == assinatura:
+                    _BAIRROS_INFLIGHT_SIGNATURE = None
+                    _BAIRROS_INFLIGHT_EVENT = None
+            if waiter is not None:
+                waiter.set()
 
 
 def get_bairros_geojson() -> dict[str, Any] | None:

backend/app/main.py

@@ -9,7 +9,7 @@ from fastapi.staticfiles import StaticFiles
 
 from app.api import auth, elaboracao, health, logs, pesquisa, repositorio, session, trabalhos_tecnicos, visualizacao
 from app.runtime_paths import resolve_frontend_dist_dir
-from app.services import auth_service
+from app.services import auth_service, visualizacao_service
 
 app = FastAPI(
     title="MESA Frame API",
@@ -57,6 +57,12 @@ app.include_router(trabalhos_tecnicos.router)
 app.include_router(logs.router)
 
 
+@app.on_event("startup")
+async def schedule_app_support_warmup() -> None:
+    # Keep startup/login responsive and warm shared caches shortly after readiness.
+    visualizacao_service.schedule_visualizacao_support_warmup(delay_seconds=1.0)
+
+
 def _mount_frontend_if_exists() -> None:
     frontend_dist = resolve_frontend_dist_dir()
     index_file = frontend_dist / "index.html"

backend/app/services/pesquisa_service.py

@@ -9,7 +9,7 @@ import unicodedata
 from dataclasses import dataclass
 from datetime import date, datetime
 from pathlib import Path
-from threading import Lock
+from threading import Event, Lock
 from typing import Any
 
 import folium
@@ -231,6 +231,7 @@ _ADMIN_FONTES_SESSION: dict[str, list[str]] = {}
 _CATALOGO_VIAS_CACHE: list[dict[str, Any]] | None = None
 _FAMILIAS_VERSOES_CACHE: dict[str, list[dict[str, Any]]] | None = None
 _FAMILIAS_VERSOES_SIGNATURE: tuple[str, tuple[tuple[str, int, int], ...]] | None = None
+_FAMILIAS_VERSOES_INFLIGHT: dict[tuple[str, tuple[tuple[str, int, int], ...]], Event] = {}
 
 
 def _resolver_repositorio_modelos() -> model_repository.ModelRepositoryResolution:
@@ -601,12 +602,11 @@ def _montar_familias_versoes_modelos(caminhos_modelo: list[Path]) -> dict[str, l
     familias: dict[str, list[dict[str, Any]]] = {}
 
     for caminho in caminhos_modelo:
-        resumo = _carregar_resumo_com_cache(caminho)
         info = _extrair_info_versao_modelo(
             {
-                "id": resumo.get("id") or caminho.stem,
+                "id": caminho.stem,
                 "arquivo": caminho.name,
-                "nome_modelo": resumo.get("nome_modelo") or caminho.stem,
+                "nome_modelo": caminho.stem,
             }
         )
         if info is None:
@@ -618,7 +618,7 @@ def _montar_familias_versoes_modelos(caminhos_modelo: list[Path]) -> dict[str, l
                 "sufixo": sufixo,
                 "id": modelo_id,
                 "arquivo": caminho.name,
-                "nome_modelo": str(resumo.get("nome_modelo") or modelo_id).strip() or modelo_id,
+                "nome_modelo": modelo_id,
             }
         )
 
@@ -646,26 +646,42 @@ def obter_familias_versoes_modelos_cache(caminhos_modelo: list[Path] | None = No
     caminhos = list(caminhos_modelo) if caminhos_modelo is not None else list(resolved.modelos_dir.glob("*.dai"))
     assinatura = (resolved.signature, _assinatura_modelos_familias(caminhos))
 
-    with _CACHE_LOCK:
-        if _FAMILIAS_VERSOES_SIGNATURE == assinatura and isinstance(_FAMILIAS_VERSOES_CACHE, dict):
-            return {
-                chave: [dict(item) for item in itens]
-                for chave, itens in _FAMILIAS_VERSOES_CACHE.items()
-            }
+    while True:
+        with _CACHE_LOCK:
+            if _FAMILIAS_VERSOES_SIGNATURE == assinatura and isinstance(_FAMILIAS_VERSOES_CACHE, dict):
+                return {
+                    chave: [dict(item) for item in itens]
+                    for chave, itens in _FAMILIAS_VERSOES_CACHE.items()
+                }
 
-    familias = _montar_familias_versoes_modelos(caminhos)
+            inflight = _FAMILIAS_VERSOES_INFLIGHT.get(assinatura)
+            if inflight is None:
+                inflight = Event()
+                _FAMILIAS_VERSOES_INFLIGHT[assinatura] = inflight
+                is_builder = True
+            else:
+                is_builder = False
 
-    with _CACHE_LOCK:
-        _FAMILIAS_VERSOES_SIGNATURE = assinatura
-        _FAMILIAS_VERSOES_CACHE = {
-            chave: [dict(item) for item in itens]
-            for chave, itens in familias.items()
-        }
+        if is_builder:
+            try:
+                familias = _montar_familias_versoes_modelos(caminhos)
+                with _CACHE_LOCK:
+                    _FAMILIAS_VERSOES_SIGNATURE = assinatura
+                    _FAMILIAS_VERSOES_CACHE = {
+                        chave: [dict(item) for item in itens]
+                        for chave, itens in familias.items()
+                    }
+                return {
+                    chave: [dict(item) for item in itens]
+                    for chave, itens in familias.items()
+                }
+            finally:
+                with _CACHE_LOCK:
+                    waiter = _FAMILIAS_VERSOES_INFLIGHT.pop(assinatura, None)
+                if waiter is not None:
+                    waiter.set()
 
-    return {
-        chave: [dict(item) for item in itens]
-        for chave, itens in familias.items()
-    }
+        inflight.wait()
 
 
 def _agrupar_nomes_modelo_por_familia(values: list[Any]) -> dict[str, list[str]]:

backend/app/services/visualizacao_service.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
+from time import sleep
 from threading import Lock, Thread
 from typing import Any
 
@@ -31,6 +32,7 @@ from app.core.elaboracao.core import (
 from app.core.elaboracao.formatadores import formatar_avaliacao_html
 from app.core.visualizacao.map_payload import build_leaflet_payload, build_visualizacao_map_payload
 from app.models.session import SessionState
+from app.runtime_log import append_runtime_log
 from app.services import model_repository, pesquisa_service, trabalhos_tecnicos_service
 from app.services.equacao_service import build_equacoes_payload, exportar_planilha_equacao
 from app.services.knn_avaliacao_service import estimar_valor_knn_avaliacao
@@ -421,7 +423,7 @@ def listar_modelos_repositorio() -> dict[str, Any]:
     return sanitize_value(model_repository.list_repository_models())
 
 
-def _warm_visualizacao_support_caches_async() -> None:
+def schedule_visualizacao_support_warmup(*, delay_seconds: float = 0.0) -> None:
     global _MAP_SUPPORT_WARMUP_SIGNATURE
     try:
         signature = model_repository.resolve_model_repository().signature
@@ -434,16 +436,19 @@ def _warm_visualizacao_support_caches_async() -> None:
         _MAP_SUPPORT_WARMUP_SIGNATURE = signature
 
     def _worker() -> None:
+        delay = max(0.0, float(delay_seconds))
+        if delay > 0:
+            sleep(delay)
         try:
             get_bairros_geojson()
-        except Exception:
-            pass
+        except Exception as exc:
+            append_runtime_log(f"[mesa] warmup: falha ao aquecer bairros: {exc}")
         try:
             pesquisa_service.obter_familias_versoes_modelos_cache()
-        except Exception:
-            pass
+        except Exception as exc:
+            append_runtime_log(f"[mesa] warmup: falha ao aquecer familias de modelos: {exc}")
 
-    Thread(target=_worker, name="mesa-visualizacao-map-warmup", daemon=True).start()
+    Thread(target=_worker, name="mesa-visualizacao-support-warmup", daemon=True).start()
 
 
 def carregar_modelo_repositorio(session: SessionState, modelo_id: str) -> dict[str, Any]:
@@ -473,7 +478,6 @@ def carregar_modelo(session: SessionState, caminho_arquivo: str) -> dict[str, An
     session.dados_visualizacao = None
     session.avaliacoes_visualizacao = []
     session.visualizacao_cache = {}
-    _warm_visualizacao_support_caches_async()
 
     nome_modelo = Path(caminho_arquivo).stem
     badge_html = viz_app._formatar_badge_completo(pacote, nome_modelo=nome_modelo)