如何在程序意外终止时自动卸载pypiwin32？

First off, most termination scenarios can be handled, but there are edge cases (like sudden power loss) that even the best code can't recover from. Let's walk through how to cover as many bases as possible, with a focus on Windows (your primary target) while keeping things as cross-platform as reasonable.

Step 1: First, Correctly Track If We Installed the Package #

Your original code uses a try/except to trigger installation, but this can be unreliable (e.g., import failures might not mean the package is missing). Instead, explicitly check if pypiwin32 is already installed before touching pip:

import importlib.util
import os
import sys
import atexit
import signal

# Check if a package is installed (cross-platform)
def is_package_installed(package_name):
    return importlib.util.find_spec(package_name) is not None

# Flag to track if *we* installed pypiwin32 (critical—don't uninstall user's existing packages!)
we_installed_pypiwin32 = False

Step 2: Create the Uninstall Callback #

We'll reuse this function across all termination handlers:

def cleanup_pypiwin32():
    if we_installed_pypiwin32:
        print("Cleaning up: Uninstalling pypiwin32...")
        # Use sys.executable to ensure we're using the correct pip for the current Python environment
        os.system(f"{sys.executable} -m pip uninstall -y pypiwin32")

Step 3: Cover Common Termination Scenarios #

1. Normal Exit & Uncaught Exceptions (atexit) #

The atexit module handles graceful exits: program completion, sys.exit(), or uncaught exceptions that crash the program. This is cross-platform:

# Register cleanup for normal exits
atexit.register(cleanup_pypiwin32)

2. Signals (Ctrl+C, Task Manager "End Task" on Unix/Windows) #

Catch signals like SIGINT (Ctrl+C) and SIGTERM (graceful termination request, e.g., Task Manager's "End Task" on non-Windows, or some Windows scenarios):

def signal_handler(signum, frame):
    cleanup_pypiwin32()
    sys.exit(0)

# Register signal handlers (cross-platform)
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)

3. Windows-Specific: Console/Window Close & Shutdown #

On Windows, we need to handle console close events, logoff, and shutdown using the Windows API. We'll use win32api (which comes with pypiwin32) to register a handler:

if os.name == 'nt':
    try:
        from win32api import SetConsoleCtrlHandler
    except ImportError:
        # We'll handle this after installing pypiwin32 if needed
        pass

    def windows_console_handler(event):
        # Event codes: 0=Ctrl+C, 2=Console close, 5=Logoff, 6=Shutdown
        if event in (0, 2, 5, 6):
            cleanup_pypiwin32()
            return True  # Tell Windows we've handled the event

    # Register the handler once we can import win32api
    try:
        SetConsoleCtrlHandler(windows_console_handler, True)
    except NameError:
        # If win32api isn't available yet, we'll re-register after installation
        pass

Step 4: Updated Installation Logic #

Now tie it all together with your original import logic, making sure we only set we_installed_pypiwin32 if we actually installed the package:

# Try importing pythoncom
try:
    import pythoncom
except ImportError:
    # Only install if the package isn't already present
    if not is_package_installed("pypiwin32"):
        print("pypiwin32 not found—installing...")
        os.system(f"{sys.executable} -m pip install pypiwin32")
        we_installed_pypiwin32 = True
        # Re-register the Windows handler now that win32api is available
        if os.name == 'nt':
            from win32api import SetConsoleCtrlHandler
            SetConsoleCtrlHandler(windows_console_handler, True)
        import pythoncom
    else:
        # Package exists but import failed—raise the error instead of installing again
        raise

Limitations to Keep in Mind #

• Forced Termination: If the user uses Task Manager's "End Process" (Windows) or sends SIGKILL (Unix), this can't be caught—no code runs after that.
• Sudden Power Loss: Obviously, no cleanup will happen here.
• Windows Shutdown Timeout: Windows gives processes a limited time (usually a few seconds) to handle shutdown events. If the uninstall takes too long, Windows will kill the process mid-cleanup.

Final Notes #

This solution covers all practical scenarios you're likely to encounter: normal exits, crashes, Ctrl+C, window close, logoff, and shutdown. The cross-platform parts work on Unix-like systems too, though since pypiwin32 is Windows-only, those code paths won't trigger installation/uninstallation there.

内容的提问来源于stack exchange，提问作者Ido Kadosh