Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py (versión optimizada - ARREGLADA)
+# app.py (versión CONSERVADORA - solo cache, nada más)
 import io
 import os
 import logging
@@ -12,12 +12,12 @@ from PIL import Image
 
 COG_URL = os.environ.get("COG_URL", "https://huggingface.co/datasets/Pingul/mexico-dem/resolve/main/Mexico_DEM_COG.tif")
 TILE_SIZE = 256
-CACHE_SIZE = 512  # Cachear últimas 512 tiles
 
+# Logging simple
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("dem-tiler")
 
-app = FastAPI(title="Mexico DEM TerrainRGB API (optimizado)")
+app = FastAPI(title="Mexico DEM TerrainRGB API (con cache)")
 
 app.add_middleware(
     CORSMiddleware,
@@ -27,21 +27,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# ============================================================================
-# OPTIMIZACIÓN 1: COGReader global reutilizable
-# ============================================================================
-_cog_reader = None
-
-def get_cog_reader():
-    """Reutiliza la misma conexión COG en lugar de abrir/cerrar cada vez"""
-    global _cog_reader
-    if _cog_reader is None:
-        _cog_reader = COGReader(COG_URL)
-    return _cog_reader
-
-# ============================================================================
-# OPTIMIZACIÓN 2: Encoding Terrain-RGB (tu versión original, funciona bien)
-# ============================================================================
 def encode_terrainrgb(arr: np.ndarray) -> np.ndarray:
     """
     Convierte elevación en metros a Terrain-RGB (Mapbox spec).
@@ -57,55 +42,65 @@ def encode_terrainrgb(arr: np.ndarray) -> np.ndarray:
     rgb = np.stack([R, G, B], axis=-1).astype(np.uint8)
     return rgb
 
+def elev_to_grayscale(arr: np.ndarray) -> np.ndarray:
+    """
+    Convierte elevación a imagen grayscale para debug: mapea min->0 max->255.
+    NaNs se convierten a 0 (transparente later).
+    """
+    a = np.array(arr, dtype=np.float32)
+    a = np.where(np.isfinite(a), a, np.nan)
+    vmin = np.nanpercentile(a, 2) if np.isfinite(np.nanpercentile(a, 2)) else np.nanmin(a)
+    vmax = np.nanpercentile(a, 98) if np.isfinite(np.nanpercentile(a, 98)) else np.nanmax(a)
+    if np.isnan(vmin) or np.isnan(vmax) or vmin == vmax:
+        vmin, vmax = np.nanmin(a), np.nanmax(a)
+    if np.isnan(vmin): vmin = 0.0
+    if np.isnan(vmax): vmax = vmin + 1.0
+
+    norm = (a - vmin) / (vmax - vmin)
+    norm = np.clip(norm, 0.0, 1.0)
+    img = (norm * 255).astype(np.uint8)
+    rgb = np.stack([img, img, img], axis=-1)
+    return rgb
+
 # ============================================================================
-# OPTIMIZACIÓN 3: Cache LRU para tiles
+# ÚNICA OPTIMIZACIÓN: Cache de tiles
 # ============================================================================
-@lru_cache(maxsize=CACHE_SIZE)
-def get_tile_cached(z: int, x: int, y: int) -> bytes:
+@lru_cache(maxsize=512)
+def get_tile_data(z: int, x: int, y: int) -> bytes:
     """
-    Cachea tiles generadas. Retorna bytes directamente.
-    LRU cache guarda las tiles más solicitadas en memoria.
+    Genera y cachea tiles. Esta es la única optimización añadida.
     """
     try:
-        cog = get_cog_reader()
-        data, mask = cog.tile(x, y, z, tilesize=TILE_SIZE)
-        elev = data[0].astype(np.float32)
-
-        # Aplicar mask si existe
-        if mask is not None:
-            invalid = (mask == 0)
-            elev[invalid] = np.nan
-
-        # Check si todo es nodata
-        if np.all(np.isnan(elev)):
-            raise TileOutsideBounds(f"All NaN for tile {z}/{x}/{y}")
-
-        # Reemplazar NaN con valor base
-        elev = np.nan_to_num(elev, nan=-10000.0)
-        
-        # Encode a Terrain-RGB (tu función original)
-        rgb = encode_terrainrgb(elev)
-        
-        # Convertir a PNG con compresión rápida
-        img = Image.fromarray(rgb, "RGB")
-        buf = io.BytesIO()
-        img.save(buf, format="PNG", compress_level=1)  # compress_level=1 es clave
-        
-        return buf.getvalue()
+        with COGReader(COG_URL) as cog:
+            data, mask = cog.tile(x, y, z, tilesize=TILE_SIZE)
+            elev = data[0].astype(np.float32)
+
+            if mask is not None:
+                invalid = (mask == 0)
+                elev[invalid] = np.nan
+
+            if np.all(np.isnan(elev)):
+                raise TileOutsideBounds(f"All NaN for tile {z}/{x}/{y}")
+
+            rgb = encode_terrainrgb(np.nan_to_num(elev, nan=-10000.0))
+            img = Image.fromarray(rgb, "RGB")
+            buf = io.BytesIO()
+            # compress_level=1 hace PNG más rápido (vs default 6)
+            img.save(buf, format="PNG", compress_level=1)
+            return buf.getvalue()
 
     except TileOutsideBounds:
-        # Tile transparente (cacheable también)
         blank = Image.new("RGBA", (TILE_SIZE, TILE_SIZE), (0, 0, 0, 0))
         buf = io.BytesIO()
         blank.save(buf, format="PNG", compress_level=1)
         return buf.getvalue()
 
 # ============================================================================
-# ENDPOINTS
+# ENDPOINTS (tu código original, sin cambios)
 # ============================================================================
 @app.get("/")
 def root():
-    return {"message": "Mexico DEM TerrainRGB API (optimizado)", "cog_url": COG_URL}
+    return {"message": "Mexico DEM TerrainRGB API running (with cache)", "cog_url": COG_URL}
 
 @app.get("/health")
 def health():
@@ -113,8 +108,8 @@ def health():
 
 @app.get("/cache/stats")
 def cache_stats():
-    """Endpoint para ver estadísticas del cache"""
-    info = get_tile_cached.cache_info()
+    """Nuevo: Ver estadísticas del cache"""
+    info = get_tile_data.cache_info()
     return {
         "hits": info.hits,
         "misses": info.misses,
@@ -123,29 +118,23 @@ def cache_stats():
         "hit_rate": f"{info.hits / (info.hits + info.misses) * 100:.1f}%" if (info.hits + info.misses) > 0 else "0%"
     }
 
-@app.post("/cache/clear")
-def clear_cache():
-    """Limpia el cache de tiles"""
-    get_tile_cached.cache_clear()
-    return {"status": "cache cleared"}
-
 @app.get("/info")
 def get_info():
     try:
-        cog = get_cog_reader()
-        meta = cog.info()
-        out = {
-            "bounds": meta.bounds,
-            "minzoom": meta.minzoom,
-            "maxzoom": meta.maxzoom,
-            "band_descriptions": meta.band_descriptions,
-            "statistics": {
-                "min": getattr(meta, "min", None),
-                "max": getattr(meta, "max", None)
-            },
-            "crs": str(meta.crs)
-        }
-        return out
+        with COGReader(COG_URL) as cog:
+            meta = cog.info()
+            out = {
+                "bounds": meta.bounds,
+                "minzoom": meta.minzoom,
+                "maxzoom": meta.maxzoom,
+                "band_descriptions": meta.band_descriptions,
+                "statistics": {
+                    "min": getattr(meta, "min", None),
+                    "max": getattr(meta, "max", None)
+                },
+                "crs": str(meta.crs)
+            }
+            return out
     except Exception as e:
         logger.exception("Error reading COG info")
         return {"error": str(e)}
@@ -153,57 +142,43 @@ def get_info():
 @app.get("/tiles/{z}/{x}/{y}.png")
 def get_tile(z: int, x: int, y: int):
     """
-    Tile endpoint optimizado con cache.
+    Tile endpoint con cache - LA ÚNICA DIFERENCIA con tu código original
     """
     try:
-        tile_bytes = get_tile_cached(z, x, y)
+        tile_bytes = get_tile_data(z, x, y)
         return Response(tile_bytes, media_type="image/png")
     except Exception as e:
         logger.exception(f"Unexpected error generating tile {z}/{x}/{y}")
-        return Response(status_code=500, content=f"Server error: {str(e)}")
+        return Response(status_code=500, content=f"Server error generating tile: {str(e)}")
 
 @app.get("/debug/{z}/{x}/{y}.png")
 def debug_tile(z: int, x: int, y: int):
-    """Endpoint de debug (sin cache para ver cambios en tiempo real)"""
+    """
+    Endpoint de debug (sin cambios de tu código original)
+    """
     try:
-        cog = get_cog_reader()
-        data, mask = cog.tile(x, y, z, tilesize=TILE_SIZE)
-        elev = data[0].astype(np.float32)
-        
-        if mask is not None:
-            elev[mask == 0] = np.nan
-
-        if np.all(np.isnan(elev)):
-            raise TileOutsideBounds()
-
-        # Grayscale simple
-        a = np.where(np.isfinite(elev), elev, 0)
-        if np.any(a != 0):
-            vmin = np.nanpercentile(a[a != 0], 2)
-            vmax = np.nanpercentile(a[a != 0], 98)
-        else:
-            vmin, vmax = 0, 1
-        
-        if vmin == vmax:
-            vmax = vmin + 1
-            
-        norm = np.clip((a - vmin) / (vmax - vmin), 0, 1)
-        gray = (norm * 255).astype(np.uint8)
-        
-        rgb = np.stack([gray, gray, gray], axis=-1)
-        alpha = np.where(np.isfinite(elev), 255, 0).astype(np.uint8)
-        rgba = np.dstack([rgb, alpha])
-        
-        img = Image.fromarray(rgba, "RGBA")
-        buf = io.BytesIO()
-        img.save(buf, format="PNG", compress_level=1)
-        buf.seek(0)
-        return Response(buf.getvalue(), media_type="image/png")
+        with COGReader(COG_URL) as cog:
+            data, mask = cog.tile(x, y, z, tilesize=TILE_SIZE)
+            elev = data[0].astype(np.float32)
+            if mask is not None:
+                elev[mask == 0] = np.nan
+
+            if np.all(np.isnan(elev)):
+                raise TileOutsideBounds()
+
+            rgb = elev_to_grayscale(elev)
+            alpha = np.where(np.isfinite(elev), 255, 0).astype(np.uint8)
+            rgba = np.dstack([rgb, alpha])
+            img = Image.fromarray(rgba, "RGBA")
+            buf = io.BytesIO()
+            img.save(buf, format="PNG")
+            buf.seek(0)
+            return Response(buf.getvalue(), media_type="image/png")
 
     except TileOutsideBounds:
         blank = Image.new("RGBA", (TILE_SIZE, TILE_SIZE), (0, 0, 0, 0))
         buf = io.BytesIO()
-        blank.save(buf, format="PNG", compress_level=1)
+        blank.save(buf, format="PNG")
         buf.seek(0)
         return Response(buf.getvalue(), media_type="image/png")
     except Exception as e:
@@ -213,18 +188,10 @@ def debug_tile(z: int, x: int, y: int):
 @app.get("/point")
 def get_point(lon: float, lat: float):
     try:
-        cog = get_cog_reader()
-        val = cog.point(lon, lat)
-        elevation = float(val.data[0])
-        return {"lon": lon, "lat": lat, "elevation_m": elevation}
+        with COGReader(COG_URL) as cog:
+            val = cog.point(lon, lat)
+            elevation = float(val.data[0])
+            return {"lon": lon, "lat": lat, "elevation_m": elevation}
     except Exception as e:
         logger.exception("Error sampling point")
-        return Response(status_code=500, content=f"Error: {e}")
-
-# Cleanup al cerrar
-@app.on_event("shutdown")
-def shutdown_event():
-    global _cog_reader
-    if _cog_reader is not None:
-        _cog_reader.close()
-        _cog_reader = None
+        return Response(status_code=500, content=f"Error sampling point: {e}")