Archive

How to use Application.FlashFill in the xlwings API way

The FlashFill member of the Application object in Excel is a powerful feature for automatically filling in data based on patterns it detects in your input. This functionality is particularly useful for cleaning and formatting data, such as splitting full names into first and last names, extracting numbers from text, or standardizing date formats. In xlwings, you can access this feature through the api property, which provides direct access to the underlying Excel object model. The FlashFill operation is typically applied to a range of cells, where Excel analyzes the examples provided in adjacent columns and fills the target range accordingly.

The syntax for using FlashFill in xlwings involves calling the FlashFill method on a Range object. Specifically, you first reference the target range where you want the filled data to appear, and then invoke the method. The method does not take any parameters directly in its basic form, as it relies on the adjacent source data for pattern recognition. However, it is often used in conjunction with other operations to ensure correct data alignment. In xlwings, the call is made through the Excel API, so the format is: range.api.FlashFill(). Here, range represents the xlwings Range object that corresponds to the target cells in Excel. It is important to note that FlashFill requires at least one example in the source column adjacent to the target range for pattern detection. If no clear pattern is found, Excel may not fill the data as expected, so users should verify the results.

For example, suppose you have a list of full names in column A of an Excel worksheet, such as “John Doe” and “Jane Smith”, and you want to extract the first names into column B. Using xlwings, you can write a script to apply FlashFill. First, you would manually enter the first example in cell B1 (e.g., “John” for “John Doe”) to provide a pattern. Then, in your Python code, you can use xlwings to trigger FlashFill on the range in column B where you want the first names to appear. Below is a code instance that demonstrates this:

import xlwings as xw

# Connect to the active Excel workbook
wb = xw.books.active
ws = wb.sheets['Sheet1']

# Define the target range for first names (e.g., B1:B10)
target_range = ws.range('B1:B10')

# Apply FlashFill to automatically fill based on adjacent data in column A
target_range.api.FlashFill()

# Save the workbook if needed
wb.save()

How to use Application.FixedDecimalPlaces in the xlwings API way

The Application.FixedDecimalPlaces property in Excel is a global setting that controls whether Excel automatically rounds numbers entered into cells to a fixed number of decimal places. When enabled, it applies to all data entry across the workbook until the setting is turned off. This feature is primarily used for rapid data entry where consistent decimal precision is required, such as in financial or inventory systems, without manually formatting each cell. It is important to note that this setting affects only new entries and does not alter existing cell values or their display formatting.

In the xlwings API, which provides a programmatic interface to Excel’s object model from Python, you can access and manipulate the Application.FixedDecimalPlaces property. The syntax for using this property is straightforward, as it corresponds directly to the Excel object model. The property can be set to an integer to specify the number of decimal places or to False to disable the fixed decimal rounding.

Syntax in xlwings:

app = xw.apps.active # Get the active Excel application instance
app.api.FixedDecimalPlaces = places

• places: An integer that specifies the number of decimal places to fix. The value must be between -15 and 15, inclusive. Setting places to a positive number (e.g., 2) rounds entered numbers to that many decimal places. Setting it to 0 rounds to the nearest integer. Setting it to a negative number (e.g., -2) rounds to the nearest hundred. To turn off the fixed decimal setting, assign False to the property.

Parameter Details:

Value Type	Description
Integer	Sets the fixed decimal places to the specified number (range: -15 to 15).
Boolean	Use False to disable fixed decimal rounding; True is not a valid input.

Example Usage:
Below are practical xlwings code examples demonstrating how to use the FixedDecimalPlaces property in different scenarios.

1. Enable Fixed Decimal Rounding to Two Places:
   This example activates the fixed decimal feature, setting it to round all new numeric entries to two decimal places. It is useful for standard currency inputs.

import xlwings as xw
app = xw.apps.active
app.api.FixedDecimalPlaces = 2
# Now, entering 123.456 in any cell will be stored as 123.46

2. Disable Fixed Decimal Rounding:
   To turn off the fixed decimal setting, set the property to False. This reverts Excel to its normal data entry behavior.

import xlwings as xw
app = xw.apps.active
app.api.FixedDecimalPlaces = False
# New entries will no longer be automatically rounded

3. Round to Nearest Hundred (Negative Decimal Places):
   Using a negative value allows rounding to powers of ten. Here, setting -2 rounds entries to the nearest hundred.

import xlwings as xw
app = xw.apps.active
app.api.FixedDecimalPlaces = -2
# Entering 1234 will be stored as 1200

4. Check Current Fixed Decimal Setting:
   You can also retrieve the current value of the property to inspect the setting.

import xlwings as xw
app = xw.apps.active
current_setting = app.api.FixedDecimalPlaces
print(f"Current fixed decimal places: {current_setting}")
# Output might be 2, -1, or False if disabled

How to use Application.FixedDecimal in the xlwings API way

The FixedDecimal property of the Application object in Excel is a feature that allows for the automatic rounding of numbers entered into cells to a fixed number of decimal places. This is particularly useful in scenarios where consistent decimal precision is required across data entry, such as in financial or scientific applications, without manually formatting each cell. When enabled, any number typed into a worksheet will be rounded to the specified decimal places. For example, if FixedDecimal is set to True and FixedDecimalPlaces is set to 2, entering 123.456 will result in 123.46 being stored in the cell. It’s important to note that this property affects only data entry and not existing data or calculations, and it applies globally to the Excel application instance.

In xlwings, you can access this property through the app object, which represents the Excel application. The syntax for setting or getting the FixedDecimal property is straightforward, as it is a boolean property. Here’s the basic structure:

• Get the current value: app.api.FixedDecimal
• Set the value: app.api.FixedDecimal = True or app.api.FixedDecimal = False

To specify the number of decimal places, you use the FixedDecimalPlaces property in conjunction with FixedDecimal. The FixedDecimalPlaces property takes an integer value. For example, to set two decimal places: app.api.FixedDecimalPlaces = 2. It’s essential to set FixedDecimalPlaces before or after enabling FixedDecimal, depending on your needs. The typical workflow involves enabling the property, setting the decimal places, and then disabling it when done to avoid unintended rounding in other operations.

Below is a code example demonstrating the use of FixedDecimal with xlwings:

import xlwings as xw

# Connect to the active Excel application or start a new one
app = xw.apps.active

# Enable fixed decimal rounding
app.api.FixedDecimal = True

# Set the number of decimal places to 2
app.api.FixedDecimalPlaces = 2

# Now, any number entered in Excel will be rounded to 2 decimal places
# For instance, typing 45.678 in a cell will display as 45.68

# To demonstrate, add a value to a cell in a new workbook
wb = app.books.add()
ws = wb.sheets[0]
ws.range('A1').value = 45.678 # This will be rounded to 45.68 upon entry
print(f"Value in A1: {ws.range('A1').value}") # Output should be 45.68

# Disable fixed decimal rounding after use
app.api.FixedDecimal = False

# Optionally, reset FixedDecimalPlaces to 0 (default)
app.api.FixedDecimalPlaces = 0

# Close the workbook without saving
wb.close()

How to use Application.FindFormat in the xlwings API way

The FindFormat property of the Application object in xlwings is a powerful feature for controlling the search criteria in Excel when using methods like Find or Replace. It allows you to define a set of formatting attributes (such as font color, cell fill, or number format) that Excel will use to locate cells matching that specific format. This is particularly useful for automating tasks where you need to find or modify cells based on their visual styling rather than their content.

In xlwings, you access this property through the Application object. The FindFormat property itself returns a FindFormat object. You do not set it directly to a value; instead, you configure its properties (like Font or Interior) to define the search format. After setting these properties, any subsequent Find or Replace operation will use this format as a criterion if the SearchFormat argument is set to True.

Syntax in xlwings:

import xlwings as xw

app = xw.apps.active # Get the active Excel application
find_format = app.api.FindFormat # Access the FindFormat object

Once you have the find_format object, you can set its various properties. Common properties include:

• find_format.Font.Color: Sets the font color (e.g., RGB(255, 0, 0) for red).
• find_format.Interior.Color: Sets the cell background color.
• find_format.Font.Bold: Sets the font to bold (True or False).

After configuring the format, you use it in a Find method. For example, to find the next cell with the specified format:

range_to_search = xw.books.active.sheets[0].api.UsedRange
found_cell = range_to_search.Find(What="", SearchFormat=True)

Note: The What parameter is set to an empty string "" because we are searching by format only. The SearchFormat=True tells Excel to use the format defined in FindFormat.

Example:
Suppose you want to find all cells in a worksheet that have a yellow background. Here’s how you can do it with xlwings:

import xlwings as xw

# Connect to Excel
app = xw.apps.active

# Define the search format: yellow interior
find_format = app.api.FindFormat
find_format.Interior.Color = 65535 # Yellow color in Excel's color index

# Search in the used range of the first sheet
sheet = xw.books.active.sheets[0]
search_range = sheet.api.UsedRange
first_cell = search_range.Find(What="", SearchFormat=True)

# Loop to find all matching cells
if first_cell:
    addresses = [first_cell.Address]
    next_cell = search_range.FindNext(first_cell)
    while next_cell.Address not in addresses:
        addresses.append(next_cell.Address)
        next_cell = search_range.FindNext(next_cell)
        print(f"Cells with yellow background: {addresses}")
else:
    print("No cells found with the specified format.")

How to use Application.FileValidationPivot in the xlwings API way

The Application.FileValidationPivot property in Excel’s object model is a read-only property that returns a constant indicating the status of file validation for the active workbook when it is opened in a PivotTable context. This property is particularly relevant for security and compatibility purposes, as it helps developers understand how Excel has handled file validation—such as checking for potential risks or format issues—specifically for workbooks containing PivotTables. The property’s value can be used to make decisions in VBA macros or automation scripts, ensuring that data processing proceeds only when the file validation status is acceptable.

In xlwings, which provides a Pythonic way to interact with Excel via its COM API, you can access the Application.FileValidationPivot property through the api property of an xlwings App or Book object. This allows Python scripts to retrieve the file validation status programmatically, enabling integration with data analysis workflows or automated reporting systems. The syntax in xlwings follows the pattern of accessing the underlying Excel object model, so it closely mirrors VBA usage but within Python code.

Syntax in xlwings:

• app.api.FileValidationPivot
  Here, app is an instance of xlwings.App representing the Excel application. The property returns an integer constant corresponding to the file validation status. The possible values are defined in the Excel enumeration XlFileValidationPivotMode, which includes:
• xlFileValidationPivotDefault (0): Indicates that file validation is set to the default mode, typically meaning no specific override is applied.
• xlFileValidationPivotRun (1): Indicates that file validation has been run for the PivotTable.
• xlFileValidationPivotSkip (2): Indicates that file validation was skipped for the PivotTable.

These values help determine whether Excel performed validation checks when the workbook was opened, which can be critical for security-sensitive applications. For example, if the status is xlFileValidationPivotSkip, you might want to log a warning or halt further processing to avoid potential risks.

Example Code in xlwings:
Below is a practical example demonstrating how to use the FileValidationPivot property in a Python script with xlwings. This example opens an Excel workbook, checks the file validation status for PivotTables, and prints a message based on the result. It assumes you have xlwings installed and an Excel file available.

import xlwings as xw

# Start an Excel application and open a workbook
app = xw.App(visible=False) # Run Excel in the background for automation
wb = app.books.open('example.xlsx') # Replace with your file path

# Access the FileValidationPivot property via the Application object
validation_status = app.api.FileValidationPivot

# Interpret the status based on Excel constants
if validation_status == 0:
    status_message = "Default validation mode applied."
elif validation_status == 1:
    status_message = "File validation was run for PivotTables."
elif validation_status == 2:
    status_message = "File validation was skipped for PivotTables."
else:
    status_message = "Unknown validation status."

# Output the result
print(f"File Validation Pivot Status: {validation_status} - {status_message}")

# Optionally, take action based on status
if validation_status == 2:
    print("Warning: Validation skipped. Consider manually reviewing the file for security.")

# Close the workbook and quit Excel
wb.close()
app.quit()

How to use Application.FileExportConverters in the xlwings API way

The Application.FileExportConverters property in Excel is part of the Excel Object Model and provides access to a collection of file export converters available in the application. These converters are essentially add-ins or built-in features that allow Excel to save or export workbooks in various file formats beyond the default ones, such as PDF, XPS, or other custom formats. In xlwings, this property can be utilized to programmatically inspect and manage the export options available in Excel, enabling automation of export processes and format validation in data analysis and reporting workflows.

Functionality:
The primary function of Application.FileExportConverters is to return an FileExportConverters object, which is a collection of all installed file export converters. Each converter in the collection is represented by a FileExportConverter object, which contains details like the extension, description, and file format ID. This is useful for checking if a specific export format is supported before attempting an export operation, or for listing available formats in a user interface.

Syntax in xlwings:
In xlwings, you access this property through the Application object. The syntax is straightforward, as it maps directly to the Excel Object Model. Here’s how you can call it:

import xlwings as xw

# Connect to the active Excel instance or start a new one
app = xw.App(visible=False) # or xw.App() for visible
export_converters = app.api.FileExportConverters

• app.api: This provides access to the underlying Excel COM object, allowing direct use of Excel’s properties and methods.
• FileExportConverters: This property does not take any parameters. It returns a collection object that you can iterate over or query.

Parameters and Values:
The FileExportConverters property itself has no parameters. However, the returned collection contains FileExportConverter objects, each with properties that can be accessed. Key properties include:

• Extensions: A string representing the file extension associated with the converter (e.g., “pdf”).
• Description: A string describing the converter (e.g., “PDF”).
• FileFormat: A numeric ID representing the file format in Excel constants.

You can retrieve these values by iterating through the collection. For example, to get a list of all available export formats, you can loop through each converter and extract its details.

Code Example:
Here’s a practical xlwings code example that demonstrates how to use Application.FileExportConverters to list all available export converters and their details:

import xlwings as xw

# Start an Excel application instance
app = xw.App(visible=False)

try:
    # Access the FileExportConverters collection
    converters = app.api.FileExportConverters

    # Check if any converters are available
    if converters.Count > 0:
        print("Available File Export Converters:")
        for i in range(1, converters.Count + 1):
            converter = converters.Item(i)
            print(f" - Extension: {converter.Extensions}, Description: {converter.Description}, FileFormat ID: {converter.FileFormat}")
    else:
        print("No file export converters found.")

    # Example: Check if PDF export is supported
    pdf_supported = any(converter.Extensions.lower() == 'pdf' for converter in [converters.Item(j) for j in range(1, converters.Count + 1)])
    print(f"\nPDF export supported: {pdf_supported}")

except Exception as e:
    print(f"An error occurred: {e}")
finally:
    # Close the Excel application
    app.quit()

How to use Application.FileDialog in the xlwings API way

The Application.FileDialog property in Excel’s object model is a powerful tool for displaying file dialog boxes, enabling users to select files or folders. In xlwings, this functionality is accessed through the api property, which provides direct access to the underlying Excel VBA object model. This allows Python scripts to leverage Excel’s built-in dialog interfaces for file operations, enhancing user interaction within automated workflows.

Functionality:
The FileDialog property returns a FileDialog object, which represents a single instance of a file dialog box. It can be used to display dialogs for opening files, saving files, selecting folders, or choosing file pickers. This is particularly useful for scripts that require user input for file paths, making automation more interactive and flexible.

Syntax in xlwings:
To use FileDialog in xlwings, you first access the Excel Application object via xlwings, then call the FileDialog property. The basic syntax is:

file_dialog = xw.apps.active.api.FileDialog(fileDialogType)

Here, fileDialogType is a required parameter that specifies the type of dialog to display. It accepts integer values from the MsoFileDialogType enumeration, which can be referenced via constants or direct integers. Common values include:

• 1 (or msoFileDialogOpen): For opening files.
• 2 (or msoFileDialogSaveAs): For saving files.
• 3 (or msoFileDialogFilePicker): For selecting files.
• 4 (or msoFileDialogFolderPicker): For selecting folders.

Once the FileDialog object is obtained, you can configure properties like InitialFileName or Title, and then display the dialog using the Show method. The Show method returns -1 if the user clicks OK, and 0 if canceled. Selected items can be retrieved via the SelectedItems property.

Example Code:
Below is an xlwings code example that demonstrates using FileDialog to open a file picker dialog, allowing users to select multiple Excel files, and then print the selected file paths.

import xlwings as xw

# Connect to the active Excel application
app = xw.apps.active

# Get the FileDialog object for file picking
file_dialog = app.api.FileDialog(3) # 3 corresponds to msoFileDialogFilePicker

# Set dialog properties
file_dialog.AllowMultiSelect = True
file_dialog.Title = "Select Excel Files"
file_dialog.InitialFileName = "C:\\Users\\Example\\Documents\\"

# Display the dialog and check user action
if file_dialog.Show() == -1: # User clicked OK
    selected_files = file_dialog.SelectedItems
    for file_path in selected_files:
        print(f"Selected file: {file_path}")
else:
    print("Dialog was canceled by the user.")

# Note: Ensure Excel is open and xlwings is properly installed.

How to use Application.FileConverters in the xlwings API way

The FileConverters property of the Application object in Excel provides a list of file converters that are currently installed and available for use. This is particularly useful when you need to programmatically determine which file formats Excel can open or save through external converters, such as older file types (e.g., Lotus 1-2-3, Quattro Pro) or specialized formats. In xlwings, this property can be accessed to retrieve information about these converters, enabling automation tasks that depend on specific file format support.

Functionality:
The FileConverters property returns a two-dimensional array (list of lists in Python) that contains details about each installed file converter. Each converter entry typically includes the converter’s descriptive name, the file extension it handles, and a class identifier. This information can be used to check for the availability of a converter before attempting to open or save a file in a non-native format, ensuring compatibility and preventing errors in automated workflows.

Syntax in xlwings:
In xlwings, you access the FileConverters property through the app object, which represents the Excel application. The syntax is straightforward:

app.api.FileConverters

This returns a Variant array in Excel’s object model, which xlwings converts into a Python list. The array is structured as a collection of sub-arrays, where each sub-array corresponds to one converter. The elements within each sub-array represent:

• Index 0: The converter’s descriptive name (e.g., “Lotus 1-2-3”).
• Index 1: The file extension associated with the converter (e.g., “.wk3”).
• Index 2: A class identifier or internal number for the converter.

If no converters are installed, the property returns None or an empty array in Python, depending on the Excel version and configuration.

Code Examples:
Here are practical examples using xlwings to work with the FileConverters property:

1. Retrieve and list all installed file converters:

import xlwings as xw

# Connect to the active Excel instance or start a new one
app = xw.apps.active

# Get the file converters
converters = app.api.FileConverters

# Check if converters exist and iterate through them
if converters:
    for converter in converters:
        print(f"Name: {converter[0]}, Extension: {converter[1]}, Class ID: {converter[2]}")
else:
    print("No file converters installed.")

This code prints details for each converter, helping you audit available formats.

2. Check for a specific converter by file extension:

import xlwings as xw

app = xw.apps.active
converters = app.api.FileConverters
target_extension = ".wk3" # Example for Lotus 1-2-3 files

found = False
if converters:
    for converter in converters:
        if converter[1] == target_extension:
            print(f"Converter found: {converter[0]} for {target_extension}")
            found = True
            break
if not found:
    print(f"No converter for {target_extension} is installed.")

This example verifies support for a particular file type before proceeding with operations.

3. Use in a function to validate file format support:

import xlwings as xw

def is_converter_available(extension):
app = xw.apps.active
converters = app.api.FileConverters
if converters:
    for converter in converters:
        if converter[1].lower() == extension.lower():
            return True
        return False

# Example usage
if is_converter_available(".slk"):
    print("SYLK format is supported.")
else:
    print("SYLK format is not supported.")

This function can be integrated into larger scripts to handle file conversions dynamically.

How to use Application.FeatureInstall in the xlwings API way

In the xlwings library, the Application object’s FeatureInstall property is a critical component for managing how Microsoft Excel handles the installation of optional features or add-ins that are not initially installed. This property is particularly relevant when your automation script relies on features that may not be available in a standard Excel installation, ensuring that Excel can dynamically install them as needed without manual intervention. Understanding and utilizing FeatureInstall can enhance the robustness of your xlwings scripts, especially in environments where Excel configurations vary.

Functionality:
The FeatureInstall property determines the method Excel uses to install features when they are required by a command or operation but are not currently installed. This is essential for maintaining seamless automation, as it prevents errors or interruptions that could occur if a needed feature is missing. By setting this property appropriately, you can control whether Excel prompts the user, installs features automatically, or disables the feature installation process altogether.

Syntax:
In xlwings, you can access the FeatureInstall property through the app object, which represents the Excel application. The syntax is straightforward:

app.api.FeatureInstall

This property is both readable and writable, allowing you to retrieve or set its value. The value corresponds to an enumeration that defines the installation behavior. In xlwings, you typically use integer constants from the msoFeatureInstall enumeration, which is part of the Microsoft Office object model. The key values are:

Constant Name (VBA)	xlwings Value	Description
msoFeatureInstallNone	0	Disables feature installation; Excel will not install missing features and may fail if they are required.
msoFeatureInstallOnDemand	1	Prompts the user to install features when needed, which is the default behavior in many Excel setups.
msoFeatureInstallOnDemandWithUI	2	Similar to on-demand but may include additional user interface elements during installation.
msoFeatureInstallOnDemandWithUI	2	Similar to on-demand but may include additional user interface elements during installation.

To set the property, assign one of these integer values to app.api.FeatureInstall. For example, to set it to install features automatically without user prompts, you would use msoFeatureInstallOnDemand (value 1), but note that the actual behavior can depend on Excel’s configuration and user permissions.

Code Examples:
Here are practical examples of using the FeatureInstall property in xlwings:

1. Retrieving the Current FeatureInstall Setting:
   This code checks how Excel is currently configured to handle feature installation.

import xlwings as xw
app = xw.App(visible=False) # Start Excel in the background
current_setting = app.api.FeatureInstall
print(f"Current FeatureInstall setting: {current_setting}")
app.quit()

Output might be 1, indicating on-demand installation.

2. Setting FeatureInstall to Disable Installation:
   This example configures Excel to not install any missing features, which can be useful in controlled environments where all features are pre-installed.

import xlwings as xw
app = xw.App(visible=False)
app.api.FeatureInstall = 0 # msoFeatureInstallNone
print("Feature installation disabled.")
app.quit()

3. Enabling On-Demand Installation with UI:
   This sets Excel to prompt users for installation when features are missing, providing a balance between automation and user control.

import xlwings as xw
app = xw.App(visible=True) # Make Excel visible to see prompts
app.api.FeatureInstall = 2 # msoFeatureInstallOnDemandWithUI
print("On-demand feature installation with UI enabled.")
# Perform operations that might require additional features
app.quit()

4. Integrating with a Script to Handle Missing Features:
   In a more complex scenario, you might adjust FeatureInstall based on the script’s needs. For instance, if your automation uses advanced charting tools that may not be installed, you could set it to on-demand to ensure they are available.

import xlwings as xw
app = xw.App(visible=False)
app.api.FeatureInstall = 1 # msoFeatureInstallOnDemand
workbook = app.books.open('data.xlsx')
# Add a chart that might require additional features
sheet = workbook.sheets['Sheet1']
chart = sheet.charts.add()
chart.set_source_data(sheet.range('A1:B10'))
chart.chart_type = 'xlColumnClustered'
workbook.save()
app.quit()

How to use Application.ExtendList in the xlwings API way

The Application.ExtendList property in Excel is a read-only Boolean property that indicates whether the “Extend list formats and formulas” option is enabled in Excel’s AutoCorrect settings. This setting, when turned on, automatically extends formatting and formulas when new data is added to a list, facilitating consistent data entry and calculation in structured ranges like tables. In xlwings, this property can be accessed through the api property of the App object, allowing Python scripts to check the current state of this Excel feature programmatically.

Functionality:
The primary function of ExtendList is to inform whether Excel is configured to automatically apply existing formats and formulas to new rows or columns added to a list. This is particularly useful in scenarios involving dynamic data ranges where maintaining uniformity is critical. By querying this property, developers can decide whether to rely on Excel’s built-in automation or implement custom logic for data expansion in their scripts.

Syntax in xlwings:
The property is accessed via the api interface, which mirrors Excel’s VBA object model. The syntax is straightforward:

app.api.ExtendList

This returns a Boolean value: True if the “Extend list formats and formulas” option is enabled, and False otherwise. There are no parameters for this property, as it is read-only. The property is part of the Application object, which represents the Excel instance itself.

Example Usage:
Below is a practical example demonstrating how to use ExtendList in an xlwings script. This code checks the setting and prints a message, then conditionally performs an action based on the result, such as manually extending formulas if the feature is disabled.

import xlwings as xw

# Connect to the active Excel instance or start a new one
app = xw.apps.active

# Check the state of the ExtendList property
extend_enabled = app.api.ExtendList

# Output the result
if extend_enabled:
    print("Extend list formats and formulas is ENABLED in Excel.")
else:
    print("Extend list formats and formulas is DISABLED in Excel.")

# Example: If disabled, manually copy a formula down a column in a specific worksheet
if not extend_enabled:
    wb = app.books.active
    ws = wb.sheets['Sheet1']
    # Assume a formula exists in cell B2 and we want to extend it down to B10
    formula_range = ws.range('B2:B10')
    formula_range.formula = '=A2*2' # Set a sample formula
    print("Manually extended formula in column B due to disabled ExtendList.")
else:
    print("Relying on Excel's auto-extension for formats and formulas.")

# Close the Excel instance if needed (optional)
app.quit()