What about interactive table?

[braudelan]

First thing that come to mind is sorting by column. This is probably the most useful and common operation for me. Filtering would be beautiful. And other stuff I can't think of right now.

[link89]

Is this a future goal of great-tables or not? It would be great to support some simple interactive actions like sorting by columns.

[david-waterworth]

I was wondering the same, I'd love to create a table using GT that I can display in shiny that includes basic dynamic column filter/sorting. Often I migrate user spreadsheets from excel/gsheets to shiny and this would be a nice way of doing this.

[ivelasq]

@braudelan @link89 @david-waterworth we'd love for you to check out reactable-py! https://machow.github.io/reactable-py/get-started/index.html

[mshiner]

Hi

I like the look of reactable-py combined with Great Tables. I posted an issue here as I'd like to show the table in a FastHTML app. This may help me to work around #172 and #173

Anyone able to help?

Thanks
Martyn

[paddymul]

Hey all. For what it's worth I created Buckaroo which is built around interactive data exploration. It has summary stats, extensive styling options, search, sort, forms of filtering and toggable views. BuckarooWidget is built around viewing DataFrames in jupyter without typing a bunch of options. Buckaroo the framework is capable of being heavily customized into "table apps". I recently built a dataframe diff tool on top of buckaroo https://www.youtube.com/shorts/u3PW6q36ufo as an example of the types of interactive apps that Buckaroo enables.

I'm eager to collaborate and talk to anyone who is doing cool stuff with tables.

@machow @rich-iannone I hope you don't mind me talking about my project in your issues, if there's any problem, feel free to remove the comment.

[rich-iannone]

Don’t mind at all, we love Buckaroo!

[jrycw]

I've recently been experimenting with the marimo project, and it seems like a great tool for users to explore Great Tables. With just a few lines of code, we can quickly style a selected column with a lightgray background interactively:

import marimo

__generated_with = "0.11.12"
app = marimo.App(width="medium")


@app.cell
def _():
    import polars as pl
    import marimo as mo

    from great_tables import GT, style, loc
    from great_tables.data import exibble

    df = pl.DataFrame(exibble)
    return GT, df, exibble, loc, mo, pl, style


@app.cell
def _(df, mo, pl):
    sel_cols = [col for col in df.columns if col not in {"group", "row"}]
    sel_col = mo.ui.radio.from_series(pl.Series(sel_cols), value=sel_cols[0])
    sel_col
    return sel_col, sel_cols


@app.cell
def _(GT, df, loc, sel_col, style):
    (
        GT(df)
        .tab_stub(groupname_col="group", rowname_col="row")
        .tab_style(
            style=style.fill(color="lightgray"), locations=loc.body(sel_col.value)
        )
    )
    return


if __name__ == "__main__":
    app.run()

@rich-iannone and @machow, I'm curious about the team's thoughts on this project. Could it be integrated with reactable-py? I suspect it could greatly enhance the interactivity that users have been requesting.

[jrycw]

It seems that Pointblank works quite well with Great Tables in a marimo notebook. Leveraging marimo’s built-in widgets opens up the possibility for users to interact with Pointblank through a GUI—for example, to quickly collect failed data as a CSV.

import marimo

__generated_with = "0.12.4"
app = marimo.App(width="medium")


@app.cell
def _():
    import marimo as mo
    import pointblank as pb
    return mo, pb


@app.cell
def _(pb):
    data = pb.load_dataset(dataset="small_table")
    data
    return (data,)


@app.cell
def _(mo):
    target_a = mo.ui.slider(0, 10)
    target_a
    return (target_a,)


@app.cell
def _(data, pb, target_a):
    validation = (
        pb.Validate(data=data)
        .col_vals_le(columns="a", value=target_a.value)
        .interrogate()
    )

    validation.get_sundered_data(type="fail")
    return (validation,)


if __name__ == "__main__":
    app.run()

[Yasin197]

@jrycw I'm not sure I understand, I thought the whole point was to allow a GT object to be interactive which I can't see from the example yo is posted?

[jrycw]

Sorry for not being clear. My intention was to demonstrate that the GT object (using pointblank as an example) can be interactive in the marimo environment, and we might not need to invest additional effort into that. The interactivity behaves more like a plug-in—for instance, by using reactable-py or marimo.

[Yasin197]

So I guess this is different from purely having a GT object in a Marimo environment whereby you import react-py to make the GT table dynamic without having to use mo.ui features ect

[jrycw]

Thanks for the feedback. Yes, these are two distinct approaches.

[Yasin197]

i raised an issue on marimo that reactable-py was not working in marimo and got an interesting response.
marimo-team/marimo#4058
@jrycw @machow

https://anywidget.dev/

[jrycw]

It looks like we can embed marimo widgets directly into Great Tables to add interactivity. I’ve explored this further—check out my follow-up post.

[Yasin197]

Very nice indeed! I was also thinking about being able to sort or filter GT tables directly (I guess we need reactablepy package for this?) which is the natural next step

[rich-iannone]

This looks phenomenally good (the demo) and I love that marimo widgets can be used directly inside Great Tables components (through html()) with no issues! Yeah, we definitely ought to feature these demos in the docs site. Thanks for experimenting with this and putting it all together!

[jrycw]

Thanks for all the kind words! I'd like to share a few notes based on my experiments:

1. Basic Concept
   The core idea is to first embed marimo widgets within the GT object in a single cell. Then, in another cell, you can use the reactive values (e.g. WIDGET.value) with Great Tables functions—typically through GT.FUNCTION(). I suspect even more powerful patterns could emerge using GT.pipe().

   If I understand correctly, whatever operation we want to perform needs to have a corresponding GT.FUNCTION() available.

   • For styling, we use GT.tab_style().
   • For column filtering, we use GT.cols_hide() and GT.cols_unhide().
   • For row filtering, we might need something like GT.rows_hide() and GT.rows_unhide().
   • For sorting, a GT.sort() function would likely be necessary.

   Currently, we can already target columns and rows, as shown in this example. We could do even more if the corresponding functionality is supported.

   marimo provides the widgets (and we can even define custom ones using AnyWidget), but we need a way to plug their reactive values into the Great Tables API.

2. Widget Rendering
   In some components, we might need to rely on the widget's _repr_html_() method. So, using html(WIDGET._repr_html_()) is generally safer and more consistent than html(WIDGET), which may fail in certain contexts.

3. Managing Table State
   During development, I found that having something like GT.save_snapshot() and GT.get_snapshot() could be really helpful for preserving or restoring a specific table state. While mo.state might also work for this, more experimentation is needed.

[jrycw]

wigglystuff is a great reference for creating custom widgets using anywidget.