Plottable

https://github.com/znstrider/plottable
Admin
Plottable is a Python library for creating beautifully customized, presentation-ready tables in...
Tokens:16,574
Snippets:164
Trust Score:6.9
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install plottable

Source: https://github.com/znstrider/plottable/blob/master/docs/index.rst

Use pip to install the library in your Python environment.

```bash
pip install plottable
```

--------------------------------

### Install Plottable in Editable Mode

Source: https://github.com/znstrider/plottable/blob/master/contributing.rst

Clone the repository and install the project in editable mode for development. This allows changes to be reflected immediately without reinstallation.

```bash
git clone https://github.com/znstrider/plottable.git
cd plottable

pip install -e .
```

--------------------------------

### Color Map and Path Setup

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/plots.ipynb

Set up a color map using `LinearSegmentedColormap` and obtain a file path for image plots. This is often a prerequisite for certain plot types.

```python
path = list(Path("../example_notebooks/country_flags").glob("*.png"))[0]
cmap = LinearSegmentedColormap.from_list(
    name="bugw", colors=["#ffffff", "#f2fbd2", "#c9ecb4", "#93d3ab", "#35b0ab"], N=256
)
```

--------------------------------

### Full table example with plots

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/plot_example.ipynb

Combines DataFrame creation, colormap definition, and table construction with various plot types for each column. Displays the generated table using Matplotlib.

```python
fig, ax = plt.subplots(figsize=(6, 10))

d = pd.DataFrame(np.random.random((10, 4)), columns=["A", "B", "C", "D"]).round(2)

tab = Table(
    d,
    cell_kw={
        "linewidth": 0,
        "edgecolor": "k",
    },
    textprops={"ha": "center"},
    column_definitions=[
        ColumnDefinition("index", textprops={"ha": "left"}),
        ColumnDefinition("A", plot_fn=percentile_bars, plot_kw={"is_pct": True}),
        ColumnDefinition(
            "B", width=1.5, plot_fn=percentile_stars, plot_kw={"is_pct": True}
        ),
        ColumnDefinition(
            "C",
            plot_fn=progress_donut,
            plot_kw={
                "is_pct": True,
                "formatter": "{:.0%}"
                },
            ),
        ColumnDefinition(
            "D",
            width=1.25,
            plot_fn=bar,
            plot_kw={
                "cmap": cmap,
                "plot_bg_bar": True,
                "annotate": True,
                "height": 0.5,
                "lw": 0.5,
                "formatter": decimal_to_percent,
            },
        ),
    ],
)

plt.show()
```

--------------------------------

### Create a Basic Matplotlib Table with Plottable

Source: https://context7.com/znstrider/plottable/llms.txt

Use the `Table` class to render a pandas DataFrame as a matplotlib table. Ensure matplotlib, numpy, and pandas are installed.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from plottable import Table

# Create sample data
df = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"])

# Create figure and table
fig, ax = plt.subplots(figsize=(6, 3))
tab = Table(df)

plt.show()
```

--------------------------------

### Basic Table Creation in Matplotlib

Source: https://github.com/znstrider/plottable/blob/master/README.md

Create a basic table using plottable with a pandas DataFrame. This example demonstrates the fundamental usage of the Table class.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from plottable import Table

d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"])
d = d.round(2)
fig, ax = plt.subplots(figsize=(6, 5))
tab = Table(d)

plt.show()
```

--------------------------------

### Create and Style a Plottable Table

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/bohndesliga_table.ipynb

Generate a Plottable table with customized styling, including row dividers, column label dividers, footer dividers, index column, row colors, and text properties. This example also demonstrates conditional row styling and saving the table visualization.

```python
fig, ax = plt.subplots(figsize=(14, 12))

plt.rcParams["text.color"] = text_color
plt.rcParams["font.family"] = "Roboto"

fig.set_facecolor(bg_color)
ax.set_facecolor(bg_color)

table = Table(
    perform,
    column_definitions=table_col_defs,
    row_dividers=True,
    col_label_divider=False,
    footer_divider=True,
    index_col="rank",
    columns=table_cols,
    even_row_color=row_colors["even"],
    footer_divider_kw={"color": bg_color, "lw": 2},
    row_divider_kw={"color": bg_color, "lw": 2},
    column_border_kw={"color": bg_color, "lw": 2},
    textprops={"fontsize": 16, "ha": "center", "fontname": "Roboto"},
)

for idx in [0, 1, 2, 3]:
    table.rows[idx].set_facecolor(row_colors["top4"])
    
for idx in [4, 5]:
    table.rows[idx].set_facecolor(row_colors["top6"])
    
table.rows[15].set_facecolor(row_colors["playoffs"])

for idx in [16, 17]:
    table.rows[idx].set_facecolor(row_colors["relegation"])
    table.rows[idx].set_fontcolor(row_colors["top4"])

    
fig.savefig(
    "images/bohndesliga_table_recreation.png",
    facecolor=fig.get_facecolor(),
    dpi=200,
)
```

--------------------------------

### Image Plot Example

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/plots.ipynb

Renders an image within a Matplotlib Axes using the `image` function. Requires an `ax` object and a valid image path.

```python
fig, ax = plt.subplots(figsize=(1, 1))

image(ax, path)

plt.show()
```

--------------------------------

### Providing a Text Formatter with ColumnDefinition

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/column_definition.ipynb

Format cell text appearance using a callable function passed to the 'formatter' argument of ColumnDefinition. Example uses decimal_to_percent.

```python
from plottable.formatters import decimal_to_percent

d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"])
fig, ax = plt.subplots(figsize=(6, 5))
tab = Table(d, column_definitions=[ColumnDefinition(name="A", formatter=decimal_to_percent)])

plt.show()
```

--------------------------------

### Circled Image Plot Example

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/plots.ipynb

Displays an image clipped into a circle using the `circled_image` function. Requires an `ax` object and an image path.

```python
fig, ax = plt.subplots(figsize=(1, 1))

im = circled_image(ax, path)

plt.show()
```

--------------------------------

### Percentile Bars Plot Example

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/plots.ipynb

Demonstrates the usage of the `percentile_bars` plot function. It requires an `ax` object, a value, and optionally `color`, `background_color`, and `is_pct` parameters.

```python
fig, ax = plt.subplots(figsize=(1, 0.5))

bars = percentile_bars(ax=ax, val=72, color="#b0db7c", background_color="#f0f0f0", is_pct=False)

plt.show()
```

--------------------------------

### Providing a cmap function with ColumnDefinition

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/column_definition.ipynb

Apply a colormap to cell backgrounds based on cell values by providing a callable to the 'cmap' argument. Example uses matplotlib.cm.Reds.

```python
from plottable.cmap import normed_cmap
import matplotlib.cm


d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"])
fig, ax = plt.subplots(figsize=(6, 5))
tab = Table(d, column_definitions=[ColumnDefinition(name="A", cmap=matplotlib.cm.Reds)])

plt.show()
```

--------------------------------

### Providing a text_cmap function with ColumnDefinition

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/column_definition.ipynb

Control the color of cell text based on cell values by providing a callable to the 'text_cmap' argument. Example uses matplotlib.cm.Reds.

```python
from plottable.cmap import normed_cmap
import matplotlib.cm


d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"])
fig, ax = plt.subplots(figsize=(6, 5))
tab = Table(d, column_definitions=[ColumnDefinition(name="A", text_cmap=matplotlib.cm.Reds)])

plt.show()
```

--------------------------------

### Instantiate Table with ColumnDefinition

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/column_definition.ipynb

Provide a list of ColumnDefinition objects to the Table constructor to style specific columns.

```python
Table(df, column_definitions: List[ColumnDefinition]=None)
```

--------------------------------

### Importing dependencies

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/wwc_example.ipynb

Initializes the environment and imports necessary libraries for data manipulation and plotting.

```python
%load_ext autoreload
%autoreload 2

from pathlib import Path

import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from matplotlib.colors import LinearSegmentedColormap

from plottable import ColumnDefinition, Table
from plottable.cmap import normed_cmap
from plottable.formatters import decimal_to_percent
from plottable.plots import circled_image # image
```

--------------------------------

### Map Team Names to Logo Paths

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/bohndesliga_table.ipynb

Sets up a mapping from team names to their corresponding logo file paths by scanning a directory for PNG files. This is preparation for potentially displaying team logos in the table.

```python
# mapping teamnames to logo paths

club_logo_path = Path("bundesliga_crests_22_23")
club_logo_files = list(club_logo_path.glob("*.png"))
club_logos_paths = {f.stem: f for f in club_logo_files}
```

--------------------------------

### Import ColumnDefinition and ColDef

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/column_definition.ipynb

Import ColumnDefinition or its alias ColDef for defining column attributes.

```python
from plottable import ColumnDefinition
```

```python
from plottable import ColDef
```

--------------------------------

### Create a Basic Table

Source: https://github.com/znstrider/plottable/blob/master/docs/index.rst

Initialize a Table object using a pandas DataFrame and render it with Matplotlib.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from plottable import Table

d = pd.DataFrame(np.random.random((10, 5)), columns=["A", "B", "C", "D", "E"]).round(2)
fig, ax = plt.subplots(figsize=(5, 8))
tab = Table(d)

plt.show()
```

--------------------------------

### Define Table Styling and Column Selection

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/bohndesliga_table.ipynb

Sets up a dictionary for row colors and defines the subset of columns to display in the final table.

```python
row_colors = {
    "top4": "#2d3636",
    "top6": "#516362",
    "playoffs": "#8d9386",
    "relegation": "#c8ab8d",
    "even": "#627979",
    "odd": "#68817e",
}

bg_color = row_colors["odd"]
text_color = "#e0e8df"

table_cols = ["crest", "team", "games", "W", "D", "L", "goal_difference", "gd", "pts"]
```

--------------------------------

### Locating flag images

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/wwc_example.ipynb

Builds a mapping of country names to their corresponding flag image file paths.

```python
flag_paths = list(Path("country_flags").glob("*.png"))
country_to_flagpath = {p.stem: p for p in flag_paths}
```

--------------------------------

### Previewing the data

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/wwc_example.ipynb

Displays the first few rows of the processed DataFrame.

```python
df.head()
```

--------------------------------

### Initialize Plottable Environment

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/basic_example.ipynb

Sets up the necessary imports and autoreload configuration for working with Plottable and matplotlib.

```python
%load_ext autoreload
%autoreload 2

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from plottable import Table
```

--------------------------------

### Configuring column definitions

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/wwc_example.ipynb

Sets up the visual properties, formatting, and plot functions for each column in the table.

```python
team_rating_cols = ["SPI", "OFF", "DEF"]
group_stage_cols = ["1st Place", "2nd Place", "3rd Place"]
knockout_stage_cols = list(df.columns[-5:])


col_defs = (
    [
        ColumnDefinition(
            name="Flag",
            title="",
            textprops={"ha": "center"},
            width=0.5,
            plot_fn=circled_image,
        ),
        ColumnDefinition(
            name="Team",
            textprops={"ha": "left", "weight": "bold"},
            width=1.5,
        ),
        ColumnDefinition(
            name="Group",
            textprops={"ha": "center"},
            width=0.75,
        ),
        ColumnDefinition(
            name="SPI",
            group="Team Rating",
            textprops={"ha": "center"},
            width=0.75,
        ),
        ColumnDefinition(
            name="OFF",
            width=0.75,
            textprops={
                "ha": "center",
                "bbox": {"boxstyle": "circle", "pad": 0.35},
            },
            cmap=normed_cmap(df["OFF"], cmap=matplotlib.cm.PiYG, num_stds=2.5),
            group="Team Rating",
        ),
        ColumnDefinition(
            name="DEF",
            width=0.75,
            textprops={
                "ha": "center",
                "bbox": {"boxstyle": "circle", "pad": 0.35},
            },
            cmap=normed_cmap(df["DEF"], cmap=matplotlib.cm.PiYG_r, num_stds=2.5),
            group="Team Rating",
        ),
    ]
    + [
        ColumnDefinition(
            name=group_stage_cols[0],
            title=group_stage_cols[0].replace(" ", "\n", 1),
            formatter=decimal_to_percent,
            group="Group Stage Chances",
            border="left",
        )
    ]
    + [
        ColumnDefinition(
            name=col,
            title=col.replace(" ", "\n", 1),
            formatter=decimal_to_percent,
            group="Group Stage Chances",
        )
        for col in group_stage_cols[1:]
    ]
    + [
        ColumnDefinition(
            name=knockout_stage_cols[0],

```

--------------------------------

### Create Basic Table

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/basic_example.ipynb

Generates a standard table from a pandas DataFrame and saves the output as an image.

```python
d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"]).round(2)

fig, ax = plt.subplots(figsize=(6, 3))

tab = Table(d)

plt.show()

fig.savefig("images/basic_table.png")
```

--------------------------------

### Generate and Display a Plottable Table

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/heatmap.ipynb

Generates sample data, creates a Plottable Table with custom column definitions and styling, and displays it using matplotlib. The table is then saved to a file.

```python
cities = [
    "TORONTO",
    "VANCOUVER",
    "HALIFAX",
    "CALGARY",
    "OTTAWA",
    "MONTREAL",
    "WINNIPEG",
    "EDMONTON",
    "LONDON",
    "ST. JONES",
]
months = [
    "JAN",
    "FEB",
    "MAR",
    "APR",
    "MAY",
    "JUN",
    "JUL",
    "AUG",
    "SEP",
    "OCT",
    "NOV",
    "DEC",
]

data = np.random.random((10, 12)) + np.abs(np.arange(12) - 5.5)
data = (1 - data / (np.max(data)))


d = pd.DataFrame(data, columns=months, index=cities).round(2)

fig, ax = plt.subplots(figsize=(14, 5))


column_definitions = [
    ColDef(name, cmap=cmap, formatter=lambda x: "") for name in months
] + [ColDef("index", title="", width=1.5, textprops={"ha": "right"})]

tab = Table(
    d,
    column_definitions=column_definitions,
    row_dividers=False,
    col_label_divider=False,
    textprops={"ha": "center", "fontname": "Roboto"},
    cell_kw={
        "edgecolor": "w",
        "linewidth": 0,
    },
)


tab.col_label_row.set_facecolor("k")
tab.col_label_row.set_fontcolor("w")
tab.columns["index"].set_facecolor("k")
tab.columns["index"].set_fontcolor("w")
tab.columns["index"].set_linewidth(0)


plt.show()


fig.savefig("images/calender.png", dpi=200)
```

--------------------------------

### Load Autoreload and Libraries

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/bohndesliga_table.ipynb

Initializes autoreload for interactive development and imports necessary libraries like pandas, numpy, and plottable for data manipulation and plotting.

```python
%load_ext autoreload
%autoreload 2

from pathlib import Path

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

from plottable import ColDef, Table
from plottable.plots import image
```

--------------------------------

### Table Configuration Arguments

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/table.ipynb

A comprehensive list of arguments available for the Table class to customize data presentation, styling, and layout.

```python
"""
Args:
    df (pd.DataFrame):
        A pandas DataFrame with your table data
    ax (mpl.axes.Axes, optional):
        matplotlib axes. Defaults to None.
    index_col (str, optional):
        column to set as the DataFrame index. Defaults to None.
    columns (List[str], optional):
        columns to use. If None defaults to all columns.
    column_definitions (List[plottable.column_def.ColumnDefinition], optional):
        ColumnDefinitions for columns that should be styled. Defaults to None.
    textprops (Dict[str, Any], optional):
        textprops are passed to each TextCells matplotlib.pyplot.text. Defaults to {}.
    cell_kw (Dict[str, Any], optional):
        cell_kw are passed to to each cells matplotlib.patches.Rectangle patch.
        Defaults to {}.
    col_label_cell_kw (Dict[str, Any], optional):
        col_label_cell_kw are passed to to each ColumnLabels cells
        matplotlib.patches.Rectangle patch. Defaults to {}.
    col_label_divider (bool, optional):
        Whether to plot a divider line below the column labels. Defaults to True.
    col_label_divider_kw (Dict[str, Any], optional):
        col_label_divider_kw are passed to plt.plot. Defaults to {}.
    footer_divider (bool, optional):
        Whether to plot a divider line below the table. Defaults to False.
    footer_divider_kw (Dict[str, Any], optional):
        footer_divider_kw are passed to plt.plot. Defaults to {}.
    row_dividers (bool, optional):
        Whether to plot divider lines between rows. Defaults to True.
    row_divider_kw (Dict[str, Any], optional):
        row_divider_kw are passed to plt.plot. Defaults to {}.
    column_border_kw (Dict[str, Any], optional):
        column_border_kw are passed to plt.plot. Defaults to {}.
    even_row_color (str | Tuple, optional):
        facecolor of the even row cell's patches
    odd_row_color (str | Tuple, optional):
        facecolor of the even row cell's patches
"""
```

--------------------------------

### Accessing Columns and Rows

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/rows_and_columns.ipynb

Demonstrates how to access columns by name and rows by their integer index (iloc).

```APIDOC
## Accessing Columns and Rows

### Description
Access columns by their name and rows by their integer location (iloc).

### Method
N/A (Code examples)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```python
# Accessing a column by name
column_data = table.columns[column_name]

# Accessing a row by integer index
row_data = table.rows[idx]

# Accessing the column label row
column_labels = table.col_label_row
```

### Response
N/A
```

--------------------------------

### Plottable Initialization and Imports

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/plots.ipynb

Import necessary libraries and modules for using Plottable, including `matplotlib`, `pandas`, and specific plot types from `plottable.plots`.

```python
%load_ext autoreload
%autoreload 2

from pathlib import Path

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from matplotlib.colors import LinearSegmentedColormap

from plottable import ColumnDefinition, Table
from plottable.plots import *
```

--------------------------------

### Create custom lambda and function formatters

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/formatters.ipynb

Custom formatters can be simple lambda functions or more complex Python functions.

```python
lambda x: round(x, 2)
```

```python
def my_formatter(cell_content: Any) -> str | Number: ...
```

--------------------------------

### Create a table with progress donut and custom formatter

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/plot_example.ipynb

Generates a table with a 'progress_donut' plot in column C. Uses Python's string formatting for percentages via the 'formatter' keyword in 'plot_kw'.

```python
ColumnDefinition(
    "C",
    plot_fn=progress_donut,
    plot_kw={
        "is_pct": True,
        "formatter": "{:.0%}"
        },
    ),
```

--------------------------------

### Loading and preparing data

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/wwc_example.ipynb

Defines the columns to load and reads the CSV file into a pandas DataFrame.

```python
cols = [
    "team",
    "points",
    "group",
    "spi",
    "global_o",
    "global_d",
    "group_1",
    "group_2",
    "group_3",
    "make_round_of_16",
    "make_quarters",
    "make_semis",
    "make_final",
    "win_league",
]

df = pd.read_csv(
    "data/wwc_forecasts.csv",
    usecols=cols,
)
```

--------------------------------

### Auto-Set Font Colors for Contrast

Source: https://context7.com/znstrider/plottable/llms.txt

Ensure text readability on colored backgrounds using the autoset_fontcolors method.

```python
import matplotlib.pyplot as plt
import matplotlib.cm
import numpy as np
import pandas as pd
from plottable import Table, ColumnDefinition
from plottable.font import contrasting_font_color, contrasting_font_color_w3c

df = pd.DataFrame(np.random.random((5, 3)), columns=["A", "B", "C"]).round(2)

fig, ax = plt.subplots(figsize=(6, 5))
tab = Table(
    df,
    column_definitions=[
        ColumnDefinition(name="A", cmap=matplotlib.cm.Reds),
        ColumnDefinition(name="B", cmap=matplotlib.cm.Blues),
        ColumnDefinition(name="C", cmap=matplotlib.cm.Greens),
    ]
)

# Auto-set contrasting font colors for all columns
tab.autoset_fontcolors()

# Or specify columns and custom threshold
tab.autoset_fontcolors(colnames=["A", "B"], thresh=150)

# Or use W3C contrast algorithm
tab.autoset_fontcolors(fn=contrasting_font_color_w3c)

plt.show()
# Output: Table with automatically adjusted text colors for readability on colored backgrounds
```

--------------------------------

### plottable.helpers Module

Source: https://github.com/znstrider/plottable/blob/master/docs/plottable.rst

Documentation for the plottable.helpers submodule, detailing its members, undocumented members, and inheritance.

```APIDOC
## plottable.helpers Module

### Description
Details the contents of the plottable.helpers submodule.

### Members

.. automodule:: plottable.helpers
   :members:
   :undoc-members:
   :show-inheritance:
```

--------------------------------

### Setting Cell and Text Properties

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/rows_and_columns.ipynb

Shows how to set visual properties for cells (rectangle patches) and text using available setter functions.

```APIDOC
## Setting Cell and Text Properties

### Description
Set cell properties (like facecolor) and text properties (like fontcolor) for rows and columns.

### Method
N/A (Code examples)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```python
# Setting facecolor for a column
table.columns[column_name].set_facecolor("#f0f0f0")

# Setting facecolor for a row
table.rows[0].set_facecolor("#f0f0f0")

# Available rectangle patch setters:
# set_alpha, set_color, set_edgecolor, set_facecolor, set_fill, set_hatch, set_linestyle, set_linewidth

# Available fontproperty setters:
# set_fontcolor, set_fontfamily, set_fontsize, set_ha, set_ma
```

### Response
N/A
```

--------------------------------

### Create a Custom Colormap

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/heatmap.ipynb

Defines a custom LinearSegmentedColormap named 'BuYl' with specified colors for use in table cell coloring.

```python
cmap = LinearSegmentedColormap.from_list(
    name="BuYl", colors=["#01a6ff", "#eafedb", "#fffdbb", "#ffc834"], N=256
)
```

--------------------------------

### Mapping column names

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/wwc_example.ipynb

Creates a dictionary to rename raw data columns to human-readable labels.

```python
colnames = [
    "Team",
    "Points",
    "Group",
    "SPI",
    "OFF",
    "DEF",
    "1st Place",
    "2nd Place",
    "3rd Place",
    "Make Rd Of 16",
    "Make Quarters",
    "Make Semis",
    "Make Finals",
    "Win World Cup",
]

col_to_name = dict(zip(cols, colnames))
```

--------------------------------

### Create a table with bar plot and formatter function

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/plot_example.ipynb

Generates a table with a 'bar' plot in column D. Uses a custom formatter function 'decimal_to_percent' and includes styling options like 'cmap', 'plot_bg_bar', 'annotate', 'height', and 'lw'.

```python
ColumnDefinition(
    "D",
    width=1.25,
    plot_fn=bar,
    plot_kw={
        "cmap": cmap,
        "plot_bg_bar": True,
        "annotate": True,
        "height": 0.5,
        "lw": 0.5,
        "formatter": decimal_to_percent,
    },
)
```

--------------------------------

### Configure Plotting Backend

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/wwc_example.ipynb

Sets Matplotlib's runtime configuration parameters for font family and savefig bounding box. Ensures consistent plot appearance.

```python
plt.rcParams["font.family"] = ["DejaVu Sans"]
plt.rcParams["savefig.bbox"] = "tight"
```

--------------------------------

### Style Columns with ColumnDefinition

Source: https://context7.com/znstrider/plottable/llms.txt

Utilize `ColumnDefinition` or `ColDef` for fine-grained control over individual column appearance, including titles, widths, text properties, and alignment.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from plottable import Table, ColumnDefinition, ColDef

df = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"])

fig, ax = plt.subplots(figsize=(8, 5))
tab = Table(
    df,
    column_definitions=[
        ColumnDefinition(name="index", textprops={"ha": "left", "weight": "bold"}),
        ColumnDefinition(name="A", title="Column A", width=2),
        ColDef(name="B", textprops={"ha": "center", "fontsize": 12}),
    ]
)

plt.show()
```

--------------------------------

### Create a table with percentile stars

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/plot_example.ipynb

Generates a table with a 'percentile_stars' plot in column B. Set 'width' to 1.5 and 'is_pct' to True for percentage-based plotting.

```python
ColumnDefinition(
    "B", width=1.5, plot_fn=percentile_stars, plot_kw={"is_pct": True}
)
```

--------------------------------

### Format Code with Black

Source: https://github.com/znstrider/plottable/blob/master/contributing.rst

Use the black code formatter to ensure consistent code style across the project. Run black on all Python files or specify individual files.

```bash
black
```

```bash
black <filename.py>
```

--------------------------------

### Helper Functions for Match Points and Standings

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/bohndesliga_table.ipynb

Provides two helper functions: `add_points` to calculate points awarded in each match and `get_wins_draws_losses` to aggregate win, draw, and loss counts for each team.

```python
def add_points(df: pd.DataFrame) -> pd.DataFrame:
    df["pts_home"] = np.where(
        df["score1"] > df["score2"], 3, np.where(df["score1"] == df["score2"], 1, 0)
    )
    df["pts_away"] = np.where(
        df["score1"] < df["score2"], 3, np.where(df["score1"] == df["score2"], 1, 0)
    )
    
    return df


def get_wins_draws_losses(games: pd.DataFrame) -> pd.DataFrame:
    return (
        games.rename({"pts_home": "pts", "team1": "team"}, axis=1)
        .groupby("team")["pts"]
        .value_counts()
        .add(
            games.rename({"pts_away": "pts", "team2": "team"}, axis=1)
            .groupby("team")["pts"]
            .value_counts(),
            fill_value=0,
        )
        .astype(int)
        .rename("count")
        .reset_index(level=1)
        .pivot(columns="pts", values="count")
        .rename({0: "L", 1: "D", 3: "W"}, axis=1)[["W", "D", "L"]]
    )
```

--------------------------------

### Apply string formatters to columns

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/formatters.ipynb

Pass standard Python format strings directly to the formatter argument of ColDef.

```python
d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"]).round(4)
fig, ax = plt.subplots(figsize=(8, 4))
tab = Table(d, column_definitions=[ColDef(name="A", title="2 Decimals", formatter="{:.2f}"), 
                                   ColDef(name="B", title="Percentage", formatter="{:.1%}"),
                                   ColDef(name="C", title="Exponent\nNotation", formatter="{:.2e}")])

plt.show()
```

--------------------------------

### Create a table with percentile bars

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/plot_example.ipynb

Generates a table with a 'percentile_bars' plot in column A. Ensure 'is_pct' is set to True for percentage-based plotting.

```python
ColumnDefinition("A", plot_fn=percentile_bars, plot_kw={"is_pct": True})
```

--------------------------------

### Create and Save Plottable Table

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/wwc_example.ipynb

Generates a Matplotlib figure and axes, then creates a Plottable Table with specified column definitions and styling. The table is then saved to a PNG file.

```python
fig, ax = plt.subplots(figsize=(20, 22))

table = Table(
    df,
    column_definitions=col_defs,
    row_dividers=True,
    footer_divider=True,
    ax=ax,
    textprops={"fontsize": 14},
    row_divider_kw={"linewidth": 1, "linestyle": (0, (1, 5))},
    col_label_divider_kw={"linewidth": 1, "linestyle": "-"},
    column_border_kw={"linewidth": 1, "linestyle": "-"},
).autoset_fontcolors(colnames=["OFF", "DEF"])

fig.savefig("images/wwc_table.png", facecolor=ax.get_facecolor(), dpi=200)
```

--------------------------------

### Prepare and Sort Performance Data

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/bohndesliga_table.ipynb

Adds a crest column, sorts the dataframe by points and goal difference, and formats goal statistics.

```python
perform.insert(0, "crest", perform["team"])
perform["crest"] = perform["crest"].replace(club_logos_paths)

# sort by table standings
perform = perform.sort_values(by=["pts", "gd", "gf"], ascending=False)

for colname in ["gd", "gf", "ga"]:
    perform[colname] = perform[colname].astype("int32")

perform["goal_difference"] = perform["gf"].astype(str) + ":" + perform["ga"].astype(str)

perform["rank"] = list(range(1, 19))
```

--------------------------------

### Plottable Package Overview

Source: https://github.com/znstrider/plottable/blob/master/docs/plottable.rst

This section provides an overview of the plottable package and its submodules. It lists the available submodules and indicates that members, undocumented members, and inheritance information are shown for each.

```APIDOC
## Plottable Package

### Description
Provides an overview of the plottable Python package and its submodules.

### Submodules
- plottable.cell
- plottable.cmap
- plottable.column_def
- plottable.font
- plottable.formatters
- plottable.helpers
- plottable.plots
- plottable.table

### Module Contents

.. automodule:: plottable
   :members:
   :undoc-members:
   :show-inheritance:
```

--------------------------------

### Define and Load Data URLs

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/bohndesliga_table.ipynb

Defines a dictionary of URLs for soccer data and loads the latest SPI matches data into a pandas DataFrame.

```python
FIVETHIRTYEIGHT_URLS = {
    "SPI_MATCHES": "https://projects.fivethirtyeight.com/soccer-api/club/spi_matches.csv",
    "SPI_MATCHES_LATEST": "https://projects.fivethirtyeight.com/soccer-api/club/spi_matches_latest.csv",
}

df = pd.read_csv(FIVETHIRTYEIGHT_URLS["SPI_MATCHES_LATEST"])
```

--------------------------------

### Create Tables with Alternating Row Colors

Source: https://context7.com/znstrider/plottable/llms.txt

Improve readability by styling tables with alternating row colors using `even_row_color` and `odd_row_color`. Row dividers can be optionally disabled.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from plottable import Table

df = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"])

fig, ax = plt.subplots(figsize=(6, 3))
tab = Table(
    df,
    row_dividers=False,
    odd_row_color="#f0f0f0",
    even_row_color="#e0f6ff"
)

plt.show()
```

--------------------------------

### plottable.formatters Module

Source: https://github.com/znstrider/plottable/blob/master/docs/plottable.rst

Documentation for the plottable.formatters submodule, detailing its members, undocumented members, and inheritance.

```APIDOC
## plottable.formatters Module

### Description
Details the contents of the plottable.formatters submodule.

### Members

.. automodule:: plottable.formatters
   :members:
   :undoc-members:
   :show-inheritance:
```

--------------------------------

### plottable.table Module

Source: https://github.com/znstrider/plottable/blob/master/docs/plottable.rst

Documentation for the plottable.table submodule, detailing its members, undocumented members, and inheritance.

```APIDOC
## plottable.table Module

### Description
Details the contents of the plottable.table submodule.

### Members

.. automodule:: plottable.table
   :members:
   :undoc-members:
   :show-inheritance:
```

--------------------------------

### Create Styled Table with Alternating Colors

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/basic_example.ipynb

Customizes table appearance by disabling row dividers and setting specific colors for odd and even rows.

```python
d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"]).round(2)

fig, ax = plt.subplots(figsize=(6, 3))

tab = Table(d, row_dividers=False, odd_row_color="#f0f0f0", even_row_color="#e0f6ff")

plt.show()

fig.savefig("images/alternating_row_color.png")
```

--------------------------------

### plottable.cmap Module

Source: https://github.com/znstrider/plottable/blob/master/docs/plottable.rst

Documentation for the plottable.cmap submodule, detailing its members, undocumented members, and inheritance.

```APIDOC
## plottable.cmap Module

### Description
Details the contents of the plottable.cmap submodule.

### Members

.. automodule:: plottable.cmap
   :members:
   :undoc-members:
   :show-inheritance:
```

--------------------------------

### plottable.column_def Module

Source: https://github.com/znstrider/plottable/blob/master/docs/plottable.rst

Documentation for the plottable.column_def submodule, detailing its members, undocumented members, and inheritance.

```APIDOC
## plottable.column_def Module

### Description
Details the contents of the plottable.column_def submodule.

### Members

.. automodule:: plottable.column_def
   :members:
   :undoc-members:
   :show-inheritance:
```

--------------------------------

### plottable.cell Module

Source: https://github.com/znstrider/plottable/blob/master/docs/plottable.rst

Documentation for the plottable.cell submodule, detailing its members, undocumented members, and inheritance.

```APIDOC
## plottable.cell Module

### Description
Details the contents of the plottable.cell submodule.

### Members

.. automodule:: plottable.cell
   :members:
   :undoc-members:
   :show-inheritance:
```

--------------------------------

### Access and Modify Table Rows and Columns

Source: https://context7.com/znstrider/plottable/llms.txt

Access specific rows using `tab.rows[index]` and columns via `tab.columns[name]` or `tab.get_column(name)`. Both support chained styling methods for customization.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from plottable import Table

df = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"]).round(2)

fig, ax = plt.subplots(figsize=(6, 5))
tab = Table(df)

# Style specific row
tab.rows[0].set_facecolor("#ffcccc")
tab.rows[0].set_fontcolor("#990000")

# Style specific column
tab.get_column("A").set_facecolor("#ccffcc")
tab.get_column("A").set_fontsize(14)
tab.get_column("A").set_fontfamily("monospace")

# Style multiple rows
for row in tab.get_even_rows():
    row.set_alpha(0.8)

plt.show()
# Output: First row highlighted red, column A highlighted green with larger monospace font
```

--------------------------------

### plottable.font Module

Source: https://github.com/znstrider/plottable/blob/master/docs/plottable.rst

Documentation for the plottable.font submodule, detailing its members, undocumented members, and inheritance.

```APIDOC
## plottable.font Module

### Description
Details the contents of the plottable.font submodule.

### Members

.. automodule:: plottable.font
   :members:
   :undoc-members:
   :show-inheritance:
```

--------------------------------

### plottable.plots Module

Source: https://github.com/znstrider/plottable/blob/master/docs/plottable.rst

Documentation for the plottable.plots submodule, detailing its members, undocumented members, and inheritance.

```APIDOC
## plottable.plots Module

### Description
Details the contents of the plottable.plots submodule.

### Members

.. automodule:: plottable.plots
   :members:
   :undoc-members:
   :show-inheritance:
```

--------------------------------

### Set Column Face Color

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/rows_and_columns.ipynb

Set the background color for a specific column. Requires the column to be accessed by name first.

```python
table.columns[column_name].set_facecolor("#f0f0f0")
```

--------------------------------

### Customize Table Dividers

Source: https://context7.com/znstrider/plottable/llms.txt

Control the styling of row, label, and footer dividers using Table parameters and keyword dictionaries.

```python
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from plottable import Table

df = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"]).round(2)

fig, ax = plt.subplots(figsize=(6, 5))
tab = Table(
    df,
    col_label_divider=True,
    col_label_divider_kw={"linewidth": 2, "color": "black"},
    row_dividers=True,
    row_divider_kw={"linewidth": 0.5, "color": "gray"},
    footer_divider=True,
    footer_divider_kw={"linewidth": 2, "color": "black"},
)

plt.show()
# Output: Table with thick black header/footer dividers and thin gray row dividers
```

--------------------------------

### Define Table Columns with Plottable

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/bohndesliga_table.ipynb

Set up column definitions for a Plottable table, specifying properties like width, title, image plotting function, text alignment, and formatting.

```python
table_col_defs = [
    ColDef("rank", width=0.5, title=""),
    ColDef("crest", width=0.35, plot_fn=image, title=""),
    ColDef("team", width=2.5, title="", textprops={"ha": "left"}),
    ColDef("games", width=0.5, title="Games"),
    ColDef("W", width=0.5),
    ColDef("D", width=0.5),
    ColDef("L", width=0.5),
    ColDef("goal_difference", title="Goals"),
    ColDef("gd", width=0.5, title="", formatter="{:+}"),
    ColDef("pts", border="left", title="Points"),
]
```

--------------------------------

### Define available formatter signatures

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/formatters.ipynb

These function signatures represent the interface for built-in formatters provided by the library.

```python
def decimal_to_percent(val: float) -> str: ...
    """Formats Numbers to a string, replacing
        0 with "–"
        1 with "✓"
        values < 0.01 with "<1%" and
        values > 0.99 with ">99%"
    """


def tickcross(val: Number | bool) -> str: ...
    """formats a bool or (0, 1) value to a tick "✔" or cross "✖"."""


def signed_integer(val: int) -> str: ...
    """formats an integer to a string that includes the sign, ie. 1 to "+1"."""
```

--------------------------------

### Progress Donut Plot

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/plots.ipynb

Creates a progress donut chart using the `progress_donut` function. Requires an `ax` object and a value. `textprops` can be used to style the displayed text.

```python
fig, ax = plt.subplots(figsize=(1, 1))
donut = progress_donut(ax, 73, textprops={"fontsize": 14})
plt.show()
```

--------------------------------

### Bar Plot with Annotations and Styling

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/plots.ipynb

Generates a bar plot with value annotations, a background bar, and custom height using parameters like `plot_bg_bar`, `cmap`, `annotate`, and `height`.

```python
fig, ax = plt.subplots(figsize=(1, 1))
b = bar(ax, 0.5, plot_bg_bar=True, cmap=cmap, annotate=True, lw=1, height=0.35)
plt.show()
```

--------------------------------

### Calculate Team Performance Statistics

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/bohndesliga_table.ipynb

Aggregates team performance statistics including points, goal difference, goals for/against, expected goals, and total games played. It combines home and away team stats and then adds win, draw, and loss counts.

```python
perform = (
    bl.groupby("team1")[[ 
        "pts_home",
        "score1",
        "score2",
        "xg1",
        "xg2",
    ]]
    .sum()
    .set_axis(
        [
            "pts",
            "gf",
            "ga",
            "xgf",
            "xga",
        ],
        axis=1,
    )
    .add(
        bl.groupby("team2")[[ 
            "pts_away",
            "score2",
            "score1",
            "xg2",
            "xg1",
        ]]
        .sum()
        .set_axis(
            [
                "pts",
                "gf",
                "ga",
                "xgf",
                "xga",
            ],
            axis=1,
        )
    )
)

perform.index.name = "team"

perform["gd"] = perform["gf"] - perform["ga"]

perform = perform[
    [
        "pts",
        "gd",
        "gf",
        "ga",
        "xgf",
        "xga",
    ]
]

perform["games"] = bl.groupby("team1").size().add(bl.groupby("team2").size())
```

```python
wins_draws_losses = get_wins_draws_losses(bl)
perform = pd.concat([perform, wins_draws_losses], axis=1)
```

--------------------------------

### Setting Column Widths with ColumnDefinition

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/column_definition.ipynb

Adjust the relative width of a column using the 'width' argument in ColumnDefinition. A value greater than 1 increases the width, while a value less than 1 decreases it.

```python
d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"])
fig, ax = plt.subplots(figsize=(6, 5))
tab = Table(d, column_definitions=[ColumnDefinition(name="A", width=2)])

plt.show()
```

--------------------------------

### Create Normalized and Centered Colormaps

Source: https://context7.com/znstrider/plottable/llms.txt

Use `centered_cmap` to create diverging colormaps centered on zero or a custom value. Ensure data is provided for normalization.

```python
import matplotlib.pyplot as plt
import matplotlib.cm
import pandas as pd
from plottable import Table, ColumnDefinition
from plottable.cmap import normed_cmap, centered_cmap

# Data with positive and negative values
df = pd.DataFrame({
    "Metric": ["Revenue", "Costs", "Profit", "Growth"],
    "Value": [120, 85, 35, -12],
    "Change": [0.15, -0.08, 0.22, -0.05]
})

fig, ax = plt.subplots(figsize=(6, 4))
tab = Table(
    df,
    index_col="Metric",
    column_definitions=[
        ColumnDefinition(
            name="Change",
            cmap=centered_cmap(df["Change"], cmap=matplotlib.cm.RdYlGn, center=0)
        ),
    ]
)
tab.autoset_fontcolors(colnames=["Change"])

plt.show()
# Output: Positive changes shown in green, negative in red, centered at zero
```

--------------------------------

### Apply a lambda formatter to a column

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/formatters.ipynb

Use a lambda function to round values in a specific column.

```python
d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"]).round(2)
fig, ax = plt.subplots(figsize=(8, 4))
tab = Table(d, column_definitions=[ColDef(name="A", formatter=lambda x: round(x, 1))])

plt.show()
```

--------------------------------

### Group Columns with ColumnDefinition

Source: https://github.com/znstrider/plottable/blob/master/docs/notebooks/column_definition.ipynb

Use the group argument to create a spanner label spanning multiple columns with the same group name.

```python
from plottable.cmap import normed_cmap
import matplotlib.cm


d = pd.DataFrame(np.random.random((5, 5)), columns=["A", "B", "C", "D", "E"]).round(2)
fig, ax = plt.subplots(figsize=(6, 5))
tab = Table(d, column_definitions=[ColumnDefinition(name="A", group="group_name"), 
                                   ColumnDefinition(name="B", group="group_name")])

plt.show()
```

--------------------------------

### Define Table Columns

Source: https://github.com/znstrider/plottable/blob/master/docs/example_notebooks/wwc_example.ipynb

Defines columns for a table, specifying names, titles, formatting, colormaps, and grouping. Used for creating structured data visualizations.

```python
ColumnDefinition(
            name=knockout_stage_cols[0].replace(" ", "\n", 1),
            formatter=decimal_to_percent,
            cmap=cmap,
            group="Knockout Stage Chances",
            border="left",
        )
    ]
    + [
        ColumnDefinition(
            name=col,
            title=col.replace(" ", "\n", 1),
            formatter=decimal_to_percent,
            cmap=cmap,
            group="Knockout Stage Chances",
        )
        for col in knockout_stage_cols[1:]
    ])
```
Tokens:
Raw