### Install Great Tables Python Package

Source: https://posit-dev.github.io/great-tables/articles/intro.html/blog/introduction_great_tables

Instructions on how to install the `great_tables` package using pip, the Python package installer.

```bash
pip install great_tables
```

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

### Install Project Dependencies

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/contributing

Instructions for installing the 'great-tables' project and its development dependencies using pip. This includes editable mode installation, development-specific packages, and additional dependencies for image generation.

```Shell
pip install -e .
```

```Shell
pip install .[dev]
```

```Shell
pip install .[all]
```

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

### Install Great Tables Python Package

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/index

This snippet demonstrates the straightforward installation process for the `great_tables` package using pip, the standard Python package installer. This command is the initial step required to begin utilizing the library's functionalities.

```Python
pip install great_tables
```

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

### Installing Great Tables Python Package via pip

Source: https://posit-dev.github.io/great-tables/articles/intro.html/articles/intro

This command shows how to install the `great_tables` package from PyPI using the `pip` package installer. It's the standard method for adding the library to your Python environment, making it available for use in your projects.

```Bash
$ pip install great_tables
```

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

### Initialize Great Tables with Pandas and Polars DataFrames

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/basic-styling

This snippet imports necessary libraries and prepares `GT` objects from the `airquality` dataset, demonstrating setup for both Pandas and Polars DataFrames for subsequent styling examples.

```Python
import polars as pl

from great_tables import GT, from_column, style, loc
from great_tables.data import airquality

air_head = airquality.head()

gt_air = GT(air_head)
gt_pl_air = GT(pl.from_pandas(air_head))
```

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

### Install Great Tables with Extra Dependencies

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.save

This command installs the `great_tables` library along with its extra dependencies, including `selenium` and `PIL`, which are required for functionalities like saving tables as images or PDFs. Ensure you have pip installed before running this command.

```Bash
pip install great_tables[extra]
```

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

### Initialize a Base Great Table

Source: https://posit-dev.github.io/great-tables/articles/intro.html/blog/introduction-0.12.0/index

This Python code sets up a foundational Great Table object from the `exibble` dataset. It demonstrates basic table creation, column hiding, and adding a title, subtitle, and source note, serving as the starting point for font styling examples.

```Python
from great_tables import GT, exibble, style, loc

gt_tbl = (
    GT(exibble.head(), rowname_col="row", groupname_col="group")
    .cols_hide(columns=["char", "fctr", "date", "time"])
    .tab_header(
        title="A small piece of the exibble dataset",
        subtitle="Displaying the first five rows (of eight)",
    )
    .tab_source_note(
        source_note="This dataset is included in Great Tables."
    )
)

gt_tbl
```

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

### Create a Basic Great Tables GT Object for Examples

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/table-theme-premade

This Python code snippet initializes a `GT` object using a subset of the `exibble` dataset. It demonstrates basic table construction, including setting a header, subtitle, stubhead, number and currency formatting, and adding a source note. This object serves as a foundation for subsequent examples of `opt_*` methods.

```python
from great_tables import GT, exibble, md

lil_exibble = exibble.head(5)[["num", "char", "row", "group"]]

gt_ex = (
    GT(lil_exibble, rowname_col="row", groupname_col="group")
    .tab_header(
        title=md("Data listing from exibble"),
        subtitle=md("This is a **Great Tables** dataset."),
    )
    .tab_stubhead(label="row")
    .fmt_number(columns="num")
    .fmt_currency(columns="currency")
    .tab_source_note(source_note="This is only a portion of the dataset.")
    .opt_vertical_padding(scale=0.5)
)

gt_ex
```

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

### Move Multiple Columns to Start of Table with Great Tables

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.cols_move_to_start

This example illustrates how to move multiple columns, 'year' and 'population', to the beginning of a Great Tables table using the `cols_move_to_start()` method. It builds upon the previous example's `countrypops_mini` dataset and demonstrates passing a list of column names.

```Python
GT(countrypops_mini).cols_move_to_start(columns=["year", "population"])
```

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

### Create a Basic Great Tables Object for Theming Examples

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/table-theme-options

This Python snippet initializes a `GT` object using the `exibble` dataset, configuring row and group names. It then adds a header, subtitle, stubhead, and source note to the table, creating a foundational object to be used in subsequent styling and theming examples.

```python
from great_tables import GT, exibble

gt_ex = (
    GT(exibble.head(5), rowname_col="row", groupname_col="group")
    .tab_header("THE HEADING", "(a subtitle)")
    .tab_stubhead("THE STUBHEAD")
    .tab_source_note("THE SOURCE NOTE")
)

gt_ex
```

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

### Organize Table Columns with Spanners and Movement in Great Tables

Source: https://posit-dev.github.io/great-tables/articles/intro.html/blog/introduction_great_tables

This Python example illustrates how to enhance table readability using the `airquality` dataset and the Great Tables library. It demonstrates adding multiple column spanners with `tab_spanner` to logically group related columns and reordering columns to the start of the table using `cols_move_to_start` for improved presentation.

```Python
from great_tables.data import airquality

airquality_mini = airquality.head(10).assign(Year=1973)

(
    GT(airquality_mini)
    .tab_header(
        title="New York Air Quality Measurements",
        subtitle="Daily measurements in New York City (May 1-10, 1973)",
    )
    .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"),
    )
    .tab_spanner(label="Date", columns=["Year", "Month", "Day"])
    .tab_spanner(label="Measurement", columns=["Ozone", "Solar.R", "Wind", "Temp"])
    .cols_move_to_start(columns=["Year", "Month", "Day"])
)
```

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

### Format Air Quality Data Table with Spanners and HTML Labels

Source: https://posit-dev.github.io/great-tables/articles/intro.html/examples/index

This Python code showcases `great_tables` for presenting air quality measurements. It adds a header, subtitle, defines column spanners for 'Time' and 'Measurement' categories, moves time-related columns to the start, and applies custom HTML labels to measurement columns for better readability.

```python
from great_tables import GT, html
from great_tables.data import airquality

airquality_mini = airquality.head(10).assign(Year = 1973)

(
    GT(airquality_mini)
    .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")
    )
)
```

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

### Output of fmt_number Python example

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/vals.fmt_number

Shows the expected output when formatting numbers using `vals.fmt_number` with the given parameters in the example.

```text
['0.33', '777,000.00']
```

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

### Format Ontario Municipalities Data with Great Tables

Source: https://posit-dev.github.io/great-tables/articles/intro.html/examples/index

This example shows how to load and process municipal data, create markdown-formatted URLs for websites and map locations, and then display the data as a `great_tables` table. It utilizes `fmt_markdown` for links, `fmt_number` for numerical columns, and `cols_label` for custom column headers with HTML.

```Python
from great_tables import GT, html
from great_tables.data import towny

towny_mini = (
    towny[["name", "website", "density_2021", "land_area_km2", "latitude", "longitude"]]
    .sort_values("density_2021", ascending=False)
    .head(10)
)

towny_mini["url_name"] = [""] + towny_mini["name"] + ["]"] + ["("] + towny_mini["website"] + [")"]

towny_mini["location"] = (
    ["[map](http://maps.google.com/?ie=UTF8&hq=&ll="]
    + towny_mini["latitude"].astype(str)
    + [","]
    + towny_mini["longitude"].astype(str)
    + [")"]
)

(
    GT(
        towny_mini[["url_name", "location", "land_area_km2", "density_2021"]],
        rowname_col="url_name",
    )
    .tab_header(
        title="The Municipalities of Ontario",
        subtitle="The top 10 highest population density in 2021",
    )
    .tab_stubhead(label="Municipality")
    .fmt_markdown(columns=["url_name", "location"])
    .fmt_number(columns=["land_area_km2", "density_2021"], decimals=1)
    .cols_label(
        land_area_km2=html("land area, <br>km<sup>2</sup>"),
        density_2021=html("density, <br>people/km<sup>2</sup>"),
    )
)
```

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

### Python Example: Formatting Bytes with vals.fmt_bytes

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/vals.fmt_bytes

This example demonstrates how to use `vals.fmt_bytes` from the `great_tables` library to convert a list of byte values into human-readable strings, specifically showing the output for decimal standard formatting.

```python
from great_tables import vals

vals.fmt_bytes([123.45, 3615844.256], standard="decimal")
# Expected output: ['123 B', '3.6 MB']
```

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

### Python Example Output: Formatted Currency Values

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/vals.fmt_currency

The expected output from the `great_tables.vals.fmt_currency` function when applied to the example input `[1.02, 3.46]` with `decimals=3`.

```text
['$1.020', '$3.460']
```

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

### API Parameters: vals.fmt_time Function

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/vals.fmt_time

Detailed descriptions of each parameter for the `vals.fmt_time` function, including type, purpose, and examples.

```APIDOC
x : X
    A list of values to be formatted.

time_style : TimeStyle = 'iso'
    The time style to use. By default this is the short name "iso" which corresponds to how times are formatted within ISO 8601 datetime values. There are 5 time styles in total and their short names can be viewed using `info_time_style()`.

pattern : str = '{x}'
    A formatting pattern that allows for decoration of the formatted value. The formatted value is represented by the `{x}` (which can be used multiple times, if needed) and all other characters will be interpreted as string literals.

locale : str | None = None
    An optional locale identifier that can be used for formatting values according the locale’s rules. Examples include "en" for English (United States) and "fr" for French (France).
```

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

### API Time Styles: vals.fmt_time Argument

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/vals.fmt_time

A table illustrating the available preset time styles for the `time_style` argument in `vals.fmt_time`, showing their short names, example outputs for `14:35:00`, and notes.

```APIDOC
|  | Time Style | Output | Notes |
| --- | --- | --- | --- |
| 1 | "iso" | "14:35:00" | ISO 8601, 24h |
| 2 | "iso-short" | "14:35" | ISO 8601, 24h |
| 3 | "h_m_s_p" | "2:35:00 PM" | 12h |
| 4 | "h_m_p" | "2:35 PM" | 12h |
| 5 | "h_p" | "2 PM" | 12h |
```

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

### Displaying Great Tables with GT.show

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.show

This Python example illustrates how to effectively use the `GT.show()` method to render `great_tables` objects. It demonstrates displaying both the beginning and end portions of the `exibble` dataset, showcasing the method's direct application.

```Python
from great_tables import GT, exibble

GT(exibble.head(2)).show()
GT(exibble.tail(2)).show()
```

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

### Python Example: Formatting Time with fmt_time

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.fmt_time

Demonstrates how to use the `fmt_time()` method with the `exibble` dataset. This example filters the dataset to include only 'date' and 'time' columns, then formats the 'time' column using the 'h_m_s_p' time style.

```python
from great_tables import GT, exibble

exibble_mini = exibble[["date", "time"]]

(
    GT(exibble_mini)
    .fmt_time(columns="time", time_style="h_m_s_p")
)
```

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

### Python Example: Applying Row Striping to a GT Table

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.opt_row_striping

This Python example demonstrates how to construct a `great_tables` GT object from the `exibble` dataset, apply various formatting options like header, number, and currency formatting, and then enable row striping using the `opt_row_striping()` method for improved readability.

```python
from great_tables import GT, exibble, md

(
    GT(
        exibble[["num", "char", "currency", "row", "group"]],
        rowname_col="row",
        groupname_col="group"
    )
    .tab_header(
        title=md("Data listing from **exibble**"),
        subtitle=md("`exibble` is a **Great Tables** dataset.")
    )
    .fmt_number(columns="num")
    .fmt_currency(columns="currency")
    .tab_source_note(source_note="This is only a subset of the dataset.")
    .opt_row_striping()
)
```

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

### Python Example: Convert Markdown to HTML with vals.fmt_markdown

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/vals.fmt_markdown

Illustrates how to use `vals.fmt_markdown` from `great_tables` to convert multiple Markdown strings into their corresponding HTML representations. The example defines two Markdown text blocks and shows the function call along with the expected HTML output.

```python
from great_tables import vals

text_1 = """
### This is Markdown.

Markdown’s syntax is comprised entirely of
punctuation characters, which punctuation
characters have been carefully chosen so as
to look like what they mean... assuming
you’ve ever used email.
"""

text_2 = """
Info on Markdown syntax can be found
[here](https://daringfireball.net/projects/markdown/).
"""

vals.fmt_markdown([text_1, text_2])
```

```text
['<h3>This is Markdown.</h3>\n<p>Markdown’s syntax is comprised entirely of\npunctuation characters, which punctuation\ncharacters have been carefully chosen so as\nto look like what they mean... assuming\nyou’ve ever used email.',\n'Info on Markdown syntax can be found\n<a href="https://daringfireball.net/projects/markdown/">here</a>.']
```

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

### Python Example: Basic Usage of vals.fmt_roman

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/vals.fmt_roman

Demonstrates how to import and use the `vals.fmt_roman` function to convert a list of integers into Roman numerals.

```python
from great_tables import vals

vals.fmt_roman([3, 5])
```

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

### Example HTML Output from great_tables

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.as_raw_html

This HTML snippet represents the raw HTML output generated by the `great_tables` library from the styled table object. It includes inline CSS for styling and the table structure, demonstrating the full rendered output.

```HTML
<div id="igylmnduox" style="padding-left:0px;padding-right:0px;padding-top:10px;padding-bottom:10px;overflow-x:auto;overflow-y:auto;width:auto;height:auto;">
<style>
#igylmnduox table {
          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Helvetica Neue', 'Fira Sans', 'Droid Sans', Arial, sans-serif;
          -webkit-font-smoothing: antialiased;
          -moz-osx-font-smoothing: grayscale;
        }

#igylmnduox thead, tbody, tfoot, tr, td, th { border-style: none; }
 tr { background-color: transparent; }
#igylmnduox p { margin: 0; padding: 0; }
 #igylmnduox .gt_table { display: table; border-collapse: collapse; line-height: normal; margin-left: auto; margin-right: auto; color: #333333; font-size: 16px; font-weight: normal; font-style: normal; background-color: #FFFFFF; width: auto; border-top-style: solid; border-top-width: 2px; border-top-color: #A8A8A8; border-right-style: none; border-right-width: 2px; border-right-color: #D3D3D3; border-bottom-style: solid; border-bottom-width: 2px; border-bottom-color: #A8A8A8; border-left-style: none; border-left-width: 2px; border-left-color: #D3D3D3; }
 #igylmnduox .gt_caption { padding-top: 4px; padding-bottom: 4px; }
 #igylmnduox .gt_title { color: #333333; font-size: 125%; font-weight: initial; padding-top: 4px; padding-bottom: 4px; padding-left: 10px; padding-right: 10px; border-bottom-color: #FFFFFF; border-bottom-width: 0; }
 #igylmnduox .gt_subtitle { color: #333333; font-size: 85%; font-weight: initial; padding-top: 3px; padding-bottom: 5px; padding-left: 10px; padding-right: 10px; border-top-color: #FFFFFF; border-top-width: 0; }
 #igylmnduox .gt_heading { background-color: Azure; text-align: center; border-bottom-color: #FFFFFF; border-left-style: none; border-left-width: 1px; border-left-color: #D3D3D3; border-right-style: none; border-right-width: 1px; border-right-color: #D3D3D3; }
 #igylmnduox .gt_bottom_border { border-bottom-style: solid; border-bottom-width: 2px; border-bottom-color
```

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

### Build Documentation Locally

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/contributing

Command to build the project's documentation site locally. This is useful for previewing changes during development and the output is generated in the `docs/_site` folder.

```Shell
make docs-build
```

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

### Python: Scale Table Vertical Padding by Factor of 3

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.opt_vertical_padding

This example demonstrates how to initialize a `GT` table using the `exibble` dataset and then apply `opt_vertical_padding` with a `scale` factor of `3` to significantly increase the vertical spacing between table elements.

```Python
from great_tables import GT, exibble, md

gt_tbl = (
    GT(
        exibble[["num", "char", "currency", "row", "group"]],
        rowname_col="row",
        groupname_col="group"
    )
    .tab_header(
        title=md("Data listing from **exibble**"),
        subtitle=md("`exibble` is a **Great Tables** dataset.")
    )
    .fmt_number(columns="num")
    .fmt_currency(columns="currency")
    .tab_source_note(source_note="This is only a subset of the dataset.")
)

gt_tbl.opt_vertical_padding(scale=3)
```

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

### Move Single Column to Start of Table with Great Tables

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.cols_move_to_start

This example demonstrates how to use the `cols_move_to_start()` method to move a single column, 'year', to the beginning of a Great Tables table. It uses a subset of the `countrypops` dataset to create a `GT` object and then applies the method.

```Python
from great_tables import GT
from great_tables.data import countrypops

countrypops_mini = countrypops.loc[countrypops["country_name"] == "Fiji"][
    ["country_name", "year", "population"]
].tail(5)

GT(countrypops_mini).cols_move_to_start(columns="year")
```

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

### Preview of data.gibraltar Dataset Structure

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/data.gibraltar

A textual preview showing the number of rows and columns, along with the data types and sample values for the first few entries of each column in the `data.gibraltar` dataset.

```Text
Rows: 1431
Columns: 10
$ date       <str> '2023-05-01', '2023-05-01', '2023-05-01'
$ time       <str> '00:20', '00:50', '01:20'
$ temp       <f64> 18.9, 18.9, 17.8
$ dew_point  <f64> 12.8, 13.9, 13.9
$ humidity   <f64> 0.68, 0.73, 0.77
$ wind_dir   <str> 'W', 'WSW', 'W'
$ wind_speed <f64> 6.7, 7.2, 6.7
$ wind_gust  <f64> 0.0, 0.0, 0.0
$ pressure   <f64> 1015.2, 1015.2, 1014.6
$ condition  <str> 'Fair', 'Fair', 'Fair'
```

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

### Initialize Great Tables GT Object with Sample Data

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/column-selection

This snippet demonstrates how to import `GT` from `great_tables` and `exibble` data, then create a `GT` object from a subset of `exibble` data. It prepares a small table for subsequent column manipulation examples.

```Python
from great_tables import GT
from great_tables.data import exibble

lil_exibble = exibble[["num", "char", "fctr", "date", "time"]].head(4)
gt_ex = GT(lil_exibble)

gt_ex
```

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

### Conditional Table Styling with Polars Selectors in Great Tables

Source: https://posit-dev.github.io/great-tables/articles/intro.html/blog/introduction_great_tables

This Python example illustrates how to perform conditional styling in 'Great Tables' by integrating 'Polars' column selectors and expressions. It applies a yellow fill color to cells in columns starting with 'Te' where the 'Temp' column's value is greater than 70, showcasing powerful data-driven styling.

```Python
import polars.selectors as cs

(
    GT(airquality_mini)
    .tab_style(
        style=style.fill(color="yellow"),
        locations=loc.body(
            columns=cs.starts_with("Te"),
            rows=pl.col("Temp") > 70
        )
    )
)
```

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

### Create a Basic Display Table with Great Tables in Python

Source: https://posit-dev.github.io/great-tables/articles/intro.html/blog/introduction_great_tables

Demonstrates how to import the `GT` class and `exibble` dataset, then create and display a basic HTML table from a Pandas-like DataFrame using the `GT()` constructor.

```python
from great_tables import GT, exibble

# Create a display table with the `exibble` dataset
gt_tbl = GT(exibble)

# Now, show the gt table
gt_tbl
```

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

### Select Columns and Rows with Pandas Functions/Lambdas

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/basic-styling

This example demonstrates using Python functions (lambdas) for dynamic column and row selection with Pandas DataFrames. The `columns` argument uses a lambda to select columns starting with 'Te', and `rows` uses a lambda to select rows where 'Temp' is greater than 70. A static yellow fill is applied to a Great Tables object backed by Pandas.

```Python
gt_air.tab_style(
    style=style.fill(color="yellow"),
    locations=loc.body(
        columns=lambda col_name: col_name.startswith("Te"),
        rows=lambda D: D["Temp"] > 70,
    )
)
```

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

### Create a Basic Table with Great Tables in Python

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.tab_options

This snippet demonstrates how to initialize a `GT` table object using the `exibble` dataset, selecting specific columns and defining row and group names. It also shows how to add a header with a title and subtitle, format numeric and currency columns, and include a source note, preparing a base table for further styling.

```Python
from great_tables import GT, exibble, md

gt_tbl = (
  GT(
    exibble[["num", "char", "currency", "row", "group"]],
    rowname_col="row",
    groupname_col="group"
  )
  .tab_header(
    title=md("Data listing from **exibble**"),
    subtitle=md("`exibble` is a **Great Tables** dataset.")
  )
  .fmt_number(columns="num")
  .fmt_currency(columns="currency")
  .tab_source_note(source_note="This is only a subset of the dataset.")
)

gt_tbl
```

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

### Create a Basic Table with GT() in Python

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT

Demonstrates the most basic usage of the `GT()` class by passing the `exibble` dataset directly to create a simple output table.

```python
from great_tables import GT, exibble

GT(exibble)
```

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

### Apply Default Table Stylization with GT.opt_stylize (Python)

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.opt_stylize

This Python example demonstrates how to create a `GT` table from the `exibble` dataset, add various components like header, number and currency formatting, and a source note, then apply the default styling using `opt_stylize()`.

```python
from great_tables import GT, exibble, md

gt_tbl = (
      GT(
        exibble[["num", "char", "currency", "row", "group"]],
        rowname_col="row",
        groupname_col="group"
      )
      .tab_header(
        title=md("Data listing from **exibble**"),
        subtitle=md("`exibble` is a **Great Tables** dataset.")
      )
      .fmt_number(columns="num")
      .fmt_currency(columns="currency")
      .tab_source_note(source_note="This is only a subset of the dataset.")
      .opt_stylize()
    )

gt_tbl
```

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

### Import Great Tables Library for Theming

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/table-theme-options

This initial code snippet imports the necessary `GT` class and `exibble` dataset from the `great_tables` library, which are foundational for creating and styling tables. It serves as a starting point for building a custom table theme.

```Python
from great_tables import GT, exibble

# TODO: are there names we can give the three colors?
```

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

### Create a basic GT table object with `exibble` data in Python

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/basic-formatting

This snippet initializes a `great_tables.GT` object using a subset of the `exibble` dataset. It demonstrates how to load data and create a basic table before any formatting is applied, showing the raw numeric, date, time, and currency values.

```python
from great_tables import GT
from great_tables.data import exibble
from great_tables import vals

gt_ex = GT(exibble[["num", "date", "time", "currency"]].head(5))

gt_ex
```

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

### Run Pre-Commit Checks

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/contributing

Command to manually verify that all changes pass pre-commit checks, ensuring code quality and formatting standards are met before committing.

```Shell
pre-commit run --all-files
```

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

### Python Example: Unhiding Columns with GT.cols_unhide

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.cols_unhide

Demonstrates how to use `GT.cols_unhide()` in Python to reveal a column that was previously hidden using `cols_hide()`. The example uses the `countrypops` dataset to create a table, hides the 'year' column, and then unhides it.

```python
from great_tables import GT
from great_tables.data import countrypops

countrypops_mini = countrypops.loc[countrypops["country_name"] == "Benin"][
    ["country_name", "year", "population"]
].tail(5)

GT(countrypops_mini).cols_hide(columns="year").cols_unhide(columns="year")
```

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

### Python Example: Move Multiple Columns to End

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.cols_move_to_end

This example shows how to move multiple columns, 'year' and 'country_name', to the end of the column series using `GT.cols_move_to_end()`. The relative order of the moved columns is maintained.

```python
GT(countrypops_mini).cols_move_to_end(columns=["year", "country_name"])
```

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

### Python: Programmatic Styling with GT.pipe Method

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.pipe

This example shows how to achieve the same conditional styling as the previous example more programmatically using the `GT.pipe()` method. It defines a helper function `tbl_style` that applies styles iteratively and then pipes the `GT` object through it.

```python
columns = ["land_area_km2", "density_2021"]
colors = ["lightgray", "lightblue"]

def tbl_style(gtbl: GT, columns: list[str], colors: list[str]) -> GT:
    for column, color in zip(columns, colors):
        gtbl = gtbl.tab_style(
            style=style.fill(color=color),
            locations=loc.body(columns=column, rows=pl.col(column).eq(pl.col(column).max())),
        )
    return gtbl

(
    GT(
        towny_mini[["name", "land_area_km2", "density_2021"]],
        rowname_col="name",
    ).pipe(tbl_style, columns, colors)
)
```

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

### Prepare and Initialize Solar Zenith Angle Table

Source: https://posit-dev.github.io/great-tables/articles/intro.html/examples/index

This snippet demonstrates how to load and preprocess solar zenith angle (SZA) data using `polars`, filtering by latitude and time, dropping nulls, and pivoting the data by month and time. It then initializes a `great_tables` object with the processed data, setting 'month' as the row name column, and begins a `data_color` operation, which is incomplete in this snippet.

```Python
from great_tables import GT, html
from great_tables.data import sza
import polars as pl
import polars.selectors as cs

sza_pivot = (
    pl.from_pandas(sza)
    .filter((pl.col("latitude") == "20") & (pl.col("tst") <= "1200"))
    .select(pl.col("*").exclude("latitude"))
    .drop_nulls()
    .pivot(values="sza", index="month", on="tst", sort_columns=True)
)

(
    GT(sza_pivot, rowname_col="month")
    .data_color(
```

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

### Example: Moving 'population' column after 'country_name' in GT table

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.cols_move

Demonstrates how to use the `cols_move()` method to reposition the 'population' column after the 'country_name' column in a `GT` table. The example uses a subset of the `countrypops` dataset for illustration.

```python
from great_tables import GT
from great_tables.data import countrypops

countrypops_mini = countrypops.loc[countrypops["country_name"] == "Japan"][
    ["country_name", "year", "population"]
].tail(5)

(
    GT(countrypops_mini)
    .cols_move(
        columns="population",
        after="country_name"
    )
)
```

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

### Run Project Tests

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/contributing

Commands for executing tests using pytest. This includes running all tests or targeting a specific test file for focused testing.

```Shell
make test
```

```Shell
pytest tests/test_file.py
```

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

### Import Great Tables and Load Sample Data

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/index

This code block imports essential components from the `great_tables` library, including the core `GT` class and utility functions like `md` and `html`. It then loads a subset of the `islands` dataset, provided by `great_tables.data`, into a Pandas DataFrame, preparing it for subsequent table creation.

```Python
from great_tables import GT, md, html
from great_tables.data import islands

islands_mini = islands.head(10)
```

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

### Python Example: Formatting Roman Numerals with GT.fmt_roman

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.fmt_roman

Illustrates how to use `GT.fmt_roman` in Python to convert a column of Arabic numbers to Roman numerals within a `great_tables` DataFrame. The example creates a DataFrame, initializes a GT object, and applies the formatting.

```python
import pandas as pd
from great_tables import GT

numbers_tbl = pd.DataFrame({"arabic": [1, 8, 24, 85], "roman": [1, 8, 24, 85]})

(
    GT(numbers_tbl, rowname_col="arabic")
    .fmt_roman(columns="roman")
)
```

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

### Preview of data.peeps Dataset Structure and Sample Data

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/data.peeps

Displays the structure, data types, and a few sample rows for the `peeps` dataset, including column names and their inferred types, as it would appear in a console output.

```Text
Rows: 100
Columns: 14
$ name_given   <str> 'Ruth', 'Peter', 'Fanette'
$ name_family  <str> 'Conte', 'Möller', 'Gadbois'
$ address      <str> '4299 Bobcat Drive', '3705 Hidden Pond Road', '4200 Swick Hill Street'
$ city         <str> 'Baileys Crossroads', 'Red Boiling Springs', 'New Orleans'
$ state_prov   <str> 'MD', 'TN', 'LA'
$ postcode     <str> '22041', '37150', '70112'
$ country      <str> 'USA', 'USA', 'USA'
$ email_addr   <str> 'rcconte@example.com', 'pmoeller@example.com', 'fan_gadbois@example.com'
$ phone_number <str> '240-783-7630', '615-699-3517', '985-205-2970'
$ country_code <str> '1', '1', '1'
$ gender       <str> 'female', 'male', 'female'
$ dob          <str> '1949-03-16', '1939-11-22', '1970-12-20'
$ height_cm    <i64> 153, 175, 167
$ weight_kg    <f64> 76.4, 74.9, 61.6
```

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

### Python Example: Move Single Column to End

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.cols_move_to_end

This example demonstrates how to use `GT.cols_move_to_end()` to move a single column, 'year', to the end of the column series in a Great Tables object. It uses a filtered subset of the `countrypops` dataset for illustration.

```python
from great_tables import GT
from great_tables.data import countrypops

countrypops_mini = countrypops.loc[countrypops["country_name"] == "Benin"][
    ["country_name", "year", "population"]
].tail(5)

GT(countrypops_mini).cols_move_to_end(columns="year")
```

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

### Create Pandas DataFrame for Great Tables Examples

Source: https://posit-dev.github.io/great-tables/articles/intro.html/blog/rendering-images/index

This Python snippet demonstrates the creation of a `Pandas` DataFrame named `metro_mini` from a `data` dictionary. This DataFrame serves as the input for subsequent examples showcasing image rendering functionalities in `great-tables`.

```Python
metro_mini = pd.DataFrame(data)
metro_mini
```

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

### Preview of exibble Dataset Structure

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/data.exibble

This snippet shows the structure of the `exibble` dataset, including the number of rows and columns, and the data types and first few values for each column. It helps understand the dataset's composition for testing `great_tables` functions.

```text
Rows: 8
Columns: 9
$ num      <f64> 0.1111, 2.222, 33.33
$ char     <str> 'apricot', 'banana', 'coconut'
$ fctr     <str> 'one', 'two', 'three'
$ date     <str> '2015-01-15', '2015-02-15', '2015-03-15'
$ time     <str> '13:35', '14:40', '15:45'
$ datetime <str> '2018-01-01 02:22', '2018-02-02 14:33', '2018-03-03 03:44'
$ currency <f64> 49.95, 17.95, 1.39
$ row      <str> 'row_1', 'row_2', 'row_3'
$ group    <str> 'grp_a', 'grp_a', 'grp_a'
```

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

### Initialize GT object with `exibble` data for row selection examples

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/row-selection

Demonstrates how to import `GT`, `exibble`, `loc`, `style` from `great_tables` and create a `GT` object from a subset of `exibble` data. This object (`lil_exibble`) will be used in subsequent examples to illustrate row selection.

```Python
from great_tables import GT, exibble, loc, style

lil_exibble = exibble[["num", "char", "currency"]].head(3)
gt_ex = GT(lil_exibble)
```

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

### Preview of data.constants Dataset Structure

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/data.constants

This snippet shows a structural preview of the `data.constants` dataset, detailing the number of rows and columns, along with the data types and sample values for the first few entries of each column.

```Data Preview
Rows: 354
Columns: 6
$ name      <str> 'alpha particle-electron mass ratio',
                  'alpha particle mass',
                  'alpha particle mass energy equivalent'
$ value     <f64> 7294.29954142, 6.6446573357e-27, 5.9719201914e-10
$ uncert    <f64> 2.4e-07, 2e-36, 1.8e-19
$ sf_value  <i64> 12, 11, 11
$ sf_uncert <i64> 2, 2, 2
$ units     <str> None, 'kg', 'J'
```

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

### Preview of Pizza Sales Dataset Structure

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/data.pizzaplace

Displays a summary of the pizza sales dataset, including row and column counts, and a sample of the data for each column with its inferred data type.

```Console Output
Rows: 49574
Columns: 7
$ id    <str> '2015-000001', '2015-000002', '2015-000002'
$ date  <str> '2015-01-01', '2015-01-01', '2015-01-01'
$ time  <str> '11:38:36', '11:57:40', '11:57:40'
$ name  <str> 'hawaiian', 'classic_dlx', 'mexicana'
$ size  <str> 'M', 'M', 'M'
$ type  <str> 'classic', 'classic', 'veggie'
$ price <f64> 13.25, 16.0, 16.0
```

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

### Example: Formatting Integers with `vals.fmt_integer` and No Separators

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/vals.fmt_integer

Demonstrates how to use the `vals.fmt_integer` function from the `great_tables` library to format a list of numeric values as integers. This example specifically shows the effect of setting `use_seps=False` to disable digit group separators, resulting in plain integer strings.

```python
from great_tables import vals

vals.fmt_integer([100000.1, 2000000000.2], use_seps=False)
```

```text
['100000', '2000000000']
```

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

### Create and Display a Basic Table with Great Tables

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/index

This snippet illustrates how to instantiate a `GT` object by passing a Pandas DataFrame (`islands_mini`) to its constructor, thereby creating a display table. In a notebook environment, simply calling the `gt_tbl` object will render the table. For console applications, the `show()` method can be used to open the HTML table in the default browser.

```Python
# Create a display table showing ten of the largest islands in the world
gt_tbl = GT(islands_mini)

# Show the output table
gt_tbl
```

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

### Python Example: Using GT.sub_zero to Substitute Zeros

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.sub_zero

This Python example demonstrates how to use `GT.sub_zero` to replace zero values in a `great_tables` GT object. It initializes a Polars DataFrame with numerical data, applies `fmt_scientific` for formatting, and then uses `sub_zero` to change '0' to 'nil' in the 'numbers' column.

```python
from great_tables import GT
import polars as pl

single_vals_df = pl.DataFrame(
    {
        "i": range(1, 8),
        "numbers": [2.75, 0, -3.2, 8, 1e-10, 0, 2.6e9]
    }
)

GT(single_vals_df).fmt_scientific(columns="numbers").sub_zero()
```

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

### Python Example: Adding a Source Note to a GT Table

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.tab_source_note

This Python example demonstrates how to use the `tab_source_note()` method to add a custom source note to a table created with the `great_tables` library. It initializes a `GT` object with a subset of the `gtcars` dataset and then applies a source note to its footer.

```python
from great_tables import GT
from great_tables.data import gtcars

gtcars_mini = gtcars[["mfr", "model", "msrp"]].head(5)

(
    GT(gtcars_mini, rowname_col="model")
    .tab_source_note(source_note="From edmunds.com")
)
```

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

### GT.opt_stylize Method Parameters

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/GT.opt_stylize

Details the parameters for the `GT.opt_stylize` method, including their types, default values, valid options, and descriptions.

```APIDOC
style : int = 1
  Six numbered styles are available. Simply provide a number from `1` (the default) to `6` to choose a distinct look.
color : str = 'blue'
  The color scheme of the table. The default value is "blue". The valid values are "blue", "cyan", "pink", "green", "red", and "gray".
add_row_striping : bool = True
  An option to enable row striping in the table body for the style chosen.
```

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

### Create Pandas DataFrame for Great Tables Examples

Source: https://posit-dev.github.io/great-tables/articles/intro.html/blog/rendering-images

This Python snippet demonstrates the creation of a `Pandas` DataFrame named `metro_mini` from a predefined `data` dictionary. This DataFrame serves as the input data for subsequent `great-tables` examples, providing a structured dataset for table generation.

```Python
metro_mini = pd.DataFrame(data)
metro_mini
```

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

### Basic Great Tables GT Object Initialization

Source: https://posit-dev.github.io/great-tables/articles/intro.html/blog/polars-styling/index

This snippet illustrates the fundamental steps to begin using `great_tables`. It covers importing essential modules like `polars` and `GT`, and preparing a `polars.DataFrame` to instantiate a `GT` object, which serves as the starting point for all subsequent table styling operations.

```python
import polars as pl
import polars.selectors as cs

from great_tables import GT
from great_tables.data import airquality
```

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

### Create Pandas DataFrame for Image Formatting Example

Source: https://posit-dev.github.io/great-tables/articles/intro.html/blog/rendering-images

This Python snippet creates a Pandas DataFrame named `metro_mini4`. It copies existing `data` and adds a new column "case4" which is a duplicate of the "lines" column, preparing the data for image rendering examples.

```Python
metro_mini4 = pd.DataFrame({**data, "case4": data["lines"]})
metro_mini4
```

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

### Previewing the `gtcars` Dataset Structure

Source: https://posit-dev.github.io/great-tables/articles/intro.html/reference/data.gtcars

Displays the structure and initial rows of the `gtcars` dataset, including column names, data types, and sample values. This preview helps in understanding the dataset's composition and the types of data stored in each column.

```R
Rows: 47
Columns: 15
$ mfr         <str> 'Ford', 'Ferrari', 'Ferrari'
$ model       <str> 'GT', '458 Speciale', '458 Spider'
$ year        <i64> 2017, 2015, 2015
$ trim        <str> 'Base Coupe', 'Base Coupe', 'Base'
$ bdy_style   <str> 'coupe', 'coupe', 'convertible'
$ hp          <f64> 647.0, 597.0, 562.0
$ hp_rpm      <f64> 6250.0, 9000.0, 9000.0
$ trq         <f64> 550.0, 398.0, 398.0
$ trq_rpm     <f64> 5900.0, 6000.0, 6000.0
$ mpg_c       <f64> 11.0, 13.0, 13.0
$ mpg_h       <f64> 18.0, 17.0, 17.0
$ drivetrain  <str> 'rwd', 'rwd', 'rwd'
$ trsmn       <str> '7a', '7a', '7a'
$ ctry_origin <str> 'United States', 'Italy', 'Italy'
$ msrp        <f64> 447000.0, 291744.0, 263553.0
```

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

### Format Dates and Times with vals.fmt_date() and vals.fmt_time() in Python

Source: https://posit-dev.github.io/great-tables/articles/intro.html/get-started/basic-formatting

Provides examples for formatting dates and times using `vals.fmt_date()` and `vals.fmt_time()`. It demonstrates different date and time styles, such as full weekday, month, day, year, or simplified hour and minute formats.

```Python
fmt_date_1 = vals.fmt_date(
    ["2015-03-15", "2017-08-18", "2020-04-12"], date_style="wday_month_day_year"
)
fmt_date_2 = vals.fmt_date(["2015-03-15", "2017-08-18", "2020-04-12"], date_style="month_day_year")
fmt_time_1 = vals.fmt_time(["23:03", "00:55", "08:23"], time_style="h_m_p")
fmt_time_2 = vals.fmt_time(["23:03", "00:55", "08:23"], time_style="h_p")

print(fmt_date_1, fmt_date_2, fmt_time_1, fmt_time_2, sep="\n")
```