Tech'n'Take https://tech.ycwu.space/ This is Jerry Wu's Tech'n'take. quarto-1.9.37 Sun, 10 May 2026 00:00:00 GMT Rust Notes #3: Iterator collect and Result short-circuiting Jerry Wu https://tech.ycwu.space/posts/rust-notes-3/20260510.html

Rust Notes 3

Today, while reading the Rust documentation for the Iterator trait, I came across an interesting note in the collect method section.

It explains that collect() is more flexible than it might first appear:

collect() can also create instances of types that are not typical collections. For example, a String can be built from chars, and an iterator of Result<T, E> items can be collected into Result<Collection<T>, E>.

This behavior is particularly useful when you want either:

  • to short-circuit immediately when the first error occurs, or
  • all operations to succeed and collect the results.

For example:

fn main() {
    let v1 = vec!["not 42", "43"];
    let r1: Result<Vec<_>, _> = v1.iter().map(|s| s.parse::<i32>()).collect();
    println!("{r1:?}"); // Err(ParseIntError { kind: InvalidDigit })

    let v2 = vec!["42", "43"];
    let r2: Result<Vec<_>, _> = v2.iter().map(|s| s.parse::<i32>()).collect();
    println!("{r2:?}"); // Ok([42, 43])
}

In r1, the string "not 42" fails to parse as an i32, so the entire computation short-circuits and returns the first error (ParseIntError). The subsequent value "43" is never processed.

In contrast, r2 contains only valid numeric strings, so all elements are successfully parsed and collected into a Vec<i32> wrapped in Ok.

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> rust https://tech.ycwu.space/posts/rust-notes-3/20260510.html Sun, 10 May 2026 00:00:00 GMT Rust Notes #2: Trait-Based Conversions in Iterators Jerry Wu https://tech.ycwu.space/posts/rust-notes-2/20260509.html

Rust Notes 2

Today I read some code in Rust by Example and came across an interesting usage of iterator combinators.

Typically, I would pass a closure to Iterator::map(), but a more elegant approach is to use a trait function pointer directly. For example:

fn main() {
    let v = vec!["42"];
    let r1: Vec<_> = v.iter().map(|s| s.to_string()).collect();
    let r2: Vec<_> = v.into_iter().map(String::from).collect();
}

An alternative implementation for r1 is:

let r1: Vec<_> = v.iter().map(|&s| String::from(s)).collect();

Using .to_string() or String::from() here is mostly a matter of coding style.

The item type produced by v.iter() is &&str. In the first version, we rely on Rust’s auto-deref feature with |s| s.to_string(). In the second version, we manually destructure the extra reference layer using |&s|, converting the item from &&str to &str, which can then be passed directly to String::from().

For r1, we provide a closure that is applied to each item of the iterator. For r2, however, we directly pass the String::from function.

This technique becomes especially useful when type constraints are already clear from context. Instead of explicitly referring to a concrete constructor like String::from, Rust allows us to rely on more general trait-based conversions. For example, the book demonstrates that .map_err(From::from) leverages the From::from function as a generic conversion mechanism, letting the compiler infer the appropriate target error type from the surrounding Result context. This makes the code more flexible and reduces the need to commit to a specific concrete type at the point of transformation.

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> rust https://tech.ycwu.space/posts/rust-notes-2/20260509.html Sat, 09 May 2026 00:00:00 GMT Rust Notes #1: Loop Scope vs Python Jerry Wu https://tech.ycwu.space/posts/rust-notes-1/20260311.html

Rust Notes 1

For the last couple of months, I’ve been busy learning Rust and suddenly realized that I haven’t written a blog post in a while. So I’d like to share an interesting pattern I encountered while learning Rust from the perspective of a Python developer.

In the following Rust code, I initially expected to see idx=2 and n=3, but the compiler complained.

fn main() {
    let v = vec![1, 2, 3];
    for (idx, n) in v.iter().enumerate() {
        println!("{idx}, {n}");
    }
    println!("{idx}, {n}"); // panic!
}

What I had in mind was that the Rust code would translate conceptually into something like the following Python code:

v = [1,2,3]
for idx, n in enumerate(v):
    print(f"{idx}, {n}")
print(f"{idx}, {n}") # 2, 3

Frankly speaking, I was puzzled for a while before realizing that (idx, n) in the Rust for loop is actually a pattern. The variables idx and n exist only within the scope of the loop body, so they are not available outside the for block.

Learning Rust keeps things refreshing and interesting every time I come across a pattern that differs from Python. I hope to continue sharing short Rust notes like this in the future.

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> rust python https://tech.ycwu.space/posts/rust-notes-1/20260311.html Wed, 11 Mar 2026 00:00:00 GMT Notes on Turtle Island Jerry Wu https://tech.ycwu.space/posts/turtle-island-notes/20250721.html

Turtle Island docs

This is a short post documenting some things I often forget while building Turtle Island.

Output Column Names

In Polars, if an explicit name isn’t provided, the output column will take the name of the first expression. This default behavior is generally helpful, but it can lead to unexpected results—especially when the first expression doesn’t directly represent a column. For example, if the first expression is pl.lit(), the resulting column name will be "literal".

This isn’t a big issue when dealing with a single column, but it becomes problematic when using expressions like pl.all() or pl.col("*"). In such cases, logic that depends on column names often breaks.

My current workaround is to tweak the internal logic so that the returned expression doesn’t start with something like pl.lit(), especially in functions that aim to support wildcard expressions.

Expression Context vs DataFrame Context

Since Polars expressions are designed to be evaluated later (not immediately), we cannot rely on any runtime properties of the DataFrame when building them. That means things like the shape or number of rows in the DataFrame are not available during expression construction.

However, some built-in Polars functions help bridge this gap. For instance, pl.len() returns an expression that can be used to represent the number of rows in the future evaluation context. This is useful for writing general-purpose logic in Turtle Island.

A major caveat is that Polars expressions can’t be evaluated directly in Python. You can’t write something like if pl.len() or pl.len() + 1 as regular Python code. These expressions must be used inside other Polars expressions or functions—such as pl.int_range(0, pl.len() + 1)—where they’ll be correctly interpreted and evaluated within the Polars execution context.

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python polars ti https://tech.ycwu.space/posts/turtle-island-notes/20250721.html Mon, 21 Jul 2025 00:00:00 GMT Turtle Island: A Utility Kit for Polars Expressions Jerry Wu https://tech.ycwu.space/posts/turtle-island-intro/20250706.html This weekend, I started building a Python package called Turtle Island, which collects some of my ideas for helper functions aimed at reducing boilerplate when writing Polars expressions.

Currently, Turtle Island offers the following nine utilities:

  • case_when() – A cleaner and more readable way to construct chained conditional logic in Polars.
  • make_index() – Creates a virtual row index as a Polars expression, without materializing it as a column.
  • bucketize_lit() – Assigns literal values to rows in a round-robin pattern based on their index.
  • bucketize() – A more general version of bucketize_lit() that cycles through multiple Polars expressions, enabling advanced use cases with dynamic column values.
  • is_every_nth_row() – Identifies every n-th row using a modulo operation on the row index.
  • move_cols_to_start() – Reorders selected columns to appear at the beginning of the DataFrame.
  • move_cols_to_end() – Reorders selected columns to appear at the end of the DataFrame.
  • make_hyperlink() – Generates HTML anchor (<a>) tags from text and url columns for rendering clickable links.
  • make_tooltip() – Creates HTML tooltips from label and tooltip columns for hoverable text display.

Here’s a quick example that uses ti.is_every_nth_row() to build a Polars expression suitable for styling tables interactively with Great Tables:

import polars as pl
from great_tables import GT, loc, style
from great_tables.data import countrypops

import turtle_island as ti

df_pd = countrypops.sample(10).loc[:, ["country_name", "year", "population"]]
df_pl = pl.from_pandas(df_pd)
row_expr = ti.is_every_nth_row(3)

(
    GT(df_pl)
    .tab_style(style=style.fill("lightblue"), locations=loc.body(rows=row_expr))
    .tab_style(style=style.fill("papayawhip"), locations=loc.body(rows=~row_expr))
    .opt_stylize(style=3, color="pink")
)

Styling table using Turtle Island

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python polars ti https://tech.ycwu.space/posts/turtle-island-intro/20250706.html Sun, 06 Jul 2025 00:00:00 GMT Creating an Integrated marimo UI Explorer with Great Tables Jerry Wu https://tech.ycwu.space/posts/marimo-gt-ui-reference/20250704.html While working with marimo widgets, I often find myself wanting a quick glance at what each widget looks like or which parameters it accepts. That’s when I realized—this was a perfect opportunity to build an interactive UI cheatsheet using Great Tables inside a marimo notebook.

marimo UI explorer with Great Tables

NoteGive It a Sec – WASM Magic Happening

The widgets may take a few moments to load, as they rely on WebAssembly under the hood.

This interactive table includes four columns:

  1. A link to the documentation.
  2. A live widget preview.
  3. Its current reactive value.
  4. A code snippet with an accordion that reveals the widget’s signature.

To keep things playful, I added a touch of randomness—so the table appears slightly different each time it loads.

link widget value code
[Switch](https://docs.marimo.io/api/inputs/switch/) False
switch(value: bool = False, *, label: str = '', disabled: bool = False, on_change: Optional[Callable[[bool], None]] = None)
[CheckBox](https://docs.marimo.io/api/inputs/checkbox/) False
checkbox(value: bool = False, *, label: str = '', disabled: bool = False, on_change: Optional[Callable[[bool], None]] = None)
[Date](https://docs.marimo.io/api/inputs/dates/) 2026-05-10
date(start: Optional[date | str] = None, stop: Optional[date | str] = None, value: Optional[date | str] = None, *, label: str = '', on_change: Optional[Callable[[date], None]] = None, full_width: bool = False, disabled: bool = False)
[Run Button](https://docs.marimo.io/api/inputs/run_button/) False
run_button(kind: Literal['neutral', 'success', 'warn', 'danger'] = 'neutral', disabled: bool = False, tooltip: Optional[str] = None, *, label: str = 'click to run', on_change: Optional[Callable[[Any], None]] = None, full_width: bool = False, keyboard_shortcut: Optional[str] = None)
[Button](https://docs.marimo.io/api/inputs/button/) 0
button(on_click: Optional[Callable[[Any], Any]] = None, value: Optional[Any] = None, kind: Literal['neutral', 'success', 'warn', 'danger'] = 'neutral', disabled: bool = False, tooltip: Optional[str] = None, *, label: str = 'click here', on_change: Optional[Callable[[Any], None]] = None, full_width: bool = False, keyboard_shortcut: Optional[str] = None)
[Number](https://docs.marimo.io/api/inputs/number/) 1
number(start: Optional[float] = None, stop: Optional[float] = None, step: Optional[float] = None, value: Optional[float] = None, debounce: bool = False, *, label: str = '', on_change: Optional[Callable[[Optional[Numeric]], None]] = None, full_width: bool = False, disabled: bool = False)
[Slider](https://docs.marimo.io/api/inputs/slider/) 1
slider(start: Optional[Numeric] = None, stop: Optional[Numeric] = None, step: Optional[Numeric] = None, value: Optional[Numeric] = None, debounce: bool = False, disabled: bool = False, orientation: Literal['horizontal', 'vertical'] = 'horizontal', show_value: bool = False, include_input: bool = False, steps: Optional[Sequence[Numeric]] = None, *, label: str = '', on_change: Optional[Callable[[Optional[Numeric]], None]] = None, full_width: bool = False)
[Range Slider](https://docs.marimo.io/api/inputs/range_slider/) [2, 6]
range_slider(start: Optional[Numeric] = None, stop: Optional[Numeric] = None, step: Optional[Numeric] = None, value: Optional[Sequence[Numeric]] = None, debounce: bool = False, orientation: Literal['horizontal', 'vertical'] = 'horizontal', show_value: bool = False, steps: Optional[Sequence[Numeric]] = None, *, label: str = '', on_change: Optional[Callable[[Sequence[Numeric]], None]] = None, full_width: bool = False, disabled: bool = False)
[Radio](https://docs.marimo.io/api/inputs/radio/) Apples
radio(options: Sequence[str] | dict[str, Any], value: Optional[str] = None, inline: bool = False, *, label: str = '', on_change: Optional[Callable[[Any], None]] = None, disabled: bool = False)
[Dropdown](https://docs.marimo.io/api/inputs/dropdown/) Apples
dropdown(options: Sequence[Any] | dict[str, Any], value: Optional[Any] = None, allow_select_none: Optional[bool] = None, searchable: bool = False, *, label: str = '', on_change: Optional[Callable[[Any], None]] = None, full_width: bool = False)
[MultiSelect](https://docs.marimo.io/api/inputs/multiselect/) []
multiselect(options: Sequence[Any] | dict[str, Any], value: Optional[Sequence[Any]] = None, *, label: str = '', on_change: Optional[Callable[[list[object]], None]] = None, full_width: bool = False, max_selections: Optional[int] = None)
[Text](https://docs.marimo.io/api/inputs/text/)
text(value: str = '', placeholder: str = '', kind: Literal['text', 'password', 'email', 'url'] = 'text', max_length: Optional[int] = None, disabled: bool = False, debounce: bool | int = True, *, label: str = '', on_change: Optional[Callable[[str], None]] = None, full_width: bool = False)
[Text Area](https://docs.marimo.io/api/inputs/text_area/)
text_area(value: str = '', placeholder: str = '', max_length: Optional[int] = None, disabled: bool = False, debounce: bool | int = True, rows: Optional[int] = None, *, label: str = '', on_change: Optional[Callable[[str], None]] = None, full_width: bool = False)

One interesting discovery: the new state of the mo.ui.run_button doesn’t persist as expected. This may be resolved by more effectively using marimo’s reactive state, which I plan to explore further.

Check out the full marimo code below or view it on molab.

import marimo

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


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

    return (mo,)


@app.cell
def _():
    import random
    from collections.abc import Iterable

    import pandas as pd
    from great_tables import GT, html

    return GT, Iterable, html, pd, random


@app.cell
def _(Iterable):
    def render_widget(widget):
        if hasattr(widget, "_display_"):
            render_method = "_display_"
        elif hasattr(widget, "_repr_html_"):
            render_method = "_repr_html_"
        elif hasattr(widget, "_mime_"):
            render_method = "_mime_"
        else:
            raise ValueError("The object does not have a valid render method.")
        return getattr(widget, render_method)()

    def render_widgets(widgets):
        if not isinstance(widgets, Iterable):
            widgets = [widgets]
        return [render_widget(widget) for widget in widgets]

    def strify_widget_value(widget):
        return str(widget.value)

    def strify_widget_values(widgets):
        if not isinstance(widgets, Iterable):
            widgets = [widgets]
        return [strify_widget_value(w) for w in widgets]

    return render_widgets, strify_widget_values


@app.cell
def _(mo, random):
    switch = mo.ui.switch()
    checkbox = mo.ui.checkbox(label="check me")
    date = mo.ui.date()
    run_botton = mo.ui.run_button(label="Run")
    button = mo.ui.button(
        value=0, on_click=lambda value: value + 1, label="increment"
    )
    number = mo.ui.number(1, 10)
    slider = mo.ui.slider(1, 10, 1)
    range_slider = mo.ui.range_slider(1, 10, 2, value=[2, 6])
    radio = mo.ui.radio(options=["Apples", "Oranges"], value="Apples")
    dropdown = mo.ui.dropdown(options=["Apples", "Oranges"], value="Apples")
    multiselect = mo.ui.multiselect(options=["Apples", "Oranges"])
    text = mo.ui.text(placeholder="placeholder...", debounce=False)
    text_area = mo.ui.text_area(placeholder="placeholder...", debounce=False)

    widgets = mo.ui.array(
        [
            switch,
            checkbox,
            date,
            run_botton,
            button,
            number,
            slider,
            range_slider,
            radio,
            dropdown,
            multiselect,
            text,
            text_area,
        ]
    )

    col_widget_link = [
        mo.md("[Switch](https://docs.marimo.io/api/inputs/switch/)"),
        mo.md("[CheckBox](https://docs.marimo.io/api/inputs/checkbox/)"),
        mo.md("[Date](https://docs.marimo.io/api/inputs/dates/)"),
        mo.md("[Run Button](https://docs.marimo.io/api/inputs/run_button/)"),
        mo.md("[Button](https://docs.marimo.io/api/inputs/button/)"),
        mo.md("[Number](https://docs.marimo.io/api/inputs/number/)"),
        mo.md("[Slider](https://docs.marimo.io/api/inputs/slider/)"),
        mo.md(
            "[Range Slider](https://docs.marimo.io/api/inputs/range_slider/)"
        ),
        mo.md("[Radio](https://docs.marimo.io/api/inputs/radio/)"),
        mo.md("[Dropdown](https://docs.marimo.io/api/inputs/dropdown/)"),
        mo.md("[MultiSelect](https://docs.marimo.io/api/inputs/multiselect/)"),
        mo.md("[Text](https://docs.marimo.io/api/inputs/text/)"),
        mo.md("[Text Area](https://docs.marimo.io/api/inputs/text_area/)"),
    ]

    col_code = [
        mo.accordion(
            {
                "switch = mo.ui.switch()": "`switch(value: bool = False, *, label: str = '', disabled: bool = False, on_change: Optional[Callable[[bool], None]] = None)`"
            }
        ),
        mo.accordion(
            {
                'checkbox = mo.ui.checkbox(label="check me")': "`checkbox(value: bool = False, *, label: str = '', disabled: bool = False, on_change: Optional[Callable[[bool], None]] = None)`"
            }
        ),
        mo.accordion(
            {
                "date = mo.ui.date()": "`date(start: Optional[date | str] = None, stop: Optional[date | str] = None, value: Optional[date | str] = None, *, label: str = '', on_change: Optional[Callable[[date], None]] = None, full_width: bool = False, disabled: bool = False)`"
            }
        ),
        mo.accordion(
            {
                'run_botton = mo.ui.run_button(label="Run")': "`run_button(kind: Literal['neutral', 'success', 'warn', 'danger'] = 'neutral', disabled: bool = False, tooltip: Optional[str] = None, *, label: str = 'click to run', on_change: Optional[Callable[[Any], None]] = None, full_width: bool = False, keyboard_shortcut: Optional[str] = None)`",
            }
        ),
        mo.accordion(
            {
                'button = mo.ui.button(value=0, on_click=lambda value: value + 1, label="increment")': "`button(on_click: Optional[Callable[[Any], Any]] = None, value: Optional[Any] = None, kind: Literal['neutral', 'success', 'warn', 'danger'] = 'neutral', disabled: bool = False, tooltip: Optional[str] = None, *, label: str = 'click here', on_change: Optional[Callable[[Any], None]] = None, full_width: bool = False, keyboard_shortcut: Optional[str] = None)`"
            }
        ),
        mo.accordion(
            {
                "number = mo.ui.number(1, 10)": "`number(start: Optional[float] = None, stop: Optional[float] = None, step: Optional[float] = None, value: Optional[float] = None, debounce: bool = False, *, label: str = '', on_change: Optional[Callable[[Optional[Numeric]], None]] = None, full_width: bool = False, disabled: bool = False)`"
            }
        ),
        mo.accordion(
            {
                "slider = mo.ui.slider(1, 10, 1)": "`slider(start: Optional[Numeric] = None, stop: Optional[Numeric] = None, step: Optional[Numeric] = None, value: Optional[Numeric] = None, debounce: bool = False, disabled: bool = False, orientation: Literal['horizontal', 'vertical'] = 'horizontal', show_value: bool = False, include_input: bool = False, steps: Optional[Sequence[Numeric]] = None, *, label: str = '', on_change: Optional[Callable[[Optional[Numeric]], None]] = None, full_width: bool = False)`"
            }
        ),
        mo.accordion(
            {
                "range_slider = mo.ui.range_slider(1, 10, 2, value=[2, 6])": "`range_slider(start: Optional[Numeric] = None, stop: Optional[Numeric] = None, step: Optional[Numeric] = None, value: Optional[Sequence[Numeric]] = None, debounce: bool = False, orientation: Literal['horizontal', 'vertical'] = 'horizontal', show_value: bool = False, steps: Optional[Sequence[Numeric]] = None, *, label: str = '', on_change: Optional[Callable[[Sequence[Numeric]], None]] = None, full_width: bool = False, disabled: bool = False)`"
            }
        ),
        mo.accordion(
            {
                'radio = mo.ui.radio(options=["Apples", "Oranges"], value="Apples")': "`radio(options: Sequence[str] | dict[str, Any], value: Optional[str] = None, inline: bool = False, *, label: str = '', on_change: Optional[Callable[[Any], None]] = None, disabled: bool = False)`"
            }
        ),
        mo.accordion(
            {
                'dropdown = mo.ui.dropdown(options=["Apples", "Oranges"], value="Apples")': "`dropdown(options: Sequence[Any] | dict[str, Any], value: Optional[Any] = None, allow_select_none: Optional[bool] = None, searchable: bool = False, *, label: str = '', on_change: Optional[Callable[[Any], None]] = None, full_width: bool = False)`"
            }
        ),
        mo.accordion(
            {
                'multiselect = mo.ui.multiselect(options=["Apples", "Oranges"])': "`multiselect(options: Sequence[Any] | dict[str, Any], value: Optional[Sequence[Any]] = None, *, label: str = '', on_change: Optional[Callable[[list[object]], None]] = None, full_width: bool = False, max_selections: Optional[int] = None)`"
            }
        ),
        mo.accordion(
            {
                'text = mo.ui.text(placeholder="placeholder...", debounce=False)': "`text(value: str = '', placeholder: str = '', kind: Literal['text', 'password', 'email', 'url'] = 'text', max_length: Optional[int] = None, disabled: bool = False, debounce: bool | int = True, *, label: str = '', on_change: Optional[Callable[[str], None]] = None, full_width: bool = False)`"
            }
        ),
        mo.accordion(
            {
                'text_area = mo.ui.text_area(placeholder="placeholder...", debounce=False)': "`text_area(value: str = '', placeholder: str = '', max_length: Optional[int] = None, disabled: bool = False, debounce: bool | int = True, rows: Optional[int] = None, *, label: str = '', on_change: Optional[Callable[[str], None]] = None, full_width: bool = False)`"
            }
        ),
    ]

    # table styling
    _style_number_start, _style_number_end = 1, 6
    style_widget = mo.ui.slider(
        _style_number_start,
        _style_number_end,
        value=random.randint(_style_number_start, _style_number_end),
        label="Style Number",
    )

    _colors = ["blue", "cyan", "pink", "green", "red", "gray"]
    color_widget = mo.ui.radio(
        options=_colors,
        value=random.choice(_colors),
        label="Style Color",
        inline=True,
    )
    return col_code, col_widget_link, color_widget, style_widget, widgets


@app.cell
def _(
    col_code,
    col_widget_link,
    pd,
    render_widgets,
    strify_widget_values,
    widgets,
):
    col_widget = render_widgets(widgets)
    col_value = strify_widget_values(widgets)

    data = {
        "link": col_widget_link,
        "widget": col_widget,
        "value": col_value,
        "code": col_code,
    }

    df = pd.DataFrame(data)
    return (df,)


@app.cell
def _(GT, color_widget, df, html, style_widget):
    gt = (
        GT(df)
        .cols_align("left")
        .opt_all_caps()
        .tab_header(html(style_widget), html(color_widget))
    )
    return (gt,)


@app.cell
def _(color_widget, gt, style_widget):
    (
        gt.opt_stylize(style=style_widget.value, color=color_widget.value)
        .opt_align_table_header("left")
        .cols_width({"widget": "20%"})
    )
    return


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

This post was drafted by me, with AI assistance to refine the content.

]]> python marimo gt https://tech.ycwu.space/posts/marimo-gt-ui-reference/20250704.html Fri, 04 Jul 2025 00:00:00 GMT Time Machine for Great Tables in marimo Jerry Wu https://tech.ycwu.space/posts/marimo-gt-time-machine/20250626.html This post demonstrates how to build a “time machine” that lets you easily navigate through different stages of table construction using Great Tables in a marimo notebook.

Time Machine for Great Tables

Building the Time Machine Core

NoteGive It a Sec – WASM Magic Happening

The widgets may take a few moments to load, as they rely on WebAssembly under the hood.

The goal is to create a WigGT object that behaves like a GT object from Great Tables. As we progressively build the table, we maintain two versions:

  • The original (non-interactive) table
  • An interactive version that includes a marimo widget (in this case, a slider)

This setup allows us to move back and forth through the table-building steps and see how each method transforms the output — effectively creating a table “time machine.”

Let’s break it down.

Getting the Allowed Method Names

First, we need a list of Great Tables methods that should be wrapped and recorded. For now, this list is constructed manually, but ideally, Great Tables could expose this for easier third-party use.

def get_allowed_member_names() -> list[str]:
    return ["fmt", "fmt_number", ...]

The lazify Decorator

The lazify decorator wraps each method call and stores it in a pipeline. This allows us to defer execution until we’re ready to materialize the final table using .collect(). Only the selected methods from Great Tables will be decorated.

def lazify(cls: GT) -> GT:
    def add_to_pipeline(func: Callable[..., GT]) -> callable:
        @wraps(func)
        def wrapper(self, *args, **kwargs):
            def inner(self):
                return func(self, *args, **kwargs)

            # container for storing callable objects
            self._pipeline.append(inner)
            return self

        wrapper.__signature__ = inspect.signature(func)
        return wrapper

    for member_name in get_allowed_member_names():
        setattr(
            cls, member_name, add_to_pipeline(getattr(GT, member_name))
        )
    return cls

Designing the WigGT Class

Here are the main ideas behind the design:

  1. Original tables are stored in self._tables, accessible via the .tables property.
  2. Interactive versions with embedded marimo widgets are stored in self._wtables. These aren’t exposed directly — interaction is done through the marimo UI.
  3. The rendering method follows marimo’s convention, trying _display_, then _repr_html_, and finally _mime_, in that order.

With this setup, WigGT tracks the full transformation pipeline and allows easy replay of each step through a slider.

@lazify
class WigGT:
    def __init__(self, *args, widget, **kwargs):
        self._args = args
        self._widget = widget
        self._kwargs = kwargs
        self.set_to_init()

    @property
    def tables(self) -> list[GT]:
        return list(self._tables)  # return a new list

    def _widgetify(self, obj: GT) -> GT:
        return obj.tab_source_note(html(self._widget))

    def collect(self) -> Self:
        if not self._is_collect:
            new_obj = self._tables[0]  # don't use self._wtables[0]
            for f in self._pipeline:
                new_obj = f(self=copy.copy(new_obj))
                self._tables.append(new_obj)
                self._wtables.append(self._widgetify(new_obj))
            self._is_collect = True
        return self

    def _repr_html_(self) -> str:
        try:
            obj = self._wtables[self._widget.value]
        except IndexError:
            obj = self._wtables[-1]

        if hasattr(obj, "_display_"):
            render_method = "_display_"
        elif hasattr(obj, "_repr_html_"):
            render_method = "_repr_html_"
        elif hasattr(obj, "_mime_"):
            render_method = "_mime_"
        else:
            raise AttributeError(
                "The object does not have a valid render method."
            )
        return getattr(obj, render_method)()  # remember to invoke

    def set_to_init(self) -> None:
        if not getattr(self, "_pipeline", None):
            self._pipeline: list[callable] = []
        else:
            self._pipeline.clear()

        if not getattr(self, "_tables", None):
            self._tables = []
        else:
            self._tables.clear()

        if not getattr(self, "_wtables", None):
            self._wtables = []
        else:
            self._wtables.clear()

        obj = self._make_gt()
        self._tables.append(obj)
        self._wtables.append(self._widgetify(obj))
        self._is_collect = False

    def _make_gt(self) -> GT:
        return GT(*self._args, **self._kwargs)

marimo

Now we’re ready to time travel through the table-building process!

Create a Slider to Navigate Table States

We begin by creating a slider that represents each step in the build pipeline.

  • Step 0 is the original GT object.
  • Step 1 applies the first method call, and so on.
WarningSlider Range Limitation

Because all method calls are deferred, we can’t determine the total number of steps ahead of time. This means the developer needs to manually specify a reasonable range for the slider. If the selected index exceeds the available range, the last table will be shown by default.

time_widget = mo.ui.slider(start=0, stop=6, step=1, value=0, label="Step")

Build the Lazy Table Sequence

Next, we use an example from the Great Tables documentation to create a lazy WigGT object. This will internally store each method call but won’t execute them just yet.

You’ll see a slider widget embedded in the table’s source note — but it won’t be functional until we finalize the process.

lazy_wig_gt = (
    WigGT(airquality.head(10).assign(Year=1973), widget=time_widget)
    .opt_stylize(color="pink", style=2)
    .tab_header(
        title="New York Air Quality Measurements",
        subtitle="Daily measurements in New York City (May 1-10, 1973)",
    )
    .tab_spanner(label="Time", columns=["Year", "Month", "Day"])
    .tab_spanner(
        label="Measurement", columns=["Ozone", "Solar_R", "Wind", "Temp"]
    )
    .cols_move_to_start(columns=["Year", "Month", "Day"])
    .cols_label(
        Ozone=html("Ozone,<br>ppbV"),
        Solar_R=html("Solar R.,<br>cal/m<sup>2</sup>"),
        Wind=html("Wind,<br>mph"),
        Temp=html("Temp,<br>&deg;F"),
    )
)
lazy_wig_gt
Ozone Solar_R Wind Temp Month Day Year
41.0 190.0 7.4 67 5 1 1973
36.0 118.0 8.0 72 5 2 1973
12.0 149.0 12.6 74 5 3 1973
18.0 313.0 11.5 62 5 4 1973
14.3 56 5 5 1973
28.0 14.9 66 5 6 1973
23.0 299.0 8.6 65 5 7 1973
19.0 99.0 13.8 59 5 8 1973
8.0 19.0 20.1 61 5 9 1973
194.0 8.6 69 5 10 1973

Trigger Execution with .collect()

To make the slider work, we call .collect() on the WigGT instance. This executes the stored methods and generates a list of tables, one for each step.

Once collected, you can interactively slide through each version of the table!

wig_gt = lazy_wig_gt.collect()
wig_gt
Ozone Solar_R Wind Temp Month Day Year
41.0 190.0 7.4 67 5 1 1973
36.0 118.0 8.0 72 5 2 1973
12.0 149.0 12.6 74 5 3 1973
18.0 313.0 11.5 62 5 4 1973
14.3 56 5 5 1973
28.0 14.9 66 5 6 1973
23.0 299.0 8.6 65 5 7 1973
19.0 99.0 13.8 59 5 8 1973
8.0 19.0 20.1 61 5 9 1973
194.0 8.6 69 5 10 1973

Access All Built Tables

Finally, you can retrieve all constructed tables using the .tables property, which returns a list of GT objects.

wig_gt.tables

Full marimo code

Check out the full marimo code below or view it on molab.

import marimo

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


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

    return (mo,)


@app.cell
def _():
    import copy
    import inspect
    from functools import wraps
    from typing import Callable, Self

    import pandas as pd
    from great_tables import GT, html
    from great_tables.data import airquality

    return Callable, GT, Self, airquality, copy, html, inspect, wraps


@app.cell
def _(Callable, GT, Self, copy, html, inspect, wraps):
    def get_allowed_member_names() -> list[str]:
        """
        Manually constructing the list —
        it would be great if Great Tables exposed the available method names.
        """
        return [
            "fmt",
            "fmt_number",
            "fmt_integer",
            "fmt_percent",
            "fmt_scientific",
            "fmt_currency",
            "fmt_bytes",
            "fmt_roman",
            "fmt_date",
            "fmt_time",
            "fmt_datetime",
            "fmt_markdown",
            "fmt_image",
            "fmt_icon",
            "fmt_flag",
            "fmt_units",
            "fmt_nanoplot",
            "data_color",
            "sub_missing",
            "sub_zero",
            "opt_stylize",
            "opt_align_table_header",
            "opt_all_caps",
            "opt_footnote_marks",
            "opt_row_striping",
            "opt_vertical_padding",
            "opt_horizontal_padding",
            "opt_table_outline",
            "opt_table_font",
            "cols_align",
            "cols_width",
            "cols_label",
            "cols_move",
            "cols_move_to_start",
            "cols_move_to_end",
            "cols_hide",
            "cols_unhide",
            "tab_header",
            "tab_source_note",
            "tab_spanner",
            "tab_stubhead",
            "tab_style",
            "tab_options",
            "row_group_order",
            "tab_stub",
            "with_id",
            "with_locale",
            "save",
            "show",
            "as_raw_html",
            "write_raw_html",
            "as_latex",
            "pipe",
        ]

    def lazify(cls: GT) -> GT:
        def add_to_pipeline(func: Callable[..., GT]) -> callable:
            @wraps(func)
            def wrapper(self, *args, **kwargs):
                def inner(self):
                    return func(self, *args, **kwargs)

                # container for storing callable objects
                self._pipeline.append(inner)
                return self

            wrapper.__signature__ = inspect.signature(func)
            return wrapper

        for member_name in get_allowed_member_names():
            setattr(
                cls, member_name, add_to_pipeline(getattr(GT, member_name))
            )
        return cls

    @lazify
    class WigGT:
        def __init__(self, *args, widget, **kwargs):
            self._args = args
            self._widget = widget
            self._kwargs = kwargs
            self.set_to_init()

        @property
        def tables(self) -> list[GT]:
            return list(self._tables)  # return a new list

        def _widgetify(self, obj: GT) -> GT:
            return obj.tab_source_note(html(self._widget))

        def collect(self) -> Self:
            if not self._is_collect:
                new_obj = self._tables[0]  # don't use self._wtables[0]
                for f in self._pipeline:
                    new_obj = f(self=copy.copy(new_obj))
                    self._tables.append(new_obj)
                    self._wtables.append(self._widgetify(new_obj))
                self._is_collect = True
            return self

        def _repr_html_(self) -> str:
            try:
                obj = self._wtables[self._widget.value]
            except IndexError:
                obj = self._wtables[-1]

            if hasattr(obj, "_display_"):
                render_method = "_display_"
            elif hasattr(obj, "_repr_html_"):
                render_method = "_repr_html_"
            elif hasattr(obj, "_mime_"):
                render_method = "_mime_"
            else:
                raise AttributeError(
                    "The object does not have a valid render method."
                )
            return getattr(obj, render_method)()  # remember to invoke

        def set_to_init(self) -> None:
            if not getattr(self, "_pipeline", None):
                self._pipeline: list[callable] = []
            else:
                self._pipeline.clear()

            if not getattr(self, "_tables", None):
                self._tables = []
            else:
                self._tables.clear()

            if not getattr(self, "_wtables", None):
                self._wtables = []
            else:
                self._wtables.clear()

            obj = self._make_gt()
            self._tables.append(obj)
            self._wtables.append(self._widgetify(obj))
            self._is_collect = False

        def _make_gt(self) -> GT:
            return GT(*self._args, **self._kwargs)

    return (WigGT,)


@app.cell
def _(mo):
    time_widget = mo.ui.slider(start=0, stop=6, step=1, value=0, label="Step")
    time_widget
    return (time_widget,)


@app.cell
def _(WigGT, airquality, html, time_widget):
    # The lazy_wig_gt object is not interactive until collect() is called.
    lazy_wig_gt = (
        WigGT(airquality.head(10).assign(Year=1973), widget=time_widget)
        .opt_stylize(color="pink", style=2)
        .tab_header(
            title="New York Air Quality Measurements",
            subtitle="Daily measurements in New York City (May 1-10, 1973)",
        )
        .tab_spanner(label="Time", columns=["Year", "Month", "Day"])
        .tab_spanner(
            label="Measurement", columns=["Ozone", "Solar_R", "Wind", "Temp"]
        )
        .cols_move_to_start(columns=["Year", "Month", "Day"])
        .cols_label(
            Ozone=html("Ozone,<br>ppbV"),
            Solar_R=html("Solar R.,<br>cal/m<sup>2</sup>"),
            Wind=html("Wind,<br>mph"),
            Temp=html("Temp,<br>&deg;F"),
        )
    )
    lazy_wig_gt
    return (lazy_wig_gt,)


@app.cell
def _(lazy_wig_gt):
    # The wig_gt object is now interactive
    wig_gt = lazy_wig_gt.collect()
    wig_gt
    return (wig_gt,)


@app.cell
def _(wig_gt):
    # retrieve all `gt` tables
    wig_gt.tables
    return


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

In Closing

marimo has turned out to be far more powerful than I expected — I’ve had a lot of fun experimenting with it.

I highly recommend checking out their YouTube channel, which is full of high-quality content across many Python topics.

This idea was heavily inspired by their videos — all credit goes to the amazing marimo team!

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python marimo gt https://tech.ycwu.space/posts/marimo-gt-time-machine/20250626.html Thu, 26 Jun 2025 00:00:00 GMT Interactive Django Deployment Checklist with marimo Jerry Wu https://tech.ycwu.space/posts/marimo-django-deployment-checklist/20250625.html I love Django—it covers pretty much everything I need in a web environment. However, when it comes time to deploy a project to production, there are always a bunch of pre-deployment checks, and I can never seem to remember them all. I find myself constantly revisiting the official Django deployment checklist page.

Today I realized I don’t need all the detailed information every time—just a simple reminder list is enough. So, I built an interactive Django deployment checklist using Great Tables in marimo and hosted it on marimo.app. Now I can interact with it whenever I need a quick double-check.

Django deployment checklist

marimo

NoteGive It a Sec – WASM Magic Happening

The widgets may take a few moments to load, as they rely on WebAssembly under the hood.

  1. I asked AI to generate a checklist and wrapped it in a Polars DataFrame called df.
  2. I created 10 switch widgets and stacked them into an array widget named status_widgets to represent the status of each checklist item.
  3. I extracted the HTML representation of each widget via its _repr_html_() method and inserted it as a new "Status" column in df, which I then wrapped in a Great Tables GT object.
  4. I added two source notes using GT.tab_source_note()—one to display progress, and another for a visual progress bar.
  5. Finally, I gave the table a nice header with GT.tab_header() and applied some styling using GT.opt_stylize().
✅ Django Deployment Checklist
Status Task Notes
Set DEBUG = False Never deploy with DEBUG = True ⚠️
Configure ALLOWED_HOSTS Include your domain(s) or IP address 🌐
Set up a secret key Use a strong, secure key from an environment variable 🔐
Collect static files Run `python manage.py collectstatic` 📦
Apply database migrations Run `python manage.py migrate` 🗃️
Set up gunicorn or uWSGI Use as a WSGI server in production 🔄
Configure reverse proxy (e.g., Nginx) Serve static/media files and forward to WSGI server 🧭
Secure the database Use strong credentials, disable remote root login 🛡️
Set up HTTPS (SSL) Use Let's Encrypt or your own certificate 🔒
Configure logging & monitoring Track errors and app performance 📊
0 / 10

Check out the full marimo code below or view it on molab.

import marimo

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


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

    return (mo,)


@app.cell
def _():
    import polars as pl
    from great_tables import GT, html, md

    return GT, html, pl


@app.cell
def _(pl):
    tasks = [
        "Set DEBUG = False",
        "Configure ALLOWED_HOSTS",
        "Set up a secret key",
        "Collect static files",
        "Apply database migrations",
        "Set up gunicorn or uWSGI",
        "Configure reverse proxy (e.g., Nginx)",
        "Secure the database",
        "Set up HTTPS (SSL)",
        "Configure logging & monitoring",
    ]

    notes = [
        "Never deploy with DEBUG = True ⚠️",
        "Include your domain(s) or IP address 🌐",
        "Use a strong, secure key from an environment variable 🔐",
        "Run `python manage.py collectstatic` 📦",
        "Run `python manage.py migrate` 🗃️",
        "Use as a WSGI server in production 🔄",
        "Serve static/media files and forward to WSGI server 🧭",
        "Use strong credentials, disable remote root login 🛡️",
        "Use Let's Encrypt or your own certificate 🔒",
        "Track errors and app performance 📊",
    ]

    n_row = len(tasks)
    status = ["☐"] * n_row
    data = {"Status": status, "Task": tasks, "Notes": notes}

    df = pl.DataFrame(data)
    return df, n_row


@app.cell
def _(mo, n_row):
    status_widget = mo.ui.switch()
    status_widgets = mo.ui.array([status_widget] * n_row)
    return (status_widgets,)


@app.function
def create_bar(
    x: float,
    max_width: int,
    height: int,
    background_color1: str,
    background_color2: str,
) -> str:
    width = round(max_width * x, 2)
    px_width = f"{width}px"
    return f"""\
    <div style="width: {max_width}px; background-color: {background_color1};">\
        <div style="height:{height}px;width:{px_width};background-color:{background_color2};"></div>\
    </div>\
    """


@app.cell
def _(GT, df, html, n_row, pl, status_widgets):
    done_count = sum(s.value for s in status_widgets)

    gt = (
        GT(
            df.with_columns(
                pl.Series(
                    [status._repr_html_() for status in status_widgets]
                ).alias("Status")
            )
        )
        .tab_source_note(f"{done_count} / {n_row}")
        .tab_source_note(
            html(
                create_bar(
                    done_count / n_row,
                    max_width=750,
                    height=20,
                    background_color1="lightgray",
                    background_color2="#66CDAA",
                )
            )
        )
        .tab_header("✅ Django Deployment Checklist")
        .opt_stylize(color="cyan", style=4)
    )
    gt
    return


if __name__ == "__main__":
    app.run()
WarningDisclaimer
  1. This table is for demonstration purposes only. You should customize it based on your own needs.
  2. This post was drafted by me, with AI assistance to refine the content.
]]> python marimo gt django https://tech.ycwu.space/posts/marimo-django-deployment-checklist/20250625.html Wed, 25 Jun 2025 00:00:00 GMT Send Email via marimo Jerry Wu https://tech.ycwu.space/posts/resend-via-marimo/20250625.html This post demonstrates how to send emails using Resend from within a marimo app.

Resend via marimo

It seems the app runs fine locally but doesn’t work in a WASM environment. It’ll be interesting to explore where the boundaries of WASM lie.

Check out the full marimo code below or view it on molab.

Show full code 
import marimo

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


@app.cell
def _():
    import marimo as mo
    import os
    from html import escape
    import polars as pl
    import resend

    return escape, mo, resend


@app.cell
def _(escape, resend):
    def send_email(d: dict[str, str]) -> None:
        """
        https://resend.com/docs/send-with-python
        """
        resend.api_key = d["RESEND_API_KEY"]
        from_ = d["from_"]
        to = [mail.strip() for mail in d["to"].split(",")]
        subject = d["subject"]
        html_ = escape(d["content"]).replace("\n", "<br>")

        params: resend.Emails.SendParams = {
            "from": from_,
            "to": to,
            "subject": subject,
            "html": html_,
        }

        email = resend.Emails.send(params)

    return (send_email,)


@app.cell
def _(mo, send_email):
    # Create a form with multiple eleme
    form = (
        mo.md(
            """
        **marimo mail**
        {RESEND_API_KEY}

        {from_}

        {to}

        {subject}

        {content}
    """
        )
        .batch(
            RESEND_API_KEY=mo.ui.text(
                label="RESEND_API_KEY", kind="password", full_width=True
            ),
            from_=mo.ui.text(label="From", kind="email", full_width=True),
            to=mo.ui.text(label="To", kind="email", full_width=True),
            subject=mo.ui.text(label="Subject", full_width=True),
            content=mo.ui.text_area(full_width=True),
        )
        .form(show_clear_button=True, on_change=send_email)
    )
    form
    return


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

This post was drafted by me, with AI assistance to refine the content.

]]> python marimo resend https://tech.ycwu.space/posts/resend-via-marimo/20250625.html Wed, 25 Jun 2025 00:00:00 GMT Great Tables with marimo in Quarto Jerry Wu https://tech.ycwu.space/posts/gt-marimo-in-quarto/20250612.html This is a follow-up to my previous post.

Great Tables with marimo in Quarto

marimo

NoteGive It a Sec – WASM Magic Happening

The widgets may take a few moments to load, as they rely on WebAssembly under the hood.

Here, I demonstrate how marimo widgets can be embedded in Great Tables by wrapping them with the html() function provided by the library. This allows interactive widgets to control the table’s appearance in a Quarto environment via WASM — a surprisingly powerful capability, in my opinion.

col1 col2 color
2 x lightgrey
5 y lightblue
7 y lightblue
10 z papayawhip
15 z papayawhip

Check out the full marimo code below or view it on molab.

import marimo

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


@app.cell
def _():
    import marimo as mo
    import polars as pl
    from great_tables import GT, html

    return GT, html, mo, pl


@app.cell
def _(pl):
    data = {
        "col1": [2, 5, 7, 10, 15],
        "col2": ["x", "y", "y", "z", "z"],
        "color": [
            "lightgrey",
            "lightblue",
            "lightblue",
            "papayawhip",
            "papayawhip",
        ],
    }
    df = pl.DataFrame(data)
    return (df,)


@app.cell
def _(GT, df, html, mo):
    style_widget = mo.ui.slider(1, 6, label="Style Number")

    _colors = ["blue", "cyan", "pink", "green", "red", "gray"]
    color_widget = mo.ui.radio(
        options=_colors, value=_colors[0], label="Style Color", inline=True
    )

    row_striping_widget = mo.ui.switch(value=True, label="Row Striping?")

    gt = (
        GT(df)
        .tab_header(html(style_widget), html(color_widget))
        .tab_source_note(html(row_striping_widget))
        .opt_align_table_header("left")
    )
    return color_widget, gt, row_striping_widget, style_widget


@app.cell
def _(color_widget, gt, row_striping_widget, style_widget):
    gt.opt_stylize(
        style=style_widget.value,
        color=color_widget.value,
        add_row_striping=row_striping_widget.value,
    )
    return


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

This post was drafted by me, with AI assistance to refine the content.

]]> python gt marimo https://tech.ycwu.space/posts/gt-marimo-in-quarto/20250612.html Thu, 12 Jun 2025 00:00:00 GMT marimo in Quarto Jerry Wu https://tech.ycwu.space/posts/marimo-in-quarto/20250607.html This post demonstrates that Polars, Great Tables, and marimo can successfully run within a Quarto environment (as shown in this post). The example uses a table styler selector from Great Tables—and I’m honestly surprised it works!

marimo in Quarto

marimo

NoteGive It a Sec – WASM Magic Happening

The widgets may take a few moments to load, as they rely on WebAssembly under the hood.
col1 col2 color
2 x lightgrey
5 y lightblue
7 y lightblue
10 z papayawhip
15 z papayawhip

Check out the full marimo code below or view it on molab.

import marimo

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


@app.cell
def _():
    import marimo as mo
    import polars as pl
    from great_tables import GT, loc, style

    return GT, mo, pl


@app.cell
def _(pl):
    data = {
        "col1": [2, 5, 7, 10, 15],
        "col2": ["x", "y", "y", "z", "z"],
        "color": ["lightgrey", "lightblue", "lightblue", "papayawhip", "papayawhip"],
    }
    df = pl.DataFrame(data)
    return (df,)


@app.cell
def _(mo):
    style_widget = mo.ui.slider(1, 6, label="Select Style Number")
    mo.output.append(style_widget)

    _colors = ["blue", "cyan", "pink", "green", "red", "gray"]
    color_widget = mo.ui.radio(
        options=_colors, value=_colors[0], label="Select Style Color"
    )
    mo.output.append(color_widget)

    row_striping_widget = mo.ui.switch(value=True, label="Add Row Striping?")
    mo.output.append(row_striping_widget)
    return color_widget, row_striping_widget, style_widget


@app.cell
def _(GT, color_widget, df, row_striping_widget, style_widget):
    GT(df).opt_stylize(
        style=style_widget.value,
        color=color_widget.value,
        add_row_striping=row_striping_widget.value,
    )
    return


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

This post was drafted by me, with AI assistance to refine the content.

]]> python marimo https://tech.ycwu.space/posts/marimo-in-quarto/20250607.html Sat, 07 Jun 2025 00:00:00 GMT Styling tricks in Great Tables Jerry Wu https://tech.ycwu.space/posts/styling-tricks-table-body/20250526.html This post highlights a powerful yet underused feature in Great Tables: using existing columns to style the table body via from_column().

Let’s say you have the following Polars DataFrame df:

import polars as pl
from great_tables import GT, from_column, loc, style
from great_tables.data import films


df_style = pl.DataFrame(
    {
        "color": ["papayawhip", "lightblue", "lightgreen"],
        "size": ["small", "x-large", "medium"],
        "weight": ["normal", "bold", "lighter"],
        "align": ["right", "center", "left"],
    }
)

columns = ["year", "title", "run_time"]

df = pl.concat(
    [
        pl.from_pandas(films.head(3).loc[:, columns]),
        df_style,
    ],
    how="horizontal",
)

print(df)
shape: (3, 7)
┌──────┬───────────────────────────┬──────────┬────────────┬─────────┬─────────┬────────┐
│ year ┆ title                     ┆ run_time ┆ color      ┆ size    ┆ weight  ┆ align  │
│ ---  ┆ ---                       ┆ ---      ┆ ---        ┆ ---     ┆ ---     ┆ ---    │
│ i64  ┆ str                       ┆ str      ┆ str        ┆ str     ┆ str     ┆ str    │
╞══════╪═══════════════════════════╪══════════╪════════════╪═════════╪═════════╪════════╡
│ 1946 ┆ The Lovers                ┆ 1h 30m   ┆ papayawhip ┆ small   ┆ normal  ┆ right  │
│ 1946 ┆ Anna and the King of Siam ┆ 2h 8m    ┆ lightblue  ┆ x-large ┆ bold    ┆ center │
│ 1946 ┆ Blood and Fire            ┆ 1h 40m   ┆ lightgreen ┆ medium  ┆ lighter ┆ left   │
└──────┴───────────────────────────┴──────────┴────────────┴─────────┴─────────┴────────┘

The color, size, weight, and align columns contain style-related metadata. We can use from_column() to map this metadata to four styling options provided by Great Tables—style.fill(), style.text(), style.borders(), and style.css()—all of which are built on the internal CellStyle class.

(
    GT(df)
    .tab_style(
        style=[
            style.fill(color=from_column("color")),
            style.text(
                size=from_column("size"),
                weight=from_column("weight"),
                align=from_column("align"),
            ),
        ],
        locations=loc.body(columns),
    )
    .cols_hide(df_style.columns)
    .opt_stylize(style=6, color="gray")
)
year title run_time
1946 The Lovers 1h 30m
1946 Anna and the King of Siam 2h 8m
1946 Blood and Fire 1h 40m

One last note: from_column() works with both Pandas and Polars DataFrames. For Polars users, you can also pass expressions directly without wrapping them in from_column(). The following code produces the same styled table as shown above:

(
    GT(df)
    .tab_style(
        style=[
            style.fill(color=pl.col("color")),
            style.text(
                size=pl.col("size"), weight=pl.col("weight"), align=pl.col("align")
            ),
        ],
        locations=loc.body(columns),
    )
    .cols_hide(df_style.columns)
    .opt_stylize(style=6, color="gray")
)
WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python pandas polars gt https://tech.ycwu.space/posts/styling-tricks-table-body/20250526.html Mon, 26 May 2025 00:00:00 GMT case_when() in Polars Jerry Wu https://tech.ycwu.space/posts/casewhen-in-polars/20250525.html This is a follow-up to my previous post.

While the conditional branching mechanism of pl.when().then().otherwise() is quite powerful, I often find it a bit verbose—especially when the conditions are complex. In those cases, it becomes harder to validate the correctness of each branch at a glance.

On the other hand, I find the pd.Series.case_when() pattern in Pandas slightly more concise and readable. However, I’ve always wished it supported a fallback mechanism like Polars’ .otherwise().

In the end, I thought it would be interesting to borrow the concept behind pd.Series.case_when() and implement it as a standalone utility function in Polars.

case_when()

The case_when() function accepts two arguments:

  • caselist: A list of two-element tuples, where the first item is the condition (used in pl.when()), and the second is the corresponding result expression (used in .then()).
  • otherwise: A fallback expression used in .otherwise() if no conditions match.

The given example demonstrates how case_when() can simplify conditional logic compared to the more verbose pl.when().then().otherwise() chain.

from functools import cache
from typing import Any

import polars as pl


def case_when(
    caselist: list[tuple[pl.Expr, pl.Expr]], otherwise: pl.Expr | None = None
) -> pl.Expr:
    """
    Simplifies conditional logic in Polars by chaining multiple `when-then` expressions.

    Parameters
    ----------
    caselist
        A list of (condition, value) pairs. Each condition is evaluated in order,
        and the corresponding value is returned when a condition is met.
    otherwise
        The fallback value to use if none of the conditions match.

    Returns
    -------
    pl.Expr

    Examples:
    -------
    ```python
    import polars as pl

    df = pl.DataFrame({"x": [1, 2, 3, 4]})

    expr = case_when(
        caselist=[
            (pl.col("x") < 2, pl.lit("small")),
            (pl.col("x") < 4, pl.lit("medium"))
        ],
        otherwise=pl.lit("large"),
    ).alias("size")

    # This is equivalent to writing:
    # expr = (
    #     pl.when(pl.col("x") < 2)
    #       .then(pl.lit("small"))
    #       .when(pl.col("x") < 4)
    #       .then(pl.lit("medium"))
    #       .otherwise(pl.lit("large"))
    #       .alias("size")
    # )

    df.with_columns(expr)
    ```
    shape: (4, 2)
    ┌─────┬────────┐
    │ x   ┆ size   │
    │ --- ┆ ---    │
    │ i64 ┆ str    │
    ├─────┼────────┤
    │ 1   ┆ small  │
    │ 2   ┆ medium │
    │ 3   ┆ medium │
    │ 4   ┆ large  │
    └─────┴────────┘
    """
    (first_when, first_then), *cases = caselist

    # first
    expr = pl.when(first_when).then(first_then)

    # middles
    for when, then in cases:
        expr = expr.when(when).then(then)

    # last
    expr = expr.otherwise(otherwise)

    return expr

Custom Expression Namespace

With case_when() in place, we can refactor the DiscreteSplitter expression namespace like this:

@cache
def _mod_expr(n: int) -> pl.Expr:
    return pl.int_range(pl.len(), dtype=pl.UInt32).mod(n)


def _litify(lits: list[Any]) -> list[pl.lit]:
    return [pl.lit(lit) for lit in lits]


@pl.api.register_expr_namespace("spt")
class DiscreteSplitter:
    def __init__(self, expr: pl.Expr) -> None:
        self._expr = expr

    def _get_expr(self, lits: list[Any], name: str):
        n = len(lits)
        mod_expr = _mod_expr(n)
        *litified, litified_otherwise = _litify(lits)
        caselist = [(mod_expr.eq(i), lit) for i, lit in enumerate(litified)]
        return case_when(caselist, litified_otherwise).alias(name)

    def binarize(self, lit1: Any, lit2: Any, name: str = "binarized") -> pl.Expr:
        return self.bucketize([lit1, lit2], name)

    def trinarize(
        self, lit1: Any, lit2: Any, lit3: Any, name: str = "trinarized"
    ) -> pl.Expr:
        return self.bucketize([lit1, lit2, lit3], name)

    def bucketize(self, lits: list[Any], name: str = "bucketized") -> pl.Expr:
        return self._get_expr(lits, name)

Now, bucketize() is the primary method that encapsulates the core logic for categorical mapping. binarize() and trinarize() are just convenient wrappers for common cases.

Here’s a simple example of using the custom expression namespace:

df = (
    pl.DataFrame({"n": [100, 50, 72, 83, 97, 42, 20, 51, 77]})
    .with_row_index(offset=1)
    .with_columns(
        pl.col("").spt.binarize("lightblue", "papayawhip"),
        pl.col("").spt.trinarize("one", "two", "three"),
        pl.col("").spt.bucketize([1, 2, 3, 4]),
    )
)
shape: (9, 5)
┌───────┬─────┬────────────┬────────────┬────────────┐
│ index ┆ n   ┆ binarized  ┆ trinarized ┆ bucketized │
│ ---   ┆ --- ┆ ---        ┆ ---        ┆ ---        │
│ u32   ┆ i64 ┆ str        ┆ str        ┆ i32        │
╞═══════╪═════╪════════════╪════════════╪════════════╡
│ 1     ┆ 100 ┆ lightblue  ┆ one        ┆ 1          │
│ 2     ┆ 50  ┆ papayawhip ┆ two        ┆ 2          │
│ 3     ┆ 72  ┆ lightblue  ┆ three      ┆ 3          │
│ 4     ┆ 83  ┆ papayawhip ┆ one        ┆ 4          │
│ 5     ┆ 97  ┆ lightblue  ┆ two        ┆ 1          │
│ 6     ┆ 42  ┆ papayawhip ┆ three      ┆ 2          │
│ 7     ┆ 20  ┆ lightblue  ┆ one        ┆ 3          │
│ 8     ┆ 51  ┆ papayawhip ┆ two        ┆ 4          │
│ 9     ┆ 77  ┆ lightblue  ┆ three      ┆ 1          │
└───────┴─────┴────────────┴────────────┴────────────┘

Custom DataFrame Namespace

Instead of relying on pl.DataFrame.with_row_index(), we can also use _mod_expr() directly to enable similar categorization.

Here’s how the DiscreteSplitter can be implemented as a custom DataFrame namespace:

@pl.api.register_dataframe_namespace("spt")
class DiscreteSplitter:
    def __init__(self, df: pl.DataFrame) -> None:
        self._df = df

    def _get_expr(self, lits: list[Any], name: str):
        n = len(lits)
        mod_expr = _mod_expr(n)
        *litified, litified_otherwise = _litify(lits)
        caselist = [(mod_expr.eq(i), lit) for i, lit in enumerate(litified)]
        return case_when(caselist, litified_otherwise).alias(name)

    def _get_final_df(self, lits: list[Any], name: str) -> pl.DataFrame:
        cls = type(self)
        expr = self._get_expr(lits, name)
        new_spt = cls(self._df.with_columns(expr))
        return new_spt._df

    def binarize(self, lit1: Any, lit2: Any, name: str = "binarized") -> pl.DataFrame:
        return self.bucketize([lit1, lit2], name=name)

    def trinarize(
        self, lit1: Any, lit2: Any, lit3: Any, name: str = "trinarized"
    ) -> pl.DataFrame:
        return self.bucketize([lit1, lit2, lit3], name=name)

    def bucketize(self, lits: list[Any], name: str = "bucketized") -> pl.DataFrame:
        return self._get_final_df(lits, name)

Example usage:

df = (
    pl.DataFrame({"n": [100, 50, 72, 83, 97, 42, 20, 51, 77]})
    .spt.binarize("lightblue", "papayawhip")
    .spt.trinarize("one", "two", "three")
    .spt.bucketize([1, 2, 3, 4])
    .with_row_index(offset=1)
)
shape: (9, 5)
┌───────┬─────┬────────────┬────────────┬────────────┐
│ index ┆ n   ┆ binarized  ┆ trinarized ┆ bucketized │
│ ---   ┆ --- ┆ ---        ┆ ---        ┆ ---        │
│ u32   ┆ i64 ┆ str        ┆ str        ┆ i32        │
╞═══════╪═════╪════════════╪════════════╪════════════╡
│ 1     ┆ 100 ┆ lightblue  ┆ one        ┆ 1          │
│ 2     ┆ 50  ┆ papayawhip ┆ two        ┆ 2          │
│ 3     ┆ 72  ┆ lightblue  ┆ three      ┆ 3          │
│ 4     ┆ 83  ┆ papayawhip ┆ one        ┆ 4          │
│ 5     ┆ 97  ┆ lightblue  ┆ two        ┆ 1          │
│ 6     ┆ 42  ┆ papayawhip ┆ three      ┆ 2          │
│ 7     ┆ 20  ┆ lightblue  ┆ one        ┆ 3          │
│ 8     ┆ 51  ┆ papayawhip ┆ two        ┆ 4          │
│ 9     ┆ 77  ┆ lightblue  ┆ three      ┆ 1          │
└───────┴─────┴────────────┴────────────┴────────────┘

Conclusion

Extracting the conditional logic into a standalone case_when() function turned out to be both a practical and satisfying exercise—perfect for a rainy afternoon of coding. It not only improves readability but also makes the branching logic easier to reuse and reason about.

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python polars https://tech.ycwu.space/posts/casewhen-in-polars/20250525.html Sun, 25 May 2025 00:00:00 GMT Custom Row Selector in Great Tables Jerry Wu https://tech.ycwu.space/posts/gt-row-selector/20250511.html This short post shows how we can create custom row selectors in Great Tables by leveraging the row index. While it may or may not be adopted by the team, I thought it would be fun to document it here on the blog.

I recently created a utility called every_n_row(), designed to work with both Pandas and Polars DataFrames (support for pyarrow is still under investigation). With every_n_row(), we can easily target alternating rows—for example, select odd rows using every_n_row(2) and even rows using either every_n_row(2, 1) or ~every_n_row(2).

import polars as pl

from great_tables import GT, every_n_row, loc, style
from great_tables.data import countrypops

df_pd = countrypops.sample(5).loc[:, ["country_name", "year", "population"]]
df_pl = pl.from_pandas(df_pd)

(
    GT(df_pd)
    .tab_style(style=style.fill("lightblue"), locations=loc.body(rows=every_n_row(2)))
    .tab_style(style=style.fill("papayawhip"), locations=loc.body(rows=every_n_row(2, 1)))
    .opt_stylize(style=3, color="pink")
)

(
    GT(df_pl)
    .tab_style(style=style.fill("lightblue"), locations=loc.body(rows=every_n_row(2)))
    .tab_style(style=style.fill("papayawhip"), locations=loc.body(rows=~every_n_row(2)))
    .opt_stylize(style=3, color="pink")
)

Row Selector: every_n_row

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python pandas polars gt https://tech.ycwu.space/posts/gt-row-selector/20250511.html Sun, 11 May 2025 00:00:00 GMT Polars Custom Expression Namespace Jerry Wu https://tech.ycwu.space/posts/polars-custom-expr-namespace/20250417.html Today I explored how to register a custom expression namespace in Polars. This feature turned out to be super helpful for solving a common problem I run into when building tables or plots—colorizing rows based on their row index.

Here is the code snippet: Code Snippet

Show full code 
from typing import Any

import polars as pl
from great_tables import GT, loc, style


@pl.api.register_expr_namespace("spt")
class DiscreteSplitter:
    def __init__(self, expr: pl.Expr) -> None:
        self._expr = expr

    def _mod_expr(self, n: int) -> pl.Expr:
        return pl.int_range(pl.len(), dtype=pl.UInt32).mod(n)

    def binarize(
        self, lit1: str, lit2: str, name: str = "binarized"
    ) -> pl.Expr:
        mod_expr = self._mod_expr(2)
        return (
            pl.when(mod_expr.eq(0))
            .then(pl.lit(lit1))
            .otherwise(pl.lit(lit2))
            .alias(name)
        )

    def trinarize(
        self, lit1: str, lit2: str, lit3: str, name: str = "trinarized"
    ) -> pl.Expr:
        mod_expr = self._mod_expr(3)
        return (
            pl.when(mod_expr.eq(0))
            .then(pl.lit(lit1))
            .when(mod_expr.eq(1))
            .then(pl.lit(lit2))
            .otherwise(pl.lit(lit3))
            .alias(name)
        )

    def bucketize(
        self, lits: list[Any], name: str = "bucketized"
    ) -> pl.Expr:
        mod_expr = self._mod_expr(len(lits))

        # first
        expr = pl.when(mod_expr.eq(0)).then(pl.lit(lits[0]))

        # middles
        for i, one_lit in enumerate(lits[1:-1], start=1):
            expr = expr.when(mod_expr.eq(i)).then(pl.lit(one_lit))

        # last
        expr = expr.otherwise(pl.lit(lits[-1]))
        return expr.alias(name)


df = (
    pl.DataFrame({"n": [100, 50, 72, 83, 97, 42, 20, 51, 77]})
    .with_row_index(offset=1)
    .with_columns(
        pl.col("").spt.binarize("lightblue", "papayawhip"),
        pl.col("").spt.trinarize("one", "two", "three"),
        pl.col("").spt.bucketize([1, 2, 3, 4]),
    )
)

(
    GT(df)
    .tab_style(style=style.fill(pl.col("binarized")), locations=loc.body())
    .opt_stylize(style=6)
)

Step-by-Step Breakdown

Registering the Namespace

We use pl.api.register_expr_namespace() to attach our class to the spt namespace. Once registered, we can call our methods like this: pl.col("any").spt.binarize(...).

@pl.api.register_expr_namespace("spt")
class DiscreteSplitter:
    def __init__(self, expr: pl.Expr) -> None:
        self._expr = expr

Helper: Row-Index Based Modulo Expression

To assign values based on row position, we need a way to refer to the row index inside an expression. Polars provides a trick using pl.int_range(pl.len()), as shown in pl.DataFrame.with_row_index().

@pl.api.register_expr_namespace("spt")
class DiscreteSplitter:
    def _mod_expr(self, n: int) -> pl.Expr:
        return pl.int_range(pl.len(), dtype=pl.UInt32).mod(n)

binarize: Two Groups

This method maps alternating rows into two categories using pl.when().then().otherwise().

@pl.api.register_expr_namespace("spt")
class DiscreteSplitter:
    def binarize(
        self, lit1: str, lit2: str, name: str = "binarized"
    ) -> pl.Expr:
        mod_expr = self._mod_expr(2)
        return (
            pl.when(mod_expr.eq(0))
            .then(pl.lit(lit1))
            .otherwise(pl.lit(lit2))
            .alias(name)
        )

trinarize: Three Groups

Similar to binarize, but splits the rows into three groups using two when().then() branches before the final otherwise().

@pl.api.register_expr_namespace("spt")
class DiscreteSplitter:
    def trinarize(
        self, lit1: str, lit2: str, lit3: str, name: str = "trinarized"
    ) -> pl.Expr:
        mod_expr = self._mod_expr(3)
        return (
            pl.when(mod_expr.eq(0))
            .then(pl.lit(lit1))
            .when(mod_expr.eq(1))
            .then(pl.lit(lit2))
            .otherwise(pl.lit(lit3))
            .alias(name)
        )

bucketize: N Groups

A generalized version of the above, which dynamically assigns values from a list across n groups:

@pl.api.register_expr_namespace("spt")
class DiscreteSplitter:
    def bucketize(
        self, lits: list[Any], name: str = "bucketized"
    ) -> pl.Expr:
        mod_expr = self._mod_expr(len(lits))

        # first
        expr = pl.when(mod_expr.eq(0)).then(pl.lit(lits[0]))

        # middles
        for i, one_lit in enumerate(lits[1:-1], start=1):
            expr = expr.when(mod_expr.eq(i)).then(pl.lit(one_lit))

        # last
        expr = expr.otherwise(pl.lit(lits[-1]))
        return expr.alias(name)

Example Usage

Here’s a simple example that demonstrates how the custom namespace works in practice:

df = (
    pl.DataFrame({"n": [100, 50, 72, 83, 97, 42, 20, 51, 77]})
    .with_row_index(offset=1)
    .with_columns(
        pl.col("").spt.binarize("lightblue", "papayawhip"),
        pl.col("").spt.trinarize("one", "two", "three"),
        pl.col("").spt.bucketize([1, 2, 3, 4]),
    )
)

This produces the following DataFrame:

shape: (9, 5)
┌───────┬─────┬────────────┬────────────┬────────────┐
│ index ┆ n   ┆ binarized  ┆ trinarized ┆ bucketized │
│ ---   ┆ --- ┆ ---        ┆ ---        ┆ ---        │
│ u32   ┆ i64 ┆ str        ┆ str        ┆ i32        │
╞═══════╪═════╪════════════╪════════════╪════════════╡
│ 1     ┆ 100 ┆ lightblue  ┆ one        ┆ 1          │
│ 2     ┆ 50  ┆ papayawhip ┆ two        ┆ 2          │
│ 3     ┆ 72  ┆ lightblue  ┆ three      ┆ 3          │
│ 4     ┆ 83  ┆ papayawhip ┆ one        ┆ 4          │
│ 5     ┆ 97  ┆ lightblue  ┆ two        ┆ 1          │
│ 6     ┆ 42  ┆ papayawhip ┆ three      ┆ 2          │
│ 7     ┆ 20  ┆ lightblue  ┆ one        ┆ 3          │
│ 8     ┆ 51  ┆ papayawhip ┆ two        ┆ 4          │
│ 9     ┆ 77  ┆ lightblue  ┆ three      ┆ 1          │
└───────┴─────┴────────────┴────────────┴────────────┘

Note: Since the custom logic is based on the row index rather than actual column values, you can safely use pl.col("") as a placeholder when calling the namespace methods.

Each new column shows how rows are grouped using the row index modulo 2, 3, or 4—useful for highlighting patterns or applying styling.

For instance, you can use the binarized column with Great Tables like this:

(
    GT(df)
    .tab_style(style=style.fill(pl.col("binarized")), locations=loc.body())
    .opt_stylize(style=6)
)

Table with alternating row colors

Conclusion

Registering a custom expression namespace in Polars is a powerful way to encapsulate and reuse logic across your codebase. In this post, we created a DiscreteSplitter class to simplify index-based grouping, enabling operations like binarize, trinarize, and bucketize. This approach keeps your expressions clean and composable, especially when generating tables or plots that require styling based on row position.

It’s also worth noting that Polars supports similar registration for Series, LazyFrame, and DataFrame objects—check out the official documentation for more details.

Remark

Here’s a rough draft showing how to achieve a similar effect using the DataFrame namespace. I might revisit and refine this approach in the future.

Show full code 
from typing import Any

import polars as pl
from great_tables import GT, loc, style


@pl.api.register_dataframe_namespace("spt")
class DiscreteSplitter:
    def __init__(self, df: pl.DataFrame) -> None:
        self._df = df
        self._mod_colname = "mod"
        self._mod_col = pl.col(self._mod_colname)
        self._idx_colname = "index"
        self._idx_col = pl.col(self._idx_colname)

    def _get_df(self, n: int) -> pl.DataFrame:
        return self._df.with_row_index(self._idx_colname).with_columns(
            self._idx_col.mod(n).alias(self._mod_colname)
        )

    def _get_final_df(self, n: int, expr: pl.Expr) -> pl.DataFrame:
        return (
            self._get_df(n)
            .with_columns(expr)
            .drop([self._idx_colname, self._mod_colname])
        )

    def binarize(
        self, lit1: str, lit2: str, name: str = "binarized"
    ) -> pl.DataFrame:
        n = 2

        expr = (
            pl.when(self._mod_col.eq(0))
            .then(pl.lit(lit1))
            .otherwise(pl.lit(lit2))
            .alias(name)
        )

        self._df = self._get_final_df(n, expr)
        return self._df

    def trinarize(
        self, lit1: str, lit2: str, lit3: str, name: str = "trinarized"
    ) -> pl.DataFrame:
        n = 3

        expr = (
            pl.when(self._mod_col.eq(0))
            .then(pl.lit(lit1))
            .when(self._mod_col.eq(1))
            .then(pl.lit(lit2))
            .otherwise(pl.lit(lit3))
            .alias(name)
        )

        self._df = self._get_final_df(n, expr)
        return self._df

    def bucketize(
        self, lits: list[Any], name: str = "bucketized"
    ) -> pl.DataFrame:
        n = len(lits)

        # first
        expr = pl.when(self._mod_col.eq(0)).then(pl.lit(lits[0]))

        # middles
        for i, one_lit in enumerate(lits[1:-1], start=1):
            expr = expr.when(self._mod_col.eq(i)).then(pl.lit(one_lit))

        # last
        expr = expr.otherwise(pl.lit(lits[-1]))

        # alias
        expr = expr.alias(name)

        self._df = self._get_final_df(n, expr)
        return self._df


df = (
    pl.DataFrame({"n": [100, 50, 72, 83, 97, 42, 20, 51, 77]})
    .spt.binarize("lightblue", "papayawhip")
    .spt.trinarize("one", "two", "three")
    .spt.bucketize([1, 2, 3, 4])
    .with_row_index(offset=1)
)

(
    GT(df)
    .tab_style(style=style.fill(pl.col("binarized")), locations=loc.body())
    .opt_stylize(style=6)
)
WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python polars https://tech.ycwu.space/posts/polars-custom-expr-namespace/20250417.html Thu, 17 Apr 2025 00:00:00 GMT Clone the Reciprocal Tariffs Table Using Plotnine Jerry Wu https://tech.ycwu.space/posts/clone-reciprocal-tariffs-table-p9/20250416.html This post presents a recreated visualization using Polars and plotnine, based on my earlier work.

Below is the final figure: Cloned Reciprocal Tariffs Table

Show full code 
import polars as pl
from matplotlib.figure import Figure
from plotnine import (
    aes,
    element_blank,
    element_rect,
    element_text,
    geom_segment,
    geom_text,
    ggplot,
    position_nudge,
    scale_color_identity,
    scale_size_identity,
    scale_y_discrete,
    theme,
    theme_void,
    watermark,
)


# source1: https://truthsocial.com/@realDonaldTrump/114270398531479278
# source2:
# "https://upload.wikimedia.org/wikipedia/commons/
# thumb/3/36/Seal_of_the_President_of_the_United_States.svg/
# 800px-Seal_of_the_President_of_the_United_States.svg.png"
logo_filename = "logo_resized.png"

data = {
    "country": [
        "China",
        "European Union",
        "Vietnam",
        "Taiwan",
        "Japan",
        "India",
        "South Korea",
        "Thailand",
        "Switzerland",
        "Indonesia",
        "Malaysia",
        "Cambodia",
        "United Kingdom",
        "South Africa",
        "Brazil",
        "Bangladesh",
        "Singapore",
        "Israel",
        "Philippines",
        "Chile",
        "Australia",
        "Pakistan",
        "Turkey",
        "Sri Lanka",
        "Colombia",
    ],
    "tariffs_charged": [
        "67%",
        "39%",
        "90%",
        "64%",
        "46%",
        "52%",
        "50%",
        "72%",
        "61%",
        "64%",
        "47%",
        "97%",
        "10%",
        "60%",
        "10%",
        "74%",
        "10%",
        "33%",
        "34%",
        "10%",
        "10%",
        "58%",
        "10%",
        "88%",
        "10%",
    ],
    "reciprocal_tariffs": [
        "34%",
        "20%",
        "46%",
        "32%",
        "24%",
        "26%",
        "25%",
        "36%",
        "31%",
        "32%",
        "24%",
        "49%",
        "10%",
        "30%",
        "10%",
        "37%",
        "10%",
        "17%",
        "17%",
        "10%",
        "10%",
        "29%",
        "10%",
        "44%",
        "10%",
    ],
}

country, tariffs_charged, reciprocal_tariffs = data.keys()

dark_navy_blue = "#0B162A"  # background
light_blue = "#B5D3E7"  # row
white = "#FFFFFF"  # row
yellow = "#F6D588"  # "reciprocal_tariffs" column
gold = "#FFF8DE"  # logo

fontname_georgia = "Georgia"  # title
fontname_roboto = "Roboto"  # body


def tweak_df() -> pl.DataFrame:
    # column width
    x_col1_start, x_col1_end = 5, 52.5
    x_col2_start, x_col2_end = 60, 75
    x_col3_start, x_col3_end = 82.5, 97.5

    # x-position for body text
    x_col1_text = 5
    x_col2_text = x_col2_start + (x_col2_end - x_col2_start) / 3 + 1
    x_col3_text = x_col3_start + (x_col3_end - x_col3_start) / 3 + 1

    return (
        pl.DataFrame(data)
        .with_row_index()
        .with_columns(
            pl.col(country).cast(pl.Categorical),
            pl.when(pl.col("index").mod(2).eq(0))
            .then(pl.lit(light_blue))
            .otherwise(pl.lit(white))
            .alias("color_mod"),
            pl.lit(x_col1_start).alias("x_col1_start"),
            pl.lit(x_col1_end).alias("x_col1_end"),
            pl.lit(x_col2_start).alias("x_col2_start"),
            pl.lit(x_col2_end).alias("x_col2_end"),
            pl.lit(x_col3_start).alias("x_col3_start"),
            pl.lit(x_col3_end).alias("x_col3_end"),
            pl.lit(x_col1_text).alias("x_col1_text"),
            pl.lit(x_col2_text).alias("x_col2_text"),
            pl.lit(x_col3_text).alias("x_col3_text"),
        )
    )


def get_textdata_df(x_ref: float = 0.0, y_ref: float = 0.0) -> pl.DataFrame:
    title_fontsize = 16
    title_fontweight = "bold"
    heading_fontsize = 8
    heading_fontweight = "bold"
    subheading_fontsize = 6
    subheading_fontweight = "normal"

    textdata_df = pl.DataFrame(
        {
            "label": [
                "Reciprocal Tariffs",  # title
                "Country",  # col1
                "Tariffs Charged",  # col2
                "to the U.S.A.",
                "Including",
                "Currency Manipulation",
                "and Trade Barriers",
                "U.S.A. Discounted",  # col3
                "Reciprocal Tariffs",
            ],
            "x": [
                x_ref + 34.0,
                x_ref + 29.5,
                x_ref + 67.5,
                x_ref + 67.5,
                x_ref + 67.5,
                x_ref + 67.5,
                x_ref + 67.5,
                x_ref + 89.5,
                x_ref + 89.5,
            ],
            "y": [
                y_ref + 27,
                y_ref + 25.5,
                y_ref + 26.8,
                y_ref + 26.4,
                y_ref + 26.1,
                y_ref + 25.8,
                y_ref + 25.5,
                y_ref + 26.0,
                y_ref + 25.6,
            ],
            "color": [
                gold,
                white,
                white,
                white,
                white,
                white,
                white,
                white,
                white,
            ],
            "fontsize": [
                title_fontsize,
                heading_fontsize,
                heading_fontsize,
                heading_fontsize,
                subheading_fontsize,
                subheading_fontsize,
                subheading_fontsize,
                heading_fontsize,
                heading_fontsize,
            ],
            "fontweight": [
                title_fontweight,
                heading_fontweight,
                heading_fontweight,
                heading_fontweight,
                subheading_fontweight,
                subheading_fontweight,
                subheading_fontweight,
                heading_fontweight,
                heading_fontweight,
            ],
            "fontname": [
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
            ],
        }
    )
    return textdata_df


def plot_g() -> ggplot:
    geom_segment_props = {"size": 8, "lineend": "round"}

    geom_text_props = {
        "ha": "left",
        "va": "center",
        "position": position_nudge(y=-0.08),
        "size": 10,
        "fontweight": "bold",
    }

    return (
        ggplot(data=df, mapping=aes(y=country, yend=country))
        # col1 segment
        + geom_segment(
            mapping=aes(x="x_col1_start", xend="x_col1_end", color="color_mod"),
            **geom_segment_props,
        )
        # col2 segment
        + geom_segment(
            mapping=aes(x="x_col2_start", xend="x_col2_end", color="color_mod"),
            **geom_segment_props,
        )
        # col3 segment
        + geom_segment(
            mapping=aes(x="x_col3_start", xend="x_col3_end"),
            color=yellow,
            **geom_segment_props,
        )
        # col1 text
        + geom_text(aes(x="x_col1_text", label=country), **geom_text_props)
        # col2 text
        + geom_text(aes(x="x_col2_text", label=tariffs_charged), **geom_text_props)
        # col3 text
        + geom_text(aes(x="x_col3_text", label=reciprocal_tariffs), **geom_text_props)
        # using "color_mod" column directly
        + scale_color_identity()
        # expand extra space
        + scale_y_discrete(
            limits=df.select(country).reverse().to_series().to_list(),
            expand=(0.02, 0, 0, 1.5),
        )
        # title and headers
        + geom_text(
            data=textdata_df,
            mapping=aes(
                x="x",
                y="y",
                label="label",
                color="color",
                size="fontsize",
                fontweight="fontweight",
                fontname="fontname",
            ),
            va="bottom",
            ha="center",
        )
        # using "size" column directly
        + scale_size_identity()
        # logo
        + watermark(logo_filename, 100, 2235)
    )


def themify(p: ggplot) -> Figure:
    return (
        p
        + theme_void()
        + theme(
            legend_position="none",  # turns off the legend
            axis_text_x=element_blank(),
            axis_text_y=element_blank(),
            axis_title_x=element_blank(),
            axis_title_y=element_blank(),
            panel_background=element_rect(fill=dark_navy_blue),
            plot_background=element_rect(fill=dark_navy_blue),
            text=element_text(family=fontname_roboto),
            dpi=300,
            figure_size=(6, 8),
        )
    ).draw(show=False)


df = tweak_df()
textdata_df = get_textdata_df()
p = plot_g()
fig = themify(p)
fig

Preparing the DataFrames

Main DataFrame

We start by extracting the data from a previous project. The country column is converted to a categorical type, which simplifies handling in plotnine. To enable alternating row colors in the final visualization, we also create a new column called color_mod. Additional columns are created to define the positions for the segments and text labels.

def tweak_df() -> pl.DataFrame:
    # column width
    x_col1_start, x_col1_end = 5, 52.5
    x_col2_start, x_col2_end = 60, 75
    x_col3_start, x_col3_end = 82.5, 97.5

    # x-position for body text
    x_col1_text = 5
    x_col2_text = x_col2_start + (x_col2_end - x_col2_start) / 3 + 1
    x_col3_text = x_col3_start + (x_col3_end - x_col3_start) / 3 + 1

    return (
        pl.DataFrame(data)
        .with_row_index()
        .with_columns(
            pl.col(country).cast(pl.Categorical),
            pl.when(pl.col("index").mod(2).eq(0))
            .then(pl.lit(light_blue))
            .otherwise(pl.lit(white))
            .alias("color_mod"),
            pl.lit(x_col1_start).alias("x_col1_start"),
            pl.lit(x_col1_end).alias("x_col1_end"),
            pl.lit(x_col2_start).alias("x_col2_start"),
            pl.lit(x_col2_end).alias("x_col2_end"),
            pl.lit(x_col3_start).alias("x_col3_start"),
            pl.lit(x_col3_end).alias("x_col3_end"),
            pl.lit(x_col1_text).alias("x_col1_text"),
            pl.lit(x_col2_text).alias("x_col2_text"),
            pl.lit(x_col3_text).alias("x_col3_text"),
        )
    )

df = tweak_df()

Textdata DataFrame

Next, we create another DataFrame that contains information for all the text elements, such as text color, font size, and font weight, for the title and headers.

def get_textdata_df(
    x_ref: float = 0.0, y_ref: float = 0.0
) -> pl.DataFrame:
    title_fontsize = 16
    title_fontweight = "bold"
    heading_fontsize = 8
    heading_fontweight = "bold"
    subheading_fontsize = 6
    subheading_fontweight = "normal"

    textdata_df = pl.DataFrame(
        {
            "label": [
                "Reciprocal Tariffs",  # title
                "Country",  # col1
                "Tariffs Charged",  # col2
                "to the U.S.A.",
                "Including",
                "Currency Manipulation",
                "and Trade Barriers",
                "U.S.A. Discounted",  # col3
                "Reciprocal Tariffs",
            ],
            "x": [
                x_ref + 34.0,
                x_ref + 29.5,
                x_ref + 67.5,
                x_ref + 67.5,
                x_ref + 67.5,
                x_ref + 67.5,
                x_ref + 67.5,
                x_ref + 89.5,
                x_ref + 89.5,
            ],
            "y": [
                y_ref + 27,
                y_ref + 25.5,
                y_ref + 26.8,
                y_ref + 26.4,
                y_ref + 26.1,
                y_ref + 25.8,
                y_ref + 25.5,
                y_ref + 26.0,
                y_ref + 25.6,
            ],
            "color": [
                gold,
                white,
                white,
                white,
                white,
                white,
                white,
                white,
                white,
            ],
            "fontsize": [
                title_fontsize,
                heading_fontsize,
                heading_fontsize,
                heading_fontsize,
                subheading_fontsize,
                subheading_fontsize,
                subheading_fontsize,
                heading_fontsize,
                heading_fontsize,
            ],
            "fontweight": [
                title_fontweight,
                heading_fontweight,
                heading_fontweight,
                heading_fontweight,
                subheading_fontweight,
                subheading_fontweight,
                subheading_fontweight,
                heading_fontweight,
                heading_fontweight,
            ],
            "fontname": [
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
                fontname_georgia,
            ],
        }
    )
    return textdata_df

textdata_df = get_textdata_df()

Constructing the ggplot Object

With the processed DataFrame ready, we can now build the ggplot() object:

def plot_g() -> ggplot:
    geom_segment_props = {"size": 8, "lineend": "round"}

    geom_text_props = {
        "ha": "left",
        "va": "center",
        "position": position_nudge(y=-0.08),
        "size": 10,
        "fontweight": "bold",
    }

    return (
        ggplot(data=df, mapping=aes(y=country, yend=country))
        # col1 segment
        + geom_segment(
            mapping=aes(x="x_col1_start", xend="x_col1_end", color="color_mod"),
            **geom_segment_props,
        )
        # col2 segment
        + geom_segment(
            mapping=aes(x="x_col2_start", xend="x_col2_end", color="color_mod"),
            **geom_segment_props,
        )
        # col3 segment
        + geom_segment(
            mapping=aes(x="x_col3_start", xend="x_col3_end"),
            color=yellow,
            **geom_segment_props,
        )
        # col1 text
        + geom_text(aes(x="x_col1_text", label=country), **geom_text_props)
        # col2 text
        + geom_text(aes(x="x_col2_text", label=tariffs_charged), **geom_text_props)
        # col3 text
        + geom_text(aes(x="x_col3_text", label=reciprocal_tariffs), **geom_text_props)
        # using "color_mod" column directly
        + scale_color_identity()
        # expand extra space
        + scale_y_discrete(
            limits=df.select(country).reverse().to_series().to_list(),
            expand=(0.02, 0, 0, 1.5),
        )
        # title and headers
        + geom_text(
1            data=textdata_df,
            mapping=aes(
                x="x",
                y="y",
                label="label",
                color="color",
                size="fontsize",
                fontweight="fontweight",
                fontname="fontname",
            ),
            va="bottom",
            ha="center",
        )
        # using "size" column directly
        + scale_size_identity()
        # logo
        + watermark(logo_filename, 100, 2235)
    )
1
The data= argument is set to textdata_df, which contains all the custom label and styling details for the title and column headers.

What’s happening here?

  1. geom_segment(): Since I couldn’t find a way to apply border radius, I used geom_segment() with lineend="round" as the best available workaround. Thick lines serve as cell backgrounds.
  2. geom_text(): Adds text for each column.
  3. scale_color_identity(): Uses the color values directly from the color_mod column, without applying a scale.
  4. scale_y_discrete(): Reorders the country axis and tweaks padding to add space above and below the table.
  5. scale_size_identity(): Similar to color scaling, this instructs plotnine to use the font sizes specified in the fontsize column without transformation.
  6. watermark(): Embeds a logo. Since there’s no native figure size parameter in plotnine, I manually scaled the output.

Custom Theme

We apply a tailored theme with themify() to refine the figure’s appearance:

def themify(p: ggplot) -> Figure:
    return (
        p
        + theme_void()
        + theme(
            legend_position="none",  # turns off the legend
            axis_text_x=element_blank(),
            axis_text_y=element_blank(),
            axis_title_x=element_blank(),
            axis_title_y=element_blank(),
            panel_background=element_rect(fill=dark_navy_blue),
            plot_background=element_rect(fill=dark_navy_blue),
            text=element_text(family=fontname_roboto),
            dpi=300,
            figure_size=(6, 8),
        )
    ).draw(show=False)

Final Rendering

Now, let’s tie it all together:

p = plot_g()
fig = themify(p)
fig

Closing Thoughts

This post showcases how plotnine can be used to create table-like visualizations. I’m genuinely impressed by its capabilities — it’s surprisingly fun to approach a table as a figure.

Throughout this exploration, I learned a lot from this repository, which won the Plotnine Contest 2024. It’s a fantastic example of what’s possible with the library.

It would be exciting to explore how plotnine and Great Tables might work together to enable even richer visual storytelling — I’m looking forward to diving into that next.

WarningDisclaimer
  1. This table is intended as a self-practice project, and the data in the table may not be 100% accurate. Please refer to the original source if you require verified data.
  2. This post was drafted by me, with AI assistance to refine the content.
]]> python polars plotnine https://tech.ycwu.space/posts/clone-reciprocal-tariffs-table-p9/20250416.html Wed, 16 Apr 2025 00:00:00 GMT Weekend Challenge – Recreating a Data Visualization with Polars and Plotnine Jerry Wu https://tech.ycwu.space/posts/p9-polars-alta-ski-resort/20250412.html This post is part of a visualization recreation challenge using Polars and plotnine, inspired by my earlier work.

It marks my first serious dive into plotnine—an impressive library with a bit of a learning curve.
I’ll walk through the journey I took to recreate the visualization. Some parts may overlap with the earlier post, but I believe that’s acceptable to keep this one self-contained.

The final figure, shown below, visualizes temperature trends for the ski season in Alta over the past few decades.

Alta ski resort

Show full code 
import polars as pl
import polars.selectors as cs
from highlight_text import ax_text
from matplotlib.axes import Axes
from matplotlib.figure import Figure

from plotnine import (
    aes,
    element_blank,
    element_text,
    geom_line,
    geom_point,
    geom_segment,
    geom_text,
    ggplot,
    labs,
    scale_color_cmap,
    scale_x_continuous,
    scale_y_continuous,
    theme,
    theme_classic,
)

# https://github.com/mattharrison/datasets/raw/refs/heads/master/data/alta-noaa-1980-2019.csv
data_path = "alta-noaa-1980-2019.csv"
columns = ["DATE", "TOBS"]
idx_colname = "DAY_OF_SEASON"
temp_colname = "temp"

heading_fontsize = 9.5
heading_fontweight = "bold"
subheading_fontsize = 8
subheading_fontweight = "normal"
source_fontsize = 6.5
source_fontweight = "light"
axis_fontsize = 7
axis_fontweight = "normal"
sub_props = {"fontsize": subheading_fontsize, "fontweight": subheading_fontweight}

grey = "#aaaaaa"
red = "#e3120b"
blue = "#0000ff"


def get_season_expr(col: str = "DATE", alias: str = "SEASON") -> pl.expr:
    return (
        (
            pl.when((pl.col(col).dt.month().is_between(5, 10, closed="both")))
            .then(pl.lit("Summer "))
            .otherwise(pl.lit("Ski "))
        )
        .add(
            pl.when(pl.col(col).dt.month() < 11)
            .then(pl.col(col).dt.year().cast(pl.String))
            .otherwise(pl.col(col).dt.year().add(1).cast(pl.String))
        )
        .alias(alias)
    )


def add_day_of_season_expr(
    col: str = "DATE", group_col: str = "SEASON", alias: str = "DAY_OF_SEASON"
) -> pl.expr:
    return (
        (pl.col(col) - pl.col(col).min()).dt.total_days().over(group_col).alias(alias)
    )


def tweak_df(
    data_path: str, columns: list[str], idx_colname: str = "DAY_OF_SEASON"
) -> pl.DataFrame:
    return (
        pl.scan_csv(data_path)
        .select(columns)
        .with_columns(
            pl.col("DATE").str.to_datetime(),
            pl.col("TOBS").interpolate(),
        )
        .sort("DATE")
        .with_columns(
            # Caveat: Cannot be placed in the previous `with_columns()`
            # due to different statuses of `TOBS`.
            pl.col("TOBS").rolling_mean(window_size=28, center=True).alias("TMEAN"),
            get_season_expr(col="DATE", alias="SEASON"),
        )
        .with_columns(
            add_day_of_season_expr(col="DATE", group_col="SEASON", alias=idx_colname)
        )
        .collect()
    )


def plot_temps(_df: pl.DataFrame, idx_colname: str = "DAY_OF_SEASON") -> ggplot:
    season_temps = _df.filter(pl.col("SEASON").str.contains("Ski")).pivot(
        "SEASON", index=idx_colname, values="TMEAN", aggregate_function="first"
    )

    # main
    df_main = season_temps.unpivot(
        (cs.starts_with("Ski") - cs.by_name("Ski 2019")),
        index=idx_colname,
        variable_name="year",
        value_name=temp_colname,
    ).select(
        idx_colname,
        temp_colname,
        pl.col("year").str.slice(-4).cast(pl.Int32),
    )

    # decades
    decades = [1980, 1990, 2000, 2010]
    blues = ["#0055EE", "#0033CC", "#0011AA", "#3377FF"]

    df_decade = pl.concat(
        [
            season_temps.select(
                idx_colname,
                pl.mean_horizontal(cs.contains(str(decade)[:-1])).alias(temp_colname),
                pl.lit(b).alias("color"),
            )
            for b, decade in zip(blues, decades)
        ],
        how="vertical",
    )

    # decade points
    df_decade_pts = (
        df_decade.group_by(pl.col("color"), maintain_order=True)
        .agg(
            pl.col(idx_colname).first().append(pl.col(idx_colname).last()),
            pl.col(temp_colname).first().append(pl.col(temp_colname).last()),
        )
        .explode(idx_colname, temp_colname)
    )

    # decade annotations
    decade_annts = (
        df_decade_pts.filter(pl.col(idx_colname).eq(pl.col(idx_colname).max()))
        .select(temp_colname)
        .to_series()
        .to_list()
    )

    df_decade_annt = pl.DataFrame(
        {
            "x": [185] * len(decade_annts),
            # adjust y position for better appearance
            "y": [
                decade_annts[0],
                decade_annts[1] + 0.5,
                decade_annts[2] - 3,
                decade_annts[3],
            ],
            "color": blues,
            "label": decades,
        }
    )

    # ski_2019
    ski_2019 = (
        season_temps.select(
            idx_colname, pl.col("Ski 2019").alias(temp_colname)
        ).drop_nulls()  # "DAY_OF_SEASON"=181, "temp"=null
    )

    # ski_2019 points
    ski_2019_pts = pl.concat([ski_2019.head(1), ski_2019.tail(1)])

    # ggplot
    return (
        ggplot(mapping=aes(x=idx_colname, y=temp_colname))
        # multiple grey lines
        + geom_line(
            mapping=aes(color="factor(year)"),
            data=df_main,
            alpha=0.2,
            size=0.5,
        )
        # 4 blue lines
        + geom_line(
            mapping=aes(fill="factor(color)"),
            data=df_decade,
            color=df_decade["color"],
            size=0.5,
            lineend="round",
        )
        # 2019 red line
        + geom_line(
            data=ski_2019,
            color=red,
            size=0.8,
            lineend="round",
        )
        # 1 black dashed line for temp=32F
        + geom_segment(
            mapping=aes(x=0, xend=200, y=32, yend=32),
            size=0.5,
            linetype="dashed",
        )
        # start and end dots for 4 blue lines
        + geom_point(
            mapping=aes(x=idx_colname, y=temp_colname),
            data=df_decade_pts,
            color=df_decade_pts["color"],
            size=0.2,
        )
        # start and end dots for 2019 red line
        + geom_point(
            mapping=aes(x=idx_colname, y=temp_colname),
            data=ski_2019_pts,
            color=red,
            size=1,
        )
        # annotations for 4 blue lines
        + geom_text(
            mapping=aes(x="x", y="y", label="label"),
            data=df_decade_annt,
            color=df_decade_annt["color"],
            size=axis_fontsize,
            fontweight=axis_fontweight,
            ha="left",
            va="center",
        )
        + labs(x="Day of season", y="")
        + scale_x_continuous(
            breaks=[0, 50, 100, 150],
            limits=(0, 200),
            expand=(0, 10, 0, 15),
        )
        + scale_y_continuous(breaks=[10, 32, 40], limits=(10, 70), expand=(0, 0))
        + scale_color_cmap("Greys", guide=None)
    )


def points_to_inches(points):
    return points / 72


def themify(p: ggplot) -> Figure:
    figsize = (160, 165)  # pts
    figsize_inches = [points_to_inches(dim) for dim in figsize]

    return (
        p
        + theme_classic()
        + theme(
            axis_line_y=element_blank(),
            axis_title_x=element_text(weight=axis_fontweight, size=axis_fontsize),
            axis_title_y=element_text(weight=axis_fontweight, size=axis_fontsize),
            axis_text_x=element_text(color="black"),
            axis_text_y=element_text(color="black"),
            dpi=300,
            figure_size=figsize_inches,
            aspect_ratio=2 / 3,
            text=element_text("Roboto"),
        )
    ).draw(show=False)


def add_ax_text(ax: Axes) -> Axes:
    ax_text(
        s="<Alta Ski Resort>\n<Temperature trends by >\n<decade>< and ><2019>",
        x=-5,
        y=55,
        fontsize=heading_fontsize,
        ax=ax,
        va="bottom",
        ha="left",
        zorder=5,
        highlight_textprops=[
            {"fontsize": heading_fontsize, "fontweight": heading_fontweight},
            sub_props,
            {"color": blue, **sub_props},
            sub_props,
            {"color": red, **sub_props},
        ],
    )

    ax.text(
        0,
        -10,
        "Source: NOAA",
        fontsize=source_fontsize,
        fontweight=source_fontweight,
        color=grey,
    )
    return ax


df = tweak_df(data_path, columns, idx_colname)
p = plot_temps(df, idx_colname)
fig = themify(p)
ax = fig.axes[0]
ax = add_ax_text(ax)
fig

Data Processing Pipeline

Below is the data pipeline used to generate the DataFrame for the upcoming visualization stage:

data_path = "alta-noaa-1980-2019.csv"
columns = ["DATE", "TOBS"]
idx_colname = "DAY_OF_SEASON"
temp_colname = "temp"


def tweak_df(data_path: str, columns: list[str], idx_colname: str = "DAY_OF_SEASON"):
    return (
        pl.scan_csv(data_path)
1        .select(columns)
        .with_columns(
2            pl.col("DATE").str.to_datetime(),
3            pl.col("TOBS").interpolate(),
        )
        .sort("DATE")
        .with_columns(
            # Caveat: Cannot be placed in the previous `with_columns()`
            # due to different statuses of `TOBS`.
4            pl.col("TOBS").rolling_mean(window_size=28, center=True).alias("TMEAN"),
5            get_season_expr(col="DATE", alias="SEASON"),
        )
        .with_columns(
6            add_day_of_season_expr(col="DATE", group_col="SEASON", alias=idx_colname)
        )
        .collect()
    )
1
Select the DATE column (dates) and TOBS column (recorded temperatures in Fahrenheit).
2
Convert the DATE column to a datetime format.
3
Perform interpolation on the TOBS column.
4
Compute a 28-day rolling average for TOBS.
5
Use get_season_expr() to categorize each date into a SEASON.
6
Apply add_day_of_season_expr() to calculate DAY_OF_SEASON, representing days elapsed since the start of the season.

The first three steps involve straightforward Polars expressions. In the following two sub-sections, we’ll dive deeper into steps 5 and 6.

Categorizing Dates into Summer and Ski Seasons

To analyze seasonal trends, we classify dates into two categories:

  • Summer: Covers May through October.
  • Ski: Covers November through April.

If a date falls in November or December, it is assigned to the following year’s season. For example, 2015-10-31 is categorized as Summer 2015, while 2015-11-01 belongs to Ski 2016.

To implement this logic, we define get_season_expr(), which leverages Polars’ when-then-otherwise expressions to determine the season and year.

def get_season_expr(col: str = "DATE", alias: str = "SEASON") -> pl.expr:
    return (
        (
            pl.when((pl.col(col).dt.month().is_between(5, 10, closed="both")))
            .then(pl.lit("Summer "))
            .otherwise(pl.lit("Ski "))
        )
        .add(
            pl.when(pl.col(col).dt.month() < 11)
            .then(pl.col(col).dt.year().cast(pl.String))
            .otherwise(pl.col(col).dt.year().add(1).cast(pl.String))
        )
        .alias(alias)
    )

In this function:

  • If the month is between May and October, the function assigns "Summer ". Otherwise, it assigns "Ski " (with a trailing space for concatenation).
  • The year is determined based on the month: dates from January to October retain their current year, while those in November and December are shifted to the next year.

By applying this function, we can add a SEASON column to a DataFrame, ensuring each date is categorized correctly.

Calculating the Total Days for Each Season

Once we have the seasonal categories, we calculate DAY_OF_SEASON, which tracks the number of days elapsed within each season. This is achieved using the pl.expr.over() expression, which operates similarly to Pandas’ groupby().transform(), applying transformations within groups.

def add_day_of_season_expr(
    col: str = "DATE", group_col: str = "SEASON", alias: str = "DAY_OF_SEASON"
) -> pl.expr:
    return (
        (pl.col(col) - pl.col(col).min()).dt.total_days().over(group_col).alias(alias)
    )

Touchups

Adding a Theme

We apply a custom theme using the themify() function, adjusting various themeable elements to refine the plot’s appearance:

def points_to_inches(points):
    return points / 72


def themify(p: ggplot) -> Figure:
    figsize = (160, 165)  # pts
    figsize_inches = [points_to_inches(dim) for dim in figsize]

    return (
        p
        + theme_classic()
        + theme(
            axis_line_y=element_blank(),
            axis_title_x=element_text(weight=axis_fontweight, size=axis_fontsize),
            axis_title_y=element_text(weight=axis_fontweight, size=axis_fontsize),
            axis_text_x=element_text(color="black"),
            axis_text_y=element_text(color="black"),
            dpi=300,
            figure_size=figsize_inches,
            aspect_ratio=2 / 3,
            text=element_text("Roboto"),
        )
    ).draw(show=False)

Adding a Title and Source Note

For the title, we use ax_text() from the HighlightText library. It allows inline text highlighting using < >, letting us emphasize specific parts of the title like <Alta Ski Resort>, <Temperature trends by >, <decade>, < and >, and <2019> with customized styles.

To add a source note, we simply use Matplotlib’s ax.text():

def add_ax_text(ax: Axes) -> Axes:
    ax_text(
        s="<Alta Ski Resort>\n<Temperature trends by >\n<decade>< and ><2019>",
        x=-5,
        y=55,
        fontsize=heading_fontsize,
        ax=ax,
        va="bottom",
        ha="left",
        zorder=5,
        highlight_textprops=[
            {"fontsize": heading_fontsize, "fontweight": heading_fontweight},
            sub_props,
            {"color": blue, **sub_props},
            sub_props,
            {"color": red, **sub_props},
        ],
    )

    ax.text(
        0,
        -10,
        "Source: NOAA",
        fontsize=source_fontsize,
        fontweight=source_fontweight,
        color=grey,
    )
    return ax

Rendering the Plot

Now we put everything together and render the final plot. A key trick here is retrieving the ax object using fig.axes[0], which allows us to apply both HighlightText and regular Matplotlib functions.

df = tweak_df(data_path, columns, idx_colname)
p = plot_temps(df, idx_colname)
fig = themify(p)
ax = fig.axes[0]
ax = add_ax_text(ax)
fig

Takeaways

Wrapping up this post, I’ve come to appreciate how powerful the plotnine library truly is. While its aesthetic system requires a bit of mental shift, it offers a clean, expressive way to build layered visualizations.

One key takeaway for me is that each layer can operate on its own dataset, which adds a lot of flexibility. What I enjoyed most, though, is the theme system—it makes it easy to define a consistent visual style that can be reused across different plots.

One limitation I ran into was the lack of a plotnine-native alternative to pli.subplot_mosaic(). This feature allows for more granular layout control—for example, dividing the figure into separate axes with custom height ratios for the title, main plot, and source note using gridspec_kw={"height_ratios": [6, 12, 1]}.

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python polars matplotlib plotnine https://tech.ycwu.space/posts/p9-polars-alta-ski-resort/20250412.html Sat, 12 Apr 2025 00:00:00 GMT How to Access the Axes in Plotnine Jerry Wu https://tech.ycwu.space/posts/access-axes-in-plotnine/20250411.html This is a short post documenting my experience trying to retrieve the Axes from plotnine.

The idea was inspired by this code and this video I came across, but the original solution didn’t quite work for me. Fortunately, I found that we can access the list of Axes directly using either fig.axes or fig.get_axes().

In the example below, I adapt a snippet from the plotnine documentation to demonstrate how to highlight text in color using HighlightText.

plotnine used in combination with HighlightText

import highlight_text as ht
from plotnine import aes, geom_point, ggplot, labs, theme_matplotlib, theme_set
from plotnine.data import mpg

theme_set(theme_matplotlib())

p = (
    ggplot(mpg, aes(x="displ", y="hwy"))
    + geom_point()
    + labs(x="displacement", y="horsepower")
)

fig = p.draw()
ax = fig.axes[0]  # or via fig.get_axes()[0]
ht_ax_text = 'Color highlighted by <HighlightText::{"color": "#E58606"}>'
ht.ax_text(4, 40, ht_ax_text, vsep=3, fontsize=9, va="top", ax=ax)
fig
WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python matplotlib plotnine https://tech.ycwu.space/posts/access-axes-in-plotnine/20250411.html Fri, 11 Apr 2025 00:00:00 GMT Clone the Reciprocal Tariffs Table Using Great Tables Jerry Wu https://tech.ycwu.space/posts/clone-reciprocal-tariffs-table/20250403.html This post demonstrates how to clone the Reciprocal Tariffs table that President Donald Trump announced on April 2 on Truth Social.

Since the code is largely self-explanatory, I will highlight some tricks and caveats I encountered while building the table:

  1. The data dictionary was extracted with the help of AI.
  2. The border radius was one of the trickiest aspects of the table—it took some time to figure out how to fill the gap between the rounded corners and the rectangle. Fortunately, I drew inspiration from the Great Tables example, Highest Paid Athletes in 2023. The solution was to use two <div> tags, which allowed me to assign distinct colors to the inside and outside of the border.
  3. I created four empty columns—["0", "1", "2", "3"]—to serve as borders. This allowed for easier adjustment of border properties such as color and width. An interesting feature of GT.cols_width() is that you can set column widths using percentages, and the total doesn’t need to add up to exactly 100%—it just works. This is especially handy when experimenting with different table designs, as it lets you estimate widths without worrying about precise calculations.
  4. I added a “mod” column to help distinguish whether a row’s index is odd or even. This made it possible to combine pl.when().then().otherwise() with pl.Expr.map_elements(). Although pl.Expr.map_elements() is generally considered an anti-pattern in Polars, I believe it fits my use case well.
  5. The column_labels_border_bottom_style= parameter in GT.tab_options() is key to hiding the line between the column labels and the table body.
  6. Logo embedding might seem a bit tricky if you’re new to Great Tables; I suggest reading the blog post that details how to render images anywhere in Great Tables.
  7. To enhance the overall visual effect, I added a row at the end of the table and filled it with the same background color.
  8. The original table featured two rings, but I was only able to implement the inner one using GT.opt_table_outline(). I decided to leave it out for a cleaner appearance.
  9. While the color codes and font properties could be further enhanced, Great Tables successfully replicates the table’s structure and style with only minor differences.

Cloned Reciprocal Tariffs Table

Show full code 
import polars as pl
from great_tables import GT, google_font, html, loc, style, vals

# source1: https://truthsocial.com/@realDonaldTrump/114270398531479278
# source2:
# "https://upload.wikimedia.org/wikipedia/commons/
# thumb/3/36/Seal_of_the_President_of_the_United_States.svg/
# 800px-Seal_of_the_President_of_the_United_States.svg.png"
logo = vals.fmt_image("logo.png", height=150)[0]

data = {
    "country": [
        "China",
        "European Union",
        "Vietnam",
        "Taiwan",
        "Japan",
        "India",
        "South Korea",
        "Thailand",
        "Switzerland",
        "Indonesia",
        "Malaysia",
        "Cambodia",
        "United Kingdom",
        "South Africa",
        "Brazil",
        "Bangladesh",
        "Singapore",
        "Israel",
        "Philippines",
        "Chile",
        "Australia",
        "Pakistan",
        "Turkey",
        "Sri Lanka",
        "Colombia",
    ],
    "tariffs_charged": [
        "67%",
        "39%",
        "90%",
        "64%",
        "46%",
        "52%",
        "50%",
        "72%",
        "61%",
        "64%",
        "47%",
        "97%",
        "10%",
        "60%",
        "10%",
        "74%",
        "10%",
        "33%",
        "34%",
        "10%",
        "10%",
        "58%",
        "10%",
        "88%",
        "10%",
    ],
    "reciprocal_tariffs": [
        "34%",
        "20%",
        "46%",
        "32%",
        "24%",
        "26%",
        "25%",
        "36%",
        "31%",
        "32%",
        "24%",
        "49%",
        "10%",
        "30%",
        "10%",
        "37%",
        "10%",
        "17%",
        "17%",
        "10%",
        "10%",
        "29%",
        "10%",
        "44%",
        "10%",
    ],
}

dark_navy_blue = "#0B162A"  # background
light_blue = "#B5D3E7"  # row
white = "#FFFFFF"  # row
yellow = "#F6D588"  # "reciprocal_tariffs" column
gold = "#FFF8DE"  # logo


def change_border_radius(
    x: str, border_radius: str, background_color1: str, background_color2: str
) -> str:
    return f"""\
    <div style="background-color: {background_color1};border: None">\
        <div style="border-radius: {border_radius};\
                    background-color:{background_color2};">\
            &nbsp;{x}\
        </div>\
    </div>\
    """


def change_border_radius_expr(
    cols: pl.Expr,
    return_dtype: pl.DataType,
    border_radius: str,
    background_color1: str,
    background_color2: str,
) -> pl.Expr:
    return cols.map_elements(
        lambda x: change_border_radius(
            x, border_radius, background_color1, background_color2
        ),
        return_dtype=return_dtype,
    )


df = (
    pl.DataFrame(data)
    .with_row_index("mod")
    .with_columns(pl.col("mod").mod(2), *[pl.lit("").alias(str(i)) for i in range(4)])
    .with_columns(
        # "country" and "tariffs_charged" columns
        pl.when(pl.col("mod").eq(0))
        .then(
            change_border_radius_expr(
                pl.col("country", "tariffs_charged"),
                pl.String,
                "5px",
                dark_navy_blue,
                light_blue,
            )
        )
        .otherwise(
            change_border_radius_expr(
                pl.col("country", "tariffs_charged"),
                pl.String,
                "5px",
                dark_navy_blue,
                white,
            )
        ),
        # "reciprocal_tariffs" column
        change_border_radius_expr(
            pl.col("reciprocal_tariffs"), pl.String, "5px", dark_navy_blue, yellow
        ),
    )
    .select(["0", "country", "1", "tariffs_charged", "2", "reciprocal_tariffs", "3"])
    # add a row at the end of the table
    .pipe(
        lambda df_: pl.concat(
            [df_, pl.DataFrame({col: "" for col in df_.columns})], how="vertical"
        )
    )
)

# inner_ring_style, inner_ring_width, inner_ring_color = "dashed", "3px", "orange"

(
    GT(df)
    .cols_align(
        "center", columns=["tariffs_charged", "reciprocal_tariffs"]
    )
    .cols_label(
        {
            "country": html(
                f"""\
                <br>\
                <div>\
                    {logo}&nbsp;\
                    <span style="color: {gold}; font-size: 40px;">\
                        &nbsp&nbsp;Reciprocal Tariffs\
                    </span>\
                </div>\
                <br>\
                <b>Country</b>\
                """
            ),
            "tariffs_charged": html(
                """\
                <b>Tariffs Charged<br>to the U.S.A.</b>\
                <br>\
                <span style="font-size: 12px;">\
                    Including<br>Currency Manipulation<br>and Trade Barriers\
                </span>\
                """
            ),
            "reciprocal_tariffs": html(
                "<b>U.S.A. Discounted<br>Reciprocal Tariffs</b>"
            ),
            "0": "",
            "1": "",
            "2": "",
            "3": "",
        }
    )
    .cols_width(
        {
            "country": "50%",
            "0": "3%",
            "1": "7%",
            "2": "7%",
            "3": "3%",
            "tariffs_charged": "18%",
            "reciprocal_tariffs": "18%",
        }
    )
    # For labels and body:
    # set the background color of the labels and body to `dark_navy_blue`
    .tab_style(
        style=style.fill(color=dark_navy_blue),
        locations=[loc.column_labels(), loc.body()],
    )
    # For body:
    # set the border color of the body to `dark_navy_blue`
    # set the weight and size
    .tab_style(
        style=[
            style.borders(sides="all", color=dark_navy_blue),
            style.text(weight="bold", size="xx-large"),
        ],
        locations=loc.body(),
    )
    # For labels:
    # set the font, weight, size and color
    # center-align the labels
    .tab_style(
        style=[
            style.text(
                font=google_font(name="Georgia"),
                weight="bold",
                size="large",
                color=white,
            ),
            style.css("text-align: center;"),
        ],
        locations=loc.column_labels(),
    )
    # hide the bottom line of the label section
    .tab_options(column_labels_border_bottom_style="hidden")
    # set the body background color to `dark_navy_blue` for the last row
    .tab_style(
        style=style.fill(color=dark_navy_blue),
        locations=loc.body(rows=[-1]),
    )
    # .opt_table_outline(
    #     style=inner_ring_style,
    #     width=inner_ring_width,
    #     color=inner_ring_color,
    # )
    # need to adjust `window_size` to obtain a higher-quality figure
    # .save("reciprocal_tariffs_gt.png", web_driver="firefox", window_size=(1200, 1000))
)

Remark

Added on July 11, 2025

I’ve been actively developing the Turtle Island library and found this example to be a great opportunity to test its usability.

I was genuinely surprised by how well ti.case_when() and ti.is_every_nth_row() worked together to refactor the code into a more concise and expressive form. Since ti.is_every_nth_row() returns an expression, we aren’t actually creating a new column in the DataFrame—it’s more like adding a virtual column.

This experience has further strengthened my confidence in the design and practical value of Turtle Island.

If using Turtle Island 
import turtle_island as ti

# "country" and "tariffs_charged" columns
country_tariffs_charged_expr = ti.case_when(
    caselist=[
        (
            ti.is_every_nth_row(2),
            change_border_radius_expr(
                pl.col("country", "tariffs_charged"),
                pl.String,
                "5px",
                dark_navy_blue,
                light_blue,
            ),
        )
    ],
    otherwise=change_border_radius_expr(
        pl.col("country", "tariffs_charged"),
        pl.String,
        "5px",
        dark_navy_blue,
        white,
    ),
)

# "reciprocal_tariffs" column
reciprocal_tariffs_expr = change_border_radius_expr(
    pl.col("reciprocal_tariffs"),
    pl.String,
    "5px",
    dark_navy_blue,
    yellow,
)

df = (
    pl.DataFrame(data)
    .with_columns(
        country_tariffs_charged_expr,
        reciprocal_tariffs_expr,
        *[pl.lit("").alias(str(i)) for i in range(4)],
    )
    .select(["0", "country", "1", "tariffs_charged", "2", "reciprocal_tariffs", "3"])
    # add a row at the end of the table
    .pipe(
        lambda df_: pl.concat(
            [df_, pl.DataFrame({col: "" for col in df_.columns})], how="vertical"
        )
    )
)
WarningDisclaimer
  1. This table is intended as a self-practice project, and the data in the table may not be 100% accurate. Please refer to the original source if you require verified data.
  2. This post was drafted by me, with AI assistance to refine the content.
]]> python polars gt https://tech.ycwu.space/posts/clone-reciprocal-tariffs-table/20250403.html Thu, 03 Apr 2025 00:00:00 GMT Applying Custom Color Palettes to the Table Body in Great Tables Jerry Wu https://tech.ycwu.space/posts/table-body-custom-palette/20250225.html This post provides a concise guide on styling the table body with custom colors using Pandas and Polars.

There are two primary methods for applying a color palette: one leverages a pre-existing column containing color values, while the other determines colors dynamically based on conditions. I’ll walk you through both approaches.

Since all the generated tables will have the same appearance, I’ll display the final result just once:

Table Body with a Custom Palette

Preparations

We’ll start by creating a data dictionary, which will be used with Pandas or Polars later. Additionally, we’ll define a color_mapping dictionary to store the palette information for styling.

import pandas as pd
import polars as pl
from great_tables import GT, from_column, loc, style
from polars import selectors as cs

data = {
    "col1": [2, 5, 7, 10, 15],
    "col2": ["x", "y", "y", "z", "z"],
    "color": ["lightgrey", "lightblue", "lightblue", "papayawhip", "papayawhip"],
}

color_mapping = {"x": "lightgrey", "y": "lightblue", "z": "papayawhip"}

Pandas

First, we create a Pandas DataFrame called df_pd using data as the input:

Code 
df_pd = pd.DataFrame(data)
print(df_pd)
   col1 col2       color
0     2    x   lightgrey
1     5    y   lightblue
2     7    y   lightblue
3    10    z  papayawhip
4    15    z  papayawhip

Using an Existing Column

In this straightforward scenario, the DataFrame already contains a predefined column with color names for each row. You can use the from_column() function provided by Great Tables to apply colors to the table body:

(
    GT(df_pd)
    .tab_style(style=style.fill(color=from_column("color")), locations=loc.body())
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)

Using Functions

In cases where colors need to be determined dynamically based on conditions, the pd.Series.case_when() function can be very useful. The following example categorizes the values of the col1 column into three different colors:

def color_selector(df_):
    return df_["col1"].case_when(
        [
            (df_["col1"].lt(3), "lightgrey"),  # <3
            (df_["col1"].lt(10), "lightblue"),  # <10
            (df_["col1"].ge(10), "papayawhip"),  # >=10
        ]
    )


(
    GT(df_pd)
    .tab_style(style=style.fill(color=color_selector), locations=loc.body())
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)

For categorical-like columns (e.g., col2), a simple value-to-color mapping may be sufficient. In such cases, a predefined dictionary can be used with pd.Series.map() or pd.Series.replace():

(
    GT(df_pd)
    .tab_style(
        style=style.fill(color=lambda df_: df_["col2"].map(color_mapping)),
        locations=loc.body(),
    )
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)
(
    GT(df_pd)
    .tab_style(
        style=style.fill(color=lambda df_: df_["col2"].replace(color_mapping)),
        locations=loc.body(),
    )
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)

Alternatively, if you prefer sticking with the same approach, pd.Series.case_when() still works:

def color_selector(df_):
    return df_["col2"].case_when(
        [
            (df_["col2"].eq("x"), "lightgrey"),
            (df_["col2"].eq("y"), "lightblue"),
            (df_["col2"].eq("z"), "papayawhip"),
        ]
    )


(
    GT(df_pd)
    .tab_style(style=style.fill(color=color_selector), locations=loc.body())
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)

Polars

Just like before, let’s start by creating a Polars DataFrame named df_pl using data as input:

Code 
df_pl= pl.DataFrame(data)
print(df_pl)
shape: (5, 3)
┌──────┬──────┬────────────┐
│ col1 ┆ col2 ┆ color      │
│ ---  ┆ ---  ┆ ---        │
│ i64  ┆ str  ┆ str        │
╞══════╪══════╪════════════╡
│ 2    ┆ x    ┆ lightgrey  │
│ 5    ┆ y    ┆ lightblue  │
│ 7    ┆ y    ┆ lightblue  │
│ 10   ┆ z    ┆ papayawhip │
│ 15   ┆ z    ┆ papayawhip │
└──────┴──────┴────────────┘

Using an Existing Column

If the DataFrame already contains a column specifying colors, we can apply them directly with from_column():

(
    GT(df_pl)
    .tab_style(style=style.fill(color=from_column("color")), locations=loc.body())
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)

As another option, we can reference the color column using a Polars expression:

(
    GT(df_pl)
    .tab_style(style=style.fill(color=pl.col("color")), locations=loc.body())
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)

Using Conditional Logic with Polars Expressions

For cases where colors need to be assigned dynamically, pl.when() provides a structured way to define conditions. The example below assigns colors based on the values in col1:

color_selector_expr = (
    pl.when(pl.col("col1").lt(3))  # <3
    .then(pl.lit("lightgrey"))
    .when(pl.col("col1").lt(10))  # <10
    .then(pl.lit("lightblue"))
    .when(pl.col("col1").ge(10))  # >=10
    .then(pl.lit("papayawhip"))
)

(
    GT(df_pl)
    .tab_style(style=style.fill(color=color_selector_expr), locations=loc.body())
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)

For categorical-like columns (e.g., col2), predefined mappings can be applied efficiently using pl.Expr.replace():

(
    GT(df_pl)
    .tab_style(
        style=style.fill(color=pl.col("col2").replace(color_mapping)),
        locations=loc.body(),
    )
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)

Alternatively, if you prefer the conditional approach, pl.when() can still be used:

color_selector_expr = (
    pl.when(pl.col("col2").eq(pl.lit("x")))
    .then(pl.lit("lightgrey"))
    .when(pl.col("col2").eq(pl.lit("y")))
    .then(pl.lit("lightblue"))
    .when(pl.col("col2").eq(pl.lit("z")))
    .then(pl.lit("papayawhip"))
)


(
    GT(df_pl)
    .tab_style(style=style.fill(color=color_selector_expr), locations=loc.body())
    .cols_align(align="center")
    .opt_stylize(style=3, color="pink")
)

Final Notes

In this post, we explored how to use a custom color palette to style table backgrounds with style.fill(). The same approach can be applied to customize text color using style.text() or adjust border color with style.borders().

Lastly, remember that loc.body() allows you to target specific columns and rows, giving you precise control over table styling.

WarningDisclaimer

This post was drafted by me, with AI assistance to refine the content.

]]> python pandas polars gt https://tech.ycwu.space/posts/table-body-custom-palette/20250225.html Tue, 25 Feb 2025 00:00:00 GMT