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.

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.tsx
index 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.py
new file mode 100644
index 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.py
index 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 0
n = 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.py
index 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 _loggers
from marimo._output.data import data as mo_data
from marimo._output.mime import MIME
from 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_NAME
from marimo._plugins.ui._impl.tables.table_manager import TableManager
from 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.py
index 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 io
import json
from typing import TYPE_CHECKING, Any
from 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:
@staticmethod
diff --git a/tests/_plugins/ui/_impl/tables/test_geometry.py b/tests/_plugins/ui/_impl/tables/test_geometry.py
index 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 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(
@@ -951,6 +957,11 @@ 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(
diff --git a/tests/_plugins/ui/_impl/test_table.py b/tests/_plugins/ui/_impl/test_table.py
index 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 io
import json
from datetime import date, timedelta
from 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]("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()
+
+
+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()
+
+
+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 GetSizeBytesResponse
from marimo._plugins.ui._impl.tables.table_manager import (