Auto-deploy from GitHub

app.py

@@ -1,17 +1,18 @@
 # uvicorn app:app --reload
-
+import os
 import uvicorn
-from fastapi import Body, FastAPI, UploadFile, File, Response 
+from fastapi import Body, FastAPI, UploadFile, File, Response
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 import traceback
-import numpy as np 
-import json 
+import numpy as np
+import json
 
 from detect import DengueDetector
 from municipal_predictor import DenguePredictor
 from state_predictor import StatePredictor
 
+
 def default_json_serializer(obj):
     if isinstance(obj, np.integer):
         return int(obj)
@@ -21,26 +22,45 @@ def default_json_serializer(obj):
         return obj.tolist()
     raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable")
 
-detector: DengueDetector = None
-predictor: DenguePredictor = None
-state_predictor: StatePredictor = None
+
+detector: DengueDetector | None = None
+predictor: DenguePredictor | None = None
+state_predictor: StatePredictor | None = None
+
+# Se api irá utilizar datasets baixados do hugging face ou os locais
+ONLINE: bool = True
 
 app = FastAPI()
 
-# --- evento de startup para carregar os modelos ---
+
 @app.on_event("startup")
 async def startup_event():
     global detector, predictor, state_predictor
     print("Executando evento de startup: Carregando os módulos de IA...")
+
+    offline_flag = (not ONLINE)
+    local_city_inf = None
+    local_state_inf = None
+
     detector = DengueDetector()
-    predictor = DenguePredictor()
     try:
-        state_predictor = StatePredictor()
+        predictor = DenguePredictor(
+            offline=offline_flag,
+            local_inference_path=local_city_inf,
+        )
+    except Exception as e:
+        print("[WARN] DenguePredictor (municipal) não inicializado:", str(e))
+        predictor = None
+    try:
+        state_predictor = StatePredictor(
+            offline=offline_flag,
+            local_inference_path=local_state_inf,
+        )
     except Exception as e:
-        # Não bloqueia a API se o modelo estadual faltar; a rota retornará 503
         print("[WARN] StatePredictor não inicializado:", str(e))
         state_predictor = None
-    print("Módulos de IA carregados com sucesso. API pronta.")
+    print("Módulos de IA carregados com sucesso. API pronta. Modo:", "online" if ONLINE else "offline")
+
 
 # --- CORS ---
 origins = ["https://previdengue.vercel.app", "http://localhost:3000", "*"]
@@ -49,13 +69,19 @@ app.add_middleware(
     allow_origins=origins,
     allow_credentials=True,
     allow_methods=["*"],
-    allow_headers=["*"]
+    allow_headers=["*"],
 )
 
-# --- Rotas ---
+
 @app.get("/")
 def health_check():
-    return {"status": "ok", "message": "API de Dengue rodando!"}
+    return {
+        "status": "ok",
+        "message": "API de Dengue rodando!",
+        "mode": "online" if ONLINE else "offline",
+        "online": ONLINE,
+    }
+
 
 @app.post("/detect/")
 async def detect(file: UploadFile = File(...)):
@@ -63,9 +89,11 @@ async def detect(file: UploadFile = File(...)):
         return JSONResponse(status_code=503, content={"error": "Detector ainda não foi inicializado."})
     try:
         content = await file.read()
-        result = detector.detect_image(content)  
+        result = detector.detect_image(content)
         return JSONResponse(content=result)
     except Exception as e:
+        tb_str = traceback.format_exc()
+        print(tb_str)
         return JSONResponse(status_code=500, content={"error": str(e)})
 
 
@@ -77,21 +105,20 @@ async def predict_dengue_route(payload: dict = Body(...)):
         ibge_code_str = payload.get("ibge_code")
         if ibge_code_str is None:
             raise ValueError("O campo 'ibge_code' é obrigatório.")
-        
+
         ibge_code = int(ibge_code_str)
-        # Sempre retorna histórico completo; frontend controla a janela visível
         result = predictor.predict(ibge_code)
-        
+
         json_content = json.dumps(result, default=default_json_serializer)
-        
+
         return Response(content=json_content, media_type="application/json")
 
     except Exception as e:
         tb_str = traceback.format_exc()
-        print(tb_str) 
+        print(tb_str)
         return JSONResponse(status_code=500, content={
             "error": str(e),
-            "traceback": tb_str 
+            "traceback": tb_str,
         })
 
 
@@ -99,9 +126,12 @@ async def predict_dengue_route(payload: dict = Body(...)):
 async def predict_dengue_state_route(payload: dict = Body(...)):
     global state_predictor
     if state_predictor is None:
-        # Tenta inicializar preguiçosamente no primeiro uso
         try:
-            state_predictor = StatePredictor()
+            local_state_inf = None
+            state_predictor = StatePredictor(
+                offline=(not ONLINE),
+                local_inference_path=local_state_inf,
+            )
         except Exception as e:
             return JSONResponse(status_code=503, content={"error": f"Preditor estadual ainda não foi inicializado: {str(e)}"})
     try:
@@ -111,8 +141,6 @@ async def predict_dengue_state_route(payload: dict = Body(...)):
         if not state_sigla:
             raise ValueError("O campo 'state' (sigla) é obrigatório.")
 
-        # year/week são opcionais; se omitidos, prevê após o último ponto conhecido
-        # Sempre retorna histórico completo; frontend controla a janela visível
         result = state_predictor.predict(
             str(state_sigla).upper(),
             year=int(year) if year is not None else None,
@@ -127,5 +155,5 @@ async def predict_dengue_state_route(payload: dict = Body(...)):
         print(tb_str)
         return JSONResponse(status_code=500, content={
             "error": str(e),
-            "traceback": tb_str
+            "traceback": tb_str,
         })

detect.py

@@ -131,7 +131,6 @@ class DengueDetector:
                         all_scores.append(float(confidences[j]))
                         all_classes.append(int(class_ids[j]))
 
-        final_indices = []
         final_boxes = []
         final_scores = []
         final_classes = []

models/detect.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:27a0e59e4f7573d93e1a4ead65ddbde30cc8f5b8db31fe089cfffda4baa2b43b
-size 52117266
+oid sha256:d3d07392eada71e3c173a9626f6acd9706590c115dcf6eae48652fd10ea7c28b
+size 155794973

municipal_predictor.py

@@ -27,8 +27,10 @@ def asymmetric_mse(y_true, y_pred):
     return tf.reduce_mean(loss)
 
 class DenguePredictor:
-    def __init__(self, project_root=None):
+    def __init__(self, project_root=None, offline: bool = False, local_inference_path: str | None = None):
         self.project_root = Path(project_root) if project_root else Path(__file__).resolve().parent
+        self.offline = bool(offline)
+        self.local_inference_path = Path(local_inference_path) if local_inference_path else None
         self.sequence_length = 12
         self.horizon = 6
         self.year_min_train = 2014
@@ -66,15 +68,38 @@ class DenguePredictor:
         else:
             self.city_to_idx = {}
 
-        hf_token = os.environ.get("HF_TOKEN")
-        inference_path = hf_hub_download(
-            repo_id="previdengue/predict_inference_data",
-            filename="inference_data.parquet",
-            repo_type="dataset",
-            token=hf_token
-        )
-
-        df = pd.read_parquet(inference_path)
+        # Load inference dataset (HF online or local offline)
+        df = None
+        if self.offline:
+            # Somente .parquet é aceito no modo offline
+            candidate_paths = []
+            if self.local_inference_path:
+                candidate_paths.append(self.local_inference_path)
+            candidate_paths.append(models_dir / "inference_data.parquet")
+
+            found = None
+            for p in candidate_paths:
+                try:
+                    if p and Path(p).exists() and str(p).lower().endswith(".parquet"):
+                        found = Path(p)
+                        break
+                except Exception:
+                    continue
+            if not found:
+                raise FileNotFoundError(
+                    "Offline mode enabled but no local Parquet dataset found. "
+                    "Place 'inference_data.parquet' under models/ or pass a valid 'local_inference_path' (.parquet)."
+                )
+            df = pd.read_parquet(found)
+        else:
+            hf_token = os.environ.get("HF_TOKEN")
+            inference_path = hf_hub_download(
+                repo_id="previdengue/predict_inference_data",
+                filename="inference_data.parquet",
+                repo_type="dataset",
+                token=hf_token
+            )
+            df = pd.read_parquet(inference_path)
         df["codigo_ibge"] = df["codigo_ibge"].astype(int)
         df["ano"] = df["ano"].astype(int)
         df["semana"] = df["semana"].astype(int)

state_predictor.py

@@ -20,8 +20,10 @@ def asymmetric_mse(y_true, y_pred):
     return tf.reduce_mean(loss)
 
 class StatePredictor:
-    def __init__(self, project_root=None):
+    def __init__(self, project_root=None, offline: bool = False, local_inference_path: str | None = None):
         self.project_root = Path(project_root) if project_root else Path(__file__).resolve().parent
+        self.offline = bool(offline)
+        self.local_inference_path = Path(local_inference_path) if local_inference_path else None
         self.sequence_length = 12
         self.horizon = 6
         self.dynamic_features = [
@@ -64,26 +66,53 @@ class StatePredictor:
         else:
             self.state_peak_map = {}
 
-        # inference dataset (HF only)
-        hf_token = os.environ.get("HF_TOKEN")
-        hf_repo = "previdengue/predict_inference_data_estadual"
-        hf_filename = "inference_data_estadual.parquet"
-        try:
-            hf_path = hf_hub_download(
-                repo_id=hf_repo,
-                filename=hf_filename,
-                repo_type="dataset",
-                token=hf_token,
-            )
-            df_loaded = pd.read_parquet(hf_path)
-        except Exception as e:
-            raise FileNotFoundError(
-                "Could not download 'inference_data_estadual.parquet' from HF repo 'previdengue/predict_inference_data_estadual'. "
-                "Ensure the dataset exists and set HF_TOKEN if the repo requires authentication."
-            ) from e
+        # inference dataset: HF online or local offline (.parquet only)
+        if self.offline:
+            # Somente .parquet é aceito no modo offline
+            candidate_paths = []
+            if self.local_inference_path:
+                candidate_paths.append(self.local_inference_path)
+            # Candidatos comuns no diretório de modelos
+            candidate_paths.append(models_dir / "inference_data_state.parquet")
+            candidate_paths.append(models_dir / "inference_data_estadual.parquet")
 
-        # normalize
-        df = df_loaded.copy()
+            found = None
+            for p in candidate_paths:
+                try:
+                    if p and Path(p).exists() and str(p).lower().endswith(".parquet"):
+                        found = Path(p)
+                        break
+                except Exception:
+                    continue
+            if not found:
+                raise FileNotFoundError(
+                    "Offline mode enabled but no local Parquet state dataset found. "
+                    "Place 'inference_data_state.parquet' or 'inference_data_estadual.parquet' under models/ or pass a valid 'local_inference_path' (.parquet)."
+                )
+            df = pd.read_parquet(found)
+        else:
+            # Tenta baixar do HF; se falhar, tenta arquivo local como fallback
+            df = None
+            try:
+                hf_token = os.environ.get("HF_TOKEN")
+                inference_path = hf_hub_download(
+                    repo_id="previdengue/predict_inference_data",
+                    filename="inference_data_estadual.parquet",
+                    repo_type="dataset",
+                    token=hf_token,
+                )
+                df = pd.read_parquet(inference_path)
+            except Exception:
+                # Fallback local
+                for p in [models_dir / "inference_data_state.parquet", models_dir / "inference_data_estadual.parquet"]:
+                    if p.exists():
+                        df = pd.read_parquet(p)
+                        break
+                if df is None:
+                    raise FileNotFoundError(
+                        "Online state dataset not available from HF and no local fallback found. "
+                        "Place 'inference_data_estadual.parquet' under models/ or switch APP_MODE to 'offline'."
+                    )
         required = ["estado_sigla", "year", "week", "casos_soma"]
         if any(col not in df.columns for col in required):
             raise ValueError("State dataset missing required columns: ['estado_sigla','year','week','casos_soma']")