Data Display

def dataframe(data=None, width=None, height=None, use_container_width=False, hide_index=None, column_order=None, column_config=None, selection_mode="single-row", on_select="rerun", key=None):
    """
    Display a dataframe as an interactive table.
    
    Parameters:
    - data: DataFrame, array-like, or dict to display
    - width (int): Table width in pixels
    - height (int): Table height in pixels
    - use_container_width (bool): Use full container width
    - hide_index (bool): Hide row indices
    - column_order (list): Custom column order
    - column_config (dict): Column configuration mapping
    - selection_mode (str): Row selection mode ('single-row', 'multi-row', 'single-column', 'multi-column', or 'disabled')
    - on_select (str): Behavior on selection ('rerun' or 'ignore')
    - key (str): Unique key for the widget
    
    Returns:
    DataFrame selection information
    """

def data_editor(data, width=None, height=None, use_container_width=False, hide_index=None, column_order=None, column_config=None, num_rows="fixed", disabled=False, key=None, on_change=None, args=None, kwargs=None):
    """
    Display an editable data table.
    
    Parameters:
    - data: DataFrame, array-like, or dict to edit
    - width (int): Table width in pixels
    - height (int): Table height in pixels
    - use_container_width (bool): Use full container width
    - hide_index (bool): Hide row indices
    - column_order (list): Custom column order
    - column_config (dict): Column configuration mapping
    - num_rows (str): Row management ('fixed', 'dynamic')
    - disabled (bool): Disable editing
    - key (str): Unique key for the widget
    - on_change (callable): Function to call when data changes
    - args (tuple): Arguments to pass to on_change function
    - kwargs (dict): Keyword arguments to pass to on_change function
    
    Returns:
    DataFrame: Edited data
    """

def table(data=None):
    """
    Display a static table.
    
    Parameters:
    - data: DataFrame, array-like, or dict to display as table
    
    Returns:
    None
    """

def metric(label, value, delta=None, delta_color="normal", help=None, label_visibility="visible"):
    """
    Display a metric in large, prominent formatting.
    
    Parameters:
    - label (str): Metric label
    - value: Metric value (number or string)
    - delta: Change in metric value (number or string)
    - delta_color (str): Color for delta ('normal', 'inverse', or 'off')
    - help (str): Optional tooltip text
    - label_visibility (str): Label visibility ('visible', 'hidden', 'collapsed')
    
    Returns:
    None
    """

# Base column configuration
class Column:
    """Base column configuration class."""
    def __init__(self, label=None, width=None, help=None, disabled=None, required=None):
        """
        Parameters:
        - label (str): Column display name
        - width (str): Column width ('small', 'medium', 'large', or pixel value)
        - help (str): Help text for column header
        - disabled (bool): Disable editing for this column
        - required (bool): Mark column as required
        """

# Text column configuration
class TextColumn(Column):
    """Text column configuration with validation."""
    def __init__(self, max_chars=None, validate=None, **kwargs):
        """
        Parameters:
        - max_chars (int): Maximum character count
        - validate (str or callable): Validation pattern or function
        """

# Number column configuration  
class NumberColumn(Column):
    """Numeric column configuration with formatting."""
    def __init__(self, min_value=None, max_value=None, step=None, format=None, **kwargs):
        """
        Parameters:
        - min_value (float): Minimum allowed value
        - max_value (float): Maximum allowed value
        - step (float): Step size for increments
        - format (str): Number format string
        """

# Checkbox column configuration
class CheckboxColumn(Column):
    """Boolean checkbox column configuration."""
    pass

# Selectbox column configuration
class SelectboxColumn(Column):
    """Dropdown selection column configuration."""
    def __init__(self, options, **kwargs):
        """
        Parameters:
        - options (list): Available options for selection
        """

# Date and time column configurations
class DateColumn(Column):
    """Date column configuration."""
    def __init__(self, min_value=None, max_value=None, format="YYYY-MM-DD", step=1, **kwargs):
        """
        Parameters:
        - min_value (date): Minimum date
        - max_value (date): Maximum date
        - format (str): Date format string
        - step (int): Step size in days
        """

class TimeColumn(Column):
    """Time column configuration."""
    def __init__(self, min_value=None, max_value=None, format="HH:mm", step=60, **kwargs):
        """
        Parameters:
        - min_value (time): Minimum time
        - max_value (time): Maximum time
        - format (str): Time format string
        - step (int): Step size in seconds
        """

class DatetimeColumn(Column):
    """Datetime column configuration."""
    def __init__(self, min_value=None, max_value=None, format="YYYY-MM-DD HH:mm", step=60, timezone=None, **kwargs):
        """
        Parameters:
        - min_value (datetime): Minimum datetime
        - max_value (datetime): Maximum datetime
        - format (str): Datetime format string
        - step (int): Step size in seconds
        - timezone (str): Timezone name
        """

# Link column configuration
class LinkColumn(Column):
    """URL link column configuration."""
    def __init__(self, validate=None, max_chars=None, display_text=None, **kwargs):
        """
        Parameters:
        - validate (str or callable): URL validation pattern or function
        - max_chars (int): Maximum character count
        - display_text (str or callable): Custom display text or function
        """

# List column configuration
class ListColumn(Column):
    """List/array column configuration."""
    pass

# Image column configuration
class ImageColumn(Column):
    """Image display column configuration."""
    pass

# Chart column configurations
class LineChartColumn(Column):
    """Line chart column configuration."""
    def __init__(self, y_min=None, y_max=None, **kwargs):
        """
        Parameters:
        - y_min (float): Minimum Y-axis value
        - y_max (float): Maximum Y-axis value
        """

class BarChartColumn(Column):
    """Bar chart column configuration."""
    def __init__(self, y_min=None, y_max=None, **kwargs):
        """
        Parameters:
        - y_min (float): Minimum Y-axis value
        - y_max (float): Maximum Y-axis value
        """

class AreaChartColumn(Column):
    """Area chart column configuration."""
    def __init__(self, y_min=None, y_max=None, **kwargs):
        """
        Parameters:
        - y_min (float): Minimum Y-axis value
        - y_max (float): Maximum Y-axis value
        """

# Progress column configuration
class ProgressColumn(Column):
    """Progress bar column configuration."""
    def __init__(self, min_value=0, max_value=100, format=None, **kwargs):
        """
        Parameters:
        - min_value (float): Minimum progress value
        - max_value (float): Maximum progress value
        - format (str): Progress display format
        """

# JSON column configuration
class JsonColumn(Column):
    """JSON data column configuration."""
    pass

import streamlit as st
import pandas as pd
import numpy as np

# Create sample data
data = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David'],
    'Age': [25, 30, 35, 28],
    'Salary': [50000, 60000, 70000, 55000],
    'Active': [True, True, False, True]
})

# Display as interactive dataframe
st.subheader("Interactive DataFrame")
st.dataframe(data, use_container_width=True)

# Display as static table
st.subheader("Static Table")
st.table(data.head(2))

# Configure columns with specific types and formatting
column_config = {
    "Name": st.column_config.TextColumn(
        "Employee Name",
        help="Full name of employee",
        max_chars=50,
        required=True
    ),
    "Age": st.column_config.NumberColumn(
        "Age (years)",
        help="Employee age in years",
        min_value=18,
        max_value=65,
        step=1,
        format="%d"
    ),
    "Salary": st.column_config.NumberColumn(
        "Annual Salary",
        help="Annual salary in USD",
        min_value=0,
        format="$%d"
    ),
    "Active": st.column_config.CheckboxColumn(
        "Currently Active",
        help="Whether employee is currently active"
    )
}

# Display with custom column configuration
edited_df = st.data_editor(
    data,
    column_config=column_config,
    num_rows="dynamic",
    use_container_width=True
)

st.write("Edited data:", edited_df)

import random

# Display key metrics with deltas
col1, col2, col3, col4 = st.columns(4)

with col1:
    st.metric(
        label="Revenue",
        value="$125,000",
        delta="$12,000",
        help="Monthly revenue with change from last month"
    )

with col2:
    st.metric(
        label="Users",
        value="2,847",
        delta="-15",
        delta_color="inverse"
    )

with col3:
    st.metric(
        label="Conversion Rate",
        value="3.2%",
        delta="0.8%"
    )

with col4:
    st.metric(
        label="Churn Rate",
        value="2.1%",
        delta="-0.3%",
        delta_color="inverse"
    )

# Sample product data
products = pd.DataFrame({
    'Product': ['Widget A', 'Widget B', 'Widget C'],
    'Price': [10.99, 15.99, 8.99],
    'In Stock': [True, False, True],
    'Category': ['Electronics', 'Home', 'Electronics']
})

# Configure with selectbox for categories
config = {
    'Category': st.column_config.SelectboxColumn(
        'Product Category',
        options=['Electronics', 'Home', 'Clothing', 'Books'],
        required=True
    ),
    'Price': st.column_config.NumberColumn(
        'Price ($)',
        min_value=0,
        format='$%.2f'
    )
}

# Editable table with dynamic rows
edited_products = st.data_editor(
    products,
    column_config=config,
    num_rows="dynamic",  # Allow adding/removing rows
    key="product_editor"
)

# Show summary
st.write(f"Total products: {len(edited_products)}")
st.write(f"Total value: ${edited_products['Price'].sum():.2f}")

# DataFrame with selection handling
selection = st.dataframe(
    data,
    selection_mode="multi-row",
    on_select="rerun",
    key="data_selection"
)

if selection.selection.rows:
    selected_data = data.iloc[selection.selection.rows]
    st.write("Selected rows:")
    st.dataframe(selected_data)
else:
    st.write("No rows selected")