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.

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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.tsx
index 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.tsx
index 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.tsx
index 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 filtering
filterFn: 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.ts
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.ts
index 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.ts
index 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.tsx
index 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 types
return [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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.py
index 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.py
index 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 types
if db_type.startswith(
("union", "map", "struct", "list", "array", "json")
diff --git a/marimo/_data/models.py b/marimo/_data/models.py
index 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 library
diff --git a/marimo/_data/preview_column.py b/marimo/_data/preview_column.py
index 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, None
if stats.total == 0:
diff --git a/marimo/_data/sql_summaries.py b/marimo/_data/sql_summaries.py
index 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_count
FROM {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_result
return ColumnStats(total=count, unique=unique, nulls=null_count)
diff --git a/marimo/_dependencies/dependencies.py b/marimo/_dependencies/dependencies.py
index 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.py
index 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 class
diff --git a/marimo/_plugins/ui/_impl/table.py b/marimo/_plugins/ui/_impl/table.py
index 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,
+ )
+ continue
category = _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.py
new file mode 100644
index 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 value
diff --git a/marimo/_plugins/ui/_impl/tables/ibis_table.py b/marimo/_plugins/ui/_impl/tables/ibis_table.py
index 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.py
index 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_NAME
from 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 self
frame = 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:
+ continue
if is_narwhals_string_type(dtype):
# Cast to string as pandas may fail for certain values
expressions.append(
@@ -393,7 +432,10 @@ class NarwhalsTableManager(
# As of Oct 2025, DuckDB does not support "nearest" interpolation
quantile_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_names
def 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.py
index 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 nw
from marimo import _loggers
from marimo._data.models import ExternalDataType
-from marimo._dependencies.dependencies import DependencyManager
from marimo._messaging.msgspec_encoder import enc_hook
from marimo._output.data.data import sanitize_json_bigint
from 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 NarwhalsTableManager
from marimo._plugins.ui._impl.tables.selection import INDEX_COLUMN_NAME
from 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):
@staticmethod
def 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 dataframe
for 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] = converted
return _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 PandasTableManager
diff --git a/marimo/_plugins/ui/_impl/tables/polars_table.py b/marimo/_plugins/ui/_impl/tables/polars_table.py
index 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.py
index 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), True
return df.with_row_index(name=INDEX_COLUMN_NAME).to_native(), True # type: ignore[return-value]
return data, True # already has a row index
return data, False
diff --git a/marimo/_server/ai/providers.py b/marimo/_server/ai/providers.py
index 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 = None
if ssl_verify:
ctx = None # Initialize ctx to avoid UnboundLocalError
- client = None # Initialize client to avoid UnboundLocalError
if 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.yaml
index 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
- string
diff --git a/packages/openapi/src/api.ts b/packages/openapi/src/api.ts
index 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.py
index 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.py
index 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.py
index 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 PreviewDatasetColumnCommand
from marimo._utils.platform import is_windows
from tests._data.mocks import create_dataframes
+from tests._plugins.ui._impl.tables import geometry_fixtures as geo
from tests.mocks import snapshotter
from 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]("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.py
index 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 == 0
assert 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.py
index 8c03f867fb..5648e84851 100644
--- a/tests/_messaging/test_enc_hook.py
+++ b/tests/_messaging/test_enc_hook.py
@@ -2,6 +2,7 @@
import decimal
import json
+import sys
import pytest
@@ -141,3 +142,14 @@ def test_serialize_decimal() -> None:
decimal_obj = decimal.Decimal("-0")
result = enc_hook(decimal_obj)
assert result == "-0"
+
+
+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.json
index 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.py
new file mode 100644
index 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) == {}
+
+
+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",
+ )
+
+
+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()
+
+
+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()
+
+
+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.py
index 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 gpd
manager = 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.py
index 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"] == 3
assert table._component_args["max-columns"] == DEFAULT_MAX_COLUMNS