Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

39.3 KB
Raw Blame
# Copyright 2026 Marimo. All rights reserved.

from __future__ import annotations

import json
import subprocess
import sys
from contextlib import contextmanager
from pathlib import Path
from typing import TYPE_CHECKING, Any, Literal

import pytest

from marimo import _loggers
from marimo._plugins import ui
from marimo._plugins.ui._impl.dataframes.transforms.types import (
    FilterCondition,
    FilterGroup,
)
from marimo._plugins.ui._impl.table import (
    ColumnSummariesArgs,
    SearchTableArgs,
    SortArgs,
)
from marimo._plugins.ui._impl.tables.geometry import (
    GEOMETRY_CELL_CAP,
    GeometryColumnInfo,
    find_geometry_columns,
    format_geometry_cell,
)
from marimo._plugins.ui._impl.tables.narwhals_table import (
    NarwhalsTableManager,
)
from marimo._plugins.ui._impl.tables.table_manager import TableManager
from marimo._plugins.ui._impl.tables.utils import get_table_manager
from tests._plugins.ui._impl.tables import geometry_fixtures as geo

if TYPE_CHECKING:
    from collections.abc import Iterator


class TestFormatGeometryCell:
    def test_none_passes_through(self) -> None:
        assert format_geometry_cell(None, "objects") is None

    def test_wkb_placeholder(self) -> None:
        assert (
            format_geometry_cell(geo.WKB_POINT_1_2, "wkb")
            == f"<geometry, {len(geo.WKB_POINT_1_2)} B>"
        )

    def test_wkt_passthrough_and_cap(self) -> None:
        assert format_geometry_cell("POINT (1 2)", "wkt") == "POINT (1 2)"
        long = "POLYGON ((" + "1 2, " * 200 + "1 2))"
        capped = format_geometry_cell(long, "wkt")
        assert capped == long[:GEOMETRY_CELL_CAP] + "..."

    def test_other_passes_through(self) -> None:
        assert format_geometry_cell([1.0, 2.0], "other") == [1.0, 2.0]


@pytest.mark.requires("geopandas")
class TestPandasDetection:
    def test_detects_all_geometry_columns(self) -> None:
        import narwhals.stable.v2 as nw

        frame = nw.from_native(geo.gdf_multi_geometry(), eager_only=True)

        assert find_geometry_columns(frame) == {
            "geom_a": GeometryColumnInfo(
                encoding="objects", external_type="geometry"
            ),
            "geom_b": GeometryColumnInfo(
                encoding="objects", external_type="geometry"
            ),
        }

    def test_false_positives_not_detected(self) -> None:
        import narwhals.stable.v2 as nw

        frame = nw.from_native(
            geo.pandas_shapely_object_column(), eager_only=True
        )

        assert find_geometry_columns(frame) == {}


@pytest.mark.requires("pyarrow")
class TestArrowDetection:
    def test_detects_wkb_extension(self) -> None:
        import narwhals.stable.v2 as nw

        frame = nw.from_native(geo.arrow_wkb_known_crs())

        assert find_geometry_columns(frame) == {
            "geom": GeometryColumnInfo(
                encoding="wkb", external_type="geoarrow.wkb"
            )
        }

    def test_detects_ogc_wkb_extension(self) -> None:
        import narwhals.stable.v2 as nw

        frame = nw.from_native(geo.arrow_ogc_wkb())

        assert find_geometry_columns(frame) == {
            "geom": GeometryColumnInfo(encoding="wkb", external_type="ogc.wkb")
        }

    def test_detects_wkt_extension(self) -> None:
        import narwhals.stable.v2 as nw

        frame = nw.from_native(geo.arrow_wkt())

        assert find_geometry_columns(frame) == {
            "geom": GeometryColumnInfo(
                encoding="wkt", external_type="geoarrow.wkt"
            )
        }

    def test_detects_other_geoarrow_extension(self) -> None:
        import narwhals.stable.v2 as nw

        frame = nw.from_native(geo.arrow_other_geoarrow())

        assert find_geometry_columns(frame) == {
            "geom": GeometryColumnInfo(
                encoding="other", external_type="geoarrow.point"
            )
        }

    def test_ignores_fields_without_extension_metadata(self) -> None:
        import narwhals.stable.v2 as nw
        import pyarrow as pa

        table = pa.table(geo.false_positive_data())

        assert find_geometry_columns(nw.from_native(table)) == {}

    def test_ignores_non_geo_extensions(self) -> None:
        import narwhals.stable.v2 as nw
        import pyarrow as pa

        field = pa.field(
            "u",
            pa.binary(),
            metadata={b"ARROW:extension:name": b"arrow.uuid"},
        )
        table = pa.table({"u": [b"x"]}, schema=pa.schema([field]))

        assert find_geometry_columns(nw.from_native(table)) == {}

    @pytest.mark.parametrize(
        ("name", "encoding"),
        [
            ("geoarrow.wkb", "wkb"),
            ("ogc.wkb", "wkb"),
            ("geoarrow.wkt", "wkt"),
        ],
    )
    def test_detects_registered_extension_types(
        self, name: str, encoding: str
    ) -> None:
        import narwhals.stable.v2 as nw
        import pyarrow as pa

        storage_type = pa.string() if encoding == "wkt" else pa.binary()
        with geo.registered_arrow_extension(name, storage_type) as extension:
            table = pa.table(
                {"geom": geo.registered_extension_column(extension, [[None]])}
            )

            assert find_geometry_columns(nw.from_native(table)) == {
                "geom": GeometryColumnInfo(
                    encoding=encoding,  # type: ignore[arg-type]
                    external_type=name,
                )
            }

    def test_ignores_registered_non_geo_extension(self) -> None:
        import narwhals.stable.v2 as nw
        import pyarrow as pa

        with geo.registered_arrow_extension(
            "example.label", pa.string(), b""
        ) as extension:
            table = pa.table(
                {"label": geo.registered_extension_column(extension, [["a"]])}
            )

            assert find_geometry_columns(nw.from_native(table)) == {}

    def test_manager_field_type_uses_geometry_semantics(self) -> None:
        manager = get_table_manager(geo.arrow_wkb_known_crs())

        assert manager.get_field_type("geom") == (
            "geometry",
            "geoarrow.wkb",
        )


@pytest.mark.requires("duckdb")
class TestDuckDBDetection:
    def test_detects_crs_parameterized_geometry_column(self) -> None:
        conn = geo.duckdb_crs_geometry_connection()
        try:
            manager = get_table_manager(conn.table("crs_geometry"))

            assert manager.get_field_type("geom") == (
                "geometry",
                "GEOMETRY('OGC:CRS84')",
            )
            assert manager._geometry_columns["geom"].encoding == "wkb"
        finally:
            conn.close()

    def test_detects_geometry_relation_columns(self) -> None:
        import narwhals.stable.v2 as nw

        conn = geo.duckdb_spatial_connection()
        try:
            relation = geo.duckdb_geometry_relation(conn)
            frame = nw.from_native(relation, pass_through=False)
            assert find_geometry_columns(frame) == {
                "geom": GeometryColumnInfo(
                    encoding="wkb", external_type="GEOMETRY"
                )
            }
        finally:
            conn.close()

    def test_detects_fixed_layout_spatial_columns(self) -> None:
        import narwhals.stable.v2 as nw

        conn = geo.duckdb_spatial_connection()
        try:
            relation = conn.sql(
                "SELECT ST_Point2D(1.0, 2.0) AS p2d, "
                "CAST(ST_GeomFromText('LINESTRING(0 0, 1 1)')"
                " AS LINESTRING_2D) AS l2d, "
                "CAST(ST_GeomFromText('POLYGON((0 0, 1 0, 1 1, 0 0))')"
                " AS POLYGON_2D) AS pg2d, "
                "ST_Extent(ST_GeomFromText('LINESTRING(0 0, 1 1)')) AS box"
            )
            frame = nw.from_native(relation, pass_through=False)
            infos = find_geometry_columns(frame)
            assert {
                name: (info.encoding, info.external_type)
                for name, info in infos.items()
            } == {
                "p2d": ("other", "POINT_2D"),
                "l2d": ("other", "LINESTRING_2D"),
                "pg2d": ("other", "POLYGON_2D"),
                "box": ("other", "BOX_2D"),
            }
        finally:
            conn.close()

    def test_wkb_blob_stays_ordinary(self) -> None:
        import narwhals.stable.v2 as nw

        conn = geo.duckdb_spatial_connection()
        try:
            # ST_AsWKB declares plain BLOB; bytes are never inferred.
            relation = conn.sql("SELECT ST_AsWKB(ST_Point(1.0, 2.0)) AS wkb")
            frame = nw.from_native(relation, pass_through=False)
            assert find_geometry_columns(frame) == {}
        finally:
            conn.close()

    def test_plain_relation_not_detected(self) -> None:
        import duckdb
        import narwhals.stable.v2 as nw

        conn = duckdb.connect()
        try:
            relation = conn.sql("SELECT 1 AS a, 'x' AS b")
            frame = nw.from_native(relation, pass_through=False)
            assert find_geometry_columns(frame) == {}
        finally:
            conn.close()


@pytest.mark.requires("pyarrow")
class TestArrowManager:
    def test_wkb_cells_render_placeholder(self) -> None:
        manager = get_table_manager(geo.arrow_wkb_known_crs())

        rows = json.loads(manager.to_json_str())

        assert rows[0]["geom"] == f"<geometry, {len(geo.WKB_POINT_1_2)} B>"
        assert rows[1]["geom"] is None

    def test_wkt_cells_pass_through_and_cap(self) -> None:
        manager = get_table_manager(geo.arrow_wkt())

        rows = json.loads(manager.to_json_str())

        assert rows[0]["geom"] == "POINT (1 2)"
        assert rows[1]["geom"] == "POINT Z (1 2 3)"
        assert rows[2]["geom"] is None

    def test_formatting_preserves_schema_metadata(self) -> None:
        import pyarrow as pa

        manager = get_table_manager(geo.arrow_wkb_known_crs())

        formatted = manager.apply_formatting({"a": lambda x: x + 1})
        native = formatted.data.to_native()

        assert isinstance(native, pa.Table)
        field = native.schema.field("geom")
        assert field.metadata[b"ARROW:extension:name"] == b"geoarrow.wkb"
        assert formatted.get_field_type("geom") == (
            "geometry",
            "geoarrow.wkb",
        )

    def test_selection_column_preserves_geoarrow_metadata(self) -> None:
        from marimo._plugins.ui._impl.tables.selection import (
            INDEX_COLUMN_NAME,
            add_selection_column,
        )

        table, has_stable_row_id = add_selection_column(
            geo.arrow_wkb_known_crs()
        )
        field = table.schema.field("geom")

        assert has_stable_row_id is True
        assert INDEX_COLUMN_NAME in table.column_names
        assert field.metadata[b"ARROW:extension:name"] == b"geoarrow.wkb"
        assert ui.table(geo.arrow_wkb_known_crs())._manager.get_field_type(
            "geom"
        ) == ("geometry", "geoarrow.wkb")

    def test_formatting_skips_geometry_columns_in_mapping(self) -> None:
        manager = get_table_manager(geo.arrow_wkb_known_crs())

        formatted = manager.apply_formatting(
            {"a": lambda x: x + 1, "geom": lambda _x: "formatted"}
        )
        native = formatted.data.to_native()

        assert native.column("a").to_pylist() == [1, 2]
        assert formatted.get_field_type("geom") == (
            "geometry",
            "geoarrow.wkb",
        )
        assert (
            native.schema.field("geom").metadata[b"ARROW:extension:name"]
            == b"geoarrow.wkb"
        )

    def test_json_format_mapping_ignores_geometry_column(self) -> None:
        manager = get_table_manager(geo.arrow_wkb_known_crs())

        rows = json.loads(
            manager.to_json_str(
                format_mapping={"geom": lambda _x: "formatted"}
            )
        )

        assert rows[0]["geom"] == f"<geometry, {len(geo.WKB_POINT_1_2)} B>"
        assert rows[1]["geom"] is None

    def test_search_skips_geometry(self) -> None:
        manager = get_table_manager(geo.arrow_wkt())

        assert manager.search("POINT").get_num_rows() == 0

    def test_top_k_returns_empty(self) -> None:
        manager = get_table_manager(geo.arrow_wkb_known_crs())

        assert manager.calculate_top_k_rows("geom", 10) == []

    def test_unique_values_returns_empty(self) -> None:
        manager = get_table_manager(geo.arrow_wkb_known_crs())

        assert manager.get_unique_column_values("geom") == []

    def test_stats_counts_only(self) -> None:
        manager = get_table_manager(geo.arrow_wkb_known_crs())

        stats = manager.get_stats("geom")
        assert stats.total == 2
        assert stats.nulls == 1
        assert stats.unique is None


@pytest.mark.requires("duckdb", "pyarrow")
class TestDuckDBManager:
    @pytest.fixture
    def manager(self) -> Iterator[TableManager[Any]]:
        conn = geo.duckdb_spatial_connection()
        try:
            yield get_table_manager(geo.duckdb_geometry_relation(conn))
        finally:
            conn.close()

    def test_wkb_cells_render_placeholder(
        self, manager: TableManager[Any]
    ) -> None:
        rows = json.loads(manager.to_json_str())

        cells = {row["a"]: row["geom"] for row in rows}
        assert cells[1] == "<geometry, 21 B>"
        assert cells[2] is None

    def test_json_format_mapping_keeps_placeholder(
        self, manager: TableManager[Any]
    ) -> None:
        rows = json.loads(
            manager.to_json_str(format_mapping={"a": lambda x: x * 10})
        )

        cells = {row["a"]: row["geom"] for row in rows}
        assert cells[10] == "<geometry, 21 B>"
        assert cells[20] is None

    def test_search_skips_geometry(self, manager: TableManager[Any]) -> None:
        assert manager.search("POINT").get_num_rows() == 0

    def test_top_k_returns_empty(self, manager: TableManager[Any]) -> None:
        assert manager.calculate_top_k_rows("geom", 10) == []

    def test_unique_values_returns_empty(
        self, manager: TableManager[Any]
    ) -> None:
        assert manager.get_unique_column_values("geom") == []

    def test_stats_counts_only(self, manager: TableManager[Any]) -> None:
        stats = manager.get_stats("geom")
        assert stats.total == 2
        assert stats.nulls == 1
        assert stats.unique is None

    def test_point_2d_cells_render_structs(self) -> None:
        conn = geo.duckdb_spatial_connection()
        try:
            manager = get_table_manager(
                conn.sql("SELECT ST_Point2D(1.0, 2.0) AS p2d")
            )
            assert manager.get_field_type("p2d") == ("geometry", "POINT_2D")
            rows = json.loads(manager.to_json_str())
            assert rows[0]["p2d"] == {"x": 1.0, "y": 2.0}
        finally:
            conn.close()


@pytest.mark.requires("pandas")
class TestNarwhalsGeometryContract:
    @staticmethod
    def _manager() -> NarwhalsTableManager[Any, Any]:
        import pandas as pd

        manager = NarwhalsTableManager.from_dataframe(
            pd.DataFrame(
                {
                    "name": ["a", "b"],
                    "geometry": ["POINT (0 0)", None],
                }
            )
        )
        manager.__dict__["_geometry_columns"] = {
            "geometry": GeometryColumnInfo(
                encoding="objects", external_type="geometry"
            )
        }
        return manager

    def test_semantic_type_overrides_dtype(self) -> None:
        manager = self._manager()

        assert manager.get_field_type("geometry") == ("geometry", "geometry")
        assert manager.get_field_type("name")[0] == "string"

    def test_search_skips_geometry(self) -> None:
        manager = self._manager()

        assert manager.search("POINT").get_num_rows() == 0

    def test_top_k_returns_empty(self) -> None:
        manager = self._manager()

        assert manager.calculate_top_k_rows("geometry", 10) == []

    def test_unique_values_returns_empty(self) -> None:
        manager = self._manager()

        assert manager.get_unique_column_values("geometry") == []

    def test_stats_counts_only(self) -> None:
        manager = self._manager()

        stats = manager.get_stats("geometry")
        assert stats.total == 2
        assert stats.nulls == 1
        assert stats.unique is None
        assert stats.min is None


@pytest.mark.requires("geopandas")
class TestGeoPandasManager:
    def test_field_type_uses_geometry_semantics(self) -> None:
        manager = get_table_manager(geo.gdf_point_known_crs())

        assert manager.get_field_type("geometry") == ("geometry", "geometry")

    def test_transforms_preserve_subclass_and_crs(self) -> None:
        import geopandas as gpd

        frame = geo.gdf_point_known_crs()
        frame["name"] = frame["name"].astype(object)
        manager = get_table_manager(frame)
        for transformed in (
            manager.sort_values([SortArgs(by="name", descending=True)]),
            manager.take(1, 0),
            manager.select_columns(["name", "geometry"]),
        ):
            native = transformed.data.to_native()
            assert isinstance(native, gpd.GeoDataFrame)
            assert str(native.crs) == "EPSG:4326"

    def test_host_filter_preserves_subclass_and_crs(self) -> None:
        import geopandas as gpd

        table = ui.table(geo.gdf_point_known_crs())
        filters = FilterGroup(
            children=(
                FilterCondition(
                    column_id="name",
                    operator="equals",
                    value="a",
                ),
            )
        )

        response = table._search(
            SearchTableArgs(
                page_size=10,
                page_number=0,
                filters=filters,
            )
        )
        native = table._searched_manager.data.to_native()

        assert response.total_rows == 1
        assert isinstance(native, gpd.GeoDataFrame)
        assert str(native.crs) == "EPSG:4326"

    def test_formatting_preserves_subclass_and_crs(self) -> None:
        import geopandas as gpd

        manager = get_table_manager(geo.gdf_point_known_crs())
        formatted = manager.apply_formatting({"name": str.upper})
        native = formatted.data.to_native()

        assert isinstance(native, gpd.GeoDataFrame)
        assert str(native.crs) == "EPSG:4326"

    def test_edge_frames_load_without_error(self) -> None:
        for make_frame in (
            geo.gdf_no_active_geometry,
            geo.gdf_stale_pointer,
            geo.gdf_dropped_active,
        ):
            manager = get_table_manager(make_frame())
            assert isinstance(manager.to_json_str(), str)

    def test_cells_render_capped_wkt(self) -> None:
        import geopandas as gpd
        from shapely.geometry import LineString

        geometry = LineString((index, index) for index in range(100))
        manager = get_table_manager(
            gpd.GeoDataFrame({"geometry": [geometry]}, geometry="geometry")
        )

        rows = json.loads(manager.to_json_str())
        assert rows[0]["geometry"] == (
            str(geometry)[:GEOMETRY_CELL_CAP] + "..."
        )

    def test_mixed_column_names_render_capped_wkt(self) -> None:
        import geopandas as gpd
        from shapely.geometry import LineString

        geometry = LineString((index, index) for index in range(100))
        frame = gpd.GeoDataFrame(
            {"name": ["a"], 1: gpd.GeoSeries([geometry])},
            geometry=1,
        )

        manager = get_table_manager(frame)
        rows = json.loads(manager.to_json_str())

        assert list(frame.columns) == ["name", 1]
        assert manager.get_column_names() == ["name", "1"]
        assert rows[0]["1"] == (str(geometry)[:GEOMETRY_CELL_CAP] + "...")

    def test_json_geometry_formatting_failure_falls_back(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        from marimo._plugins.ui._impl.tables import pandas_table

        manager = get_table_manager(geo.gdf_point_known_crs())

        def fail_formatting(*_args: Any, **_kwargs: Any) -> None:
            raise RuntimeError("intentional formatting failure")

        monkeypatch.setattr(
            pandas_table, "_format_geometry_columns", fail_formatting
        )

        rows = json.loads(manager.to_json_str())

        assert rows[0] == {"name": "a", "geometry": "POINT (0 0)"}

    def test_null_cell_stays_null(self) -> None:
        manager = get_table_manager(geo.gdf_with_null())

        rows = json.loads(manager.to_json_str())
        assert rows[1]["geometry"] is None

    @pytest.mark.requires("pyarrow", "geopandas")
    def test_arrow_cells_render_wkt_and_preserve_null(self) -> None:
        from pyarrow import ipc

        manager = get_table_manager(geo.gdf_with_null())

        rows = ipc.open_file(manager.to_arrow_ipc()).read_all().to_pylist()
        assert rows[0]["geometry"] == "POINT (0 0)"
        assert rows[1]["geometry"] is None

    @pytest.mark.requires("pyarrow", "geopandas")
    def test_arrow_detection_miss_degrades_to_strings(self) -> None:
        from pyarrow import ipc

        manager = get_table_manager(geo.gdf_with_null())
        manager.__dict__["_geometry_columns"] = {}

        rows = ipc.open_file(manager.to_arrow_ipc()).read_all().to_pylist()

        assert rows[0]["geometry"] == "POINT (0 0)"
        assert rows[1]["geometry"] is None

    def test_unique_values_returns_empty(self) -> None:
        manager = get_table_manager(geo.gdf_point_known_crs())

        assert manager.get_unique_column_values("geometry") == []

    def test_search_skips_geometry(self) -> None:
        manager = get_table_manager(geo.gdf_point_known_crs())

        assert manager.search("POINT").get_num_rows() == 0

    def test_top_k_returns_empty(self) -> None:
        manager = get_table_manager(geo.gdf_point_known_crs())

        assert manager.calculate_top_k_rows("geometry", 10) == []

    def test_stats_counts_only(self) -> None:
        manager = get_table_manager(geo.gdf_with_null())

        stats = manager.get_stats("geometry")
        assert stats.total == 2
        assert stats.nulls == 1
        assert stats.unique is None
        assert stats.min is None


@pytest.mark.requires("geopandas")
class TestHostGuards:
    def test_chart_fallback_drops_geometry(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        frame = geo.gdf_point_known_crs().assign(value=[1, 2])
        table = ui.table(frame, show_column_summaries=True)

        def fail_bin_values(*_args: Any, **_kwargs: Any) -> None:
            raise RuntimeError("Intentional bin failure")

        def column_names_as_chart_data(
            manager: TableManager[Any],
        ) -> tuple[str, Literal["csv"]]:
            return ",".join(manager.get_column_names()), "csv"

        monkeypatch.setattr(table._manager, "get_bin_values", fail_bin_values)
        monkeypatch.setattr(
            type(table),
            "_to_chart_data_url",
            staticmethod(column_names_as_chart_data),
        )

        summaries = table._get_column_summaries(ColumnSummariesArgs())

        assert summaries.data == "name,value"

    def test_sort_is_ignored(self) -> None:
        table = ui.table(geo.gdf_point_known_crs())

        with _loggers.capture_output() as (_, _, records):
            response = table._search(
                SearchTableArgs(
                    page_size=10,
                    page_number=0,
                    sort=[SortArgs(by="geometry", descending=True)],
                )
            )

        rows = json.loads(response.data)
        assert [row["name"] for row in rows] == ["a", "b"]
        assert any(
            record.getMessage()
            == "Ignoring sort on geometry column 'geometry'"
            for record in records
        )

    def test_filter_is_ignored(self) -> None:
        table = ui.table(geo.gdf_point_known_crs(), selection=None)
        filters = FilterGroup(
            children=(
                FilterCondition(
                    column_id="geometry",
                    operator="contains",
                    value="POINT",
                ),
            )
        )

        with _loggers.capture_output() as (_, _, records):
            response = table._search(
                SearchTableArgs(
                    page_size=10,
                    page_number=0,
                    filters=filters,
                )
            )

        assert response.total_rows == 2
        assert any(
            record.getMessage()
            == "Ignoring filter on geometry column 'geometry'"
            for record in records
        )


@contextmanager
def _closing_data(make_data: Any) -> Any:
    produced = make_data()
    if isinstance(produced, tuple):
        conn, data = produced
        try:
            yield data
        finally:
            conn.close()
        return
    yield produced


def _duckdb_geometry() -> tuple[Any, Any]:
    conn = geo.duckdb_spatial_connection()
    return conn, geo.duckdb_geometry_relation(conn)


def _duckdb_crs_geometry() -> tuple[Any, Any]:
    conn = geo.duckdb_crs_geometry_connection()
    return conn, conn.table("crs_geometry")


@pytest.mark.parametrize(
    ("make_data", "expected_geometry"),
    [
        pytest.param(
            geo.gdf_point_known_crs,
            {"geometry": ("geometry", "geometry")},
            marks=pytest.mark.requires("geopandas"),
            id="gdf_point_known_crs",
        ),
        pytest.param(
            geo.gdf_point_missing_crs,
            {"geometry": ("geometry", "geometry")},
            marks=pytest.mark.requires("geopandas"),
            id="gdf_point_missing_crs",
        ),
        pytest.param(
            geo.gdf_multi_geometry,
            {
                "geom_a": ("geometry", "geometry"),
                "geom_b": ("geometry", "geometry"),
            },
            marks=pytest.mark.requires("geopandas"),
            id="gdf_multi_geometry",
        ),
        pytest.param(
            geo.gdf_no_active_geometry,
            {"g": ("geometry", "geometry")},
            marks=pytest.mark.requires("geopandas"),
            id="gdf_no_active_geometry",
        ),
        pytest.param(
            geo.gdf_stale_pointer,
            {"geom": ("geometry", "geometry")},
            marks=pytest.mark.requires("geopandas"),
            id="gdf_stale_pointer",
        ),
        pytest.param(
            geo.gdf_dropped_active,
            {"geom_b": ("geometry", "geometry")},
            marks=pytest.mark.requires("geopandas"),
            id="gdf_dropped_active",
        ),
        pytest.param(
            geo.gdf_with_null,
            {"geometry": ("geometry", "geometry")},
            marks=pytest.mark.requires("geopandas"),
            id="gdf_with_null",
        ),
        pytest.param(
            geo.gdf_all_null,
            {"geometry": ("geometry", "geometry")},
            marks=pytest.mark.requires("geopandas"),
            id="gdf_all_null",
        ),
        pytest.param(
            geo.gdf_mixed_types,
            {"geometry": ("geometry", "geometry")},
            marks=pytest.mark.requires("geopandas"),
            id="gdf_mixed_types",
        ),
        pytest.param(
            geo.gdf_3d,
            {"geometry": ("geometry", "geometry")},
            marks=pytest.mark.requires("geopandas"),
            id="gdf_3d",
        ),
        pytest.param(
            geo.arrow_wkb_known_crs,
            {"geom": ("geometry", "geoarrow.wkb")},
            marks=pytest.mark.requires("pyarrow"),
            id="arrow_wkb_known_crs",
        ),
        pytest.param(
            geo.arrow_wkt,
            {"geom": ("geometry", "geoarrow.wkt")},
            marks=pytest.mark.requires("pyarrow"),
            id="arrow_wkt",
        ),
        pytest.param(
            geo.arrow_wkb_missing_crs,
            {"geom": ("geometry", "geoarrow.wkb")},
            marks=pytest.mark.requires("pyarrow"),
            id="arrow_wkb_missing_crs",
        ),
        pytest.param(
            geo.arrow_ogc_wkb,
            {"geom": ("geometry", "ogc.wkb")},
            marks=pytest.mark.requires("pyarrow"),
            id="arrow_ogc_wkb",
        ),
        pytest.param(
            geo.arrow_other_geoarrow,
            {"geom": ("geometry", "geoarrow.point")},
            marks=pytest.mark.requires("pyarrow"),
            id="arrow_other_geoarrow",
        ),
        pytest.param(
            _duckdb_geometry,
            {"geom": ("geometry", "GEOMETRY")},
            marks=pytest.mark.requires("duckdb", "pyarrow"),
            id="duckdb_geometry",
        ),
        pytest.param(
            _duckdb_crs_geometry,
            {"geom": ("geometry", "GEOMETRY('OGC:CRS84')")},
            marks=pytest.mark.requires("duckdb", "pyarrow"),
            id="duckdb_crs_geometry",
        ),
    ],
)
class TestHostCorpusSmoke:
    """Host-level smoke over the geometry fixture corpus.

    Each fixture is wrapped in ui.table. Search and column summaries must
    return clean payloads with the expected geometry field types.
    """

    def test_search_and_summaries(
        self,
        make_data: Any,
        expected_geometry: dict[str, tuple[str, str]],
    ) -> None:
        with _closing_data(make_data) as data:
            table = ui.table(data, show_column_summaries=True)
            field_types = dict(table._manager.get_field_types())
            for name, expected in expected_geometry.items():
                assert field_types[name] == expected

            response = table._search(
                SearchTableArgs(page_size=10, page_number=0)
            )
            rows = json.loads(response.data)
            assert isinstance(rows, list)

            summaries = table._get_column_summaries(ColumnSummariesArgs())
            for name in expected_geometry:
                stats = summaries.stats[name]
                assert stats.unique is None
                assert stats.min is None


class TestManagerTemplateHook:
    @pytest.mark.requires("polars")
    def test_polars_uses_semantic_type(self) -> None:
        import polars as pl

        manager = get_table_manager(
            pl.DataFrame({"geometry": ["POINT (0 0)"]})
        )
        manager.__dict__["_geometry_columns"] = {
            "geometry": GeometryColumnInfo(
                encoding="wkt", external_type="geometry"
            )
        }

        assert manager.get_field_type("geometry") == ("geometry", "geometry")

    @pytest.mark.requires("ibis")
    def test_ibis_uses_semantic_type(self) -> None:
        import ibis

        manager = get_table_manager(
            ibis.memtable({"geometry": ["POINT (0 0)"]})
        )
        manager.__dict__["_geometry_columns"] = {
            "geometry": GeometryColumnInfo(
                encoding="wkt", external_type="geometry"
            )
        }

        assert manager.get_field_type("geometry") == ("geometry", "geometry")


@pytest.mark.requires("pyarrow")
def test_geoarrow_wkb_without_geopandas_or_shapely() -> None:
    repo_root = str(Path(__file__).resolve().parents[5])
    script = """
import json
import sys

sys.path.insert(0, sys.argv[1])


class BlockedDependency:
    def find_spec(self, fullname, path=None, target=None):
        del path, target
        root = fullname.partition(".")[0]
        if root == "geopandas":
            raise RuntimeError(f"blocked import: {fullname}")
        if root == "shapely":
            raise ModuleNotFoundError(fullname)
        return None


sys.meta_path.insert(0, BlockedDependency())

import pyarrow as pa
from marimo._plugins import ui
from marimo._plugins.ui._impl.table import DownloadAsArgs
from marimo._plugins.ui._impl.tables.utils import get_table_manager
from marimo._utils.data_uri import from_data_uri

wkb = bytes.fromhex("0101000000000000000000f03f0000000000000040")
schema = pa.schema(
    [
        pa.field("a", pa.int64()),
        pa.field(
            "geom",
            pa.binary(),
            metadata={
                b"ARROW:extension:name": b"geoarrow.wkb",
                b"ARROW:extension:metadata": b'{"crs": "EPSG:4326"}',
            },
        ),
    ]
)
table = pa.table({"a": [0, 1], "geom": [wkb, None]}, schema=schema)
manager = get_table_manager(table)

assert manager.get_field_type("geom") == ("geometry", "geoarrow.wkb")
rows = json.loads(manager.to_json_str())
assert rows[0]["geom"] == f"<geometry, {len(wkb)} B>"
assert rows[1]["geom"] is None
stats = manager.get_stats("geom")
assert stats.total == 2
assert stats.nulls == 1
assert stats.unique is None
assert stats.min is None

url = ui.table(table)._download_as(DownloadAsArgs(format="json")).url
downloaded = json.loads(from_data_uri(url)[1])
assert downloaded[0]["geom"] == wkb.hex()
assert downloaded[1]["geom"] is None
"""
    try:
        subprocess.run(
            [sys.executable, "-c", script, repo_root],
            check=True,
            capture_output=True,
            text=True,
        )
    except subprocess.CalledProcessError as e:
        raise AssertionError(e.stderr) from e


@pytest.mark.requires("duckdb", "pyarrow")
@pytest.mark.parametrize("indices", [[2, 0, 2], [1, 1], [], [2, 1, 0]])
def test_duckdb_geometry_selection_preserves_order_and_duplicates(
    indices: list[int],
) -> None:
    conn = geo.duckdb_export_connection()
    try:
        source = conn.sql(
            'SELECT i AS id, \'POINT (1 2)\'::GEOMETRY AS "g""eom", 1 AS "__marimo_export_row" FROM range(3) t(i)'
        )
        manager = get_table_manager(source).select_rows(indices)
        assert manager.data.implementation.is_duckdb()
        assert manager.as_frame().get_column("id").to_list() == indices
        assert 'g"eom' in manager.get_column_names()
        assert manager.data.to_native().types[1] == source.types[1]
    finally:
        conn.close()


@pytest.mark.requires("duckdb", "pyarrow")
@pytest.mark.parametrize("indices", [[-1], [3], [0, 3], [2, -1]])
def test_duckdb_geometry_selection_rejects_out_of_bounds(
    indices: list[int],
) -> None:
    conn = geo.duckdb_export_connection()
    try:
        with pytest.raises(IndexError, match="out of bounds"):
            get_table_manager(
                conn.sql(
                    "SELECT i AS id, NULL::GEOMETRY AS geom FROM range(3) t(i)"
                )
            ).select_rows(indices)
    finally:
        conn.close()


@pytest.mark.requires("duckdb", "pyarrow")
@pytest.mark.parametrize(
    "name",
    [
        "__MARIMO_EXPORT_ROW",
        "__Marimo_Export_Row",
        "__MARIMO_EXPORT_ROW_REQUESTED",
        "__Marimo_Export_Row_Order",
        "row_index",
        "ordinal",
    ],
)
def test_duckdb_selection_avoids_case_insensitive_index_collision(
    name: str,
) -> None:
    conn = geo.duckdb_export_connection()
    try:
        source = conn.sql(
            f'SELECT i AS id, NULL::GEOMETRY AS geom, 99 AS "{name}", 98 AS "__MARIMO_EXPORT_ROW_" FROM range(3) t(i)'
        )
        manager = get_table_manager(source).select_rows([2, 0, 2])
        rows = manager.data.to_native().fetchall()
        assert [row[0] for row in rows] == [2, 0, 2]
        assert [row[2:] for row in rows] == [(99, 98)] * 3
        assert manager.data.to_native().types == source.types
    finally:
        conn.close()


@pytest.mark.requires("duckdb", "pyarrow")
def test_duckdb_selection_preserves_nonportable_arrow_values() -> None:
    conn = geo.duckdb_export_connection()
    try:
        source = conn.sql(
            "SELECT NULL::GEOMETRY AS geom, '01010'::BIT AS bits, '12:34:56+05:30'::TIMETZ AS clock, 340282366920938463463374607431768211455::UHUGEINT AS large, ['01010'::BIT, NULL] AS bit_list, {'clock': '12:34:56+05:30'::TIMETZ} AS nested_clock, ['12:34:56+05:30'::TIMETZ, NULL]::TIMETZ[2] AS clock_array, MAP {'clock': '12:34:56+05:30'::TIMETZ} AS clock_map"
        )
        selected = get_table_manager(source).select_rows([0, 0])
        native = selected.data.to_native()
        assert native.types == source.types
        assert native.fetchall() == source.fetchall() * 2
    finally:
        conn.close()


@pytest.mark.requires("duckdb", "pyarrow")
def test_duckdb_selection_evaluates_volatile_source_once() -> None:
    conn = geo.duckdb_export_connection()
    calls = []

    def include(value: int) -> bool:
        calls.append(value)
        return len(calls) <= 3

    try:
        conn.create_function("include_row", include, side_effects=True)
        source = conn.sql(
            "SELECT i AS id, 'POINT (1 2)'::GEOMETRY AS geom FROM range(3) t(i) WHERE include_row(i)"
        )
        manager = get_table_manager(source).select_rows([2, 0, 2])
        assert len(calls) == 3
        for _ in range(2):
            assert [row[0] for row in manager.data.to_native().fetchall()] == [
                2,
                0,
                2,
            ]
        assert len(calls) == 3
        assert manager.data.to_native().types == source.types
    finally:
        conn.close()


@pytest.mark.requires("duckdb", "pyarrow")
def test_duckdb_snapshot_lifetime_follows_derived_native_relation() -> None:
    import gc

    conn = geo.duckdb_export_connection()
    try:
        source = get_table_manager(
            conn.sql(
                "SELECT i AS id, NULL::GEOMETRY AS geom FROM range(3) t(i)"
            )
        )
        before = conn.sql(
            "SELECT table_name FROM duckdb_tables() WHERE temporary"
        ).fetchall()
        selected = source.select_rows([2, 0, 2])
        derived = selected.select_columns(["id", "geom"])
        native = derived.data.to_native()
        descendant = native.project("id, geom")
        del selected, derived
        del native
        gc.collect()
        assert [row[0] for row in descendant.fetchall()] == [2, 0, 2]
        assert (
            conn.sql(
                "SELECT table_name FROM duckdb_tables() WHERE temporary"
            ).fetchall()
            == before
        )
        del descendant
        gc.collect()
        assert (
            conn.sql(
                "SELECT table_name FROM duckdb_tables() WHERE temporary"
            ).fetchall()
            == before
        )
        assert (
            conn.sql(
                "SELECT view_name FROM duckdb_views() WHERE NOT internal AND view_name LIKE '__marimo_selection_source_%'"
            ).fetchall()
            == []
        )
    finally:
        conn.close()


@pytest.mark.requires("duckdb", "pyarrow")
def test_duckdb_invalid_selection_releases_snapshot() -> None:
    import gc

    conn = geo.duckdb_export_connection()
    try:
        source = get_table_manager(conn.sql("SELECT NULL::GEOMETRY AS geom"))
        with pytest.raises(IndexError):
            source.select_rows([1])
        gc.collect()
        assert (
            conn.sql(
                "SELECT table_name FROM duckdb_tables() WHERE temporary AND table_name LIKE '__marimo_selection_%'"
            ).fetchall()
            == []
        )
    finally:
        conn.close()


@pytest.mark.requires("duckdb", "geopandas", "pyarrow")
def test_duckdb_selection_snapshot_preserves_crs_after_source_changes() -> (
    None
):
    from marimo._plugins.ui._impl.tables.geometry_export import (
        get_export_metadata,
    )

    conn = geo.duckdb_crs_geometry_connection()
    try:
        conn.execute(
            "CREATE TABLE locations AS SELECT i AS id, 'POINT (1 2)'::GEOMETRY('OGC:CRS84') AS geom FROM range(3) t(i)"
        )
        original = get_table_manager(conn.table("locations"))
        metadata = get_export_metadata(original)
        selected = original.select_rows([2, 0, 2])
        conn.execute("DELETE FROM locations")
        assert (
            selected.data.to_native().types == original.data.to_native().types
        )
        assert (
            get_export_metadata(selected).geometry_columns
            == metadata.geometry_columns
        )
        assert [row[0] for row in selected.data.to_native().fetchall()] == [
            2,
            0,
            2,
        ]
        assert conn.table("locations").count("*").fetchall() == [(0,)]
    finally:
        conn.close()