Add KML to TAB converter

app.py

@@ -203,6 +203,11 @@ if check_password():
                 title="Site & Sector KML Creator",
                 icon=":material/map:",
             ),
+            st.Page(
+                "apps/kml_to_tab_converter.py",
+                title="KML to TAB Converter",
+                icon=":material/conversion_path:",
+            ),
             st.Page(
                 "apps/clustering.py",
                 title="Automatic Site Clustering",

apps/kml_to_tab_converter.py

@@ -0,0 +1,88 @@
+from datetime import datetime
+from pathlib import Path
+
+import streamlit as st
+
+from utils.kml_to_tab import KmlToTabError, convert_kml_to_tab_zip
+
+
+st.title(":material/conversion_path: KML to TAB Converter")
+
+st.markdown(
+    "Upload a KML file and convert it to native MapInfo TAB tables. "
+    "The result is downloaded as a ZIP because each TAB table is made of "
+    "multiple files (`.tab`, `.dat`, `.map`, `.id`)."
+)
+
+
+def _timestamp() -> str:
+    return datetime.now().strftime("%Y%m%d_%H%M%S")
+
+
+def _find_sample_kml() -> Path | None:
+    for folder in (Path("samples"), Path("data2") / "sample"):
+        if not folder.exists():
+            continue
+        sample_files = sorted(folder.glob("*.kml"), key=lambda path: path.stat().st_mtime)
+        if sample_files:
+            return sample_files[-1]
+    return None
+
+
+sample_kml = _find_sample_kml()
+if sample_kml is not None:
+    with sample_kml.open("rb") as fh:
+        st.download_button(
+            "Download sample KML",
+            data=fh.read(),
+            file_name=sample_kml.name,
+            mime="application/vnd.google-earth.kml+xml",
+        )
+
+uploaded_file = st.file_uploader("Upload KML file", type=["kml"])
+
+if uploaded_file is None:
+    st.info("Upload a KML file to generate the MapInfo TAB ZIP.")
+    st.stop()
+
+if st.button("Convert to TAB", type="primary"):
+    st.session_state.pop("kml_to_tab_result", None)
+    st.session_state.pop("kml_to_tab_source", None)
+    try:
+        with st.spinner("Converting KML to MapInfo TAB..."):
+            result = convert_kml_to_tab_zip(uploaded_file.getvalue(), uploaded_file.name)
+        st.session_state["kml_to_tab_result"] = result
+        st.session_state["kml_to_tab_source"] = Path(uploaded_file.name).stem
+        st.success("TAB export generated.")
+    except KmlToTabError as exc:
+        st.error(str(exc))
+    except Exception as exc:  # pragma: no cover - UI safety net
+        st.error(f"Unexpected conversion error: {exc}")
+
+result = st.session_state.get("kml_to_tab_result")
+source_stem = st.session_state.get("kml_to_tab_source", "kml_to_tab")
+
+if result:
+    st.subheader("Generated layers")
+    st.dataframe(
+        [
+            {
+                "Layer": layer.name,
+                "Geometry": layer.geometry_type,
+                "Features": layer.feature_count,
+            }
+            for layer in result.layers
+        ],
+        use_container_width=True,
+        hide_index=True,
+    )
+
+    with st.expander("Files in ZIP"):
+        st.write(result.files)
+
+    st.download_button(
+        "Download TAB ZIP",
+        data=result.zip_bytes,
+        file_name=f"{source_stem}_tab_{_timestamp()}.zip",
+        mime="application/zip",
+    )

tests/test_kml_to_tab.py

@@ -0,0 +1,62 @@
+import zipfile
+from io import BytesIO
+
+import pytest
+
+from utils.kml_to_tab import KmlToTabError, convert_kml_to_tab_zip
+
+
+MIXED_KML = b"""<?xml version="1.0" encoding="UTF-8"?>
+<kml xmlns="http://www.opengis.net/kml/2.2">
+  <Document>
+    <Placemark>
+      <name>Site A</name>
+      <description>Point feature</description>
+      <Point>
+        <coordinates>50.606051,26.261322,0</coordinates>
+      </Point>
+    </Placemark>
+    <Placemark>
+      <name>Sector A</name>
+      <description>Polygon feature</description>
+      <Polygon>
+        <outerBoundaryIs>
+          <LinearRing>
+            <coordinates>
+              50.606051,26.261322,0
+              50.607051,26.261322,0
+              50.607051,26.262322,0
+              50.606051,26.261322,0
+            </coordinates>
+          </LinearRing>
+        </outerBoundaryIs>
+      </Polygon>
+    </Placemark>
+  </Document>
+</kml>
+"""
+
+
+def test_convert_kml_to_tab_zip_splits_mixed_geometries():
+    result = convert_kml_to_tab_zip(MIXED_KML, "mixed sample.kml")
+
+    with zipfile.ZipFile(BytesIO(result.zip_bytes)) as zf:
+        names = sorted(zf.namelist())
+
+    assert "mixed_sample_point.tab" in names
+    assert "mixed_sample_point.dat" in names
+    assert "mixed_sample_point.map" in names
+    assert "mixed_sample_point.id" in names
+    assert "mixed_sample_polygon.tab" in names
+    assert "mixed_sample_polygon.dat" in names
+    assert "mixed_sample_polygon.map" in names
+    assert "mixed_sample_polygon.id" in names
+    assert [(layer.geometry_type, layer.feature_count) for layer in result.layers] == [
+        ("Point", 1),
+        ("Polygon", 1),
+    ]
+
+
+def test_convert_kml_to_tab_zip_rejects_empty_input():
+    with pytest.raises(KmlToTabError, match="vide"):
+        convert_kml_to_tab_zip(b"", "empty.kml")

utils/kml_to_tab.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import io
+import re
+import struct
+import tempfile
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class KmlToTabError(RuntimeError):
+    """Raised when a KML file cannot be converted to MapInfo TAB."""
+
+
+@dataclass(frozen=True)
+class TabLayerSummary:
+    name: str
+    geometry_type: str
+    feature_count: int
+
+
+@dataclass(frozen=True)
+class TabConversionResult:
+    zip_bytes: bytes
+    layers: list[TabLayerSummary]
+    files: list[str]
+
+
+_WKB_GEOMETRY_TYPES = {
+    1: "Point",
+    2: "LineString",
+    3: "Polygon",
+    4: "MultiPoint",
+    5: "MultiLineString",
+    6: "MultiPolygon",
+    7: "GeometryCollection",
+}
+
+
+def convert_kml_to_tab_zip(kml_bytes: bytes, source_name: str) -> TabConversionResult:
+    """Convert one KML file to native MapInfo TAB tables packed into a ZIP."""
+
+    if not kml_bytes:
+        raise KmlToTabError("Le fichier KML est vide.")
+
+    pyogrio = _import_pyogrio()
+    base_name = _safe_stem(source_name)
+
+    with tempfile.TemporaryDirectory(prefix="kml_to_tab_") as tmp_dir_name:
+        tmp_dir = Path(tmp_dir_name)
+        input_path = tmp_dir / f"{base_name}.kml"
+        output_dir = tmp_dir / "tab_output"
+        output_dir.mkdir()
+        input_path.write_bytes(kml_bytes)
+
+        try:
+            metadata, _fids, geometry, field_data = pyogrio.raw.read(
+                input_path,
+                force_2d=True,
+            )
+        except Exception as exc:  # pragma: no cover - exact GDAL errors vary
+            raise KmlToTabError(f"Lecture du KML impossible: {exc}") from exc
+
+        if geometry is None or len(geometry) == 0:
+            raise KmlToTabError("Aucune geometrie exploitable trouvee dans le KML.")
+
+        fields = metadata.get("fields")
+        crs = metadata.get("crs") or "EPSG:4326"
+        geometry_groups = _group_geometry_indexes(geometry)
+        layers: list[TabLayerSummary] = []
+
+        for geometry_type, indexes in geometry_groups.items():
+            layer_name = _layer_name(base_name, geometry_type, len(geometry_groups))
+            output_path = output_dir / f"{layer_name}.tab"
+            layer_geometry = geometry[indexes]
+            layer_field_data = [column[indexes] for column in field_data]
+
+            try:
+                pyogrio.raw.write(
+                    output_path,
+                    layer_geometry,
+                    layer_field_data,
+                    fields,
+                    driver="MapInfo File",
+                    geometry_type=geometry_type,
+                    crs=crs,
+                    encoding=metadata.get("encoding") or "UTF-8",
+                )
+            except Exception as exc:  # pragma: no cover - exact GDAL errors vary
+                raise KmlToTabError(
+                    f"Ecriture du TAB impossible pour la couche {layer_name}: {exc}"
+                ) from exc
+
+            layers.append(
+                TabLayerSummary(
+                    name=layer_name,
+                    geometry_type=geometry_type,
+                    feature_count=len(indexes),
+                )
+            )
+
+        files = sorted(path.name for path in output_dir.iterdir() if path.is_file())
+        return TabConversionResult(
+            zip_bytes=_zip_directory(output_dir),
+            layers=layers,
+            files=files,
+        )
+
+
+def _import_pyogrio():
+    try:
+        import pyogrio
+    except ImportError as exc:  # pragma: no cover - depends on environment
+        raise KmlToTabError(
+            "La conversion TAB requiert pyogrio/GDAL. "
+            "Installe les dependances avec `pip install -r requirements.txt`."
+        ) from exc
+    return pyogrio
+
+
+def _safe_stem(filename: str) -> str:
+    stem = Path(filename or "converted").stem
+    stem = re.sub(r"[^A-Za-z0-9_-]+", "_", stem).strip("_")
+    return (stem or "converted")[:60]
+
+
+def _layer_name(base_name: str, geometry_type: str, group_count: int) -> str:
+    if group_count == 1:
+        return base_name
+    suffix = re.sub(r"(?<!^)(?=[A-Z])", "_", geometry_type).lower()
+    return f"{base_name}_{suffix}"[:80]
+
+
+def _group_geometry_indexes(geometry) -> dict[str, list[int]]:
+    groups: dict[str, list[int]] = {}
+
+    for index, wkb in enumerate(geometry):
+        geometry_type = _wkb_geometry_type(wkb)
+        groups.setdefault(geometry_type, []).append(index)
+
+    unsupported = sorted(
+        geometry_type
+        for geometry_type in groups
+        if geometry_type == "GeometryCollection"
+    )
+    if unsupported:
+        raise KmlToTabError(
+            "Les GeometryCollection ne sont pas supportees pour l'export TAB."
+        )
+
+    return groups
+
+
+def _wkb_geometry_type(wkb: bytes) -> str:
+    if not wkb or len(wkb) < 5:
+        raise KmlToTabError("Geometrie WKB invalide dans le KML.")
+
+    endian = "<" if wkb[0] == 1 else ">"
+    raw_code = struct.unpack(f"{endian}I", wkb[1:5])[0]
+    base_code = raw_code & 0xFF
+    geometry_type = _WKB_GEOMETRY_TYPES.get(base_code)
+
+    if geometry_type is None:
+        raise KmlToTabError(f"Type de geometrie non supporte: WKB {raw_code}.")
+
+    return geometry_type
+
+
+def _zip_directory(directory: Path) -> bytes:
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for path in sorted(directory.iterdir()):
+            if path.is_file():
+                zf.write(path, arcname=path.name)
+    return zip_buffer.getvalue()