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.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
# 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()