Blog

How to use Application.Excel4IntlMacroSheets in the xlwings API way

The Excel4IntlMacroSheets property of the Application object in Excel’s object model is a legacy feature primarily used for backward compatibility with older Excel 4.0 international macro sheets. In xlwings, this property can be accessed to retrieve a collection of sheets that are specifically Excel 4.0 international macro sheets within a workbook. These sheets are a type of macro sheet that was used in earlier versions of Excel for storing macro commands and functions, particularly in international contexts where different language settings were involved. While modern Excel development typically uses VBA (Visual Basic for Applications) for macros, the Excel4IntlMacroSheets property remains available for compatibility reasons, allowing developers to interact with or reference these legacy components programmatically.

In xlwings, the Excel4IntlMacroSheets property is accessed through the app object, which represents the Excel application. The syntax for using this property in xlwings is straightforward, as it returns a collection of sheet objects that correspond to the Excel 4.0 international macro sheets. The property does not take any parameters, making it simple to call. Here is the basic syntax:

import xlwings as xw

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

# Access the Excel4IntlMacroSheets property
intl_macro_sheets = app.api.Excel4IntlMacroSheets

In this code, app.api.Excel4IntlMacroSheets calls the underlying Excel object model property via xlwings’ api attribute, which provides direct access to Excel’s COM interface. The returned value is a collection that can be iterated over to access individual sheets. Each sheet in this collection is an object representing an Excel 4.0 international macro sheet, and you can use properties like Name to get the sheet’s name or Visible to check its visibility. Note that this property may return None or an empty collection if no such sheets exist in the workbook, so it’s good practice to handle such cases in your code.

For example, to list all Excel 4.0 international macro sheets in the active workbook, you can use the following xlwings code:

import xlwings as xw

# Start or connect to Excel
app = xw.apps.active

# Get the Excel4IntlMacroSheets collection
intl_macro_sheets = app.api.Excel4IntlMacroSheets

# Check if there are any sheets in the collection
if intl_macro_sheets is not None and intl_macro_sheets.Count > 0:
    for sheet in intl_macro_sheets:
        print(f"Sheet Name: {sheet.Name}, Visible: {sheet.Visible}")
else:
    print("No Excel 4.0 international macro sheets found.")

This code iterates through each sheet in the Excel4IntlMacroSheets collection and prints its name and visibility status. It includes error handling to account for cases where no such sheets are present. Additionally, you can perform operations on these sheets, such as activating them or reading data, though this is less common in modern workflows due to the deprecated nature of Excel 4.0 macros. For instance, to activate the first Excel 4.0 international macro sheet, you could use:

if intl_macro_sheets is not None and intl_macro_sheets.Count > 0:
    first_sheet = intl_macro_sheets(1) # Indexing starts at 1 in Excel
    first_sheet.Activate()
    print(f"Activated sheet: {first_sheet.Name}")

How to use Application.ErrorCheckingOptions in the xlwings API way

The ErrorCheckingOptions member of the Application object in Excel provides access to a collection of settings that control how Excel identifies and marks potential errors in worksheets. This includes common issues like formulas referencing empty cells, inconsistent formulas in a region, numbers stored as text, or formulas omitting adjacent cells. Through xlwings, developers can programmatically read or modify these error-checking rules to customize the workbook’s behavior, which is particularly useful when automating data validation or preparing reports where certain warnings should be suppressed for clarity.

In xlwings, the ErrorCheckingOptions is accessed via the Application object. The syntax generally follows the pattern of first obtaining the Application object, then its ErrorCheckingOptions collection, and finally specific properties or methods. The collection itself does not have a direct method call but consists of multiple Boolean properties, each corresponding to a specific error-checking rule. For example, to check or set the rule for identifying numbers formatted as text, you would use app.ErrorCheckingOptions.NumberAsText. Each property can be set to True to enable the error check or False to disable it. Key properties include:

• BackgroundChecking: Enables or disables background error checking for all rules.
• EmptyCellReferences: Checks formulas that reference empty cells.
• InconsistentFormula: Flags formulas inconsistent with others in the region.
• NumberAsText: Identifies numbers stored as text.
• OmittedCells: Detects formulas that omit adjacent cells in a range.

To use this in xlwings, start by importing the library and connecting to Excel. Here’s a code example that demonstrates reading and modifying error-checking settings:

import xlwings as xw

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

# Access the ErrorCheckingOptions collection
error_options = app.ErrorCheckingOptions

# Check current status of specific rules
print("Background checking enabled:", error_options.BackgroundChecking)
print("Empty cell reference check:", error_options.EmptyCellReferences)

# Disable the check for numbers stored as text
error_options.NumberAsText = False

# Enable checking for inconsistent formulas
error_options.InconsistentFormula = True

# Disable all error checking temporarily
error_options.BackgroundChecking = False

# Save changes (optional, as changes apply immediately to the workbook)

How to use Application.EnableSound in the xlwings API way

The EnableSound property of the Application object in the Excel object model controls whether Excel plays sounds associated with certain events, such as alerts or errors. In xlwings, this property can be accessed and modified to manage sound feedback programmatically, allowing for a quieter automation environment or toggling audio cues as needed. This is particularly useful in scripts that run unattended or in environments where sound is disruptive.

The xlwings API provides a straightforward way to interact with this property through the App object, which represents the Excel application. The property is a Boolean value: True enables sound playback, and False disables it. The syntax for getting and setting the property is as follows:

• Get the current state: app.api.EnableSound
• Set to a new state: app.api.EnableSound = False (or True)

Here, app is an instance of xw.App in xlwings. The .api attribute provides direct access to the underlying Excel object model, allowing you to use properties like EnableSound as defined in Excel’s VBA documentation. No parameters are required for this property; it simply reads or writes a Boolean value.

For example, to disable sounds in Excel during an automation task and then re-enable them, you can use the following xlwings code:

import xlwings as xw

# Start or connect to an Excel application
app = xw.App(visible=True)

# Disable sound
app.api.EnableSound = False
print("Sounds disabled.")

# Perform some tasks, such as opening a workbook and triggering an alert
wb = app.books.open('example.xlsx')
# Simulate an action that might produce sound, like an error (commented out to avoid actual errors)
# try:
# # Code that could cause an error
# except:
# pass

# Re-enable sound
app.api.EnableSound = True
print("Sounds enabled.")

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

How to use Application.EnableMacroAnimations in the xlwings API way

The EnableMacroAnimations property of the Application object in Excel is a feature that controls whether animations are displayed during the execution of macros. Animations can include visual effects such as the movement of shapes, changes in cell formatting, or other graphical transitions that might occur when VBA code runs. By default, Excel may enable these animations to provide visual feedback, but they can sometimes slow down macro performance or cause visual distractions. The EnableMacroAnimations property allows developers to programmatically turn these animations on or off, optimizing the user experience and execution speed for macros, especially in complex or repetitive tasks.

In xlwings, the EnableMacroAnimations property is accessed through the Application object, which represents the Excel application itself. xlwings provides a Pythonic interface to interact with Excel’s object model, enabling seamless integration for automation and data analysis. To use this property, you typically start by establishing a connection to an Excel instance or workbook using xlwings, then reference the Application object to set or get the property value. This property is a Boolean type, meaning it accepts True to enable animations or False to disable them. It can be useful in scenarios where you want to ensure smooth macro execution without visual interruptions, such as in batch processing or when deploying solutions to users with varying performance needs.

The syntax for accessing EnableMacroAnimations in xlwings involves the app property of a workbook or a direct application instance. For example, if you have a workbook object wb in xlwings, you can use wb.app.api.EnableMacroAnimations to get or set the value. Here, api is used to access the underlying Excel object model properties and methods. The property does not require any parameters; it is a simple read/write attribute. When setting it, you assign a Boolean value directly. For instance, to disable animations, you would set it to False, and to enable them, set it to True. It’s important to note that changes to this property affect the entire Excel application session, so any macros run afterward will adhere to the new setting until it is changed again.

Below is a code example demonstrating the use of EnableMacroAnimations with xlwings. This example shows how to disable animations before running a macro that performs data operations, then re-enable them afterward to restore the default user experience. This approach can help improve performance during intensive tasks.

import xlwings as xw

# Connect to the active Excel application or start a new one
app = xw.App(visible=True) # Set visible=True to see Excel, or False for background operation

# Access the Application object and disable macro animations
app.api.EnableMacroAnimations = False
print("Macro animations disabled.")

# Perform some Excel operations, such as opening a workbook and running a macro
wb = app.books.open('example.xlsx') # Replace with your file path
# Assume there is a macro named 'ProcessData' in the workbook; run it if needed
# wb.macro('ProcessData')() # Uncomment if a macro exists

# Example: Manipulate data without animations for speed
sheet = wb.sheets[0]
sheet.range('A1').value = 'Data Processing Complete'
sheet.range('A1').font.bold = True

# Re-enable macro animations after operations
app.api.EnableMacroAnimations = True
print("Macro animations re-enabled.")

# Save and close the workbook
wb.save()
wb.close()
app.quit()

How to use Application.EnableLivePreview in the xlwings API way

The Application.EnableLivePreview property in Excel controls whether the “Live Preview” feature is active. Live Preview allows users to see a temporary preview of formatting changes (like font styles, cell styles, or table styles) when hovering over options in the Ribbon before actually applying them. This can enhance user experience by providing immediate visual feedback. In xlwings, you can programmatically get or set this property to manage the feature’s state for the Excel application instance.

Syntax in xlwings:

app.enable_live_preview # To get the current state (returns a boolean)
app.enable_live_preview = value # To set the state

• app: This is the xlwings App object, which represents the Excel application. Typically, you obtain it via xlwings.App() or xlwings.apps.active.
• value: A boolean (True or False). Setting it to True enables Live Preview, while False disables it. The property affects the entire Excel application, so changes apply to all open workbooks.

Code Examples:

1. Check the Current Live Preview Setting:

import xlwings as xw
# Connect to the active Excel instance
app = xw.apps.active
# Get the EnableLivePreview state
current_state = app.enable_live_preview
print(f"Live Preview is currently enabled: {current_state}")

This code retrieves and prints whether Live Preview is active, returning True or False.

2. Enable Live Preview:

import xlwings as xw
# Start a new Excel instance (or use an existing one)
app = xw.App()
# Enable Live Preview
app.enable_live_preview = True
print("Live Preview has been enabled.")
# Optionally, verify by checking the state again
if app.enable_live_preview:
    print("Confirmed: Live Preview is on.")

Here, Live Preview is turned on for the application. This is useful if you want to ensure users see formatting previews during automated processes.

3. Disable Live Preview:

import xlwings as xw
# Assume an Excel instance is already running
app = xw.apps[0] # Access the first open application
# Disable Live Preview
app.enable_live_preview = False
print("Live Preview has been disabled.")

This example disables the feature, which might be preferred in scenarios where you want to minimize distractions or performance overhead during heavy Excel operations.

4. Toggle Live Preview Based on Condition:

import xlwings as xw
app = xw.apps.active
# Toggle the state: if enabled, disable it, and vice versa
app.enable_live_preview = not app.enable_live_preview
new_state = "enabled" if app.enable_live_preview else "disabled"
print(f"Live Preview is now {new_state}.")

How to use Application.EnableLargeOperationAlert in the xlwings API way

The Application.EnableLargeOperationAlert property in Excel is a setting that controls whether Excel displays a warning message when an operation affects a large number of cells (typically more than 33 million cells in a single operation). This alert is designed to prevent accidental, time-consuming, or resource-intensive operations that could slow down or crash Excel. By using the EnableLargeOperationAlert property via the xlwings API, Python scripts can programmatically enable or disable these alerts, allowing for more controlled and silent execution of large-scale data manipulations when necessary.

In xlwings, the Application object is accessed through the app property of a Book (workbook) instance or directly via xw.apps. The EnableLargeOperationAlert property is a read/write Boolean property. Its syntax in xlwings is straightforward, as it maps directly to the Excel Object Model. The property accepts and returns a Boolean value (True or False). When set to True (the default), Excel will show the large operation alert. When set to False, the alert is suppressed, allowing the operation to proceed without interruption.

Syntax:

# To get the current state of the alert
alert_status = xw.apps[0].api.EnableLargeOperationAlert
# or, if you have a specific workbook object
alert_status = wb.app.api.EnableLargeOperationAlert

# To set the state (enable or disable the alert)
xw.apps[0].api.EnableLargeOperationAlert = False # Disables the alert
wb.app.api.EnableLargeOperationAlert = True # Enables the alert

Parameters and Values:
The property does not take method parameters; it is a simple property assignment. The value must be a Boolean:

• True: Enables the large operation alert (default Excel behavior).
• False: Disables the large operation alert.

Example Usage:
Consider a scenario where a Python script needs to perform a bulk update, such as clearing contents or applying formulas across an entire large dataset that exceeds the alert threshold. To avoid the interruption of the warning dialog, you can temporarily disable the alert, execute the operation, and then restore the original setting. Here is a practical xlwings code example:

import xlwings as xw

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

# Get the current alert setting to restore it later
original_setting = app.api.EnableLargeOperationAlert

try:
    # Disable the large operation alert
    app.api.EnableLargeOperationAlert = False

    # Open a workbook and perform a large operation
    wb = app.books.open('large_dataset.xlsx')
    sheet = wb.sheets[0]

    # Example: Clear contents of a very large range (e.g., A1:Z1000000)
    # This range has 26 columns * 1,000,000 rows = 26,000,000 cells, which would     trigger the alert if enabled.
    sheet.range('A1:Z1000000').clear_contents()

    # Alternatively, perform other operations like filling formulas
    # sheet.range('A1:Z1000000').formula = '=RAND()'

    print("Large operation completed without alerts.")

finally:
    # Restore the original alert setting to ensure normal Excel behavior for the user
    app.api.EnableLargeOperationAlert = original_setting
    wb.save()
    wb.close()

How to use Application.EnableEvents in the xlwings API way

The EnableEvents member of the Application object in Excel is a property that controls whether events are triggered in Excel. Events are actions or occurrences—such as opening a workbook, changing a cell, or clicking a button—that can run automated VBA macros. By setting EnableEvents to False, you can temporarily disable all event handlers, which is useful when performing operations that might otherwise trigger unwanted recursive or cascading events. This helps prevent infinite loops, improve performance, or avoid conflicts during batch processing. In xlwings, you can access and manipulate this property through the Application object to control event behavior in your automation scripts.

Syntax in xlwings:
The property can be accessed using the following format:

app = xw.apps.active # or xw.App() for a new instance
app.api.EnableEvents = boolean_value

• app: An instance of the xlwings App object representing the Excel application.
• api.EnableEvents: This accesses the underlying Excel object model’s EnableEvents property via xlwings’ api attribute.
• boolean_value: A boolean (True or False) that sets whether events are enabled. When True, events are allowed to fire; when False, all events are suppressed.

Key Notes:

• Setting EnableEvents to False affects the entire Excel application instance, so any workbooks open in that instance will have events disabled.
• It is a best practice to reset EnableEvents to True after completing operations that require event suppression, to restore normal Excel functionality. This can be done using a try...finally block to ensure it happens even if errors occur.
• This property is commonly used in scenarios like data imports, formatting changes, or calculations where event-driven macros (e.g., Worksheet_Change) might interfere.

Example Usage in xlwings:
Here is a code example demonstrating how to use EnableEvents to prevent a Worksheet_Change event from triggering while updating cell values:

import xlwings as xw

# Connect to the active Excel instance
app = xw.apps.active
wb = app.books['SampleWorkbook.xlsx']
sheet = wb.sheets['Data']

# Disable events to avoid triggering Worksheet_Change
app.api.EnableEvents = False
try:
    # Perform operations that might trigger events
    sheet.range('A1').value = 'New Value'
    sheet.range('A2:A10').value = [[i] for i in range(1, 10)]
    print("Cells updated without triggering events.")
finally:
    # Re-enable events to restore normal behavior
    app.api.EnableEvents = True
    print("Events re-enabled.")

In this example, events are disabled before writing data to cells A1 through A10. This ensures that any VBA event handlers (like Worksheet_Change) are not executed during the update, which could be critical if those handlers modify data or cause delays. The try...finally block guarantees that events are re-enabled afterward, even if an error occurs during the update.

Another example involves toggling events during a batch process to improve performance:

import xlwings as xw

app = xw.apps.active
wb = app.books.open('Report.xlsx')
sheet = wb.sheets[0]

# Disable events for batch processing
app.api.EnableEvents = False
try:
    for row in range(1, 100):
        sheet.range((row, 1)).value = row * 2 # Fill column A with doubled values
     wb.save()
finally:
    app.api.EnableEvents = True
    print("Batch processing complete and events restored.")

How to use Application.EnableCheckFileExtensions in the xlwings API way

Introduction to Application.EnableCheckFileExtensions in xlwings

The Application.EnableCheckFileExtensions property in xlwings provides a programmatic way to control a safety feature within Microsoft Excel. This property is part of the Excel Application object model and is accessible through xlwings’ API, allowing Python scripts to interact with Excel’s application-level settings. Specifically, it manages whether Excel performs a file extension validation when opening files via the Open dialog box or related methods. When enabled, Excel checks if the file extension matches the actual file format, helping to prevent the accidental opening of potentially unsafe files. This is particularly useful in automated environments where file handling is frequent, ensuring an additional layer of security against mismatched or malicious files. Understanding and utilizing this property can enhance the robustness and safety of Excel automation scripts.

Functionality

The primary function of EnableCheckFileExtensions is to toggle Excel’s built-in file extension verification. When set to True, Excel will validate that the file extension corresponds to its actual format before opening. For example, if a file has a .xlsx extension but is actually a different format, Excel may block or warn the user. When set to False, this check is disabled, allowing files to open without such validation. This can be beneficial in controlled environments where file formats are trusted, but it may pose security risks if used indiscriminately. In xlwings, this property allows developers to dynamically adjust this setting based on script requirements, such as temporarily disabling checks during batch processing of known-safe files.

Syntax and Parameters

In xlwings, the EnableCheckFileExtensions property is accessed through the app object, which represents the Excel Application. The syntax is straightforward, as it is a property that can be both read and written. The property accepts and returns a Boolean value (True or False).

• Property Access: app.api.EnableCheckFileExtensions
• Type: Boolean (read/write)
• Default Value: Typically True in Excel’s default settings, but it may vary based on user configuration or Excel version.

To get the current state, simply read the property: current_state = app.api.EnableCheckFileExtensions. To set a new state, assign a Boolean value: app.api.EnableCheckFileExtensions = False. Note that changes made via xlwings affect the Excel instance immediately and persist for the duration of the session unless modified again. It’s important to ensure that the Excel application is properly instantiated through xlwings (e.g., using app = xw.App() or connecting to an existing instance) before accessing this property.

Code Examples

Below are practical xlwings code examples demonstrating how to use EnableCheckFileExtensions in different scenarios.

Example 1: Checking the Current Setting
This example retrieves the current status of the file extension check and prints it to the console. It’s useful for debugging or logging purposes in automation scripts.

import xlwings as xw

# Connect to an existing Excel instance or start a new one
app = xw.App(visible=False) # Run Excel in the background
try:
    # Get the current EnableCheckFileExtensions value
    check_status = app.api.EnableCheckFileExtensions
    print(f"Current EnableCheckFileExtensions setting: {check_status}")
finally:
    # Ensure the Excel instance is closed properly
    app.quit()

Example 2: Disabling the File Extension Check Temporarily
In this example, the property is set to False to disable extension checks, then a file is opened, and the setting is restored to its original state. This approach is safe for batch processing where file formats are verified externally.

import xlwings as xw

app = xw.App(visible=False)
try:
    # Save the original setting
    original_setting = app.api.EnableCheckFileExtensions

    # Disable the file extension check
    app.api.EnableCheckFileExtensions = False
    print("File extension check disabled.")

    # Open a workbook (replace 'sample.xlsx' with your file path)
    workbook = app.books.open('sample.xlsx')
    print("Workbook opened successfully.")

    # Perform operations on the workbook here...

    # Restore the original setting
    app.api.EnableCheckFileExtensions = original_setting
    print(f"File extension check restored to: {original_setting}")
finally:
    app.quit()

Example 3: Enabling the File Extension Check for Security
This example ensures that the check is enabled, which is a best practice for security in environments handling untrusted files. It can be used as a precautionary measure in scripts.

import xlwings as xw

app = xw.App(visible=False)
try:
    # Force enable the file extension check
    app.api.EnableCheckFileExtensions = True
    print("File extension check enabled for security.")

    # Open a workbook; Excel will now validate the extension
    workbook = app.books.open('data.xlsx')
    print("Workbook opened with extension validation.")
finally:
    app.quit()

How to use Application.EnableCancelKey in the xlwings API way

The Application.EnableCancelKey property in Excel’s object model controls how Excel handles interrupt requests from the user, such as pressing Ctrl+Break or Esc during a lengthy macro execution. This setting is crucial for ensuring your VBA or automation scripts can either allow user interruption for long-running processes or disable it to prevent accidental stops in critical operations. In xlwings, you can access and manipulate this property through the api property of the Application object, providing a direct bridge to Excel’s COM interface for precise control.

Functionality:
EnableCancelKey determines the behavior when a user attempts to interrupt a running procedure. It can be set to enable interruptions, disable them, or handle them with error handling, which is useful for debugging or preventing data corruption in automated tasks.

Syntax in xlwings:
In xlwings, you access this property via the Application object’s api. The syntax is:
app.api.EnableCancelKey = value
Here, app is the xlwings App instance representing the Excel application. The value parameter is an integer that specifies the interruption behavior, corresponding to Excel’s XlEnableCancelKey enumeration. The possible values are:

Value	Constant (in Excel VBA)	Description
0	xlDisabled	Disables interrupt key functionality. User interruptions are ignored.
1	xlErrorHandler	Interrupts are captured as a trappable error (error 18). Allows custom error handling in code.
2	xlInterrupt	Enables standard interruption, which can break the macro execution.

Example Usage:
Below is an xlwings code example that demonstrates how to set and check the EnableCancelKey property in a Python script. This example disables the cancel key during a time-consuming operation to prevent accidental stops, then restores it to allow interruptions afterward.

import xlwings as xw
import time

# Connect to the active Excel instance or start a new one
app = xw.apps.active if xw.apps.active else xw.App()

try:
    # Set EnableCancelKey to disable interruptions
    app.api.EnableCancelKey = 0 # Equivalent to xlDisabled
    print("Cancel key disabled. Starting long operation...")

    # Simulate a long-running task (e.g., data processing)
    for i in range(10):
        time.sleep(1) # Delay to mimic processing
        print(f"Processing step {i+1}...")

    # Restore to allow interruptions (xlInterrupt)
    app.api.EnableCancelKey = 2 # Equivalent to xlInterrupt
    print("Long operation completed. Cancel key re-enabled.")

except Exception as e:
    print(f"An error occurred: {e}")
finally:
    # Ensure the property is reset to avoid leaving Excel in a disabled state
    app.api.EnableCancelKey = 2
    print("Cleanup: Cancel key reset to default.")

How to use Application.EnableAutoComplete in the xlwings API way

The EnableAutoComplete property of the Application object in Excel is a useful feature that controls whether Excel’s AutoComplete functionality is active for cell entries. AutoComplete helps users by automatically suggesting and completing text entries based on previously entered data in the same column, thereby speeding up data input and reducing errors. In xlwings, this property can be accessed and modified to customize the Excel environment programmatically, which is particularly beneficial when automating repetitive tasks or setting up specific user interfaces.

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

• To get the current setting: app.api.EnableAutoComplete
• To set the property: app.api.EnableAutoComplete = value
  Here, app is an instance of the xlwings App class (e.g., created via xw.App() or xw.apps), and value is a Boolean: True to enable AutoComplete or False to disable it. The property applies globally to the Excel instance, affecting all open workbooks. Note that this is a property of the Excel Application object, not specific to a workbook or worksheet, so changes are immediate and persist until Excel is closed or the property is reset.

Example Usage:
Below are practical xlwings code examples demonstrating how to use the EnableAutoComplete property. These examples assume you have Excel installed and xlwings imported (via import xlwings as xw). The code can be run in a Python script or interactive environment like Jupyter.

Example 1: Checking the Current AutoComplete Status
This code snippet starts an Excel application, retrieves the current EnableAutoComplete setting, and prints it. This is useful for diagnostics or conditional logic in automation scripts.

import xlwings as xw
# Start or connect to Excel
app = xw.App(visible=True) # Set visible=False for background operation
# Get the current AutoComplete status
status = app.api.EnableAutoComplete
print(f"AutoComplete is currently enabled: {status}")
# Optionally, close the app if done
app.quit()

Example 2: Disabling AutoComplete for Data Entry Tasks
In scenarios where AutoComplete might interfere with controlled data input (e.g., during automated form filling), you can disable it temporarily. This example opens a workbook, turns off AutoComplete, performs a task (like entering data), and then re-enables it to restore default settings.

import xlwings as xw
app = xw.App(visible=True)
wb = app.books.open('example.xlsx') # Replace with your file path
# Disable AutoComplete
app.api.EnableAutoComplete = False
print("AutoComplete disabled.")
# Perform data operations: e.g., enter values in a column
sheet = wb.sheets['Sheet1']
sheet.range('A1').value = ['Apple', 'Banana', 'Cherry'] # Sample data
# Re-enable AutoComplete after task completion
app.api.EnableAutoComplete = True
print("AutoComplete re-enabled.")
# Save and close
wb.save()
wb.close()
app.quit()

Example 3: Toggling AutoComplete Based on User Preference
This example shows how to toggle the property based on a condition, such as user input or a configuration setting. It’s a flexible approach for adaptive automation.

import xlwings as xw
def set_autocomplete(enabled):
    app = xw.App(visible=False)
    app.api.EnableAutoComplete = enabled
    status = "enabled" if enabled else "disabled"
    print(f"AutoComplete {status}.")
    app.quit()

# Example toggle based on a condition (e.g., from a config file)
user_prefers_autocomplete = False # Simulated user setting
set_autocomplete(user_prefers_autocomplete)