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
feat: add GeoPandas geometry table support (#10536)
Kiran Gadhave205fa161fc71
diff --git a/frontend/src/components/data-table/__tests__/column_formatting.test.ts b/frontend/src/components/data-table/__tests__/column_formatting.test.tsindex f3131d45c3..d7cd6fe5d1 100644--- a/frontend/src/components/data-table/__tests__/column_formatting.test.ts+++ b/frontend/src/components/data-table/__tests__/column_formatting.test.ts@@ -5,6 +5,7 @@ import {prettyScientificNumber,} from "@/utils/numbers";import { applyFormat } from "../column-formatting/feature";+import { formatOptions } from "../column-formatting/types";const locale = "en-US";@@ -128,3 +129,9 @@ describe("applyFormat", () => {).toBe(123);});});++describe("formatOptions", () => {+ it("has no geometry format options", () => {+ expect(formatOptions.geometry).toEqual([]);+ });+});diff --git a/frontend/src/components/data-table/charts/__tests__/schemas.test.ts b/frontend/src/components/data-table/charts/__tests__/schemas.test.tsindex c2ade19f7e..0a06e563a9 100644--- a/frontend/src/components/data-table/charts/__tests__/schemas.test.ts+++ b/frontend/src/components/data-table/charts/__tests__/schemas.test.ts@@ -14,7 +14,7 @@ describe("ChartSchema", () => {it("normalizes an unrecognized axis column type", () => {const result = ChartSchema.parse({- general: { xColumn: { field: "geom", type: "geometry" } },+ general: { xColumn: { field: "geom", type: "bogus_type" } },});expect(result.general?.xColumn?.type).toBe("unknown");@@ -24,7 +24,7 @@ describe("ChartSchema", () => {const result = ChartSchema.parse({tooltips: {auto: false,- fields: [{ field: "geom", type: "geometry" }],+ fields: [{ field: "geom", type: "bogus_type" }],},});@@ -32,4 +32,19 @@ describe("ChartSchema", () => {{ field: "geom", type: "unknown" },]);});++ it("keeps geometry axis and tooltip field types", () => {+ const result = ChartSchema.parse({+ general: { xColumn: { field: "geom", type: "geometry" } },+ tooltips: {+ auto: false,+ fields: [{ field: "geom", type: "geometry" }],+ },+ });++ expect(result.general?.xColumn?.type).toBe("geometry");+ expect(result.tooltips?.fields).toEqual([+ { field: "geom", type: "geometry" },+ ]);+ });});diff --git a/frontend/src/components/data-table/charts/chart-spec/types.ts b/frontend/src/components/data-table/charts/chart-spec/types.tsindex 74c5005e5b..44c45f8655 100644--- a/frontend/src/components/data-table/charts/chart-spec/types.ts+++ b/frontend/src/components/data-table/charts/chart-spec/types.ts@@ -29,6 +29,7 @@ export function convertDataTypeToVega(return "quantitative";case "string":case "boolean":+ case "geometry":case "unknown":return "nominal";case "date":@@ -51,6 +52,7 @@ export function convertDataTypeToSelectable(return "number";case "string":case "boolean":+ case "geometry":case "unknown":return "string";case "date":diff --git a/frontend/src/components/data-table/column-formatting/feature.ts b/frontend/src/components/data-table/column-formatting/feature.tsindex 1de51ee5e4..e647cff3f0 100644--- a/frontend/src/components/data-table/column-formatting/feature.ts+++ b/frontend/src/components/data-table/column-formatting/feature.ts@@ -214,6 +214,7 @@ export const applyFormat = (return value;}case undefined:+ case "geometry":case "unknown":return value;default:diff --git a/frontend/src/components/data-table/column-formatting/types.ts b/frontend/src/components/data-table/column-formatting/types.tsindex 3dc46c2c11..e6aefb2f19 100644--- a/frontend/src/components/data-table/column-formatting/types.ts+++ b/frontend/src/components/data-table/column-formatting/types.ts@@ -13,6 +13,7 @@ export const formatOptions = {number: ["Auto", "Percent", "Scientific", "Engineering", "Integer"],string: ["Uppercase", "Lowercase", "Capitalize", "Title"],boolean: ["Yes/No", "On/Off"],+ geometry: [],unknown: [],} as const satisfies Record<DataType, string[]>;diff --git a/frontend/src/components/data-table/column-summary/chart-spec-model.tsx b/frontend/src/components/data-table/column-summary/chart-spec-model.tsxindex 659baf622e..1819347310 100644--- a/frontend/src/components/data-table/column-summary/chart-spec-model.tsx+++ b/frontend/src/components/data-table/column-summary/chart-spec-model.tsx@@ -836,6 +836,7 @@ export class ColumnChartSpecModel<T> {transform: transforms,};}+ case "geometry":case "unknown":return null;default:diff --git a/frontend/src/components/data-table/column-summary/column-summary.tsx b/frontend/src/components/data-table/column-summary/column-summary.tsxindex bdb8f03689..d0936bbd61 100644--- a/frontend/src/components/data-table/column-summary/column-summary.tsx+++ b/frontend/src/components/data-table/column-summary/column-summary.tsx@@ -155,6 +155,7 @@ export const TableColumnSummary = <TData, TValue>({);}return null;+ case "geometry":case "unknown":return (<div className="flex flex-col whitespace-pre">diff --git a/frontend/src/components/data-table/columns.tsx b/frontend/src/components/data-table/columns.tsxindex 4abbe302ad..783d776579 100644--- a/frontend/src/components/data-table/columns.tsx+++ b/frontend/src/components/data-table/columns.tsx@@ -320,9 +320,8 @@ export function generateColumns<T>({},// Remove any default filteringfilterFn: undefined,- // Can only sort if key is defined- // For example, unnamed index columns, won't be sortable- enableSorting: !!key,+ // Unnamed index columns and geometry columns are not sortable+ enableSorting: !!key && getMeta(key).dataType !== "geometry",meta: {...getMeta(key),width: columnWidths?.[key],@@ -485,6 +484,8 @@ function getFilterTypeForFieldType(return "time";case "boolean":return "boolean";+ case "geometry":+ return undefined;default:return undefined;}diff --git a/frontend/src/components/datasets/__tests__/icons.test.ts b/frontend/src/components/datasets/__tests__/icons.test.tsindex 23b89f0de3..84cd649bee 100644--- a/frontend/src/components/datasets/__tests__/icons.test.ts+++ b/frontend/src/components/datasets/__tests__/icons.test.ts@@ -2,7 +2,7 @@import { describe, expect, it } from "vitest";import type { DataType } from "@/core/kernel/messages";-import { DATA_TYPE_ICON, resolveDataType } from "../icons";+import { DATA_TYPE_ICON, getDataTypeColor, resolveDataType } from "../icons";describe("resolveDataType", () => {it("passes through every mapped data type", () => {@@ -12,7 +12,15 @@ describe("resolveDataType", () => {});it("resolves unmapped data types to unknown", () => {- expect(resolveDataType("geometry" as DataType)).toBe("unknown");+ expect(resolveDataType("bogus_type" as DataType)).toBe("unknown");+ });++ it("resolves geometry with its icon and color", () => {+ expect(resolveDataType("geometry")).toBe("geometry");+ expect(DATA_TYPE_ICON.geometry).toBeDefined();+ expect(getDataTypeColor("geometry")).toBe(+ "bg-(--cyan-4) dark:bg-(--cyan-5)",+ );});it("resolves data types shadowing Object.prototype keys to unknown", () => {diff --git a/frontend/src/components/datasets/icons.tsx b/frontend/src/components/datasets/icons.tsxindex 0d985e315d..4af109dfe7 100644--- a/frontend/src/components/datasets/icons.tsx+++ b/frontend/src/components/datasets/icons.tsx@@ -7,6 +7,7 @@ import {CurlyBracesIcon,HashIcon,type LucideIcon,+ MapPinIcon,ToggleLeftIcon,TypeIcon,} from "lucide-react";@@ -27,6 +28,7 @@ export const DATA_TYPE_ICON: Record<DataType | SelectableDataType, LucideIcon> =number: HashIcon,string: TypeIcon,integer: HashIcon,+ geometry: MapPinIcon,unknown: CurlyBracesIcon,};@@ -56,6 +58,8 @@ export function getDataTypeColor(return "bg-(--purple-4)";case "string":return "bg-(--blue-4)";+ case "geometry":+ return "bg-(--cyan-4) dark:bg-(--cyan-5)";case "unknown":return "bg-(--slate-4) dark:bg-(--slate-6)";default:diff --git a/frontend/src/components/datasources/__tests__/components.test.tsx b/frontend/src/components/datasources/__tests__/components.test.tsxindex 3d000665f7..13a9acf7fd 100644--- a/frontend/src/components/datasources/__tests__/components.test.tsx+++ b/frontend/src/components/datasources/__tests__/components.test.tsx@@ -12,7 +12,7 @@ describe("ColumnName", () => {try {const unrecognized = render(- <ColumnName columnName="geom" dataType={"geometry" as DataType} />,+ <ColumnName columnName="geom" dataType={"bogus_type" as DataType} />,);const unknown = render(<ColumnName columnName="geom" dataType="unknown" />,@@ -26,4 +26,17 @@ describe("ColumnName", () => {warn.mockRestore();}});++ it("renders geometry with a distinct icon", () => {+ const geometry = render(+ <ColumnName columnName="geom" dataType="geometry" />,+ );+ const unknown = render(<ColumnName columnName="geom" dataType="unknown" />);++ expect(geometry.container.querySelector(".lucide-map-pin")).not.toBeNull();+ expect(unknown.container.querySelector(".lucide-braces")).not.toBeNull();+ expect(geometry.container.innerHTML).not.toEqual(+ unknown.container.innerHTML,+ );+ });});diff --git a/frontend/src/core/codemirror/language/languages/sql/__tests__/renderers.test.tsx b/frontend/src/core/codemirror/language/languages/sql/__tests__/renderers.test.tsxindex ba51baa5c7..0cf98dba55 100644--- a/frontend/src/core/codemirror/language/languages/sql/__tests__/renderers.test.tsx+++ b/frontend/src/core/codemirror/language/languages/sql/__tests__/renderers.test.tsx@@ -9,13 +9,18 @@ import type {} from "@/core/kernel/messages";import { renderColumnInfo, renderTableInfo } from "../renderers";-const geometryColumn = {+const bogusColumn = {name: "geom",- type: "geometry" as DataType,+ type: "bogus_type" as DataType,external_type: "geometry",sample_values: [],} as DataTableColumn;+const geometryColumn = {+ ...bogusColumn,+ type: "geometry" as DataType,+} as DataTableColumn;+describe("SQL renderers", () => {it("renders table information with an unrecognized column type", () => {const table: DataTable = {@@ -26,7 +31,7 @@ describe("SQL renderers", () => {num_rows: null,num_columns: 1,variable_name: null,- columns: [geometryColumn],+ columns: [bogusColumn],primary_keys: [],indexes: [],};@@ -37,8 +42,14 @@ describe("SQL renderers", () => {});it("renders column information with an unrecognized column type", () => {- const result = render(renderColumnInfo(geometryColumn));+ const result = render(renderColumnInfo(bogusColumn));expect(result.container.querySelector("svg")).not.toBeNull();});++ it("renders geometry column information with the map pin icon", () => {+ const result = render(renderColumnInfo(geometryColumn));++ expect(result.container.querySelector(".lucide-map-pin")).not.toBeNull();+ });});diff --git a/frontend/src/core/codemirror/language/languages/sql/renderers.tsx b/frontend/src/core/codemirror/language/languages/sql/renderers.tsxindex beeed4667d..4a9d647009 100644--- a/frontend/src/core/codemirror/language/languages/sql/renderers.tsx+++ b/frontend/src/core/codemirror/language/languages/sql/renderers.tsx@@ -41,6 +41,7 @@ const DATA_TYPE_COLORS: Record<DataType, string> = {number: "bg-(--purple-4) text-(--purple-11)",integer: "bg-(--purple-4) text-(--purple-11)",string: "bg-(--blue-4) text-(--blue-11)",+ geometry: "bg-(--cyan-4) text-(--cyan-11)",unknown: "bg-(--slate-4) text-(--slate-11)",};diff --git a/frontend/src/core/kernel/messages.ts b/frontend/src/core/kernel/messages.tsindex 653db1dff0..e0a1c1e903 100644--- a/frontend/src/core/kernel/messages.ts+++ b/frontend/src/core/kernel/messages.ts@@ -11,6 +11,7 @@ export const DATA_TYPES = ["date","datetime","time",+ "geometry","unknown",] as const;export type ModelLifecycle = NotificationMessageData<"model-lifecycle">;diff --git a/frontend/src/plugins/impl/__tests__/DataEditorPlugin.test.ts b/frontend/src/plugins/impl/__tests__/DataEditorPlugin.test.tsindex 2d7642c23b..3b773d1368 100644--- a/frontend/src/plugins/impl/__tests__/DataEditorPlugin.test.ts+++ b/frontend/src/plugins/impl/__tests__/DataEditorPlugin.test.ts@@ -9,10 +9,22 @@ describe("DataEditorPlugin", () => {initialValue: { edits: [] },label: null,data: [],- fieldTypes: [["geom", ["geometry", "geometry"]]],+ fieldTypes: [["geom", ["bogus_type", "geometry"]]],editableColumns: "all",});expect(result.fieldTypes).toEqual([["geom", ["unknown", "geometry"]]]);});++ it("keeps the geometry field type", () => {+ const result = DataEditorPlugin.validator.parse({+ initialValue: { edits: [] },+ label: null,+ data: [],+ fieldTypes: [["geom", ["geometry", "geometry"]]],+ editableColumns: "all",+ });++ expect(result.fieldTypes).toEqual([["geom", ["geometry", "geometry"]]]);+ });});diff --git a/frontend/src/plugins/impl/data-editor/glide-data-editor.tsx b/frontend/src/plugins/impl/data-editor/glide-data-editor.tsxindex c88a46f9fc..902ac95e17 100644--- a/frontend/src/plugins/impl/data-editor/glide-data-editor.tsx+++ b/frontend/src/plugins/impl/data-editor/glide-data-editor.tsx@@ -390,6 +390,7 @@ export const GlideDataEditor = <T,>({// TODO: Handle specific typesreturn [column.title, new Date()];case "string":+ case "geometry":case "unknown":return [column.title, ""];default:diff --git a/frontend/src/plugins/impl/data-editor/glide-utils.ts b/frontend/src/plugins/impl/data-editor/glide-utils.tsindex 55d386f5c5..36696d8901 100644--- a/frontend/src/plugins/impl/data-editor/glide-utils.ts+++ b/frontend/src/plugins/impl/data-editor/glide-utils.ts@@ -43,6 +43,7 @@ export function getColumnHeaderIcon(fieldType: DataType): GridColumnIcon {return GridColumnIcon.HeaderDate;case "time":return GridColumnIcon.HeaderTime;+ case "geometry":case "unknown":return GridColumnIcon.HeaderString;default:diff --git a/frontend/src/plugins/impl/data-frames/__tests__/schema.test.ts b/frontend/src/plugins/impl/data-frames/__tests__/schema.test.tsindex ae16968253..8f519775fc 100644--- a/frontend/src/plugins/impl/data-frames/__tests__/schema.test.ts+++ b/frontend/src/plugins/impl/data-frames/__tests__/schema.test.ts@@ -18,7 +18,7 @@ describe("columnToFieldTypesSchema", () => {it("normalizes an unrecognized field type without discarding other fields", () => {const result = columnToFieldTypesSchema.parse([- ["geom", ["geometry", "geometry"]],+ ["geom", ["bogus_type", "geometry"]],["label", ["string", "object"]],]);@@ -27,4 +27,12 @@ describe("columnToFieldTypesSchema", () => {["label", ["string", "object"]],]);});++ it("keeps the geometry field type", () => {+ const result = columnToFieldTypesSchema.parse([+ ["geom", ["geometry", "geometry"]],+ ]);++ expect(result).toEqual([["geom", ["geometry", "geometry"]]]);+ });});diff --git a/frontend/src/plugins/impl/data-frames/utils/__tests__/operators.test.ts b/frontend/src/plugins/impl/data-frames/utils/__tests__/operators.test.tsindex f896549d8b..814325a2e1 100644--- a/frontend/src/plugins/impl/data-frames/utils/__tests__/operators.test.ts+++ b/frontend/src/plugins/impl/data-frames/utils/__tests__/operators.test.ts@@ -60,6 +60,10 @@ describe("getOperatorForDtype", () => {it("should return empty array for unknown dtype", () => {expect(getOperatorForDtype("unknown")).toEqual([]);});++ it("should return no operators for geometry", () => {+ expect(getOperatorForDtype("geometry")).toEqual([]);+ });});describe("getSchemaForOperator", () => {@@ -87,6 +91,10 @@ describe("getSchemaForOperator", () => {expect(getSchemaForOperator("unknown", "==")).toEqual([]);expect(getSchemaForOperator("int", "unknown")).toEqual([]);});++ it("should return no operand schema for geometry", () => {+ expect(getSchemaForOperator("geometry", "==")).toEqual([]);+ });});describe("isConditionValueValid", () => {diff --git a/frontend/src/plugins/impl/data-frames/utils/operators.ts b/frontend/src/plugins/impl/data-frames/utils/operators.tsindex de49348503..0f140257a4 100644--- a/frontend/src/plugins/impl/data-frames/utils/operators.ts+++ b/frontend/src/plugins/impl/data-frames/utils/operators.ts@@ -76,7 +76,7 @@ export const ALL_OPERATORS = {export type OperatorType = keyof typeof ALL_OPERATORS;-function numpyTypeToDataType(type: string): DataType {+function numpyTypeToDataType(type: string): Exclude<DataType, "geometry"> {if (!type) {return "unknown";}diff --git a/frontend/src/plugins/impl/vega/__tests__/vega.test.ts b/frontend/src/plugins/impl/vega/__tests__/vega.test.tsindex c0cf76b3c4..0ba000d477 100644--- a/frontend/src/plugins/impl/vega/__tests__/vega.test.ts+++ b/frontend/src/plugins/impl/vega/__tests__/vega.test.ts@@ -7,6 +7,7 @@ import {vegaLoadData,vegaLoader,} from "../loader";+import { getVegaFieldTypes } from "../utils";const { ZERO_WIDTH_SPACE, replacePeriodsInColumnNames, uniquifyColumnNames } =exportedForTesting;@@ -102,15 +103,32 @@ yield_error,yield_center`);});- it.each(DATA_TYPES)("should handle %s data-type", async (type) => {- const csvData = "name,value_column\nAlice,1";+ it.each(DATA_TYPES.filter((type) => type !== "geometry"))(+ "should handle %s data-type",+ async (type) => {+ const csvData = "name,value_column\nAlice,1";+ vi.spyOn(vegaLoader, "load").mockReturnValue(Promise.resolve(csvData));++ const result = await vegaLoadData(csvData, {+ type: "csv",+ parse: { value_column: type },+ });+ expect(result.length).toEqual(1);+ },+ );++ it("should parse geometry as a WKT string", async () => {+ const csvData = "name,value_column\nAlice,POINT (0 0)";vi.spyOn(vegaLoader, "load").mockReturnValue(Promise.resolve(csvData));+ const fieldTypes = getVegaFieldTypes({ value_column: "geometry" });+ expect(fieldTypes).toEqual({ value_column: "string" });+const result = await vegaLoadData(csvData, {type: "csv",- parse: { value_column: type },+ parse: fieldTypes,});- expect(result.length).toEqual(1);+ expect(result).toEqual([{ name: "Alice", value_column: "POINT (0 0)" }]);});it("should parse csv data with out of bound integers", async () => {diff --git a/frontend/src/plugins/impl/vega/utils.ts b/frontend/src/plugins/impl/vega/utils.tsindex ecc927d42d..cc9d087fb9 100644--- a/frontend/src/plugins/impl/vega/utils.ts+++ b/frontend/src/plugins/impl/vega/utils.ts@@ -55,6 +55,9 @@ export function getVegaFieldTypes(// the correct formatting. For example, a date like '2024-01-01' will// be formatted to '2024-01-01T00:00:00.000Z'.return Objects.mapValues(types, (type): VegaDataType => {+ if (type === "geometry") {+ return "string";+ }if (type === "date") {return "string";}diff --git a/marimo/_data/charts.py b/marimo/_data/charts.pyindex 84df32e923..011b216fee 100644--- a/marimo/_data/charts.py+++ b/marimo/_data/charts.py@@ -832,7 +832,7 @@ def get_chart_builder(return WrapperChartBuilder(BooleanChartBuilder())if column_type == "integer":return WrapperChartBuilder(IntegerChartBuilder())- if column_type == "unknown":+ if column_type == "unknown" or column_type == "geometry":return WrapperChartBuilder(UnknownChartBuilder())assert_never(column_type)diff --git a/marimo/_data/get_datasets.py b/marimo/_data/get_datasets.pyindex 7b0f5555fd..7b673fdbd6 100644--- a/marimo/_data/get_datasets.py+++ b/marimo/_data/get_datasets.py@@ -519,9 +519,15 @@ _STRING_TYPES = {_TIME_TYPES = {"time", "time with time zone", "timetz"}_DATETIME_TYPES = {"datetime", "interval"}_BINARY_TYPES = {"bit", "bitstring", "binary", "varbinary", "bytea"}+_GEOMETRY_TYPES = {+ "geometry",+ "point_2d",+ "linestring_2d",+ "polygon_2d",+ "box_2d",+}_UNKNOWN_TYPES = {"row",- "geometry","inet",# Null type (can occur when attaching databases or with unknown column types)"null",@@ -565,6 +571,10 @@ def _db_type_to_data_type(db_type: str) -> DataType:if db_type == "enum" or db_type.startswith("enum"):return "string"+ # Spatial extension types+ if db_type in _GEOMETRY_TYPES:+ return "geometry"+# Nested typesif db_type.startswith(("union", "map", "struct", "list", "array", "json")diff --git a/marimo/_data/models.py b/marimo/_data/models.pyindex 2b5aab5e21..0ad82c3f21 100644--- a/marimo/_data/models.py+++ b/marimo/_data/models.py@@ -17,6 +17,7 @@ DataType = Literal["date","datetime","time",+ "geometry","unknown",]# This is the data type based on the source librarydiff --git a/marimo/_data/preview_column.py b/marimo/_data/preview_column.pyindex 26f28bb523..1786b870d6 100644--- a/marimo/_data/preview_column.py+++ b/marimo/_data/preview_column.py@@ -236,8 +236,9 @@ def _get_altair_chart((column_type, _external_type) = table.get_field_type(column_name)# Nested/unknown dtypes (e.g. Polars Struct/List) can't be serialized- # through the dataframe interchange path, so skip charting silently- if column_type == "unknown":+ # through the dataframe interchange path, so skip charting silently.+ # Geometry columns get no chart either.+ if column_type in ("unknown", "geometry"):return None, None, None, Noneif stats.total == 0:diff --git a/marimo/_data/sql_summaries.py b/marimo/_data/sql_summaries.pyindex d23ec26c2e..b7c7f63fab 100644--- a/marimo/_data/sql_summaries.py+++ b/marimo/_data/sql_summaries.py@@ -56,6 +56,13 @@ def get_sql_stats(SUM(CASE WHEN "{column_name}" = FALSE THEN 1 ELSE 0 END) as false_countFROM {table_name}"""+ elif column_type == "geometry":+ stats_query = f"""+ SELECT+ COUNT(*) as count,+ SUM(CASE WHEN "{column_name}" IS NULL THEN 1 ELSE 0 END) as null_count+ FROM {table_name}+ """else:stats_query = f"""SELECT@@ -124,6 +131,9 @@ def get_sql_stats(true=true_count,false=false_count,)+ elif column_type == "geometry":+ count, null_count = stats_result+ return ColumnStats(total=count, nulls=null_count)else:count, unique, null_count = stats_resultreturn ColumnStats(total=count, unique=unique, nulls=null_count)diff --git a/marimo/_dependencies/dependencies.py b/marimo/_dependencies/dependencies.pyindex 07f002a577..7881966650 100644--- a/marimo/_dependencies/dependencies.py+++ b/marimo/_dependencies/dependencies.py@@ -245,6 +245,7 @@ class DependencyManager:ruff = Dependency("ruff")black = Dependency("black")geopandas = Dependency("geopandas")+ shapely = Dependency("shapely")pint = Dependency("pint")opentelemetry = Dependency("opentelemetry")anthropic = Dependency("anthropic")diff --git a/marimo/_messaging/msgspec_encoder.py b/marimo/_messaging/msgspec_encoder.pyindex 696c49776d..6abe7c41c0 100644--- a/marimo/_messaging/msgspec_encoder.py+++ b/marimo/_messaging/msgspec_encoder.py@@ -128,8 +128,8 @@ def enc_hook(obj: Any) -> Any:):return str(obj)- # Handle shapely geometry objects from geopandas- if DependencyManager.geopandas.imported():+ # Handle shapely geometry objects+ if DependencyManager.shapely.imported():try:# Check if it's a shapely geometry object# shapely.geometry.base.BaseGeometry is the base classdiff --git a/marimo/_plugins/ui/_impl/table.py b/marimo/_plugins/ui/_impl/table.pyindex 018c532919..b9b70801e3 100644--- a/marimo/_plugins/ui/_impl/table.py+++ b/marimo/_plugins/ui/_impl/table.py@@ -313,6 +313,12 @@ def _filter_valid_columns(if isinstance(child, FilterCondition):if child.column_id not in column_dtypes:continue+ if column_dtypes[child.column_id] == "geometry":+ LOGGER.warning(+ "Ignoring filter on geometry column '%s'",+ child.column_id,+ )+ continuecategory = _DATATYPE_TO_CATEGORY.get(column_dtypes[child.column_id], "")@@ -1191,8 +1197,9 @@ class table((column_type, external_type) = self._manager.get_field_type(column)- # For boolean columns, we can drop the column since we use stats- if column_type == "boolean" or column_type == "unknown":+ # Boolean columns render from stats; unknown and geometry+ # columns get no chart.+ if column_type in ("boolean", "unknown", "geometry"):cols_to_drop.append(column)# Handle columns with all nulls first@@ -1427,7 +1434,18 @@ class table(if sort:existing_columns = set(result.get_column_names())- valid_sort = [s for s in sort if s.by in existing_columns]+ field_types = dict(result.get_field_types())+ valid_sort: list[SortArgs] = []+ for sort_arg in sort:+ if sort_arg.by not in existing_columns:+ continue+ field_type = field_types.get(sort_arg.by)+ if field_type is not None and field_type[0] == "geometry":+ LOGGER.warning(+ "Ignoring sort on geometry column '%s'", sort_arg.by+ )+ continue+ valid_sort.append(sort_arg)if valid_sort:result = result.sort_values(valid_sort)diff --git a/marimo/_plugins/ui/_impl/tables/geometry.py b/marimo/_plugins/ui/_impl/tables/geometry.pynew file mode 100644index 0000000000..0fb889e37e--- /dev/null+++ b/marimo/_plugins/ui/_impl/tables/geometry.py@@ -0,0 +1,146 @@+# Copyright 2026 Marimo. All rights reserved.+from __future__ import annotations++from dataclasses import dataclass+from typing import TYPE_CHECKING, Any, Literal++from marimo import _loggers++if TYPE_CHECKING:+ import duckdb+ import narwhals.stable.v2 as nw+ import pandas as pd+ import pyarrow as pa++LOGGER = _loggers.marimo_logger()++GeometryEncoding = Literal["objects", "wkb", "wkt", "other"]++GEOMETRY_CELL_CAP = 512+++@dataclass(frozen=True)+class GeometryColumnInfo:+ """How a detected geometry column stores its values.++ Args:+ encoding (GeometryEncoding): The value encoding. The value is+ `objects` for shapely scalars, `wkb` for WKB bytes, `wkt` for WKT+ strings, or `other` for typing-only detection.+ external_type (str): The native type string that users see.+ """++ encoding: GeometryEncoding+ external_type: str+++def find_geometry_columns(+ frame: nw.DataFrame[Any] | nw.LazyFrame[Any],+) -> dict[str, GeometryColumnInfo]:+ """Detect geometry columns from the declared schema of a frame.++ This function returns an empty map if detection fails. A detection error+ must not prevent an ordinary table from loading.+ """+ try:+ if frame.implementation.is_pandas():+ return _pandas_geometry_columns(frame.to_native())+ if frame.implementation.is_pyarrow():+ return _pyarrow_geometry_columns(frame.to_native())+ if frame.implementation.is_duckdb():+ return _duckdb_geometry_columns(frame.to_native())+ except Exception as e:+ LOGGER.debug("Geometry detection failed: %s", e)+ return {}+++def _pandas_geometry_columns(+ native: pd.DataFrame,+) -> dict[str, GeometryColumnInfo]:+ infos: dict[str, GeometryColumnInfo] = {}+ for name, dtype in native.dtypes.items():+ if str(dtype) == "geometry":+ infos[str(name)] = GeometryColumnInfo(+ encoding="objects", external_type="geometry"+ )+ return infos+++# GeoArrow stores its type name in each field's ARROW:extension:name metadata.+_WKB_EXTENSION_NAMES = ("geoarrow.wkb", "ogc.wkb")+_WKT_EXTENSION_NAME = "geoarrow.wkt"+_GEOARROW_PREFIX = "geoarrow."+# DuckDB spatial type names used for schema-only geometry detection.+_DUCKDB_WKB_TYPE = "GEOMETRY"+_DUCKDB_2D_TYPES = frozenset(+ {"POINT_2D", "LINESTRING_2D", "POLYGON_2D", "BOX_2D"}+)+++def _pyarrow_geometry_columns(+ native: pa.Table,+) -> dict[str, GeometryColumnInfo]:+ """Detect geometry columns from pyarrow field metadata only."""+ infos: dict[str, GeometryColumnInfo] = {}+ for field in native.schema:+ metadata = field.metadata+ if not metadata:+ continue+ raw_name = metadata.get(b"ARROW:extension:name")+ if raw_name is None:+ continue+ extension_name = raw_name.decode()+ encoding: GeometryEncoding+ if extension_name in _WKB_EXTENSION_NAMES:+ encoding = "wkb"+ elif extension_name == _WKT_EXTENSION_NAME:+ encoding = "wkt"+ elif extension_name.startswith(_GEOARROW_PREFIX):+ # Other geoarrow.* types (e.g. point) are geometry for typing only.+ encoding = "other"+ else:+ # Non-geo Arrow extensions (e.g. arrow.uuid) stay ordinary columns.+ continue+ infos[field.name] = GeometryColumnInfo(+ encoding=encoding, external_type=extension_name+ )+ return infos+++def _duckdb_geometry_columns(+ native: duckdb.DuckDBPyRelation,+) -> dict[str, GeometryColumnInfo]:+ """Detect geometry columns from declared relation types."""+ infos: dict[str, GeometryColumnInfo] = {}+ for name, dtype in zip(native.columns, native.types, strict=False):+ type_name = str(dtype)+ if type_name == _DUCKDB_WKB_TYPE:+ infos[name] = GeometryColumnInfo(+ encoding="wkb", external_type=type_name+ )+ elif type_name in _DUCKDB_2D_TYPES:+ infos[name] = GeometryColumnInfo(+ encoding="other", external_type=type_name+ )+ return infos+++def format_geometry_cell(value: Any, encoding: GeometryEncoding) -> Any:+ """Render one geometry cell for the table payload.++ WKB bytes become a size placeholder. Object and WKT values become text+ with a maximum length of `GEOMETRY_CELL_CAP` characters. Other values pass+ through unchanged.+ """+ if value is None:+ return value+ if encoding == "wkb":+ if isinstance(value, (bytes, bytearray)):+ return f"<geometry, {len(value)} B>"+ return value+ if encoding in ("objects", "wkt"):+ text = str(value)+ if len(text) > GEOMETRY_CELL_CAP:+ return text[:GEOMETRY_CELL_CAP] + "..."+ return text+ return valuediff --git a/marimo/_plugins/ui/_impl/tables/ibis_table.py b/marimo/_plugins/ui/_impl/tables/ibis_table.pyindex 176f81c376..3c6d98b8c1 100644--- a/marimo/_plugins/ui/_impl/tables/ibis_table.py+++ b/marimo/_plugins/ui/_impl/tables/ibis_table.py@@ -190,7 +190,7 @@ class IbisTableManagerFactory(TableManagerFactory):return bin_values- def get_field_type(+ def _get_field_type_from_dtype(self, column_name: str) -> tuple[FieldType, ExternalDataType]:column = self._original_data[column_name]diff --git a/marimo/_plugins/ui/_impl/tables/narwhals_table.py b/marimo/_plugins/ui/_impl/tables/narwhals_table.pyindex a2a82dc5ed..b88fc1cb21 100644--- a/marimo/_plugins/ui/_impl/tables/narwhals_table.py+++ b/marimo/_plugins/ui/_impl/tables/narwhals_table.py@@ -21,6 +21,11 @@ from marimo._plugins.ui._impl.tables.format import (FormatMapping,format_value,)+from marimo._plugins.ui._impl.tables.geometry import (+ GeometryColumnInfo,+ find_geometry_columns,+ format_geometry_cell,+)from marimo._plugins.ui._impl.tables.selection import INDEX_COLUMN_NAMEfrom marimo._plugins.ui._impl.tables.table_manager import (ColumnName,@@ -104,10 +109,25 @@ class NarwhalsTableManager(ensure_ascii: bool = True,) -> str:del strict_json- frame = self.apply_formatting(format_mapping).as_frame()- return sanitize_json_bigint(- frame.rows(named=True), ensure_ascii=ensure_ascii- )+ formatted_manager = self.apply_formatting(format_mapping)+ frame = formatted_manager.as_frame()+ rows = frame.rows(named=True)+ geometry_columns = formatted_manager._geometry_columns+ if geometry_columns:+ rows = [+ {+ col: (+ format_geometry_cell(+ value, geometry_columns[col].encoding+ )+ if col in geometry_columns+ else value+ )+ for col, value in row.items()+ }+ for row in rows+ ]+ return sanitize_json_bigint(rows, ensure_ascii=ensure_ascii)def to_parquet(self) -> bytes:stream = io.BytesIO()@@ -121,15 +141,18 @@ class NarwhalsTableManager(return selfframe = self.as_frame()- _data = frame.to_dict(as_series=False).copy()- for col in _data:- if col in format_mapping:- _data[col] = [- format_value(col, x, format_mapping) for x in _data[col]- ]- return NarwhalsTableManager(- nw.from_dict(_data, backend=nw.get_native_namespace(frame))- )+ for col in frame.columns:+ if col not in format_mapping or col in self._geometry_columns:+ continue+ formatted = [+ format_value(col, x, format_mapping)+ for x in frame.get_column(col).to_list()+ ]+ series = nw.new_series(+ col, formatted, backend=frame.implementation+ )+ frame = frame.with_columns(series.alias(col))+ return NarwhalsTableManager(frame)def supports_filters(self) -> bool:return True@@ -190,6 +213,8 @@ class NarwhalsTableManager() -> list[tuple[Any, int]]:if column not in self.get_column_names():raise ValueError(f"Column {column} not found in table.")+ if column in self._geometry_columns:+ return []frame = self.as_lazy_frame()_unique_name = "__len_count__"@@ -266,8 +291,20 @@ class NarwhalsTableManager(def nw_schema(self) -> nw.Schema:return cast(nw.Schema, self.data.collect_schema())+ @cached_property+ def _geometry_columns(self) -> dict[str, GeometryColumnInfo]:+ return find_geometry_columns(self.data)+def get_field_type(self, column_name: str+ ) -> tuple[FieldType, ExternalDataType]:+ info = self._geometry_columns.get(column_name)+ if info is not None:+ return ("geometry", info.external_type)+ return self._get_field_type_from_dtype(column_name)++ def _get_field_type_from_dtype(+ self, column_name: str) -> tuple[FieldType, ExternalDataType]:dtype = self.nw_schema[column_name]dtype_string = str(dtype)@@ -314,6 +351,8 @@ class NarwhalsTableManager(for column, dtype in self.nw_schema.items():if column == INDEX_COLUMN_NAME:continue+ if column in self._geometry_columns:+ continueif is_narwhals_string_type(dtype):# Cast to string as pandas may fail for certain valuesexpressions.append(@@ -393,7 +432,10 @@ class NarwhalsTableManager(# As of Oct 2025, DuckDB does not support "nearest" interpolationquantile_interpolation = "linear"- if is_narwhals_string_type(dtype):+ if column in self._geometry_columns:+ # Geometry columns report only total and nulls.+ pass+ elif is_narwhals_string_type(dtype):exprs["unique"] = col.n_unique()elif dtype == nw.Boolean:exprs.update(@@ -681,6 +723,8 @@ class NarwhalsTableManager(return column_namesdef get_unique_column_values(self, column: str) -> list[str | int | float]:+ if column in self._geometry_columns:+ return []frame = self.data.select(nw.col(column))if is_narwhals_lazyframe(frame):frame = frame.collect()diff --git a/marimo/_plugins/ui/_impl/tables/pandas_table.py b/marimo/_plugins/ui/_impl/tables/pandas_table.pyindex 204a5d84b0..31246dc4a7 100644--- a/marimo/_plugins/ui/_impl/tables/pandas_table.py+++ b/marimo/_plugins/ui/_impl/tables/pandas_table.py@@ -11,13 +11,16 @@ import narwhals.stable.v2 as nwfrom marimo import _loggersfrom marimo._data.models import ExternalDataType-from marimo._dependencies.dependencies import DependencyManagerfrom marimo._messaging.msgspec_encoder import enc_hookfrom marimo._output.data.data import sanitize_json_bigintfrom marimo._plugins.ui._impl.tables.format import (FormatMapping,format_value,)+from marimo._plugins.ui._impl.tables.geometry import (+ GeometryColumnInfo,+ format_geometry_cell,+)from marimo._plugins.ui._impl.tables.narwhals_table import NarwhalsTableManagerfrom marimo._plugins.ui._impl.tables.selection import INDEX_COLUMN_NAMEfrom marimo._plugins.ui._impl.tables.table_manager import (@@ -48,6 +51,25 @@ def _dataframe_to_arrow_ipc(df: pd.DataFrame) -> bytes:return out.getvalue()+def _format_geometry_columns(+ df: pd.DataFrame,+ geometry_columns: dict[str, GeometryColumnInfo],+) -> None:+ import pandas as pd++ for col, geometry_info in geometry_columns.items():+ if col not in df.columns:+ continue+ df[col] = pd.Series(+ [+ format_geometry_cell(value, geometry_info.encoding)+ for value in df[col]+ ],+ index=df.index,+ dtype=object,+ )++def _trivial_range_index(index: pd.Index) -> bool:import pandas as pd@@ -170,18 +192,6 @@ def _extension_column_needs_stringify(return True-def _maybe_convert_geopandas_to_pandas(data: pd.DataFrame) -> pd.DataFrame:- # Convert to pandas dataframe since geopandas will fail on- # certain operations (like to_json(orient="records"))- if DependencyManager.geopandas.imported():- import geopandas as gpd # type: ignore- import pandas as pd-- if isinstance(data, gpd.GeoDataFrame):- return pd.DataFrame(data)- return data--class PandasTableManagerFactory(TableManagerFactory):@staticmethoddef package_name() -> str:@@ -196,7 +206,6 @@ class PandasTableManagerFactory(TableManagerFactory):type = "pandas"def __init__(self, data: pd.DataFrame) -> None:- data = _maybe_convert_geopandas_to_pandas(data)data = self._handle_multi_col_indexes(data)data = self._handle_non_string_column_names(data)self._original_data = data@@ -224,32 +233,27 @@ class PandasTableManagerFactory(TableManagerFactory):if not mixed_cols:return super().sort_values(by)- df = self.data+ df = self._original_data.copy()temp_cols: list[str] = []sort_cols: list[str] = []for col in columns:if col in mixed_cols:temp = f"__sort_{col}"- # Preserve nulls so nulls_last=True works.- # On pandas <3.0, cast(String) turns None- # into the string "None" instead of null.- df = df.with_columns(- nw.when(nw.col(col).is_null())- .then(None)- .otherwise(nw.col(col).cast(nw.String))- .alias(temp)+ series = df[col]+ df[temp] = series.where(+ series.isna(), series.astype(str))temp_cols.append(temp)sort_cols.append(temp)else:sort_cols.append(col)- df = df.sort(+ df = df.sort_values(sort_cols,- descending=descending,- nulls_last=True,- ).drop(temp_cols)- return self.with_new_data(df)+ ascending=[not value for value in descending],+ na_position="last",+ ).drop(columns=temp_cols)+ return PandasTableManager(df)# We override narwhals's to_csv_str to handle pandas# headers@@ -305,12 +309,20 @@ class PandasTableManagerFactory(TableManagerFactory):is_timedelta64_ns_dtype,)- _data = self.apply_formatting(format_mapping)._original_data- result = _data.copy() # to avoid SettingWithCopyWarning+ formatted = self.apply_formatting(format_mapping)+ # Copy to avoid SettingWithCopyWarning.+ geometry_columns = formatted._geometry_columns+ result = pd.DataFrame(formatted._original_data.copy())try:+ _format_geometry_columns(+ result,+ geometry_columns,+ )for col in result.columns:series = result[col]dtype = series.dtype+ if str(col) in geometry_columns:+ continue# Complex dtypes become {'imag': num, 'real': num} by default.# Preserve their display values instead.if is_complex_dtype(dtype):@@ -374,18 +386,40 @@ class PandasTableManagerFactory(TableManagerFactory):def to_arrow_ipc(self) -> bytes:import pyarrow as pa+ df = self._original_data+ if self._geometry_columns:+ df = pd.DataFrame(df.copy())+ _format_geometry_columns(df, self._geometry_columns)+try:- return _dataframe_to_arrow_ipc(self._original_data)+ return _dataframe_to_arrow_ipc(df)except Exception:# Fall back: convert extension-type columns that# PyArrow cannot handle (e.g. pint-pandas) to plain# values so the IPC write can succeed.- df = self._original_data.copy()+ df = pd.DataFrame(+ df.copy()+ ) # convert to base dataframe from extension dataframefor col in df.columns:try:pa.Array.from_pandas(df[col])except Exception:- df[col] = df[col].astype(object).infer_objects()+ converted = df[col].astype(object).infer_objects()+ try:+ pa.Array.from_pandas(converted)+ except Exception:+ notna = df[col].notna().to_numpy()+ converted = pd.Series(+ [+ str(value) if present else None+ for value, present in zip(+ df[col], notna, strict=True+ )+ ],+ index=df.index,+ dtype=object,+ )+ df[col] = convertedreturn _dataframe_to_arrow_ipc(df)def apply_formatting(@@ -446,9 +480,7 @@ class PandasTableManagerFactory(TableManagerFactory):if not isinstance(data.columns, pd.Index):return data- if len(data.columns) > 0 and not isinstance(- data.columns[0], str- ):+ if any(not isinstance(name, str) for name in data.columns):data_copy = data.copy()data_copy.columns = pd.Index([str(name) for name in data_copy.columns]@@ -534,9 +566,9 @@ class PandasTableManagerFactory(TableManagerFactory):return [(names[0], self._map_dtype_to_field_type(index.dtype))]- # We override the default implementation to use pandas's- # internal fields since they get displayed in the UI.- def get_field_type(+ # Override the dtype mapper to use pandas's internal fields+ # since they get displayed in the UI.+ def _get_field_type_from_dtype(self, column_name: str) -> tuple[FieldType, ExternalDataType]:dtype = self.schema[column_name]@@ -584,6 +616,8 @@ class PandasTableManagerFactory(TableManagerFactory):def get_unique_column_values(self, column: str) -> list[str | int | float]:+ if column in self._geometry_columns:+ return []return self._original_data[column].unique().tolist() # type: ignore[return-value,no-any-return]return PandasTableManagerdiff --git a/marimo/_plugins/ui/_impl/tables/polars_table.py b/marimo/_plugins/ui/_impl/tables/polars_table.pyindex b30b33a6a5..c9b1f020da 100644--- a/marimo/_plugins/ui/_impl/tables/polars_table.py+++ b/marimo/_plugins/ui/_impl/tables/polars_table.py@@ -284,7 +284,7 @@ class PolarsTableManagerFactory(TableManagerFactory):# We override the default implementation to use polars's# internal fields since they get displayed in the UI.- def get_field_type(+ def _get_field_type_from_dtype(self, column_name: str) -> tuple[FieldType, ExternalDataType]:dtype = self.schema[column_name]diff --git a/marimo/_plugins/ui/_impl/tables/selection.py b/marimo/_plugins/ui/_impl/tables/selection.pyindex 77e3e3486e..a91dd8bc69 100644--- a/marimo/_plugins/ui/_impl/tables/selection.py+++ b/marimo/_plugins/ui/_impl/tables/selection.py@@ -15,6 +15,10 @@ def add_selection_column(data: T) -> tuple[T, bool]:if nw.dependencies.is_into_dataframe(data):df = nw.from_native(cast(IntoDataFrame, data), pass_through=False)if INDEX_COLUMN_NAME not in df.columns:+ if df.implementation.is_pandas():+ native = df.to_native().copy()+ native.insert(0, INDEX_COLUMN_NAME, range(len(native)))+ return cast(T, native), Truereturn df.with_row_index(name=INDEX_COLUMN_NAME).to_native(), True # type: ignore[return-value]return data, True # already has a row indexreturn data, Falsediff --git a/marimo/_server/ai/providers.py b/marimo/_server/ai/providers.pyindex 0776f83a81..8db39e40a4 100644--- a/marimo/_server/ai/providers.py+++ b/marimo/_server/ai/providers.py@@ -487,9 +487,9 @@ class OpenAIClientMixin:)# the default httpx client uses ssl_verify=True by default under the hoood. We are checking if it's here, to see if the user overrides and uses false. If the ssl_verify argument isn't there, it is true by default+ client: DefaultAsyncHttpxClient | None = Noneif ssl_verify:ctx = None # Initialize ctx to avoid UnboundLocalError- client = None # Initialize client to avoid UnboundLocalErrorif ca_bundle_path:ctx = ssl.create_default_context(cafile=ca_bundle_path)if client_pem:diff --git a/packages/openapi/api.yaml b/packages/openapi/api.yamlindex a01cfb0301..8c956d4313 100644--- a/packages/openapi/api.yaml+++ b/packages/openapi/api.yaml@@ -1295,6 +1295,7 @@ components:- boolean- date- datetime+ - geometry- integer- number- string@@ -3001,6 +3002,7 @@ components:- boolean- date- datetime+ - geometry- integer- number- stringdiff --git a/packages/openapi/src/api.ts b/packages/openapi/src/api.tsindex 1b93049713..5b350d23f7 100644--- a/packages/openapi/src/api.ts+++ b/packages/openapi/src/api.ts@@ -4470,6 +4470,7 @@ export interface components {| "boolean"| "date"| "datetime"+ | "geometry"| "integer"| "number"| "string"@@ -5490,6 +5491,7 @@ export interface components {| "boolean"| "date"| "datetime"+ | "geometry"| "integer"| "number"| "string"diff --git a/tests/_data/test_charts.py b/tests/_data/test_charts.pyindex 5040a19ab7..3b3db763b4 100644--- a/tests/_data/test_charts.py+++ b/tests/_data/test_charts.py@@ -53,6 +53,13 @@ def test_get_chart_builder():)+def test_geometry_uses_unknown_chart_builder() -> None:+ geometry_code = get_chart_builder("geometry").altair_code("df", "geometry")+ unknown_code = get_chart_builder("unknown").altair_code("df", "geometry")++ assert geometry_code == unknown_code++def validate_and_return_codes(simple: bool) -> list[str]:outputs: list[str] = []diff --git a/tests/_data/test_get_datasets.py b/tests/_data/test_get_datasets.pyindex ae40081210..14abf97771 100644--- a/tests/_data/test_get_datasets.py+++ b/tests/_data/test_get_datasets.py@@ -682,7 +682,11 @@ def test_db_type_to_data_type_various() -> None:assert _db_type_to_data_type("timetz") == "time"# Special types- assert _db_type_to_data_type("geometry") == "unknown"+ assert _db_type_to_data_type("geometry") == "geometry"+ assert _db_type_to_data_type("point_2d") == "geometry"+ assert _db_type_to_data_type("linestring_2d") == "geometry"+ assert _db_type_to_data_type("polygon_2d") == "geometry"+ assert _db_type_to_data_type("box_2d") == "geometry"assert _db_type_to_data_type("null") == "unknown"assert _db_type_to_data_type("json") == "unknown"assert _db_type_to_data_type("row") == "unknown"diff --git a/tests/_data/test_preview_column.py b/tests/_data/test_preview_column.pyindex 16b322dd32..07f8198d72 100644--- a/tests/_data/test_preview_column.py+++ b/tests/_data/test_preview_column.py@@ -20,6 +20,7 @@ from marimo._plugins.ui._impl.charts.altair_transformer import (from marimo._runtime.commands import PreviewDatasetColumnCommandfrom marimo._utils.platform import is_windowsfrom tests._data.mocks import create_dataframes+from tests._plugins.ui._impl.tables import geometry_fixtures as geofrom tests.mocks import snapshotterfrom tests.utils import assert_serialize_roundtrip@@ -600,6 +601,24 @@ def test_preview_column_struct_skips_chart() -> None:mock_logger.warning.assert_not_called()[email protected]("altair")[email protected]("geopandas")+def test_preview_column_geometry_skips_chart() -> None:+ manager = get_table_manager(geo.gdf_point_known_crs())+ assert manager is not None++ result = get_column_preview_dataset(+ table=manager,+ table_name="table",+ column_name="geometry",+ )++ assert result.error is None+ assert result.chart_spec is None+ assert result.chart_code is None+ assert result.stats is not None++@pytest.mark.parametrize("df",create_dataframes(diff --git a/tests/_data/test_sql_summaries.py b/tests/_data/test_sql_summaries.pyindex 60aa6f6874..8397875dd4 100644--- a/tests/_data/test_sql_summaries.py+++ b/tests/_data/test_sql_summaries.py@@ -134,3 +134,29 @@ def test_get_sql_summary_datetime(setup_test_db: Any):assert summary.nulls == 0assert summary.min == datetime.datetime(2024, 1, 1, 12, 30)assert summary.max == datetime.datetime(2024, 5, 5, 16, 30)++[email protected](not HAS_DEPS, reason="optional dependencies not installed")+def test_geometry_column_type_and_stats():+ import duckdb++ try:+ duckdb.execute("INSTALL spatial")+ duckdb.execute("LOAD spatial")+ except duckdb.Error as e:+ pytest.skip(f"duckdb spatial extension unavailable: {e}")++ duckdb.execute(+ "CREATE OR REPLACE TABLE geo_stats_table AS "+ "SELECT 1 AS id, ST_Point(1.0, 2.0) AS geom "+ "UNION ALL SELECT 2, NULL"+ )+ try:+ assert get_column_type("geo_stats_table", "geom") == "geometry"++ summary = get_sql_stats("geo_stats_table", "geom", "geometry")+ assert summary.total == 2+ assert summary.nulls == 1+ assert summary.unique is None+ finally:+ duckdb.execute("DROP TABLE geo_stats_table")diff --git a/tests/_messaging/test_enc_hook.py b/tests/_messaging/test_enc_hook.pyindex 8c03f867fb..5648e84851 100644--- a/tests/_messaging/test_enc_hook.py+++ b/tests/_messaging/test_enc_hook.py@@ -2,6 +2,7 @@import decimalimport json+import sysimport pytest@@ -141,3 +142,14 @@ def test_serialize_decimal() -> None:decimal_obj = decimal.Decimal("-0")result = enc_hook(decimal_obj)assert result == "-0"++[email protected]("shapely")+def test_serialize_shapely_without_geopandas(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ from shapely.geometry import Point++ monkeypatch.delitem(sys.modules, "geopandas", raising=False)++ assert enc_hook(Point(1, 2)) == "POINT (1 2)"diff --git a/tests/_plugins/ui/_impl/tables/snapshots/false_positives.pandas.json b/tests/_plugins/ui/_impl/tables/snapshots/false_positives.pandas.jsonindex 81b44fd344..35ba148137 100644--- a/tests/_plugins/ui/_impl/tables/snapshots/false_positives.pandas.json+++ b/tests/_plugins/ui/_impl/tables/snapshots/false_positives.pandas.json@@ -14,7 +14,7 @@}},{- "raw_binary": "None",+ "raw_binary": null,"wkt_looking": null,"h3_int": {"$bigint": "622236750694711295"diff --git a/tests/_plugins/ui/_impl/tables/test_geometry.py b/tests/_plugins/ui/_impl/tables/test_geometry.pynew file mode 100644index 0000000000..a9a619f146--- /dev/null+++ b/tests/_plugins/ui/_impl/tables/test_geometry.py@@ -0,0 +1,703 @@+# Copyright 2026 Marimo. All rights reserved.++from __future__ import annotations++import json+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]++[email protected]("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) == {}++[email protected]("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)) == {}++ 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",+ )++[email protected]("duckdb")+class TestDuckDBDetection:+ 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()++[email protected]("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_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++[email protected]("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()++[email protected]("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++[email protected]("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++[email protected]("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+ )+++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")diff --git a/tests/_plugins/ui/_impl/tables/test_geometry_fixtures.py b/tests/_plugins/ui/_impl/tables/test_geometry_fixtures.pyindex 28184a18d0..8992a47493 100644--- a/tests/_plugins/ui/_impl/tables/test_geometry_fixtures.py+++ b/tests/_plugins/ui/_impl/tables/test_geometry_fixtures.py@@ -21,18 +21,18 @@ snapshot = snapshotter(__file__)@pytest.mark.requires("geopandas")class TestGeoPandasCharacterization:- def test_flattens_geodataframe_on_ingest(self) -> None:+ def test_preserves_geodataframe_on_ingest(self) -> None:import geopandas as gpdmanager = get_table_manager(geo.gdf_point_known_crs())native = manager.data.to_native()- assert not isinstance(native, gpd.GeoDataFrame)+ assert isinstance(native, gpd.GeoDataFrame)- def test_geometry_column_types_unknown(self) -> None:+ def test_geometry_column_types_geometry(self) -> None:manager = get_table_manager(geo.gdf_point_known_crs())assert dict(manager.get_field_types()) == {"name": ("string", "str"),- "geometry": ("unknown", "geometry"),+ "geometry": ("geometry", "geometry"),}@pytest.mark.parametrize(@@ -42,60 +42,60 @@ class TestGeoPandasCharacterization:geo.gdf_point_missing_crs,[("name", ("string", "str")),- ("geometry", ("unknown", "geometry")),+ ("geometry", ("geometry", "geometry")),],),(geo.gdf_multi_geometry,[- ("geom_a", ("unknown", "geometry")),- ("geom_b", ("unknown", "geometry")),+ ("geom_a", ("geometry", "geometry")),+ ("geom_b", ("geometry", "geometry")),],),(geo.gdf_no_active_geometry,[("a", ("integer", "int64")),- ("g", ("unknown", "geometry")),+ ("g", ("geometry", "geometry")),],),(geo.gdf_stale_pointer,[("name", ("string", "str")),- ("geom", ("unknown", "geometry")),+ ("geom", ("geometry", "geometry")),],),(geo.gdf_dropped_active,- [("geom_b", ("unknown", "geometry"))],+ [("geom_b", ("geometry", "geometry"))],),(geo.gdf_with_null,[("name", ("string", "str")),- ("geometry", ("unknown", "geometry")),+ ("geometry", ("geometry", "geometry")),],),(geo.gdf_all_null,[("name", ("string", "str")),- ("geometry", ("unknown", "geometry")),+ ("geometry", ("geometry", "geometry")),],),(geo.gdf_mixed_types,[("name", ("string", "str")),- ("geometry", ("unknown", "geometry")),+ ("geometry", ("geometry", "geometry")),],),(geo.gdf_3d,[("name", ("string", "str")),- ("geometry", ("unknown", "geometry")),+ ("geometry", ("geometry", "geometry")),],),],@@ -110,18 +110,18 @@ class TestGeoPandasCharacterization:@pytest.mark.requires("pyarrow")class TestGeoArrowCharacterization:- def test_wkb_types_unknown_binary(self) -> None:+ 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": ("unknown", "Binary"),+ "geom": ("geometry", "geoarrow.wkb"),}- def test_wkt_types_string(self) -> None:+ def test_wkt_types_geometry(self) -> None:manager = get_table_manager(geo.arrow_wkt())assert dict(manager.get_field_types()) == {"a": ("integer", "Int64"),- "geom": ("string", "String"),+ "geom": ("geometry", "geoarrow.wkt"),}@pytest.mark.parametrize(@@ -131,24 +131,21 @@ class TestGeoArrowCharacterization:geo.arrow_wkb_missing_crs,[("a", ("integer", "Int64")),- ("geom", ("unknown", "Binary")),+ ("geom", ("geometry", "geoarrow.wkb")),],),(geo.arrow_ogc_wkb,[("a", ("integer", "Int64")),- ("geom", ("unknown", "Binary")),+ ("geom", ("geometry", "ogc.wkb")),],),(geo.arrow_other_geoarrow,[("a", ("integer", "Int64")),- (- "geom",- ("unknown", "Array(Float64, shape=(2,))"),- ),+ ("geom", ("geometry", "geoarrow.point")),],),],@@ -163,14 +160,14 @@ class TestGeoArrowCharacterization:@pytest.mark.requires("duckdb", "polars")class TestDuckDBCharacterization:- def test_geometry_types_unknown(self) -> None:+ 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"] == ("unknown", "Unknown")+ assert field_types["geom"] == ("geometry", "GEOMETRY")finally:conn.close()@@ -186,7 +183,11 @@ class TestIbisCharacterization:class TestFalsePositiveBaselines:- """These snapshots must never change during geometry detection work."""+ """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:diff --git a/tests/_plugins/ui/_impl/test_table.py b/tests/_plugins/ui/_impl/test_table.pyindex bcbae9b79f..d292879932 100644--- a/tests/_plugins/ui/_impl/test_table.py+++ b/tests/_plugins/ui/_impl/test_table.py@@ -2043,7 +2043,7 @@ def test_dataframe_with_int_column_names():assert "DataFrame has integer column names" in str(w[0].message)# Check that the table handles integer column names correctly- assert table._manager.get_column_names() == [0, 1, 2]+ assert table._manager.get_column_names() == ["0", "1", "2"]assert table._component_args["total-columns"] == 3assert table._component_args["max-columns"] == DEFAULT_MAX_COLUMNS