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.

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

from __future__ import annotations

import json
import re

import pytest

from marimo._plugins.ui._impl.tables.utils import get_table_manager
from tests._plugins.ui._impl.tables import geometry_fixtures as geo
from tests.mocks import snapshotter

snapshot = snapshotter(__file__)

_PANDAS_STRING_STORAGE = frozenset({"str", "object"})


def _assert_field_types(
    actual: list[tuple[str, tuple[str, str]]],
    expected: list[tuple[str, tuple[str, str]]],
) -> None:
    """Compare field types, allowing pandas 2/3 string storage names."""
    assert len(actual) == len(expected)
    for (name, (sem, ext)), (exp_name, (exp_sem, exp_ext)) in zip(
        actual, expected, strict=True
    ):
        assert name == exp_name
        assert sem == exp_sem
        if sem == "string" and {ext, exp_ext} <= _PANDAS_STRING_STORAGE:
            continue
        assert ext == exp_ext


def _normalize_pandas_string_storage(text: str) -> str:
    return re.sub(r'\["string",\s*"str"\]', '["string", "object"]', text)


@pytest.mark.requires("geopandas")
class TestGeoPandasCharacterization:
    def test_preserves_geodataframe_on_ingest(self) -> None:
        import geopandas as gpd

        manager = get_table_manager(geo.gdf_point_known_crs())
        native = manager.data.to_native()
        assert isinstance(native, gpd.GeoDataFrame)

    def test_geometry_column_types_geometry(self) -> None:
        manager = get_table_manager(geo.gdf_point_known_crs())
        _assert_field_types(
            manager.get_field_types(),
            [
                ("name", ("string", "str")),
                ("geometry", ("geometry", "geometry")),
            ],
        )

    @pytest.mark.parametrize(
        ("make_frame", "expected_field_types"),
        [
            (
                geo.gdf_point_missing_crs,
                [
                    ("name", ("string", "str")),
                    ("geometry", ("geometry", "geometry")),
                ],
            ),
            (
                geo.gdf_multi_geometry,
                [
                    ("geom_a", ("geometry", "geometry")),
                    ("geom_b", ("geometry", "geometry")),
                ],
            ),
            (
                geo.gdf_no_active_geometry,
                [
                    ("a", ("integer", "int64")),
                    ("g", ("geometry", "geometry")),
                ],
            ),
            (
                geo.gdf_stale_pointer,
                [
                    ("name", ("string", "str")),
                    ("geom", ("geometry", "geometry")),
                ],
            ),
            (
                geo.gdf_dropped_active,
                [("geom_b", ("geometry", "geometry"))],
            ),
            (
                geo.gdf_with_null,
                [
                    ("name", ("string", "str")),
                    ("geometry", ("geometry", "geometry")),
                ],
            ),
            (
                geo.gdf_all_null,
                [
                    ("name", ("string", "str")),
                    ("geometry", ("geometry", "geometry")),
                ],
            ),
            (
                geo.gdf_mixed_types,
                [
                    ("name", ("string", "str")),
                    ("geometry", ("geometry", "geometry")),
                ],
            ),
            (
                geo.gdf_3d,
                [
                    ("name", ("string", "str")),
                    ("geometry", ("geometry", "geometry")),
                ],
            ),
        ],
    )
    def test_corpus_loads_and_serializes(
        self, make_frame, expected_field_types
    ) -> None:
        manager = get_table_manager(make_frame())
        _assert_field_types(manager.get_field_types(), expected_field_types)
        assert isinstance(manager.to_json_str(), str)


@pytest.mark.requires("pyarrow")
class TestGeoArrowCharacterization:
    def test_wkb_types_geometry(self) -> None:
        manager = get_table_manager(geo.arrow_wkb_known_crs())
        assert dict(manager.get_field_types()) == {
            "a": ("integer", "Int64"),
            "geom": ("geometry", "geoarrow.wkb"),
        }

    def test_wkt_types_geometry(self) -> None:
        manager = get_table_manager(geo.arrow_wkt())
        assert dict(manager.get_field_types()) == {
            "a": ("integer", "Int64"),
            "geom": ("geometry", "geoarrow.wkt"),
        }

    @pytest.mark.parametrize(
        ("make_table", "expected_field_types"),
        [
            (
                geo.arrow_wkb_missing_crs,
                [
                    ("a", ("integer", "Int64")),
                    ("geom", ("geometry", "geoarrow.wkb")),
                ],
            ),
            (
                geo.arrow_ogc_wkb,
                [
                    ("a", ("integer", "Int64")),
                    ("geom", ("geometry", "ogc.wkb")),
                ],
            ),
            (
                geo.arrow_other_geoarrow,
                [
                    ("a", ("integer", "Int64")),
                    ("geom", ("geometry", "geoarrow.point")),
                ],
            ),
        ],
    )
    def test_corpus_loads_and_serializes(
        self, make_table, expected_field_types
    ) -> None:
        manager = get_table_manager(make_table())
        assert manager.get_field_types() == expected_field_types
        assert isinstance(manager.to_json_str(), str)


@pytest.mark.requires("duckdb", "polars")
class TestDuckDBCharacterization:
    def test_geometry_types_detected(self) -> None:
        conn = geo.duckdb_spatial_connection()
        try:
            relation = geo.duckdb_geometry_relation(conn)
            manager = get_table_manager(relation)
            field_types = dict(manager.get_field_types())
            assert field_types["a"][0] == "integer"
            assert field_types["geom"] == ("geometry", "GEOMETRY")
        finally:
            conn.close()


@pytest.mark.requires("ibis")
class TestIbisCharacterization:
    def test_geometry_types_unknown(self) -> None:
        table = geo.ibis_geometry_table()
        manager = get_table_manager(table)
        field_types = dict(manager.get_field_types())
        assert field_types["a"][0] == "integer"
        assert field_types["geom"] == ("unknown", "geospatial:geometry")


class TestFalsePositiveBaselines:
    """False-positive baselines for geometry detection regressions.

    If one changes, either detection behavior regressed or a serialization
    fix changed baseline output and should be called out in the PR.
    """

    @pytest.mark.requires("pandas")
    def test_pandas(self) -> None:
        import pandas as pd

        manager = get_table_manager(pd.DataFrame(geo.false_positive_data()))
        snapshot(
            "false_positives.pandas.field_types.json",
            _normalize_pandas_string_storage(
                json.dumps(manager.get_field_types())
            ),
        )
        snapshot(
            "false_positives.pandas.json",
            manager.to_json_str(strict_json=True),
        )

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

        manager = get_table_manager(
            pl.DataFrame(geo.false_positive_data(), strict=False)
        )
        snapshot(
            "false_positives.polars.field_types.json",
            json.dumps(manager.get_field_types()),
        )
        snapshot("false_positives.polars.json", manager.to_json_str())

    @pytest.mark.requires("pyarrow")
    def test_pyarrow(self) -> None:
        import pyarrow as pa

        manager = get_table_manager(
            pa.Table.from_pydict(geo.false_positive_data())
        )
        snapshot(
            "false_positives.pyarrow.field_types.json",
            json.dumps(manager.get_field_types()),
        )
        snapshot("false_positives.pyarrow.json", manager.to_json_str())

    @pytest.mark.requires("geopandas")
    def test_shapely_objects_in_plain_column(self) -> None:
        manager = get_table_manager(geo.pandas_shapely_object_column())
        snapshot(
            "false_positives.shapely_objects.field_types.json",
            json.dumps(manager.get_field_types()),
        )


class TestOrdinaryBaselines:
    """Ordinary-table payload baselines for backends without one."""

    @pytest.mark.requires("pyarrow")
    def test_pyarrow(self) -> None:
        import pyarrow as pa

        manager = get_table_manager(pa.Table.from_pydict(geo.ordinary_data()))
        snapshot(
            "ordinary.pyarrow.field_types.json",
            json.dumps(manager.get_field_types()),
        )
        snapshot("ordinary.pyarrow.json", manager.to_json_str())

    @pytest.mark.requires("duckdb", "polars")
    def test_duckdb(self) -> None:
        import duckdb
        import polars as pl

        frame = pl.DataFrame(geo.ordinary_data())
        relation = duckdb.sql("SELECT * FROM frame")
        manager = get_table_manager(relation)
        snapshot(
            "ordinary.duckdb.field_types.json",
            json.dumps(manager.get_field_types()),
        )
        snapshot("ordinary.duckdb.json", manager.to_json_str())