Use pyshp fallback for portable shapefiles

backend/app/core/shapefile_runtime.py

@@ -30,17 +30,52 @@ def _build_transformer(source_crs: Any, target_crs: str | None):
         return None
 
 
-def load_vector_dataframe(shapefile_path: str | Path, *, target_crs: str | None = "EPSG:4326") -> pd.DataFrame:
-    import fiona
+def _iter_features_pyshp(shapefile_path: Path, *, target_crs: str | None) -> list[tuple[dict[str, Any], Any]]:
+    import shapefile
     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}")
+    reader = shapefile.Reader(str(shapefile_path))
+    try:
+        field_names = [str(field[0]) for field in reader.fields[1:]]
+        source_crs = None
+        prj_path = shapefile_path.with_suffix(".prj")
+        if prj_path.exists():
+            try:
+                source_crs = prj_path.read_text(encoding="utf-8", errors="replace")
+            except Exception:
+                source_crs = prj_path.read_text(errors="replace")
+        transformer = _build_transformer(source_crs, target_crs)
+
+        features: list[tuple[dict[str, Any], Any]] = []
+        for shape_record in reader.iterShapeRecords():
+            values = list(shape_record.record)
+            properties = {
+                field_name: values[index] if index < len(values) else None
+                for index, field_name in enumerate(field_names)
+            }
+            geometry_raw = getattr(shape_record.shape, "__geo_interface__", None)
+            geometry = None
+            if geometry_raw and geometry_raw.get("coordinates"):
+                geometry = shape(geometry_raw)
+                if transformer is not None:
+                    geometry = shapely_transform(transformer.transform, geometry)
+            features.append((properties, geometry))
+        return features
+    finally:
+        try:
+            reader.close()
+        except Exception:
+            pass
 
-    rows: list[dict[str, Any]] = []
-    with fiona.open(path) as source:
+
+def _iter_features_fiona(shapefile_path: Path, *, target_crs: str | None) -> list[tuple[dict[str, Any], Any]]:
+    import fiona
+    from shapely.geometry import shape
+    from shapely.ops import transform as shapely_transform
+
+    features: list[tuple[dict[str, Any], Any]] = []
+    with fiona.open(shapefile_path) as source:
         transformer = _build_transformer(source.crs_wkt or source.crs, target_crs)
         for feature in source:
             properties = dict(feature.get("properties") or {})
@@ -50,8 +85,35 @@ def load_vector_dataframe(shapefile_path: str | Path, *, target_crs: str | None
                 geometry = shape(geometry_raw)
                 if transformer is not None:
                     geometry = shapely_transform(transformer.transform, geometry)
-            properties["geometry"] = geometry
-            rows.append(properties)
+            features.append((properties, geometry))
+    return features
+
+
+def _load_features(shapefile_path: Path, *, target_crs: str | None = "EPSG:4326") -> list[tuple[dict[str, Any], Any]]:
+    pyshp_error = None
+    try:
+        return _iter_features_pyshp(shapefile_path, target_crs=target_crs)
+    except Exception as exc:
+        pyshp_error = exc
+
+    try:
+        return _iter_features_fiona(shapefile_path, target_crs=target_crs)
+    except Exception:
+        if pyshp_error is not None:
+            raise pyshp_error
+        raise
+
+
+def load_vector_dataframe(shapefile_path: str | Path, *, target_crs: str | None = "EPSG:4326") -> pd.DataFrame:
+    path = Path(shapefile_path).expanduser().resolve()
+    if not path.exists():
+        raise FileNotFoundError(f"Shapefile nao encontrado: {path}")
+
+    rows: list[dict[str, Any]] = []
+    for properties, geometry in _load_features(path, target_crs=target_crs):
+        row = dict(properties)
+        row["geometry"] = geometry
+        rows.append(row)
 
     return pd.DataFrame(rows)
 
@@ -63,9 +125,7 @@ def load_vector_geojson(
     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
+    from shapely.geometry import mapping
 
     path = Path(shapefile_path).expanduser().resolve()
     if not path.exists():
@@ -77,31 +137,24 @@ def load_vector_geojson(
     }
 
     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),
-                }
-            )
+    for properties_raw, geometry in _load_features(path, target_crs=target_crs):
+        if geometry is None:
+            continue
+
+        if simplify_tolerance:
+            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 dict(properties_raw)
+        )
+        feature_collection["features"].append(
+            {
+                "type": "Feature",
+                "properties": properties,
+                "geometry": mapping(geometry),
+            }
+        )
 
     return feature_collection

backend/requirements.txt

@@ -12,6 +12,7 @@ folium
 branca
 joblib
 openpyxl
+pyshp
 geopandas
 fiona
 gradio>=4.0

build/windows/mesa_frame_portable.spec

@@ -31,6 +31,7 @@ hiddenimports += collect_submodules("app")
 hiddenimports += collect_submodules("fiona")
 hiddenimports += collect_submodules("pyproj")
 hiddenimports += collect_submodules("shapely")
+hiddenimports += collect_submodules("shapefile")
 hiddenimports += [
     "uvicorn.loops.auto",
     "uvicorn.protocols.http.auto",