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.

19.1 KB
Raw Blame
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations

from dataclasses import asdict
from typing import Any, Literal
from unittest.mock import patch

import pytest

from marimo._dependencies.dependencies import DependencyManager
from marimo._plugins import ui
from marimo._plugins.ui._impl.table import DownloadAsArgs, DownloadAsResponse
from marimo._plugins.ui._impl.tables.narwhals_table import NarwhalsTableManager
from marimo._runtime.functions import EmptyArgs
from marimo._utils.parse_dataclass import parse_raw
from tests._plugins.ui._impl.tables import geometry_fixtures as fixtures


@pytest.fixture(params=[ui.table, ui.dataframe], ids=["table", "dataframe"])
def widget(request: pytest.FixtureRequest) -> Any:
    return request.param


@pytest.mark.requires("geopandas", "pyarrow")
def test_multigeometry_metadata_does_not_read_rows(widget: Any) -> None:
    source = fixtures.gdf_multi_geometry()
    subject = widget(source)
    with (
        patch.object(
            NarwhalsTableManager,
            "as_frame",
            side_effect=AssertionError("Metadata must not collect rows"),
        ),
        patch.object(
            NarwhalsTableManager,
            "to_json_str",
            side_effect=AssertionError("Metadata must not serialize rows"),
        ),
    ):
        result = subject._get_export_metadata(EmptyArgs())

    assert asdict(result) == {
        "geometry_columns": [
            {"name": "geom_a", "encoding": "objects", "crs": "EPSG:4326"},
            {"name": "geom_b", "encoding": "objects", "crs": "EPSG:3857"},
        ],
        "primary_geometry_column": "geom_a",
        "default_geometry_column": "geom_a",
        "formats": {
            "geojson": {
                "available": True,
                "reason": None,
                "missing_packages": [],
            },
            "parquet": {
                "available": True,
                "reason": None,
                "missing_packages": [],
            },
        },
    }
    assert source.geometry.name == "geom_a"


@pytest.mark.requires("geopandas")
@pytest.mark.parametrize(
    ("factory", "primary", "default"),
    [
        (fixtures.gdf_no_active_geometry, None, "g"),
        (fixtures.gdf_stale_pointer, None, "geom"),
        (fixtures.gdf_dropped_active, None, "geom_b"),
    ],
)
def test_stale_or_missing_primary_uses_sole_geometry(
    widget: Any, factory: Any, primary: str | None, default: str
) -> None:
    result = widget(factory())._get_export_metadata(EmptyArgs())
    assert (
        result.primary_geometry_column,
        result.default_geometry_column,
    ) == (
        primary,
        default,
    )


@pytest.mark.requires("geopandas")
def test_ambiguous_geometry_has_no_default(widget: Any) -> None:
    import pandas as pd

    result = widget(
        pd.DataFrame(fixtures.gdf_multi_geometry())
    )._get_export_metadata(EmptyArgs())
    assert [column.name for column in result.geometry_columns] == [
        "geom_a",
        "geom_b",
    ]
    assert result.primary_geometry_column is None
    assert result.default_geometry_column is None
    assert result.formats["geojson"].available


@pytest.mark.requires("geopandas")
def test_old_geopandas_blocks_only_geoparquet(widget: Any) -> None:
    with patch.object(
        DependencyManager.geopandas, "get_version", return_value="0.14.0"
    ):
        result = widget(fixtures.gdf_multi_geometry())._get_export_metadata(
            EmptyArgs()
        )

    assert asdict(result.formats["parquet"]) == {
        "available": False,
        "reason": "Update geopandas to 0.14.1 or newer to export GeoParquet.",
        "missing_packages": [],
    }
    assert result.formats["geojson"].available


@pytest.mark.requires("geopandas")
def test_empty_name_can_be_the_source_primary(widget: Any) -> None:
    source = fixtures.gdf_multi_geometry().rename(columns={"geom_b": ""})
    source = source.set_geometry("")
    result = widget(source)._get_export_metadata(EmptyArgs())
    assert result.primary_geometry_column == ""
    assert result.default_geometry_column == ""
    assert result.formats["geojson"].available


@pytest.mark.requires("geopandas")
def test_empty_geometry_retains_unknown_crs(widget: Any) -> None:
    source = fixtures.gdf_all_null().head(0)
    result = widget(source)._get_export_metadata(EmptyArgs())
    assert [asdict(column) for column in result.geometry_columns] == [
        {"name": "geometry", "encoding": "objects", "crs": None},
    ]


@pytest.mark.requires("geopandas")
def test_missing_pyarrow_is_reported(widget: Any) -> None:
    subject = widget(fixtures.gdf_multi_geometry())
    with patch.object(DependencyManager.pyarrow, "has", return_value=False):
        result = subject._get_export_metadata(EmptyArgs())
    assert asdict(result.formats["parquet"]) == {
        "available": False,
        "reason": "GeoParquet export requires pyarrow.",
        "missing_packages": ["pyarrow"],
    }
    assert asdict(result.formats["geojson"]) == {
        "available": True,
        "reason": None,
        "missing_packages": [],
    }


@pytest.mark.requires("geopandas")
def test_missing_geopandas_is_reported(widget: Any) -> None:
    subject = widget(fixtures.gdf_multi_geometry())
    with patch.object(DependencyManager.geopandas, "has", return_value=False):
        result = subject._get_export_metadata(EmptyArgs())
    assert asdict(result.formats["parquet"]) == {
        "available": False,
        "reason": "This pandas table needs geopandas to export GeoParquet.",
        "missing_packages": ["geopandas"],
    }
    assert asdict(result.formats["geojson"]) == {
        "available": False,
        "reason": "This pandas table needs geopandas to export GeoJSON.",
        "missing_packages": ["geopandas"],
    }


@pytest.mark.requires("geopandas", "pyarrow")
@pytest.mark.parametrize(
    "factory", [fixtures.gdf_multi_geometry, fixtures.arrow_multi_geometry]
)
@pytest.mark.parametrize(
    ("format_name", "package", "method", "code", "missing_packages"),
    [
        ("parquet", "geopandas", "has", "missing_packages", ["geopandas"]),
        ("geojson", "geopandas", "has", "missing_packages", ["geopandas"]),
        ("parquet", "pyarrow", "has", "missing_packages", ["pyarrow"]),
        ("parquet", "geopandas", "has_at_version", "unsupported_version", []),
        ("geojson", "shapely", "has_at_version", "unsupported_version", []),
    ],
)
def test_metadata_and_download_share_prerequisites(
    widget: Any,
    factory: Any,
    format_name: Literal["parquet", "geojson"],
    package: str,
    method: str,
    code: str,
    missing_packages: list[str],
) -> None:
    subject = widget(factory())
    with patch.object(
        getattr(DependencyManager, package), method, return_value=False
    ):
        eligibility = subject._get_export_metadata(EmptyArgs()).formats[
            format_name
        ]
        response = subject._download_as(
            DownloadAsArgs(format=format_name, geometry_column="geom_a")
        )
    assert asdict(eligibility) == {
        "available": False,
        "reason": response.error,
        "missing_packages": missing_packages,
    }
    assert (response.url, response.code, response.missing_packages) == (
        "",
        code,
        missing_packages or None,
    )


@pytest.mark.requires("geopandas", "pyarrow")
@pytest.mark.parametrize(
    "factory", [fixtures.gdf_multi_geometry, fixtures.arrow_multi_geometry]
)
@pytest.mark.parametrize("format_name", ["parquet", "geojson"])
def test_package_installation_changes_eligibility_and_download(
    widget: Any, factory: Any, format_name: Literal["parquet", "geojson"]
) -> None:
    subject = widget(factory())
    with patch.object(DependencyManager.geopandas, "has", return_value=False):
        assert (
            not subject._get_export_metadata(EmptyArgs())
            .formats[format_name]
            .available
        )
        assert (
            subject._download_as(
                DownloadAsArgs(format=format_name, geometry_column="geom_a")
            ).code
            == "missing_packages"
        )
    assert (
        subject._get_export_metadata(EmptyArgs())
        .formats[format_name]
        .available
    )
    response = subject._download_as(
        DownloadAsArgs(format=format_name, geometry_column="geom_a")
    )
    assert response.url
    assert response.error is None


@pytest.mark.requires("geopandas", "pyarrow")
@pytest.mark.parametrize(
    "factory", [fixtures.gdf_multi_geometry, fixtures.arrow_multi_geometry]
)
@pytest.mark.parametrize("format_name", ["parquet", "geojson"])
def test_invalid_choice_precedes_missing_package(
    widget: Any, factory: Any, format_name: Literal["parquet", "geojson"]
) -> None:
    subject = widget(factory())
    with patch.object(DependencyManager.geopandas, "has", return_value=False):
        response = subject._download_as(
            DownloadAsArgs(format=format_name, geometry_column="missing")
        )
    assert (response.code, response.column, response.missing_packages) == (
        "invalid_geometry",
        "missing",
        None,
    )
    assert response.url == ""


@pytest.mark.requires("geopandas", "pyarrow")
@pytest.mark.parametrize("format_name", ["parquet", "geojson"])
def test_invalid_declaration_and_missing_package_keep_error_precedence(
    widget: Any, format_name: Literal["parquet", "geojson"]
) -> None:
    subject = widget(fixtures.arrow_malformed_metadata())
    with patch.object(DependencyManager.geopandas, "has", return_value=False):
        eligibility = subject._get_export_metadata(EmptyArgs()).formats[
            format_name
        ]
        response = subject._download_as(
            DownloadAsArgs(format=format_name, geometry_column="geom")
        )
    assert asdict(eligibility) == {
        "available": False,
        "reason": "Geometry column 'geom' has invalid GeoArrow metadata: expected a JSON object.",
        "missing_packages": [],
    }
    assert (response.url, response.code, response.missing_packages) == (
        "",
        "missing_packages",
        ["geopandas"],
    )
    response = subject._download_as(
        DownloadAsArgs(format=format_name, geometry_column="geom")
    )
    assert (response.url, response.code, response.error) == (
        "",
        "invalid_metadata",
        eligibility.reason,
    )


@pytest.mark.requires("geopandas", "pyarrow")
def test_old_shapely_disables_only_geojson(widget: Any) -> None:
    subject = widget(fixtures.gdf_multi_geometry())
    with patch.object(
        DependencyManager.shapely, "has_at_version", return_value=False
    ):
        result = subject._get_export_metadata(EmptyArgs())
    assert asdict(result.formats["geojson"]) == {
        "available": False,
        "reason": "Update shapely to 2.0 or newer to export GeoJSON.",
        "missing_packages": [],
    }
    assert result.formats["parquet"].available


@pytest.mark.requires("geopandas", "pyarrow")
def test_arrow_crs_comes_from_field_metadata(widget: Any) -> None:
    subject = widget(fixtures.arrow_wkb_known_crs())
    result = subject._get_export_metadata(EmptyArgs())
    assert [asdict(column) for column in result.geometry_columns] == [
        {"name": "geom", "encoding": "wkb", "crs": "EPSG:4326"},
    ]
    assert {name: asdict(value) for name, value in result.formats.items()} == {
        name: {"available": True, "reason": None, "missing_packages": []}
        for name in ("parquet", "geojson")
    }


@pytest.mark.requires("geopandas")
@pytest.mark.parametrize("empty", [False, True])
def test_geojson_support_does_not_depend_on_default_crs(
    widget: Any, empty: bool
) -> None:
    import geopandas as gpd  # type: ignore[import-untyped]

    source = fixtures.gdf_multi_geometry()
    source = gpd.GeoDataFrame(
        {
            "geom_a": gpd.GeoSeries(list(source["geom_a"])),
            "geom_b": source["geom_b"],
        },
        geometry="geom_a",
    )
    if empty:
        source = source.head(0)
    subject = widget(source)
    with patch.object(
        gpd.GeoSeries,
        "to_crs",
        side_effect=AssertionError("Metadata must not reproject geometry"),
    ):
        result = subject._get_export_metadata(EmptyArgs())
    assert result.default_geometry_column == "geom_a"
    assert [column.crs for column in result.geometry_columns] == [
        None,
        "EPSG:3857",
    ]
    assert result.formats["geojson"].available


@pytest.mark.requires("pandas")
def test_ordinary_metadata_needs_no_geospatial_packages(widget: Any) -> None:
    import pandas as pd

    subject = widget(pd.DataFrame({"geometry": ["POINT (1 2)"]}))
    with patch.object(DependencyManager.geopandas, "has", return_value=False):
        assert asdict(subject._get_export_metadata(EmptyArgs())) == {
            "geometry_columns": [],
            "primary_geometry_column": None,
            "default_geometry_column": None,
            "formats": {},
        }


@pytest.mark.requires("geopandas")
def test_table_metadata_includes_columns_outside_the_preview() -> None:
    subject = ui.table(
        fixtures.gdf_multi_geometry(),
        max_columns=1,
        hidden_columns=["geom_b"],
    )
    result = subject._get_export_metadata(EmptyArgs())
    assert [column.name for column in result.geometry_columns] == [
        "geom_a",
        "geom_b",
    ]


@pytest.mark.requires("geopandas")
def test_dataframe_metadata_follows_transformed_columns() -> None:
    subject = ui.dataframe(fixtures.gdf_multi_geometry())
    subject._update(
        {"transforms": [{"type": "select_columns", "column_ids": ["geom_b"]}]}
    )
    result = subject._get_export_metadata(EmptyArgs())
    assert [column.name for column in result.geometry_columns] == ["geom_b"]
    assert result.default_geometry_column == "geom_b"


@pytest.mark.parametrize(
    "payload",
    [
        {"format": "parquet"},
        {"format": "parquet", "geometry_column": "geom_b"},
        {"format": "csv", "options": {"separator": ";"}},
    ],
)
def test_download_request_accepts_optional_geometry(
    payload: dict[str, Any],
) -> None:
    parsed = parse_raw(payload, DownloadAsArgs)
    assert parsed.geometry_column == payload.get("geometry_column")
    assert parsed.format == payload["format"]


@pytest.mark.parametrize("geometry_column", [None, "geom_b", ""])
def test_geojson_request_uses_separate_contract(
    geometry_column: str | None,
) -> None:
    from marimo._plugins.ui._impl.table import DownloadGeoJSONArgs

    payload = {"format": "geojson", "geometry_column": geometry_column}
    parsed = parse_raw(payload, DownloadGeoJSONArgs)
    assert parsed.geometry_column == geometry_column
    assert parsed.format == "geojson"
    with pytest.raises(
        ValueError, match="does not fit any type of the literal"
    ):
        parse_raw(payload, DownloadAsArgs)


def test_download_response_accepts_missing_crs() -> None:
    parsed = parse_raw(
        {"code": "missing_crs", "column": "", "error": "Declare a CRS."},
        DownloadAsResponse,
    )
    assert parsed.code == "missing_crs"
    assert parsed.column == ""


@pytest.mark.requires("geopandas")
@pytest.mark.parametrize("request_format", ["parquet", "geojson"])
def test_widget_passes_geometry_request_to_export(
    widget: Any, request_format: Literal["parquet", "geojson"]
) -> None:
    subject = widget(fixtures.gdf_multi_geometry())
    module = (
        "marimo._plugins.ui._impl.table"
        if widget is ui.table
        else "marimo._plugins.ui._impl.dataframes.dataframe"
    )
    with patch(
        f"{module}.download_as",
        return_value=("data:test", f"test.{request_format}"),
    ) as export:
        response = subject._download_as(
            DownloadAsArgs(format=request_format, geometry_column="geom_b")
        )
    assert response.url == "data:test"
    assert export.call_args.kwargs["geometry_column"] == "geom_b"


@pytest.mark.requires("duckdb", "pyarrow", "geopandas")
@pytest.mark.parametrize("empty", [False, True])
def test_duckdb_export_metadata(
    duckdb_crs_conn: Any, widget: Any, empty: bool
) -> None:
    from pyproj import CRS

    conn = duckdb_crs_conn
    source = fixtures.duckdb_export_relation(conn)
    if empty:
        source = source.limit(0)
    subject = widget(source)
    with patch.object(
        NarwhalsTableManager,
        "as_frame",
        side_effect=AssertionError("must not collect"),
    ):
        result = subject._get_export_metadata(EmptyArgs())
    assert [c.name for c in result.geometry_columns] == [
        "geom",
        "alternate",
    ]
    assert CRS.from_user_input(
        result.geometry_columns[0].crs
    ) == CRS.from_user_input("OGC:CRS84")
    assert result.geometry_columns[1].crs is None
    assert result.default_geometry_column is None
    assert all(f.available for f in result.formats.values())


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

    from marimo._plugins.ui._impl.tables.geometry_export import (
        get_export_metadata,
    )
    from marimo._plugins.ui._impl.tables.utils import get_table_manager

    conn = fixtures.duckdb_crs_geometry_connection()
    calls = []

    def count(value: int) -> int:
        calls.append(value)
        return value

    try:
        conn.create_function(
            "count_rows",
            count,
            [duckdb.sqltypes.BIGINT],
            duckdb.sqltypes.BIGINT,
            side_effects=True,
        )
        source = conn.sql(
            "SELECT count_rows(i) AS id, NULL::GEOMETRY('OGC:CRS84') AS geom FROM range(100) t(i)"
        )
        manager = get_table_manager(source)
        result = get_export_metadata(manager)
        assert result.geometry_columns[0].crs is not None
        assert calls == []
    finally:
        conn.close()


@pytest.mark.requires("duckdb", "pyarrow")
@pytest.mark.parametrize("missing", ["geopandas", "pyarrow"])
def test_duckdb_missing_packages(
    duckdb_export_conn: Any, widget: Any, missing: str
) -> None:

    conn = duckdb_export_conn
    subject = widget(conn.sql("SELECT NULL::GEOMETRY AS geom"))
    with patch.object(
        getattr(DependencyManager, missing), "has", return_value=False
    ):
        result = subject._get_export_metadata(EmptyArgs())
    assert all(
        f.missing_packages == [missing] for f in result.formats.values()
    )
    assert result.geometry_columns[0].crs is None


@pytest.mark.requires("duckdb", "pyarrow", "geopandas")
def test_duckdb_fixed_layout_disables_both_formats(
    duckdb_spatial_conn: Any, widget: Any
) -> None:

    conn = duckdb_spatial_conn
    subject = widget(
        conn.sql(
            "SELECT ST_Point(1, 2) AS geom, {'x': 1.0, 'y': 2.0}::POINT_2D AS point"
        )
    )
    result = subject._get_export_metadata(EmptyArgs())
    assert [c.encoding for c in result.geometry_columns] == [
        "wkb",
        "other",
    ]
    assert all(
        not f.available and "POINT_2D" in (f.reason or "")
        for f in result.formats.values()
    )


@pytest.mark.requires("duckdb", "pyarrow")
def test_duckdb_binary_is_not_geometry(widget: Any) -> None:
    import duckdb

    conn = duckdb.connect()
    try:
        result = widget(
            conn.sql(
                "SELECT 'POINT (1 2)'::VARCHAR AS geometry, 'abc'::BLOB AS blob"
            )
        )._get_export_metadata(EmptyArgs())
        assert result.geometry_columns == []
        assert result.formats == {}
    finally:
        conn.close()