use it from Python
Your pandas DataFrame, as a grid you can edit.
Work with a DataFrame the way you already do, then show it as an interactive data grid right where you are: in a Jupyter notebook, or in a Dash app. Scroll, sort, filter and edit in the grid, and read the edits straight back in Python with every dtype preserved. No export step, no copy of the data kept in step by hand.
pandas is the input
Hand it a DataFrame and it does the rest.
A pandas DataFrame is all either package needs. Your column dtypes map to the grid's own column types, so numbers, booleans and timestamps arrive typed rather than as text. Missing values come through as blanks, a named index becomes a leading column, and row identity is stable, so an edit always lands on the right row even when index labels repeat. The frame is sent to the browser column by column and rendered a window at a time, which is what keeps a large frame from freezing the page.
the Jupyter data grid
Edit a DataFrame in the notebook, get it back in Python.
Explore and clean a frame without leaving the cell. Show it as a grid, fix values by hand, sort and filter to find what needs attention, and pick the edited frame straight back up from the widget. Changes flow both ways, so you can push new rows or replace the frame from Python and the grid repaints.
It renders wherever ipywidgets do: JupyterLab, the classic Notebook, VS Code and Colab. On your own machine it runs free with no key.
pip install lattice-grid-jupyterimport pandas as pd
from lattice_grid_jupyter import LatticeGridWidget
df = pd.DataFrame({
"name": ["Ada", "Grace", "Linus"],
"score": [91, 88, 77],
"active": [True, False, True],
})
grid = LatticeGridWidget(df) # an editable grid over your DataFrame
grid # show it in a notebook cell
# edit cells in the grid, then read them back in Python, dtypes preserved:
grid.df
# push changes the other way, from Python into the grid:
grid.append_rows([{"name": "Edsger", "score": 95, "active": True}])
grid.set_data(df) # or replace the whole frame and repaintthe Dash data grid
A grid in your Dash app that your callbacks can read.
Put an editable grid over a DataFrame in a Dash layout, and let your callbacks respond to what a user changes. The component surfaces each edit and the current selection as ordinary props, so a cell change drives a Python callback the same way a dropdown or a slider does. Keep the server-side DataFrame in step, typed, with one call.
The grid ships inside the package, so it works with no build step and with no extra request at render time. On localhost it runs free with no key.
pip install lattice-grid-dashimport pandas as pd
from dash import Dash, Input, Output, callback, html
import lattice_grid_dash
from lattice_grid_dash import dataframe_to_data, apply_cell_edit
df = pd.DataFrame({
"name": ["Ada", "Grace", "Linus"],
"score": [91, 88, 77],
"active": [True, False, True],
})
app = Dash(__name__)
app.layout = html.Div([
lattice_grid_dash.LatticeGrid(
id="grid",
data=dataframe_to_data(df),
options={"edit": True},
),
html.Pre(id="out"),
])
@callback(Output("out", "children"), Input("grid", "cellChanged"))
def on_edit(edit):
if not edit:
return "Edit a cell to see it here."
apply_cell_edit(df, edit) # keep the server-side DataFrame in sync, typed
return f"{edit['colId']} on row {edit['key']} is now {edit['value']}"
if __name__ == "__main__":
app.run(debug=True)what you get either way
The same grid, in the tool you already use.
Typed round-trip
Edits come back cast to the column dtype, so a number stays a number and a boolean stays a boolean. There is no parsing step to write and no silent turn to text.
Built for real frames
Columns are sent column by column and rendered a window at a time, so a wide frame with a hundred thousand rows opens and scrolls without freezing the page.
Sort, filter and edit
The full grid is there: sort a column, filter to the rows that matter, and edit in place, all over the DataFrame you handed it.
Free on localhost
Both packages render the grid fully, with no watermark and no key, on your own machine. That is the everyday data-science case. Licence per domain when you deploy it for others.
One shared pandas layer
The notebook widget and the Dash component share the same DataFrame handling, so a column maps to the same grid type and an edit casts back the same way in both.
Push updates from Python
Add rows, delete rows or replace the whole frame from your code, and the grid keeps up, so a notebook can stream results into a grid as they land.
Install it and open a DataFrame.
Pick the package for where you work, point it at a frame, and see it as a grid in a minute. It runs free on your own machine, so you can try it before you decide anything.
lattice-grid-jupyter lattice-grid-dash lattice-grid-pandas Pricing