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
fix: export complete geometry text (#11012)
Kiran Gadhaveec7c2ad6ed0b
diff --git a/frontend/src/components/data-table/__tests__/export-actions.test.tsx b/frontend/src/components/data-table/__tests__/export-actions.test.tsxindex edf0bf140f..b2c8a15046 100644--- a/frontend/src/components/data-table/__tests__/export-actions.test.tsx+++ b/frontend/src/components/data-table/__tests__/export-actions.test.tsx@@ -660,3 +660,70 @@ describe("ExportActions dialog", () => {expect(screen.queryByRole("dialog")).not.toBeInTheDocument();});});++const LONG_GEOMETRY_WKT = `LINESTRING (${Array.from(+ { length: 160 },+ (_, index) => `${index} ${index % 17}`,+).join(", ")})`;+const jsonRows = [{ row_label: "long", geometry: LONG_GEOMETRY_WKT }];++describe("ExportActions clipboard geometry", () => {+ beforeEach(() => {+ vi.clearAllMocks();+ downloadAs.mockResolvedValue({+ url: "https://example.test/export",+ filename: "geometry",+ });+ });++ afterEach(() => {+ vi.unstubAllGlobals();+ });++ it.each([+ {+ label: "CSV",+ sourceFormat: "csv" as const,+ sourceText: `row_label,geometry\nlong,"${LONG_GEOMETRY_WKT}"\n`,+ expectedText: `row_label,geometry\nlong,"${LONG_GEOMETRY_WKT}"\n`,+ },+ {+ label: "TSV",+ sourceFormat: "tsv" as const,+ sourceText: `row_label\tgeometry\nlong\t${LONG_GEOMETRY_WKT}\n`,+ expectedText: `row_label\tgeometry\nlong\t${LONG_GEOMETRY_WKT}\n`,+ },+ {+ label: "JSON",+ sourceFormat: "json" as const,+ sourceText: JSON.stringify(jsonRows),+ expectedText: JSON.stringify(jsonRows, null, 2),+ },+ {+ label: "Markdown",+ sourceFormat: "json" as const,+ sourceText: JSON.stringify(jsonRows),+ expectedText: jsonToMarkdown(jsonRows),+ },+ ])(+ "copies complete geometry text as $label",+ async ({ label, sourceFormat, sourceText, expectedText }) => {+ vi.stubGlobal(+ "fetch",+ vi.fn().mockResolvedValue({+ ok: true,+ text: vi.fn().mockResolvedValue(sourceText),+ }),+ );+ renderExportActions();+ await openDialog();++ fireEvent.click(screen.getByRole("button", { name: `Copy ${label}` }));++ await waitFor(() => {+ expect(copyToClipboard).toHaveBeenCalledWith(expectedText);+ });+ expect(downloadAs).toHaveBeenCalledWith({ format: sourceFormat });+ },+ );+});diff --git a/marimo/_plugins/ui/_impl/tables/geometry_export.py b/marimo/_plugins/ui/_impl/tables/geometry_export.pynew file mode 100644index 0000000000..0fc44d0fa5--- /dev/null+++ b/marimo/_plugins/ui/_impl/tables/geometry_export.py@@ -0,0 +1,171 @@+# Copyright 2026 Marimo. All rights reserved.+from __future__ import annotations++from typing import TYPE_CHECKING, Any++import narwhals.stable.v2 as nw++from marimo._dependencies.dependencies import DependencyManager+from marimo._plugins.ui._impl.tables.geometry import GeometryColumnInfo+from marimo._plugins.ui._impl.tables.narwhals_table import (+ NarwhalsTableManager,+)+from marimo._plugins.ui._impl.tables.table_manager import TableManager+from marimo._sql.sql_quoting import quote_sql_identifier++if TYPE_CHECKING:+ import pyarrow as pa+++def prepare_geometry_text_export(+ manager: TableManager[Any],+) -> TableManager[Any]:+ """Create an export view with complete geometry text.++ Args:+ manager (TableManager[Any]): The manager for the effective export+ rows.++ Returns:+ TableManager[Any]: A manager with supported geometry columns replaced+ by complete WKT or lossless hexadecimal WKB text.+ """+ if not isinstance(manager, NarwhalsTableManager):+ return manager++ geometry_columns = manager._geometry_columns+ if not geometry_columns:+ return manager++ source_frame = manager.data+ if source_frame.implementation.is_duckdb():+ return _prepare_duckdb_export(manager, geometry_columns)++ frame = manager.as_frame()+ if frame.implementation.is_pandas():+ return _prepare_pandas_export(manager, geometry_columns)+ if frame.implementation.is_pyarrow():+ return _prepare_arrow_export(manager, geometry_columns)+ return manager+++def _prepare_pandas_export(+ manager: NarwhalsTableManager[Any, Any],+ geometry_columns: dict[str, GeometryColumnInfo],+) -> TableManager[Any]:+ import geopandas as gpd # type: ignore[import-not-found,import-untyped,unused-ignore]+ import pandas as pd++ native = manager.as_frame().to_native()+ export_frame = pd.DataFrame(native.copy())+ converted = False++ for column, info in geometry_columns.items():+ if info.encoding != "objects":+ continue+ geometry = gpd.GeoSeries(+ native[column].array,+ index=native.index,+ )+ export_frame[column] = geometry.to_wkt(rounding_precision=-1)+ converted = True++ return _with_native_data(manager, export_frame) if converted else manager+++def _prepare_arrow_export(+ manager: NarwhalsTableManager[Any, Any],+ geometry_columns: dict[str, GeometryColumnInfo],+) -> TableManager[Any]:+ import pyarrow as pa++ export_table: pa.Table = manager.as_frame().to_native()+ converted = False++ for column, info in geometry_columns.items():+ if info.encoding not in ("wkt", "wkb"):+ continue++ index = export_table.schema.get_field_index(column)+ field = export_table.schema.field(index)+ metadata = dict(field.metadata or {})+ metadata.pop(b"ARROW:extension:name", None)+ metadata.pop(b"ARROW:extension:metadata", None)+ export_type = pa.string() if info.encoding == "wkb" else field.type+ export_field = pa.field(+ field.name,+ export_type,+ nullable=field.nullable,+ metadata=metadata or None,+ )++ values = export_table.column(index)+ export_values: pa.Array[Any] | pa.ChunkedArray[Any]+ if info.encoding == "wkb":+ export_values = pa.array(+ _wkb_values_to_text(values.to_pylist()),+ type=pa.string(),+ )+ else:+ export_values = values++ export_table = export_table.set_column(+ index, export_field, export_values+ )+ converted = True++ return _with_native_data(manager, export_table) if converted else manager+++def _wkb_values_to_text(values: list[Any]) -> list[str | None]:+ if not DependencyManager.shapely.has():+ return [+ None if value is None else bytes(value).hex() for value in values+ ]++ from shapely import wkb, wkt # type: ignore[import-untyped]++ return [+ (+ None+ if value is None+ else wkt.dumps(+ wkb.loads(bytes(value)),+ rounding_precision=-1,+ trim=True,+ )+ )+ for value in values+ ]+++def _prepare_duckdb_export(+ manager: NarwhalsTableManager[Any, Any],+ geometry_columns: dict[str, GeometryColumnInfo],+) -> TableManager[Any]:+ relation = manager.data.to_native()+ expressions: list[str] = []+ converted = False++ for column in relation.columns:+ quoted = quote_sql_identifier(column, dialect="duckdb")+ info = geometry_columns.get(column)+ if (+ info is not None+ and info.encoding == "wkb"+ and info.external_type.startswith("GEOMETRY")+ ):+ expressions.append(f"ST_AsText({quoted}) AS {quoted}")+ converted = True+ else:+ expressions.append(quoted)++ if not converted:+ return manager+ return _with_native_data(manager, relation.project(", ".join(expressions)))+++def _with_native_data(+ manager: NarwhalsTableManager[Any, Any], native: Any+) -> TableManager[Any]:+ return manager.with_new_data(nw.from_native(native, pass_through=False))diff --git a/marimo/_plugins/ui/_impl/tables/table_manager.py b/marimo/_plugins/ui/_impl/tables/table_manager.pyindex 93a5e5fab8..cc4c5d2619 100644--- a/marimo/_plugins/ui/_impl/tables/table_manager.py+++ b/marimo/_plugins/ui/_impl/tables/table_manager.py@@ -169,7 +169,12 @@ class TableManager(abc.ABC, Generic[T]):return 0n = min(total_rows, sample_rows)try:- sample = self.take(n, 0).to_json_str(+ from marimo._plugins.ui._impl.tables.geometry_export import (+ prepare_geometry_text_export,+ )++ sample_manager = prepare_geometry_text_export(self.take(n, 0))+ sample = sample_manager.to_json_str(strict_json=True, ensure_ascii=True)except Exception:diff --git a/marimo/_plugins/ui/_impl/utils/dataframe.py b/marimo/_plugins/ui/_impl/utils/dataframe.pyindex 2ef12554d8..db2b9cfd6f 100644--- a/marimo/_plugins/ui/_impl/utils/dataframe.py+++ b/marimo/_plugins/ui/_impl/utils/dataframe.py@@ -10,6 +10,9 @@ from marimo import _loggersfrom marimo._output.data import data as mo_datafrom marimo._output.mime import MIMEfrom marimo._plugins.core.web_component import JSONType+from marimo._plugins.ui._impl.tables.geometry_export import (+ prepare_geometry_text_export,+)from marimo._plugins.ui._impl.tables.selection import INDEX_COLUMN_NAMEfrom marimo._plugins.ui._impl.tables.table_manager import TableManagerfrom marimo._runtime.context.types import (@@ -200,6 +203,9 @@ def download_as(allowed = ", ".join(map(repr, _EXPORT_FORMATS))raise ValueError(f"format must be one of {allowed}.")+ if ext in ("csv", "tsv", "json"):+ manager = prepare_geometry_text_export(manager)+vfile = mo_data.any_data(fmt.serialize(manager, options), ext=fmt.extension)diff --git a/tests/_plugins/ui/_impl/dataframes/test_dataframe.py b/tests/_plugins/ui/_impl/dataframes/test_dataframe.pyindex 15d733cc10..04b2d5c92f 100644--- a/tests/_plugins/ui/_impl/dataframes/test_dataframe.py+++ b/tests/_plugins/ui/_impl/dataframes/test_dataframe.py@@ -1,5 +1,7 @@from __future__ import annotations+import csv+import ioimport jsonfrom typing import TYPE_CHECKING, Anyfrom unittest.mock import Mock, patch@@ -60,6 +62,79 @@ def is_not_narwhals_dataframe(df: IntoDataFrame | IntoLazyFrame) -> bool:return not (is_narwhals_lazyframe(df) or is_narwhals_dataframe(df))[email protected]("geopandas")[email protected]("format_type", ["csv", "tsv", "json"])+ "as_pandas_dataframe",+ [False, True],+ ids=["geodataframe", "pandas-geometry-dtype"],+)+def test_dataframe_downloads_transformed_geometry_as_complete_text(+ format_type: str,+ as_pandas_dataframe: bool,+) -> None:+ import geopandas as gpd+ import pandas as pd+ from shapely import from_wkt++ long_wkt = (+ "LINESTRING Z ("+ + ", ".join(+ f"{index} {index % 17} {index % 11}" for index in range(160)+ )+ + ")"+ )+ long_geometry = from_wkt(long_wkt)+ geopandas_source = gpd.GeoDataFrame(+ {+ "row_label": ["long", "point", "null"],+ "geometry": [+ long_geometry,+ from_wkt("POINT Z (1 2 3)"),+ None,+ ],+ },+ geometry="geometry",+ crs="EPSG:4326",+ index=[3, 5, 8],+ )+ source = (+ pd.DataFrame(geopandas_source)+ if as_pandas_dataframe+ else geopandas_source+ )+ original = source.copy(deep=True)+ subject = ui.dataframe(source)+ subject._value = source.iloc[[0, 2]].copy()++ url = subject._download_as(DownloadAsArgs(format=format_type)).url+ data = from_data_uri(url)[1]+ if format_type == "json":+ rows = json.loads(data)+ else:+ delimiter = "," if format_type == "csv" else "\t"+ rows = list(+ csv.DictReader(+ io.StringIO(data.decode("utf-8")), delimiter=delimiter+ )+ )++ assert rows[0]["row_label"] == "long"+ assert rows[0]["geometry"] == long_geometry.wkt+ assert rows[1]["row_label"] == "null"+ if format_type == "json":+ assert rows[1]["geometry"] is None+ else:+ assert rows[1]["geometry"] == ""+ assert source["geometry"].iloc[0].equals_exact(long_geometry, tolerance=0)+ assert str(source["geometry"].dtype) == "geometry"+ assert source["geometry"].array.crs == "EPSG:4326"+ if as_pandas_dataframe:+ assert type(source) is pd.DataFrame+ assert not hasattr(source["geometry"], "to_wkt")+ pd.testing.assert_frame_equal(source, original)++@pytest.mark.skipif(not HAS_DEPS, reason="optional dependencies not installed")class TestDataframes:@staticmethoddiff --git a/tests/_plugins/ui/_impl/tables/test_geometry.py b/tests/_plugins/ui/_impl/tables/test_geometry.pyindex 35bf26542b..447f901963 100644--- a/tests/_plugins/ui/_impl/tables/test_geometry.py+++ b/tests/_plugins/ui/_impl/tables/test_geometry.py@@ -915,15 +915,21 @@ sys.path.insert(0, sys.argv[1])class BlockedDependency:def find_spec(self, fullname, path=None, target=None):del path, target- if fullname.partition(".")[0] in {"geopandas", "shapely"}:+ root = fullname.partition(".")[0]+ if root == "geopandas":raise RuntimeError(f"blocked import: {fullname}")+ if root == "shapely":+ raise ModuleNotFoundError(fullname)return Nonesys.meta_path.insert(0, BlockedDependency())import pyarrow as pa+from marimo._plugins import ui+from marimo._plugins.ui._impl.table import DownloadAsArgsfrom marimo._plugins.ui._impl.tables.utils import get_table_manager+from marimo._utils.data_uri import from_data_uriwkb = bytes.fromhex("0101000000000000000000f03f0000000000000040")schema = pa.schema(@@ -951,6 +957,11 @@ assert stats.total == 2assert stats.nulls == 1assert stats.unique is Noneassert 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(diff --git a/tests/_plugins/ui/_impl/test_table.py b/tests/_plugins/ui/_impl/test_table.pyindex 2b8a4d8eb7..a38a32f4f9 100644--- a/tests/_plugins/ui/_impl/test_table.py+++ b/tests/_plugins/ui/_impl/test_table.py@@ -1,6 +1,8 @@# Copyright 2026 Marimo. All rights reserved.from __future__ import annotations+import csv+import ioimport jsonfrom datetime import date, timedeltafrom enum import Enum@@ -1508,6 +1510,13 @@ def test_display_config_unpacks(df: Any) -> None:DOWNLOAD_FORMATS = ["csv", "tsv", "json", "parquet"]+TEXT_DOWNLOAD_FORMATS = ["csv", "tsv", "json"]+LONG_GEOMETRY_WKT = (+ "LINESTRING Z ("+ + ", ".join(f"{index} {index % 17} {index % 11}" for index in range(160))+ + ")"+)+POINT_GEOMETRY_WKT = "POINT Z (1 2 3)"# Parquet export requires pandas+pyarrow or polars (see the `_download_as`# short-circuit in `table.py`). In environments without those — e.g. the@@ -1634,6 +1643,279 @@ def test_download_as(df: Any) -> None:assert selected_nw["cities"][0] == "New York"+def _download_text_rows(+ table: ui.table[Any], format_type: str+) -> list[dict[str, Any]]:+ url = table._download_as(DownloadAsArgs(format=format_type)).url+ data = from_data_uri(url)[1]+ if format_type == "json":+ rows = json.loads(data)+ assert isinstance(rows, list)+ return rows+ delimiter = "," if format_type == "csv" else "\t"+ return list(+ csv.DictReader(io.StringIO(data.decode("utf-8")), delimiter=delimiter)+ )+++def _assert_complete_geometry_rows(+ rows: list[dict[str, Any]],+ format_type: str,+ expected_long: str,+) -> None:+ by_label = {row["row_label"]: row["geometry"] for row in rows}+ assert by_label["long"] == expected_long+ assert by_label["point"] == POINT_GEOMETRY_WKT+ if format_type == "json":+ assert by_label["null"] is None+ else:+ assert by_label["null"] == ""++[email protected]("geopandas")[email protected]("format_type", TEXT_DOWNLOAD_FORMATS)+def test_download_geopandas_geometry_as_complete_text(+ format_type: str,+) -> None:+ import geopandas as gpd+ from shapely import from_wkt++ long_geometry = from_wkt(LONG_GEOMETRY_WKT)+ point_geometry = from_wkt(POINT_GEOMETRY_WKT)+ source = gpd.GeoDataFrame(+ {+ "row_label": ["long", "point", "null"],+ "geometry": [long_geometry, point_geometry, None],+ },+ geometry="geometry",+ crs="EPSG:4326",+ )++ rows = _download_text_rows(ui.table(source), format_type)++ _assert_complete_geometry_rows(rows, format_type, long_geometry.wkt)+ assert source.geometry.iloc[0].equals_exact(long_geometry, tolerance=0)+ assert str(source.geometry.dtype) == "geometry"+ assert source.crs == "EPSG:4326"++[email protected]("geopandas")[email protected]("format_type", TEXT_DOWNLOAD_FORMATS)+def test_download_pandas_geometry_dtype_as_complete_text(+ format_type: str,+) -> None:+ import geopandas as gpd+ import pandas as pd+ from shapely import from_wkt++ long_geometry = from_wkt(LONG_GEOMETRY_WKT)+ geopandas_source = gpd.GeoDataFrame(+ {+ "row_label": ["long", "point", "null"],+ "geometry": [+ long_geometry,+ from_wkt(POINT_GEOMETRY_WKT),+ None,+ ],+ },+ geometry="geometry",+ crs="EPSG:4326",+ index=[3, 5, 8],+ )+ source = pd.DataFrame(geopandas_source)+ original = source.copy(deep=True)++ rows = _download_text_rows(ui.table(source), format_type)++ _assert_complete_geometry_rows(rows, format_type, long_geometry.wkt)+ assert type(source) is pd.DataFrame+ assert not hasattr(source["geometry"], "to_wkt")+ assert str(source["geometry"].dtype) == "geometry"+ assert source["geometry"].array.crs == "EPSG:4326"+ pd.testing.assert_frame_equal(source, original)++[email protected]("pyarrow")[email protected]("format_type", TEXT_DOWNLOAD_FORMATS)+def test_download_arrow_wkt_as_complete_text(format_type: str) -> None:+ import pyarrow as pa++ metadata = {b"ARROW:extension:name": b"geoarrow.wkt"}+ schema = pa.schema(+ [+ pa.field("row_label", pa.string()),+ pa.field("geometry", pa.string(), metadata=metadata),+ ]+ )+ source = pa.table(+ {+ "row_label": ["long", "point", "null"],+ "geometry": [+ LONG_GEOMETRY_WKT,+ POINT_GEOMETRY_WKT,+ None,+ ],+ },+ schema=schema,+ )++ rows = _download_text_rows(ui.table(source), format_type)++ _assert_complete_geometry_rows(rows, format_type, LONG_GEOMETRY_WKT)+ assert source.schema.field("geometry").metadata == metadata++[email protected]("pyarrow", "shapely")[email protected]("format_type", TEXT_DOWNLOAD_FORMATS)+def test_download_arrow_wkb_as_complete_wkt(format_type: str) -> None:+ import pyarrow as pa+ from shapely import from_wkt++ long_geometry = from_wkt(LONG_GEOMETRY_WKT)+ point_geometry = from_wkt(POINT_GEOMETRY_WKT)+ metadata = {b"ARROW:extension:name": b"geoarrow.wkb"}+ schema = pa.schema(+ [+ pa.field("row_label", pa.string()),+ pa.field("geometry", pa.binary(), metadata=metadata),+ ]+ )+ source = pa.table(+ {+ "row_label": ["long", "point", "null"],+ "geometry": [long_geometry.wkb, point_geometry.wkb, None],+ },+ schema=schema,+ )++ rows = _download_text_rows(ui.table(source), format_type)++ _assert_complete_geometry_rows(rows, format_type, long_geometry.wkt)+ assert source.column("geometry")[0].as_py() == long_geometry.wkb+ assert source.schema.field("geometry").metadata == metadata++[email protected]("duckdb", "pyarrow")[email protected]("format_type", TEXT_DOWNLOAD_FORMATS)+def test_download_duckdb_geometry_as_complete_text(+ format_type: str,+) -> None:+ from tests._plugins.ui._impl.tables.geometry_fixtures import (+ duckdb_spatial_connection,+ )++ connection = duckdb_spatial_connection()+ try:+ source = connection.sql(+ "SELECT * FROM (VALUES "+ "('long', ST_GeomFromText(?)), "+ "('point', ST_GeomFromText(?)), "+ "('null', NULL)) AS data(row_label, geometry)",+ params=[LONG_GEOMETRY_WKT, POINT_GEOMETRY_WKT],+ )++ with patch.object(+ DependencyManager.shapely, "has", return_value=False+ ):+ rows = _download_text_rows(ui.table(source), format_type)++ _assert_complete_geometry_rows(rows, format_type, LONG_GEOMETRY_WKT)+ assert str(source.types[1]) == "GEOMETRY"+ finally:+ connection.close()++[email protected]("pyarrow")+def test_geometry_text_download_preserves_row_selection() -> None:+ import pyarrow as pa++ metadata = {b"ARROW:extension:name": b"geoarrow.wkt"}+ schema = pa.schema(+ [+ pa.field("row_label", pa.string()),+ pa.field("geometry", pa.string(), metadata=metadata),+ ]+ )+ source = pa.table(+ {+ "row_label": ["long", "point", "null"],+ "geometry": [+ LONG_GEOMETRY_WKT,+ POINT_GEOMETRY_WKT,+ None,+ ],+ },+ schema=schema,+ )+ table = ui.table(source, selection="multi")+ table._convert_value(["0", "2"])++ rows = _download_text_rows(table, "json")++ assert rows == [+ {"row_label": "long", "geometry": LONG_GEOMETRY_WKT},+ {"row_label": "null", "geometry": None},+ ]++[email protected]("pyarrow", "shapely")+def test_invalid_wkb_does_not_publish_an_artifact() -> None:+ import pyarrow as pa+ from shapely.errors import GEOSException++ metadata = {b"ARROW:extension:name": b"geoarrow.wkb"}+ field = pa.field("geometry", pa.binary(), metadata=metadata)+ source = pa.table(+ {+ "geometry": [+ bytes.fromhex("0101000000000000000000f03f0000000000000040"),+ b"invalid",+ ]+ },+ schema=pa.schema([field]),+ )++ with (+ patch(+ "marimo._plugins.ui._impl.utils.dataframe.mo_data.any_data"+ ) as publish,+ pytest.raises(GEOSException),+ ):+ ui.table(source)._download_as(DownloadAsArgs(format="json"))++ publish.assert_not_called()++[email protected]("pyarrow")+def test_get_size_bytes_includes_complete_geometry_text() -> None:+ import pyarrow as pa++ schema = pa.schema(+ [+ pa.field("row_label", pa.string()),+ pa.field(+ "geometry",+ pa.string(),+ metadata={+ b"ARROW:extension:name": b"geoarrow.wkt",+ },+ ),+ ]+ )+ source = pa.table(+ {+ "row_label": ["long"],+ "geometry": [LONG_GEOMETRY_WKT],+ },+ schema=schema,+ )++ size_bytes = ui.table(source)._get_size_bytes(EmptyArgs()).size_bytes++ assert size_bytes is not None+ assert size_bytes > len(LONG_GEOMETRY_WKT)++def test_get_size_bytes_rpc_extrapolates_from_sample() -> None:from marimo._plugins.ui._impl.table import GetSizeBytesResponsefrom marimo._plugins.ui._impl.tables.table_manager import (