from rustpy_xlsxwriter import write_worksheet
# Freeze the first row (headers)
write_worksheet(records, "output.xlsx", freeze_row=1)
# Freeze both first row and first column
write_worksheet(records, "output.xlsx", freeze_row=1, freeze_col=1)

from rustpy_xlsxwriter import write_worksheets
# Configuration for freeze panes
freeze_config = {
    "general": {"row": 1, "col": 0},  # Apply to all sheets
    "Sheet1": {"row": 1, "col": 2},  # Override for Sheet1
    "Sheet2": {"row": 2, "col": 1}   # Override for Sheet2
}
write_worksheets(
    records_with_sheet_name,
    "output.xlsx",
    freeze_panes=freeze_config
)

from rustpy_xlsxwriter import get_version
def get_version() -> str:
    """
    Get the version of the RustPy-XlsxWriter library.

    Returns:
        str: The version string.
    """

from rustpy_xlsxwriter import write_worksheet
def write_worksheet(
    records: List[Dict[str, Any]],
    file_name: str,
    sheet_name: Optional[str] = None,
    password: Optional[str] = None,
    freeze_row: Optional[int] = None,
    freeze_col: Optional[int] = None,
):
    """
    Save records to a single sheet in an Excel file.

    Args:
        records: List of dictionaries where each dict represents a row of data.
                Dictionary keys become column headers and values become cell contents.
                Supported value types:
                - str: Text values
                - int/float: Numeric values
                - bool: Boolean values
                - None: Empty cells
                - datetime.date/datetime.datetime: Date values
        file_name: Full path including filename where the Excel file will be saved.
                  Must have .xlsx extension.
        sheet_name: Optional name for the worksheet. If not provided, defaults to 'Sheet1'.
                   Must be <= 31 chars and cannot contain [ ] : * ? / \.
        password: Optional password to protect the workbook from modifications.
        freeze_row: Optional row index to freeze.
        freeze_col: Optional column index to freeze.
    """

from rustpy_xlsxwriter import write_worksheets
def write_worksheets(
    records_with_sheet_name: List[Dict[str, List[Dict[str, Any]]]],
    file_name: str,
    password: Optional[str] = None,
    freeze_panes: Optional[Dict[str, Any]] = None,
):
    """
    Save records to multiple sheets in an Excel file.

    Args:
        records_with_sheet_name: List of dictionaries where each dict maps a sheet name to its records.
                                The records for each sheet follow the same format as write_worksheet().
                                Sheet names must be <= 31 chars and cannot contain [ ] : * ? / \.
        file_name: Full path including filename where the Excel file will be saved.
                  Must have .xlsx extension.
        password: Optional password to protect the workbook from modifications.
        freeze_panes: Optional configuration for freeze panes.
                      If provided, it should be a dictionary with the following keys:
                      - 'general': A dictionary with 'row' and 'col' keys for general freeze panes.
                      - 'Sheet Name': A dictionary where keys are sheet names and values are dictionaries
                                          with 'row' and 'col' keys for specific sheet freeze panes.
    """

from rustpy_xlsxwriter import validate_sheet_name
def validate_sheet_name(name: str) -> bool:
    """
    Validate if a sheet name is valid for Excel.

    Args:
        name: Sheet name to validate. Excel has several restrictions on valid sheet names:
              - Maximum 31 characters
              - Cannot contain characters: [ ] : * ? / \
              - Cannot be empty
              - Cannot start or end with an apostrophe
              - Cannot be 'History' (reserved name)

    Returns:
        bool: True if the sheet name is valid for Excel, False otherwise
    """

from rustpy_xlsxwriter import write_worksheet
from datetime import datetime
records = [
    {
        "Name": "Alice",
        "Age": 30,
        "City": "New York",
        "Active": True,
        "Join Date": datetime(2023, 1, 15)
    },
    {
        "Name": "Bob",
        "Age": 25,
        "City": "San Francisco",
        "Active": False,
        "Join Date": datetime(2023, 2, 1)
    },
]
# Basic usage
write_worksheet(records, "output.xlsx", sheet_name="Sheet1")
# With freeze panes - freeze first row and first column
write_worksheet(records, "output_frozen.xlsx", sheet_name="Sheet1", freeze_row=1, freeze_col=1)

from rustpy_xlsxwriter import write_worksheets
records_with_sheet_name = [
    {"Employees": [
        {
            "Name": "Alice",
            "Age": 30,
            "City": "New York",
            "Active": True
        },
        {
            "Name": "Bob",
            "Age": 25,
            "City": "San Francisco",
            "Active": False
        },
    ]},
    {"Inventory": [
        {
            "Product": "Laptop",
            "Price": 1000.0,
            "Stock": 50,
            "Available": True
        },
        {
            "Product": "Phone",
            "Price": 500.0,
            "Stock": 100,
            "Available": True
        },
    ]},
]
# Basic usage
write_worksheets(records_with_sheet_name, "output_multiple_sheets.xlsx")
# With freeze panes configuration
freeze_config = {
    "general": {"row": 1, "col": 0},  # Apply to all sheets
    "Employees": {"row": 1, "col": 2},  # Override for Employees sheet
    "Inventory": {"row": 2, "col": 1}   # Override for Inventory sheet
}
write_worksheets(
    records_with_sheet_name,
    "output_frozen.xlsx",
    freeze_pane=freeze_config
)