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(charts): allow selecting a pandas DataFrame index as a chart axis (#10097)
Kiran Gadhave6b6b1665b128
diff --git a/frontend/src/components/data-table/charts/__tests__/merge-index-fields.test.ts b/frontend/src/components/data-table/charts/__tests__/merge-index-fields.test.tsnew file mode 100644index 0000000000..6302965add--- /dev/null+++ b/frontend/src/components/data-table/charts/__tests__/merge-index-fields.test.ts@@ -0,0 +1,33 @@+/* Copyright 2026 Marimo. All rights reserved. */++import { describe, expect, it } from "vitest";+import type { FieldTypesWithExternalType } from "@/components/data-table/types";+import { mergeIndexFields } from "../charts";++describe("mergeIndexFields", () => {+ it("appends row-header (index) fields to field types", () => {+ const fieldTypes: FieldTypesWithExternalType = [["v", ["number", "int64"]]];+ const rowHeaders: FieldTypesWithExternalType = [+ ["k", ["string", "object"]],+ ];+ expect(mergeIndexFields(fieldTypes, rowHeaders)).toEqual([+ ["v", ["number", "int64"]],+ ["k", ["string", "object"]],+ ]);+ });++ it("de-dupes when an index name matches a column name", () => {+ const fieldTypes: FieldTypesWithExternalType = [["k", ["number", "int64"]]];+ const rowHeaders: FieldTypesWithExternalType = [+ ["k", ["string", "object"]],+ ];+ expect(mergeIndexFields(fieldTypes, rowHeaders)).toEqual([+ ["k", ["number", "int64"]],+ ]);+ });++ it("returns field types unchanged when there are no row headers", () => {+ const fieldTypes: FieldTypesWithExternalType = [["v", ["number", "int64"]]];+ expect(mergeIndexFields(fieldTypes, [])).toEqual(fieldTypes);+ });+});diff --git a/frontend/src/components/data-table/charts/charts.tsx b/frontend/src/components/data-table/charts/charts.tsxindex 17237b5f1f..ea1e349d20 100644--- a/frontend/src/components/data-table/charts/charts.tsx+++ b/frontend/src/components/data-table/charts/charts.tsx@@ -54,6 +54,24 @@ const CHART_HEIGHT = 290;const CHART_MAX_ROWS = 50_000;const CHART_MAX_COLUMNS = 50;+/**+ * Append row-header (index) fields to the chart field list, skipping any whose+ * name already exists as a data column so the chart builder never offers the+ * same axis twice.+ */+export function mergeIndexFields(+ fieldTypes: FieldTypesWithExternalType | null | undefined,+ rowHeaders: FieldTypesWithExternalType | null | undefined,+): FieldTypesWithExternalType {+ const base = fieldTypes ?? [];+ if (!rowHeaders || rowHeaders.length === 0) {+ return base;+ }+ const seen = new Set(base.map(([name]) => name));+ const indexFields = rowHeaders.filter(([name]) => !seen.has(name));+ return [...base, ...indexFields];+}+export interface TablePanelProps {cellId: CellId | null;data: unknown[];@@ -64,6 +82,7 @@ export interface TablePanelProps {onCloseChartBuilder?: () => void;getDataUrl?: GetDataUrl;fieldTypes?: FieldTypesWithExternalType | null;+ rowHeaders?: FieldTypesWithExternalType | null;}export const TablePanel: React.FC<TablePanelProps> = ({@@ -74,6 +93,7 @@ export const TablePanel: React.FC<TablePanelProps> = ({columns,getDataUrl,fieldTypes,+ rowHeaders,displayHeader,onCloseChartBuilder,}) => {@@ -265,7 +285,10 @@ export const TablePanel: React.FC<TablePanelProps> = ({saveChart={saveChart}saveChartType={saveChartType}getDataUrl={getDataUrl}- fieldTypes={fieldTypes ?? inferFieldTypes(dataTable.props.data)}+ fieldTypes={mergeIndexFields(+ fieldTypes ?? inferFieldTypes(dataTable.props.data),+ rowHeaders,+ )}isLargeDataset={isLargeDataset}/></TabsContent>diff --git a/frontend/src/plugins/impl/DataTablePlugin.tsx b/frontend/src/plugins/impl/DataTablePlugin.tsxindex 0da9969fe5..eb97b911cb 100644--- a/frontend/src/plugins/impl/DataTablePlugin.tsx+++ b/frontend/src/plugins/impl/DataTablePlugin.tsx@@ -805,6 +805,7 @@ export const LoadingDataTableComponent = memo(dataTable={dataTable}getDataUrl={props.get_data_url}fieldTypes={props.fieldTypes}+ rowHeaders={props.rowHeaders}cellId={cellId}/>) : (diff --git a/marimo/_plugins/ui/_impl/table.py b/marimo/_plugins/ui/_impl/table.pyindex 5271a527f2..018c532919 100644--- a/marimo/_plugins/ui/_impl/table.py+++ b/marimo/_plugins/ui/_impl/table.py@@ -1365,14 +1365,19 @@ class table("""Get the data URL for the entire table. Used for charting."""del args+ # Expose a non-trivial row index (e.g. a named datetime index) as a+ # column so it can be selected as a chart axis. Scoped to the chart+ # data path; downloads and the displayed table are unaffected.+ chart_manager = self._searched_manager.with_index_as_columns()+if DependencyManager.altair.has():- result = _to_marimo_arrow(self._searched_manager.data)+ result = _to_marimo_arrow(chart_manager.data)return GetDataUrlResponse(data_url=result["url"],format=result["format"]["type"],)- url, data_format = self._to_chart_data_url(self._searched_manager)+ url, data_format = self._to_chart_data_url(chart_manager)return GetDataUrlResponse(data_url=url,format=data_format,@@ -1849,15 +1854,6 @@ def _validate_frozen_columns(raise ValueError("The same column cannot be frozen on both sides.")if freeze_columns_left_set:- # Unnamed row headers (e.g. a default pandas index) have no stable- # client-side id, so we can't freeze them. Surface this directly- # rather than letting the frontend silently no-op.- if "" in freeze_columns_left_set and "" in row_header_names_set:- raise ValueError(- "Cannot freeze an unnamed row index. "- "Set `df.index.name = '...'` (or `df.index.names = [...]` "- "for a MultiIndex) and pass that name to freeze_columns_left."- )invalid = (freeze_columns_left_set - column_names_set - row_header_names_set)diff --git a/marimo/_plugins/ui/_impl/tables/pandas_table.py b/marimo/_plugins/ui/_impl/tables/pandas_table.pyindex 363bb2a426..9555ff12c8 100644--- a/marimo/_plugins/ui/_impl/tables/pandas_table.py+++ b/marimo/_plugins/ui/_impl/tables/pandas_table.py@@ -30,14 +30,12 @@ from marimo._plugins.ui._impl.tables.table_manager import (if TYPE_CHECKING:import pandas as pd+ from pandas._typing import DtypeObjfrom marimo._plugins.ui._impl.table import SortArgsLOGGER = _loggers.marimo_logger()-if TYPE_CHECKING:- from pandas._typing import DtypeObj-def _trivial_range_index(index: pd.Index) -> bool:import pandas as pd@@ -46,9 +44,61 @@ def _trivial_range_index(index: pd.Index) -> bool:return isinstance(index, pd.RangeIndex) and index.name is None-def _resolve_index_name(name: object, columns: set[str]) -> str:- """Return a non-conflicting index name by appending '_index' if needed."""- return f"{name}_index" if name in columns else str(name)+def _flatten_non_trivial_index(df: pd.DataFrame) -> pd.DataFrame:+ """Turn a MultiIndex or named index into regular columns.++ An unnamed default RangeIndex (0, 1, 2, ...) is left untouched. Each level+ of a MultiIndex or named index becomes its own column, named via+ `_index_level_names`.+ """+ import pandas as pd++ is_multi_index = isinstance(df.index, pd.MultiIndex)+ is_non_trivial_index = isinstance(+ df.index, pd.Index+ ) and not _trivial_range_index(df.index)++ if not is_multi_index and not is_non_trivial_index:+ return df++ names = _index_level_names(df.index, set(df.columns))+ return df.rename_axis(names).reset_index()+++def _rename_index_levels(index: pd.Index, names: list[str]) -> pd.Index:+ """Return `index` with its levels renamed to `names`, in level order."""+ import pandas as pd++ if isinstance(index, pd.MultiIndex):+ return index.set_names(names)+ return index.rename(names[0])+++def _resolve_index_name(name: object, used: set[str]) -> str:+ """Return a name absent from `used`, appending '_index' until unique."""+ resolved = str(name)+ while resolved in used:+ resolved = f"{resolved}_index"+ return resolved+++def _index_level_names(index: pd.Index, columns: set[str]) -> list[str]:+ """Column name for each index level, in level order.++ Unnamed levels are numbered `Index0`, `Index1`, ... Names colliding with+ `columns` or with an earlier level get an `_index` suffix until unique.+ """+ unnamed_count = 0+ used = set(columns)+ names: list[str] = []+ for name in index.names:+ if name is None:+ name = f"Index{unnamed_count}"+ unnamed_count += 1+ resolved = _resolve_index_name(name, used)+ used.add(resolved)+ names.append(resolved)+ return namesdef _resolve_index_column_conflicts(df: pd.DataFrame) -> pd.DataFrame:@@ -57,8 +107,6 @@ def _resolve_index_column_conflicts(df: pd.DataFrame) -> pd.DataFrame:Avoids 'ValueError: cannot insert x, already exists' on reset_index().Modifies the DataFrame in-place and returns it."""- import pandas as pd-index_names = df.index.namesconflicting_names = set(index_names) & set(df.columns)if not conflicting_names:@@ -67,11 +115,7 @@ def _resolve_index_column_conflicts(df: pd.DataFrame) -> pd.DataFrame:columns = set(df.columns)new_names = [_resolve_index_name(name, columns) for name in index_names]- if isinstance(df.index, pd.MultiIndex):- df.index = df.index.set_names(new_names)- else:- df.index = df.index.rename(new_names[0])-+ df.index = _rename_index_levels(df.index, new_names)return df@@ -264,44 +308,15 @@ class PandasTableManagerFactory(TableManagerFactory):"Error handling complex or timedelta64 dtype",exc_info=e,)+ result = _flatten_non_trivial_index(result)+return sanitize_json_bigint(to_json(result), ensure_ascii=ensure_ascii)- # Flatten row multi-index- # Reset index if it's a MultiIndex or a named Index- # (including named RangeIndex, which pandas 3.0 uses for sequential integers)- # Only skip reset for unnamed default RangeIndex (0, 1, 2, ...)- if isinstance(result.index, pd.MultiIndex) or (- isinstance(result.index, pd.Index)- and not _trivial_range_index(result.index)- ):- unnamed_indexes = any(- idx is None for idx in result.index.names- )-- index_levels = result.index.nlevels-- _resolve_index_column_conflicts(result)- index_names = result.index.names-- result = result.reset_index()-- if unnamed_indexes:- # After reset_index, the index is converted to a column- # We need to rename the new columns to empty strings- # And it must be unique for each column- # TODO: On the frontend this still displays the original index, not the renamed one- empty_name = ""- for i, idx_name in enumerate(index_names):- if idx_name is None:- result.columns.values[i] = empty_name- empty_name += " "-- if index_levels > 1:- LOGGER.warning(- "Indexes with more than one level are not well supported, call reset_index() or use mo.plain(df)"- )+ # Flatten row multi-index / named index into columns so it is+ # serialized alongside the data.+ result = _flatten_non_trivial_index(result)return sanitize_json_bigint(to_json(result), ensure_ascii=ensure_ascii@@ -405,16 +420,15 @@ class PandasTableManagerFactory(TableManagerFactory):# We override the default implementation to use pandas# headersdef get_row_headers(self) -> FieldTypes:- headers = self._get_row_headers_for_index(+ return self._get_row_headers_for_index(self._original_data.index)- # Rename headers that collide with column names so the- # frontend receives names consistent with to_json_str().- columns = set(self._original_data.columns)- return [- (_resolve_index_name(name, columns), ft)- for name, ft in headers- ]++ def with_index_as_columns(self) -> PandasTableManager:+ flattened = _flatten_non_trivial_index(self._original_data)+ if flattened is self._original_data:+ return self+ return PandasTableManager(flattened)def _has_non_trivial_index(self) -> bool:"""Check if the DataFrame has a non-trivial index that should be searched."""@@ -463,20 +477,23 @@ class PandasTableManagerFactory(TableManagerFactory):if _trivial_range_index(index):return []+ # Names are shared with the chart-data flatten path so the+ # offered fields match the serialized columns exactly.+ names = _index_level_names(+ index, set(self._original_data.columns)+ )if isinstance(index, pd.MultiIndex):- # recurse- headers: FieldTypes = []- for i in range(index.nlevels):- headers.extend(- self._get_row_headers_for_index(- index.get_level_values(i)- )+ return [+ (+ name,+ self._map_dtype_to_field_type(+ index.get_level_values(i).dtype+ ),)- return headers+ for i, name in enumerate(names)+ ]- dtype = index.dtype- field_type = self._map_dtype_to_field_type(dtype)- return [(str(index.name or ""), field_type)]+ 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.diff --git a/marimo/_plugins/ui/_impl/tables/table_manager.py b/marimo/_plugins/ui/_impl/tables/table_manager.pyindex 2cb2769f3a..3660537e5d 100644--- a/marimo/_plugins/ui/_impl/tables/table_manager.py+++ b/marimo/_plugins/ui/_impl/tables/table_manager.py@@ -208,6 +208,14 @@ class TableManager(abc.ABC, Generic[T]):for column_name in self.get_column_names()]+ def with_index_as_columns(self) -> TableManager[Any]:+ """Return a manager whose row index is exposed as regular columns.++ Backends without a row-index concept return themselves unchanged; only+ pandas has a non-trivial index to flatten.+ """+ return self+@abc.abstractmethoddef take(self, count: int, offset: int) -> TableManager[Any]:passdiff --git a/tests/_plugins/ui/_impl/tables/test_pandas_table.py b/tests/_plugins/ui/_impl/tables/test_pandas_table.pyindex f1fef6907b..51c2200b5a 100644--- a/tests/_plugins/ui/_impl/tables/test_pandas_table.py+++ b/tests/_plugins/ui/_impl/tables/test_pandas_table.py@@ -383,9 +383,9 @@ class TestPandasTableManager(unittest.TestCase):data = pd.DataFrame({"a": [1, 2, 3]}, index=["c", "d", "e"])json_data = self.factory_create_json_from_df(data)assert json_data == [- {"": "c", "a": 1},- {"": "d", "a": 2},- {"": "e", "a": 3},+ {"Index0": "c", "a": 1},+ {"Index0": "d", "a": 2},+ {"Index0": "e", "a": 3},]# Named index@@ -459,7 +459,6 @@ class TestPandasTableManager(unittest.TestCase):)assert PandasTableManagerFactory.create()(data_pivoted) is not None- @pytest.mark.xfail(reason="Implementation not yet supported")def test_to_json_multi_index_unnamed(self) -> None:data = pd.DataFrame({@@ -470,9 +469,9 @@ class TestPandasTableManager(unittest.TestCase):)json_data = self.factory_create_json_from_df(data)assert json_data == [- {"level_0": "x", "level_1": 1, "a": 1, "b": 4},- {"level_0": "y", "level_1": 2, "a": 2, "b": 5},- {"level_0": "z", "level_1": 3, "a": 3, "b": 6},+ {"Index0": "x", "Index1": 1, "a": 1, "b": 4},+ {"Index0": "y", "Index1": 2, "a": 2, "b": 5},+ {"Index0": "z", "Index1": 3, "a": 3, "b": 6},]def test_to_json_multi_index_unnamed_2(self) -> None:@@ -489,12 +488,12 @@ class TestPandasTableManager(unittest.TestCase):)json_data = self.factory_create_json_from_df(df)- # Second level converted to empty string+ # The unnamed second level is the first unnamed level, so it is "Index0"assert json_data == [- {"level1": "x", "": 1, "A": 1, "B": 5},- {"level1": "x", "": 2, "A": 2, "B": 6},- {"level1": "y", "": 1, "A": 3, "B": 7},- {"level1": "y", "": 2, "A": 4, "B": 8},+ {"level1": "x", "Index0": 1, "A": 1, "B": 5},+ {"level1": "x", "Index0": 2, "A": 2, "B": 6},+ {"level1": "y", "Index0": 1, "A": 3, "B": 7},+ {"level1": "y", "Index0": 2, "A": 4, "B": 8},]def test_to_json_multi_index_unnamed_3(self) -> None:@@ -505,13 +504,149 @@ class TestPandasTableManager(unittest.TestCase):df = df.stack(future_stack=True)json_data = self.factory_create_json_from_df(df)expected = [- {"": "cat", " ": "kg", "weight": 1.0, "height": nan},- {"": "cat", " ": "m", "weight": nan, "height": 2.0},- {"": "dog", " ": "kg", "weight": 3.0, "height": nan},- {"": "dog", " ": "m", "weight": nan, "height": 4.0},+ {"Index0": "cat", "Index1": "kg", "weight": 1.0, "height": nan},+ {"Index0": "cat", "Index1": "m", "weight": nan, "height": 2.0},+ {"Index0": "dog", "Index1": "kg", "weight": 3.0, "height": nan},+ {"Index0": "dog", "Index1": "m", "weight": nan, "height": 4.0},]assert_rows_equal_with_nan(json_data, expected)+ def test_flatten_non_trivial_index_named_single(self) -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.tables.pandas_table import (+ _flatten_non_trivial_index,+ )++ df = pd.DataFrame({"v": [1, 2]}, index=pd.Index(["a", "b"], name="k"))+ out = _flatten_non_trivial_index(df)+ assert list(out.columns) == ["k", "v"]++ def test_flatten_non_trivial_index_trivial_range_noop(self) -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.tables.pandas_table import (+ _flatten_non_trivial_index,+ )++ df = pd.DataFrame({"v": [1, 2]})+ out = _flatten_non_trivial_index(df)+ assert list(out.columns) == ["v"]++ def test_flatten_non_trivial_index_multiindex(self) -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.tables.pandas_table import (+ _flatten_non_trivial_index,+ )++ idx = pd.MultiIndex.from_tuples([("x", 1), ("y", 2)], names=["a", "b"])+ df = pd.DataFrame({"v": [1, 2]}, index=idx)+ out = _flatten_non_trivial_index(df)+ assert list(out.columns) == ["a", "b", "v"]++ def test_flatten_non_trivial_index_unnamed_gets_indexed_names(+ self,+ ) -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.tables.pandas_table import (+ _flatten_non_trivial_index,+ )++ # A single unnamed index becomes "Index0".+ df = pd.DataFrame({"v": [1, 2]}, index=pd.Index(["a", "b"]))+ out = _flatten_non_trivial_index(df)+ assert list(out.columns) == ["Index0", "v"]++ # The unnamed level of a partially-named MultiIndex is the first+ # unnamed level, so it is also "Index0".+ idx = pd.MultiIndex.from_tuples(+ [("x", 1), ("y", 2)], names=["a", None]+ )+ df2 = pd.DataFrame({"v": [1, 2]}, index=idx)+ out2 = _flatten_non_trivial_index(df2)+ assert list(out2.columns) == ["a", "Index0", "v"]++ # Two unnamed levels get distinct "Index0"/"Index1" names.+ idx3 = pd.MultiIndex.from_tuples([("x", 1), ("y", 2)])+ df3 = pd.DataFrame({"v": [1, 2]}, index=idx3)+ out3 = _flatten_non_trivial_index(df3)+ assert list(out3.columns) == ["Index0", "Index1", "v"]++ def test_flatten_non_trivial_index_synthetic_name_conflict(self) -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.tables.pandas_table import (+ _flatten_non_trivial_index,+ )++ # A real column already named "Index0" forces the flattened index+ # column to be disambiguated rather than colliding.+ df = pd.DataFrame({"Index0": [1, 2]}, index=pd.Index(["a", "b"]))+ out = _flatten_non_trivial_index(df)+ assert list(out.columns) == ["Index0_index", "Index0"]++ def test_flatten_non_trivial_index_named_level_collides_with_generated(+ self,+ ) -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.tables.pandas_table import (+ _flatten_non_trivial_index,+ )++ # A named level "Index0" alongside an unnamed level, whose generated+ # name would also be "Index0", must be disambiguated instead of+ # producing two identical columns.+ index = pd.MultiIndex.from_tuples(+ [("a", 1), ("b", 2)], names=["Index0", None]+ )+ df = pd.DataFrame({"v": [10, 20]}, index=index)+ out = _flatten_non_trivial_index(df)+ assert list(out.columns) == ["Index0", "Index0_index", "v"]++ def test_flatten_non_trivial_index_conflict_and_fallback_both_exist(+ self,+ ) -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.tables.pandas_table import (+ _flatten_non_trivial_index,+ )++ # Both the colliding column "x" and its "_index" fallback already+ # exist, so disambiguation must keep appending until unique.+ df = pd.DataFrame(+ {"x": [1, 2], "x_index": [3, 4]},+ index=pd.Index(["a", "b"], name="x"),+ )+ out = _flatten_non_trivial_index(df)+ assert list(out.columns) == ["x_index_index", "x", "x_index"]++ def test_with_index_as_columns_pandas_named_index(self) -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.tables.pandas_table import (+ PandasTableManagerFactory,+ )++ df = pd.DataFrame({"v": [1, 2]}, index=pd.Index(["a", "b"], name="k"))+ mgr = PandasTableManagerFactory.create()(df).with_index_as_columns()+ assert "k" in mgr.get_column_names()+ assert "v" in mgr.get_column_names()++ def test_with_index_as_columns_trivial_index_is_noop(self) -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.tables.pandas_table import (+ PandasTableManagerFactory,+ )++ df = pd.DataFrame({"v": [1, 2]})+ mgr = PandasTableManagerFactory.create()(df).with_index_as_columns()+ assert mgr.get_column_names() == ["v"]+@pytest.mark.skipif(not DependencyManager.numpy.has(), reason="numpy not installed")@@ -563,8 +698,8 @@ class TestPandasTableManager(unittest.TestCase):json_data = self.factory_create_json_from_df(data)assert json_data == [- {"": "All", "basic_amt,NSW": 1, "basic_amt,QLD": 1},- {"": "Full", "basic_amt,NSW": 0, "basic_amt,QLD": 1},+ {"Index0": "All", "basic_amt,NSW": 1, "basic_amt,QLD": 1},+ {"Index0": "Full", "basic_amt,NSW": 0, "basic_amt,QLD": 1},]def test_complex_data_field_types(self) -> None:@@ -613,9 +748,9 @@ class TestPandasTableManager(unittest.TestCase):manager = self.factory.create()(data)assert manager.get_row_headers() in [# pandas 2.x- [("", ("datetime", "datetime64[ns]"))],+ [("Index0", ("datetime", "datetime64[ns]"))],# pandas 3.x- [("", ("datetime", "datetime64[us]"))],+ [("Index0", ("datetime", "datetime64[us]"))],]def test_get_row_headers_timedelta_index(self) -> None:@@ -630,9 +765,9 @@ class TestPandasTableManager(unittest.TestCase):manager = self.factory.create()(data)assert manager.get_row_headers() in [# pandas 2.x- [("", ("string", "timedelta64[ns]"))],+ [("Index0", ("string", "timedelta64[ns]"))],# pandas 3.x- [("", ("string", "timedelta64[us]"))],+ [("Index0", ("string", "timedelta64[us]"))],]def test_get_row_headers_multi_index(self) -> None:@@ -688,6 +823,43 @@ class TestPandasTableManager(unittest.TestCase):header_names = [h[0] for h in headers]assert header_names == ["idx"]+ def test_get_row_headers_unnamed_multi_index(self) -> None:+ data = pd.DataFrame(+ {"A": [1, 2, 3]},+ index=pd.MultiIndex.from_tuples([("a", 1), ("b", 2), ("c", 3)]),+ )+ manager = self.factory.create()(data)+ header_names = [h[0] for h in manager.get_row_headers()]+ assert header_names == ["Index0", "Index1"]++ def test_get_row_headers_synthetic_name_conflict(self) -> None:+ data = pd.DataFrame(+ {"Index0": [1, 2]},+ index=pd.Index(["a", "b"]),+ )+ manager = self.factory.create()(data)+ header_names = [h[0] for h in manager.get_row_headers()]+ assert header_names == ["Index0_index"]++ def test_row_headers_match_flattened_columns(self) -> None:+ # The offered chart fields (row headers) must line up with the+ # serialized chart-data columns; both go through _index_level_names.+ from marimo._plugins.ui._impl.tables.pandas_table import (+ _flatten_non_trivial_index,+ )++ data = pd.DataFrame(+ {"v": [1, 2]},+ index=pd.MultiIndex.from_tuples(+ [("a", 1), ("b", 2)], names=["k", None]+ ),+ )+ manager = self.factory.create()(data)+ header_names = [h[0] for h in manager.get_row_headers()]+ flattened = list(_flatten_non_trivial_index(data).columns)+ assert header_names == ["k", "Index0"]+ assert flattened[: len(header_names)] == header_names+def test_is_type(self) -> None:assert self.manager.is_type(self.data)assert not self.manager.is_type("not a dataframe")@@ -1716,9 +1888,15 @@ class TestPandasTableManager(unittest.TestCase):manager = self.factory.create()(df)assert manager.get_row_headers() in [# pandas 2.x- [("", ("string", "object")), ("", ("integer", "int64"))],+ [+ ("Index0", ("string", "object")),+ ("Index1", ("integer", "int64")),+ ],# pandas 3.x- [("", ("string", "str")), ("", ("integer", "int64"))],+ [+ ("Index0", ("string", "str")),+ ("Index1", ("integer", "int64")),+ ],]assert manager.get_num_rows() == 4diff --git a/tests/_plugins/ui/_impl/test_table.py b/tests/_plugins/ui/_impl/test_table.pyindex 1c9c656929..bcbae9b79f 100644--- a/tests/_plugins/ui/_impl/test_table.py+++ b/tests/_plugins/ui/_impl/test_table.py@@ -1116,12 +1116,14 @@ def test_table_with_frozen_columns() -> None:not DependencyManager.pandas.has(), reason="Pandas not installed")class TestFrozenRowHeaders:- def test_freeze_unnamed_pandas_index_rejected(self) -> None:+ def test_freeze_unnamed_pandas_index(self) -> None:import pandas as pd+ # An unnamed index is exposed as the row header "Index0", so it has a+ # stable name that can be frozen like any named index.df = pd.DataFrame({"a": [1, 2, 3]}, index=["x", "y", "z"])- with pytest.raises(ValueError, match="unnamed row index"):- ui.table(df, freeze_columns_left=[""])+ table = ui.table(df, freeze_columns_left=["Index0"])+ assert table._component_args["freeze-columns-left"] == ["Index0"]def test_freeze_named_pandas_index(self) -> None:import pandas as pd@@ -1276,6 +1278,31 @@ def test_table_hidden_columns_row_header_raises() -> None:ui.table(df, hidden_columns=[name])+ not DependencyManager.pandas.has(), reason="Pandas not installed"+)+def test_get_data_url_includes_named_index() -> None:+ import pandas as pd++ from marimo._plugins.ui._impl.charts.altair_transformer import (+ _data_to_csv_string,+ )++ df = pd.DataFrame(+ {"v": [1, 2, 3]},+ index=pd.Index(["a", "b", "c"], name="k"),+ )+ table = ui.table(df)+ response = table._get_data_url(EmptyArgs())+ assert response.data_url # produced without error++ # The flattened manager exposes the index as a column.+ flattened = table._searched_manager.with_index_as_columns()+ assert "k" in flattened.get_column_names()+ csv = _data_to_csv_string(flattened.data)+ assert "k" in csv.splitlines()[0]++@pytest.mark.parametrize("df",create_dataframes({"a": [1, 2, 3], "b": ["abc", "def", None]}),@@ -2396,13 +2423,13 @@ def test_json_multi_col_idx_table() -> None:json_data = json.loads(table._component_args["data"])assert json_data == [{- "": "All",+ "Index0": "All",INDEX_COLUMN_NAME: 0,"basic_amt,NSW": 1,"basic_amt,QLD": 1,},{- "": "Full",+ "Index0": "Full",INDEX_COLUMN_NAME: 1,"basic_amt,NSW": 0,"basic_amt,QLD": 1,diff --git a/tests/_plugins/ui/_impl/utils/test_dataframe_utils.py b/tests/_plugins/ui/_impl/utils/test_dataframe_utils.pyindex 7e7f3fb319..cf189da72e 100644--- a/tests/_plugins/ui/_impl/utils/test_dataframe_utils.py+++ b/tests/_plugins/ui/_impl/utils/test_dataframe_utils.py@@ -45,9 +45,9 @@ def test_get_row_headers_pandas() -> None:df_multi = pd.DataFrame({"A": range(3)}, index=arrays)assert _get_row_headers(df_multi) in [# pandas 2.x- [("", ("string", "object")), ("", ("string", "object"))],+ [("Index0", ("string", "object")), ("Index1", ("string", "object"))],# pandas 3.x (StringDtype default)- [("", ("string", "str")), ("", ("string", "str"))],+ [("Index0", ("string", "str")), ("Index1", ("string", "str"))],]# Test with RangeIndex@@ -57,7 +57,7 @@ def test_get_row_headers_pandas() -> None:# Test with categorical Indexdf_cat = pd.DataFrame({"A": range(3)})df_cat.index = pd.CategoricalIndex(["a", "b", "c"])- assert _get_row_headers(df_cat) == [("", ("string", "category"))]+ assert _get_row_headers(df_cat) == [("Index0", ("string", "category"))]# Test with named categorical Indexdf_cat = pd.DataFrame({"A": range(3)})