toolstr

https://github.com/sslivkoff/toolstr
Admin
toolstr is a Python library that provides utilities for creating precise string representations of...
Tokens:8,344
Snippets:37
Trust Score:7.3
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install toolstr Package

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

This snippet shows the command to install the toolstr Python package using pip. It is a straightforward installation process with no external dependencies mentioned for this basic installation.

```bash
pip install toolstr
```

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

### Number Formatting Examples in Rust using etop_format

Source: https://github.com/sslivkoff/toolstr/blob/main/toolstr-rust/crates/toolstr/src/number_format/README.md

Showcases various examples of using the `NumberFormat` library in Rust to format numbers according to different specifications. It covers fixed-point, alternate forms, signs, padding, grouping, SI prefixes, and percentage conversions. The numbers to be formatted must implement the `Into<f64>` trait.

```rust
use etop_format::NumberFormat;

let num = NumberFormat::new();

assert_eq!(num.format(".1f", 0.06), "0.1");
assert_eq!(num.format("#.0f", 10.1), "10."); // float alternate form (always show a decimal point)
assert_eq!(num.format("+14d", 2_147_483_647), "   +2147483647");
assert_eq!(num.format("#b", 3), "0b11");
assert_eq!(num.format("b", 3), "11");
assert_eq!(num.format("#X", 48879), "0xBEEF");
assert_eq!(num.format(".2s", 42e6), "42M");
assert_eq!(num.format(".^20d", 12), ".........12........."); // dot filled and centered
assert_eq!(num.format("+10.0f", 255), "      +255");
assert_eq!(num.format(".0%", 0.123), "12%");
assert_eq!(num.format("+016,.2s", 42e12), "+000,000,000,042T"); // grouped zero-padded with a mandatory sign, SI-prefixed with 2 significant digits

```

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

### Rich Styling Functions for Terminal Text

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Provides examples of using `toolstr`'s rich styling utilities. This includes adding styles like bold and color to text, calculating the display width of styled text, fitting text to a specific width with ellipses, applying per-line styling, and utilizing custom color systems.

```python
import toolstr

# Add style to text
styled = toolstr.add_style("Important", "bold red")
print(styled)  # Output: [bold red]Important[/bold red]
toolstr.print(styled)  # Rendered as bold red text

# Get styled text width (accounts for markup)
text = "[bold]Hello[/bold] World"
width = toolstr.get_styled_width(text)
print(width)  # Output: 11 (markup not counted)

# Fit text to width
long_text = toolstr.add_style("This is a very long message", "cyan")
fitted = toolstr.fit_styled_width(long_text, width=15, ellipses=True)
toolstr.print(fitted)  # Output: This is a ve... (in cyan)

# Per-line styling for multiline text
multiline = "Line 1\nLine 2\nLine 3"
styled = toolstr.add_style(multiline, "green", per_line=True)
toolstr.print(styled)
# Output: Each line individually styled green

# Custom color system
toolstr.set_default_color_system('256')
toolstr.print("Colored text", style='color(123)')
# Output: Text in color using 256-color palette
```

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

### toolstr Print Tables with ASCII Border

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

This example demonstrates printing tables using toolstr.print_tables with the 'border' parameter set to 'ascii'. This is useful for environments that may not fully support extended character sets, ensuring compatibility by using standard ASCII characters for borders. The output shows the table with an ASCII border.

```text
      Name  |                     Era  |            Age  
------------+--------------------------+-----------------
  Vaalbara  |   Eoarchean-Mesoarchean  |  3,636,000,000  
  Gondwana  |      Ediacaran-Jurassic  |    550,000,000  
    Pangea  |  Carboniferous-Jurassic  |    336,000,000  
```

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

### Table with Row Indices using toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Illustrates how to add automatic row numbering to tables printed with `toolstr.print_table` using the `add_row_index` parameter. It also shows how to customize the starting index for row numbers and how to print tables with row indices but no column headers.

```python
import toolstr

rows = [
    ['Python', 'Guido van Rossum'],
    ['JavaScript', 'Brendan Eich'],
    ['Go', 'Rob Pike'],
]
labels = ['Language', 'Creator']

toolstr.print_table(rows, labels=labels, add_row_index=True)

toolstr.print_table(rows, labels=labels, add_row_index=True, row_start_index=10)

toolstr.print_table(rows, labels=None, add_row_index=True)
```

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

### toolstr Print Tables with Thick Border

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

Illustrates the use of toolstr.print_tables with the 'border' parameter set to 'thick'. This option renders the table with a heavier, thicker border style, enhancing visual separation of cells and headers. The example shows the table with a thick border applied.

```text
      Name  ┃                     Era  ┃            Age  
━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━
  Vaalbara  ┃   Eoarchean-Mesoarchean  ┃  3,636,000,000  
  Gondwana  ┃      Ediacaran-Jurassic  ┃    550,000,000  
    Pangea  ┃  Carboniferous-Jurassic  ┃    336,000,000  
```

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

### Get Diff Data Structure and Check Equality

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Demonstrates how to retrieve nested differences between two data structures using `toolstr.get_nested_diffs` and check for overall equality with `toolstr.nested_equal`. It also shows how to limit the depth and count of differences displayed with `toolstr.print_nested_diff`.

```python
import toolstr

# Assuming lhs and rhs are defined data structures
# Example:
lhs = {'a': 1, 'b': {'c': 2}}
rhs = {'a': 1, 'b': {'c': 3}}

# Get diff data structure
diffs = toolstr.get_nested_diffs(lhs, rhs)
for diff in diffs:
    print(f"{diff['type']} at {diff['index']}: {diff['lhs']} -> {diff['rhs']}")
# Output: Programmatic access to differences

# Check equality
is_equal = toolstr.nested_equal(lhs, rhs)
print(f"Equal: {is_equal}")  # Output: Equal: False

# Limit diff depth and count
toolstr.print_nested_diff(
    lhs,
    rhs,
    max_depth=2,
    max_diffs=5
)
# Output: Limited to 5 differences at depth 2 or less
```

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

### toolstr Print Tables with Thick Outer Border

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

Shows the application of toolstr.print_tables with 'outer_border' set to 'thick'. This results in a table where the outer boundary is rendered using a thicker line style, providing a more prominent enclosure for the tabular data. The example output highlights this thick outer border.

```text
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃      Name  │                     Era  │            Age  ┃
┃────────────┼──────────────────────────┼─────────────────┃
┃  Vaalbara  │   Eoarchean-Mesoarchean  │  3,636,000,000  ┃
┃  Gondwana  │      Ediacaran-Jurassic  │    550,000,000  ┃
┃    Pangea  │  Carboniferous-Jurassic  │    336,000,000  ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
```

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

### Basic Floating Point Output in Rust

Source: https://github.com/sslivkoff/toolstr/blob/main/toolstr-rust/crates/toolstr/src/number_format/README.md

Demonstrates the default output of floating-point numbers in Rust, highlighting potential precision issues. This is presented to contrast with the formatted output provided by the library.

```rust
for i in 1..=10 {
    println!("{}", 0.1 * i as f64);
}

```

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

### Table Layout and Alignment with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Explains how to control table layout and alignment using `toolstr.print_table`. This includes positioning headers ('top', 'bottom', or both), separating all rows, creating compact tables, and aligning columns to the left.

```python
import toolstr

rows = [['Apple', 'Fruit', '$2'], ['Carrot', 'Vegetable', '$1']]
labels = ['Item', 'Type', 'Price']

toolstr.print_table(rows, labels=labels, label_location='bottom')

toolstr.print_table(rows, labels=labels, label_location=[])

toolstr.print_table(rows, labels=labels, label_location=['top', 'bottom'])

toolstr.print_table(rows, labels=labels, separate_all_rows=True)

toolstr.print_table(rows, labels=labels, compact=True)

toolstr.print_table(rows, labels=labels, justify='left')
```

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

### toolstr Print Tables with Row Index

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

Demonstrates how to print tables using toolstr's print_tables function with the 'add_row_index' parameter set to True. This adds a sequential index to each row of the table. The output shows a table with columns 'Name', 'Era', and 'Age', each with a preceding row index.

```text
     │      Name  │                     Era  │            Age  
─────┼────────────┼──────────────────────────┼─────────────────
  1  │  Vaalbara  │   Eoarchean-Mesoarchean  │  3,636,000,000  
  2  │  Gondwana  │      Ediacaran-Jurassic  │    550,000,000  
  3  │    Pangea  │  Carboniferous-Jurassic  │    336,000,000  
```

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

### Basic Table Printing with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Shows how to print tabular data using `toolstr.print_table`. This function automatically calculates column widths and formats the output. It supports tables with or without headers and automatically formats numbers with commas and decimals.

```python
import toolstr

rows = [
    ['Alice', 25, 85000],
    ['Bob', 30, 92000],
    ['Charlie', 28, 78000],
]
labels = ['Name', 'Age', 'Salary']

toolstr.print_table(rows, labels=labels)

rows = [['apple', 1.5], ['banana', 0.75], ['orange', 2.0]]
toolstr.print_table(rows, labels=None)

rows = [
    ['Q1', 125000.50, 0.15],
    ['Q2', 147500.75, 0.18],
    ['Q3', 132000.25, 0.06],
]
labels = ['Quarter', 'Revenue', 'Growth']
toolstr.print_table(rows, labels=labels)
```

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

### Create Headers with Toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Generate underlined headers for terminal output, aiding in structure and readability. Options include centering, custom width, and styling with borders. The `toolstr.print_header` function provides these capabilities.

```python
import toolstr

# Header with underline
toolstr.print_header("Configuration Settings")

# Centered header
toolstr.print_header("Title", width=50, justify='center')

# Custom header styling
toolstr.print_header(
    "Important Notice",
    style='bold red',
    border='thick'
)
```

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

### Create Bullet Lists with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Generates formatted bullet point lists, including simple bullets, numbered lists, and key-value pairs. Supports custom bullet characters and styling for different components of the list item. Requires the 'toolstr' library, and advanced styling may require 'rich'.

```python
import toolstr

# Simple bullet
toolstr.print_bullet("First item")
# Output: - First item

# Numbered bullet
toolstr.print_bullet("First step", number=1)
# Output: 1. First step

# Bullet with key-value pair
toolstr.print_bullet("localhost:8080", key="Server")
# Output: - Server: localhost:8080

# Create bullet string for later use
bullet_str = toolstr.create_bullet_str(
    "Process completed successfully",
    key="Status",
    bullet_str="• "
)
print(bullet_str)
# Output: • Status: Process completed successfully

# Styled bullets (requires rich)
toolstr.print_bullet(
    "Critical error detected",
    bullet_style='red bold',
    key_style='yellow',
    value_style='red'
)
# Output: Colored and styled bullet point

# Indented bullet list
items = ["Apple", "Banana", "Cherry"]
for i, item in enumerate(items, 1):
    toolstr.print_bullet(item, number=i, indent=4)
# Output: Indented numbered list
```

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

### Column Layout with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Arranges text into multiple columns for compact display in the terminal. Supports specifying the number of columns, gap size, and automatically determining columns based on maximum height. Header rows can be preserved. Requires the 'toolstr' library.

```python
import toolstr

# Create multi-column layout from text
items = '\n'.join([f"Item {i}" for i in range(20)])

# Two columns
columnized = toolstr.columnize(items, n_columns=2)
print(columnized)
# Output:
# Item 0   Item 10
# Item 1   Item 11
# Item 2   Item 12
# ...

# Three columns with custom gap
columnized = toolstr.columnize(items, n_columns=3, gap=4)
print(columnized)
# Output: Items arranged in 3 columns with 4-space gaps

# Auto-columns based on max height
text = '\n'.join([f"Line {i}" for i in range(30)])
columnized = toolstr.columnize(text, max_height=10)
print(columnized)
# Output: Automatically determines columns to fit 10-line height

# With header rows preserved in each column
columnized = toolstr.columnize(
    text,
    n_columns=3,
    header_height=2,
    gap=' | '
)
print(columnized)
# Output: First 2 lines repeated at top of each column
```

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

### Create Outlined Text with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Generates custom text outlines with options for borders, padding, and text styling. It allows for flexible control over the appearance of text boxes for enhanced readability and visual appeal in terminal outputs. Dependencies include the 'toolstr' library.

```python
import toolstr

# Custom border configuration
text = "Processing\nPlease Wait..."
toolstr.print_outlined_text(
    text,
    upper_border=True,
    lower_border=True,
    left_border=True,
    right_border=False,
    pad=1
)
# Output with three-sided border

# Left sidebar style
toolstr.print_outlined_text(
    "Note: Check documentation",
    left_border=True,
    right_border=False,
    upper_border=False,
    lower_border=False,
    left_pad=2
)
# Output:
# │  Note: Check documentation

# Full custom control
outline_str = toolstr.get_outlined_text(
    "Custom\nMultiline\nText",
    upper_border=True,
    lower_border=True,
    left_border=True,
    right_border=True,
    left_pad=2,
    right_pad=2,
    border='thick'
)
print(outline_str)
# Output: Boxed multiline text with thick borders

# Styled outlined text
toolstr.print_outlined_text(
    "Success!",
    upper_border=True,
    lower_border=True,
    left_border=True,
    right_border=True,
    text_style='bold green',
    style='green',
    justify='center',
    width=40
)
# Output: Centered green-styled text in box
```

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

### Table Border Styles with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Demonstrates customization of table borders using `toolstr.print_table`. Options include preset styles like 'thick', 'double', and 'ascii', as well as control over the outer border using `outer_border` parameter.

```python
import toolstr

rows = [['A', 1], ['B', 2], ['C', 3]]
labels = ['Letter', 'Number']

toolstr.print_table(rows, labels=labels, border='thick')

toolstr.print_table(rows, labels=labels, border='double')

toolstr.print_table(rows, labels=labels, border='ascii')

toolstr.print_table(rows, labels=labels, outer_border=True)

toolstr.print_table(rows, labels=labels, outer_border='thick')
```

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

### Format Byte Counts with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Converts byte counts into human-readable sizes using automatic unit scaling (B, KB, MB, GB, TB, etc.). Allows control over decimal precision, use of binary units (KiB, MiB), and comma separators for better readability.

```python
import toolstr

# Automatic unit scaling
file_size = 1536000
formatted = toolstr.format_nbytes(file_size)
print(formatted)  # Output: 1.50MB

# Control decimal precision
large_file = 10737418240
formatted = toolstr.format_nbytes(large_file, decimals=3)
print(formatted)  # Output: 10.000GB

# Binary units (KiB, MiB, GiB) instead of decimal
formatted = toolstr.format_nbytes(large_file, bibytes=True, decimals=2)
print(formatted)  # Output: 10.00GiB

# Format with comma separators
formatted = toolstr.format_nbytes(large_file, commas=True, decimals=0)
print(formatted)  # Output: 10GB

# Handle zero and small values
print(toolstr.format_nbytes(0))      # Output: 0B
print(toolstr.format_nbytes(512))    # Output: 512B
```

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

### Create Text Boxes with Toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Generate bordered text boxes for organizing terminal output. This includes options for custom width, padding, text styling, and border styles. Use `toolstr.print_text_box` with various arguments for customization.

```python
import toolstr

# Simple text box
toolstr.print_text_box("System Error: Connection Timeout")

# Text box with custom width and padding
toolstr.print_text_box(
    "Status: OK",
    width=30,
    left_pad=2,
    right_pad=2,
    upper_pad=1,
    lower_pad=1
)

# Text box with styling (requires rich)
toolstr.print_text_box(
    "Warning",
    text_style='bold yellow',
    style='yellow',
    border='double'
)
```

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

### toolstr Print Tables with No Header Location

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

Illustrates the behavior of toolstr.print_tables when 'header_location' is an empty list. This typically means no header is displayed, or it defaults to a standard position if not explicitly set otherwise. The output shows the data rows without any header.

```text
  Vaalbara  │   Eoarchean-Mesoarchean  │  3,636,000,000  
  Gondwana  │      Ediacaran-Jurassic  │    550,000,000  
    Pangea  │  Carboniferous-Jurassic  │    336,000,000  
```

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

### toolstr Print Tables with Top and Bottom Headers

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

Shows how to display table headers at both the top and bottom of the table using toolstr.print_tables with 'header_location' set to ['top', 'bottom']. This can be useful for long tables where repeating the header at the end aids readability. The output includes headers at both positions.

```text
      Name  │                     Era  │            Age  
────────────┼──────────────────────────┼─────────────────
  Vaalbara  │   Eoarchean-Mesoarchean  │  3,636,000,000  
  Gondwana  │      Ediacaran-Jurassic  │    550,000,000  
    Pangea  │  Carboniferous-Jurassic  │    336,000,000  
────────────┼──────────────────────────┼─────────────────
      Name  │                     Era  │            Age  
```

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

### Generic Data Formatting with toolstr.format

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Automatically detects data types (numbers, timestamps, byte counts) and formats them appropriately using the generic `toolstr.format` function. Allows explicit `format_type` specification with custom options for fine-grained control.

```python
import toolstr
import time

# Auto-detect number
value = 12345.67
formatted = toolstr.format(value)
print(formatted)  # Output: 12,345.67

# Explicit format type with custom options
formatted = toolstr.format(value, format_type='number', decimals=1)
print(formatted)  # Output: 12,345.7

# Format timestamp
timestamp = time.time()
formatted = toolstr.format(timestamp, format_type='timestamp')
print(formatted)  # Output: ISO formatted timestamp

# Format byte count
size = 5368709120
formatted = toolstr.format(size, format_type='nbytes', decimals=1)
print(formatted)  # Output: 5.0GB

# Automatic type detection for integers
integer_val = 100
formatted = toolstr.format(integer_val)
print(formatted)  # Output: 100 (no decimals for integers)
```

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

### toolstr Print Tables with Double Border

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

Shows how to use toolstr.print_tables with the 'border' parameter set to 'double'. This results in a table with a double-line border style, offering a distinct visual appearance compared to default or single-line borders. The output displays the table with double borders.

```text
      Name  ║                     Era  ║            Age  
════════════╬══════════════════════════╬═════════════════
  Vaalbara  ║   Eoarchean-Mesoarchean  ║  3,636,000,000  
  Gondwana  ║      Ediacaran-Jurassic  ║    550,000,000  
    Pangea  ║  Carboniferous-Jurassic  ║    336,000,000  
```

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

### Format Change Between Two Values with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Demonstrates how to use the `toolstr.format_change` function to display the difference between two values. This function can handle basic changes, series data, negative changes, and custom number formatting with options for decimals and order of magnitude.

```python
from_value = 100
to_value = 150
change = toolstr.format_change(from_value=from_value, to_value=to_value)
print(change)  # Output: 100 ⟶ 150 (+50.00%)

price_series = [50, 75, 60, 85, 90]
change = toolstr.format_change(series=price_series)
print(change)  # Output: 50 ⟶ 90 (+80.00%)

change = toolstr.format_change(from_value=200, to_value=150)
print(change)  # Output: 200 ⟶ 150 (-25.00%)

change = toolstr.format_change(
    from_value=1500.5,
    to_value=2750.75,
    decimals=2,
    order_of_magnitude=True
)
print(change)  # Output: 1.50K ⟶ 2.75K (+83.30%)
```

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

### Style Tables with Rich Markup in Toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Enhance table appearance by applying colors and styles using rich markup. This includes conditional row styling based on data, per-column styling, and header styling. The `toolstr.print_table` function accepts `style`, `column_styles`, `label_style`, and `label_border` arguments.

```python
import toolstr

rows = [
    ['Error', 'Connection failed', 5],
    ['Warning', 'Slow response', 12],
    ['Info', 'Request received', 100],
]
labels = ['Level', 'Message', 'Count']

# Style function for conditional formatting
def severity_style(context):
    level = context['row'][0]
    if level == 'Error':
        return 'red'
    elif level == 'Warning':
        return 'yellow'
    return 'green'

toolstr.print_table(
    rows,
    labels=labels,
    style=severity_style
)

# Per-column styling
toolstr.print_table(
    rows,
    labels=labels,
    column_styles={
        'Level': 'bold cyan',
        'Count': 'magenta'
    }
)

# Header styling
toolstr.print_table(
    rows,
    labels=labels,
    label_style='bold underline',
    label_border='thick'
)

# Combine styles and custom formatting
toolstr.print_table(
    rows,
    labels=labels,
    label_style='bold',
    column_styles={'Level': 'red', 'Count': 'green'},
    border='double'
)
```

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

### Format Timestamps with toolstr and tooltime

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Formats Unix timestamps into various date/time string representations using the tooltime library integration. Supports ISO format, human-readable dates, and custom timezone handling via tooltime keyword arguments.

```python
import toolstr
import time

# Format Unix timestamp to ISO format (default)
timestamp = 1609459200  # 2021-01-01 00:00:00 UTC
formatted = toolstr.format_timestamp(timestamp)
print(formatted)  # Output: 2021-01-01T00:00:00+00:00

# Format to human-readable date
formatted = toolstr.format_timestamp(timestamp, representation='DateStringISO')
print(formatted)  # Output: 2021-01-01

# Current time formatting
current = time.time()
formatted = toolstr.format_timestamp(current, representation='TimestampISO')
print(formatted)  # Output: Current datetime in ISO format

# Custom timezone handling through tooltime kwargs
formatted = toolstr.format_timestamp(
    timestamp,
    representation='TimestampISO',
    to_timezone='US/Pacific'
)
print(formatted)  # Output: Timestamp in Pacific timezone
```

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

### Format Table Columns with Toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Customize the display of table columns by specifying number formats, percentage representations, and order of magnitude. This feature allows for clearer presentation of numerical data. The `toolstr.print_table` function is used with the `column_formats` argument.

```python
import toolstr

# Per-column number formatting
rows = [
    ['Q1', 125000.50, 0.15],
    ['Q2', 147500.75, 0.18],
]
labels = ['Quarter', 'Revenue', 'Growth']

toolstr.print_table(
    rows,
    labels=labels,
    column_formats={
        'Revenue': {'decimals': 0, 'order_of_magnitude': True},
        'Growth': {'percentage': True, 'decimals': 1}
    }
)
```

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

### toolstr Print Tables with Separated Rows

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

Demonstrates the use of toolstr.print_tables with 'separate_all_rows' set to True. This option adds horizontal separators between every row in the table, enhancing the distinction between individual data entries. The output shows each row clearly separated.

```text
      Name  │                     Era  │            Age  
────────────┼──────────────────────────┼─────────────────
  Vaalbara  │   Eoarchean-Mesoarchean  │  3,636,000,000  
────────────┼──────────────────────────┼─────────────────
  Gondwana  │      Ediacaran-Jurassic  │    550,000,000  
────────────┼──────────────────────────┼─────────────────
    Pangea  │  Carboniferous-Jurassic  │    336,000,000  
```

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

### Format Numbers with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Formats numeric values with options for comma separators, decimal control, scientific notation, order-of-magnitude labels, percentages, and width matching for alignment. Handles various numeric types and display requirements.

```python
import toolstr

# Basic number formatting with comma separators
value = 1234567.89
formatted = toolstr.format_number(value)
print(formatted)  # Output: 1,234,567.89

# Control decimal places
price = 99.5
formatted = toolstr.format_number(price, decimals=2, trailing_zeros=True)
print(formatted)  # Output: 99.50

# Order of magnitude with suffix (K, M, B, T, Q)
large_num = 1500000
formatted = toolstr.format_number(large_num, order_of_magnitude=True)
print(formatted)  # Output: 1.5M

# Percentage formatting
ratio = 0.856
formatted = toolstr.format_number(ratio, percentage=True)
print(formatted)  # Output: 85.60%

# Scientific notation for small values
small = 0.0000123
formatted = toolstr.format_number(small)
print(formatted)  # Output: 1.230e-5

# Match width for alignment
values = [1.5, 1500.75, 1500000]
reference = max(values)
for val in values:
    print(toolstr.format_number(val, match_width=reference, decimals=2))
# Output:
#       1.50
#   1,500.75
# 1,500,000.00
```

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

### toolstr Print Tables with Header at Bottom

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

Demonstrates how to position the table header at the bottom using toolstr.print_tables with 'header_location' set to 'bottom'. This configuration places the column titles below the data rows, which can alter the reading flow of the table. The output shows the header at the bottom.

```text
  Vaalbara  │   Eoarchean-Mesoarchean  │  3,636,000,000  
  Gondwana  │      Ediacaran-Jurassic  │    550,000,000  
    Pangea  │  Carboniferous-Jurassic  │    336,000,000  
────────────┼──────────────────────────┼─────────────────
      Name  │                     Era  │            Age  
```

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

### Render Line Plots with Toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Generate ASCII or Unicode line plots directly in the terminal. This function supports automatic axis generation, labeling, and styling for visualizing data trends. Use `toolstr.render_line_plot` or `toolstr.print_line_plot` with various styling options.

```python
import toolstr
import math

xvals = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
yvals = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# Simple line plot
plot = toolstr.render_line_plot(
    xvals=xvals,
    yvals=yvals,
    n_rows=10,
    n_columns=40
)
print(plot)

# With custom styling (requires rich)
plot = toolstr.render_line_plot(
    xvals=xvals,
    yvals=yvals,
    n_rows=10,
    n_columns=40,
    line_style='cyan',
    chrome_style='dim',
    tick_label_style='yellow'
)
print(plot)

# Multiple data series (NaN for gaps)
xvals = [x * 0.5 for x in range(20)]
yvals = [math.sin(x) for x in xvals]

plot = toolstr.render_line_plot(
    xvals=xvals,
    yvals=yvals,
    n_rows=15,
    n_columns=60
)
print(plot)

# Direct print without return value
toolstr.print_line_plot(xvals, yvals, n_rows=12, n_columns=50)
```

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

### Limit Table Column Widths and Rows with Toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Control the maximum width of individual table columns and limit the total number of rows displayed. This is useful for managing terminal space and focusing on key data. The `toolstr.print_table` function supports `max_column_widths` and `limit_rows` arguments.

```python
import toolstr

rows = [
    ['Q1', 125000.50, 0.15],
    ['Q2', 147500.75, 0.18],
]
labels = ['Quarter', 'Revenue', 'Growth']

# Limit column widths
toolstr.print_table(
    rows,
    labels=labels,
    max_column_widths={'Quarter': 3, 'Revenue': 10}
)

# Limit total rows displayed
long_rows = [[i, i**2] for i in range(100)]
toolstr.print_table(
    long_rows,
    labels=['n', 'n²'],
    limit_rows=5,
    limit_rows_at='middle'
)
```

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

### Compare Nested Data with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Compares nested dictionaries and lists, generating a detailed difference report in a formatted table. It highlights changes in values, additions, and modifications within complex data structures. Requires the 'toolstr' library.

```python
import toolstr

# Compare nested dictionaries
lhs = {
    'name': 'Alice',
    'age': 30,
    'scores': [85, 90, 95],
    'metadata': {'level': 5}
}
rhs = {
    'name': 'Alice',
    'age': 31,
    'scores': [85, 92, 95],
    'metadata': {'level': 6, 'bonus': True}
}

# Print formatted diff table
toolstr.print_nested_diff(lhs, rhs, lhs_name='current', rhs_name='updated')
# Output:
#   type  │ index            │ current  │ updated
# ────────┼──────────────────┼──────────┼─────────
#  value  │ age              │ 30       │ 31
#  value  │ scores.1         │ 90       │ 92
#  keys   │ metadata         │          │ bonus
#  value  │ metadata.level   │ 5        │ 6
```

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

### Justify Table Columns with Toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Control the alignment of text within table columns. This allows for consistent and readable table layouts. The `toolstr.print_table` function is used with the `column_justify` argument to specify alignment for individual columns.

```python
import toolstr

# Per-column justification
toolstr.print_table(
    rows,
    labels=labels,
    column_justify={'Item': 'left', 'Type': 'center', 'Price': 'right'}
)
```

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

### toolstr Print Tables with Outer Border

Source: https://github.com/sslivkoff/toolstr/blob/main/README.md

Presents the usage of toolstr.print_tables with the 'outer_border' parameter set to True. This option adds a border only around the perimeter of the table, while the internal cell separators remain as default. The output shows a table with a distinct outer border.

```text
┌────────────┬──────────────────────────┬─────────────────┐
│      Name  │                     Era  │            Age  │
├────────────┼──────────────────────────┼─────────────────┤
│  Vaalbara  │   Eoarchean-Mesoarchean  │  3,636,000,000  │
│  Gondwana  │      Ediacaran-Jurassic  │    550,000,000  │
│    Pangea  │  Carboniferous-Jurassic  │    336,000,000  │
└────────────┴──────────────────────────┴─────────────────┘
```

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

### Sort Table Data with Toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Sort the rows of a table based on the values in a specified column. This allows for easy analysis and presentation of ordered data. Use the `sort_column` and `descending` arguments in `toolstr.print_table`.

```python
import toolstr

rows = [
    ['Q1', 125000.50, 0.15],
    ['Q2', 147500.75, 0.18],
]
labels = ['Quarter', 'Revenue', 'Growth']

toolstr.print_table(rows, labels=labels, sort_column='Revenue', descending=True)
```

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

### Print Horizontal Lines with toolstr

Source: https://context7.com/sslivkoff/toolstr/llms.txt

Prints horizontal divider lines that automatically adjust to the terminal width or can be set to a fixed width. Supports custom characters and styling, useful for section separation. Requires the 'toolstr' library.

```python
import toolstr

# Default horizontal line (full terminal width)
toolstr.print_horizontal_line()
# Output: ─────────────────────────── (full width)

# Fixed width line
toolstr.print_horizontal_line(n=50)
# Output: ────────────────────────────────────────────── (50 chars)

# Bottom-aligned line character
toolstr.print_horizontal_line(character='bottom')
# Output:                           

# Top-aligned line character
toolstr.print_horizontal_line(character='top')
# Output: 🭶🭶🭶🭶🭶🭶🭶🭶🭶🭶🭶🭶🭶🭶🭶🭶🭶🭶

# Styled line (requires rich)
toolstr.print_horizontal_line(style='bold cyan')
# Output: Cyan colored horizontal line

# Section separator pattern
print("Section 1 Content")
toolstr.print_horizontal_line(n=40, style='dim')
print("Section 2 Content")
# Output: Content separated by styled divider
```
Tokens:
Raw