When working with Python, there may be situations where you want to automatically run a Python file when a USB device is connected to your computer. This can be useful for tasks such as automatically backing up files or syncing data between devices. In this article, we will explore three different ways to achieve this functionality.

Solution 1: Using the watchdog library

The first solution involves using the watchdog library, which is a Python API and shell utilities to monitor file system events. We can utilize this library to detect when a USB device is connected and trigger the execution of our Python file.

import os
import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class USBEventHandler(FileSystemEventHandler):
    def on_created(self, event):
        if event.is_directory:
            return
        elif event.src_path.startswith('/Volumes/'):
            # Replace '/Volumes/' with the appropriate path for your system
            # This condition checks if the event is related to a USB device being connected
            # You can modify this condition based on your system's file system structure
            print("USB device connected!")
            # Execute your Python file here

event_handler = USBEventHandler()
observer = Observer()
observer.schedule(event_handler, path='/Volumes/', recursive=False)
observer.start()

try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    observer.stop()
observer.join()

In this solution, we create a custom event handler class that inherits from FileSystemEventHandler. We override the on_created method to check if the event is related to a USB device being connected. If it is, we execute our Python file.

Solution 2: Using the pyudev library

The second solution involves using the pyudev library, which is a Python binding for libudev, the device manager for the Linux kernel. This library allows us to monitor and interact with devices on a Linux system.

import pyudev
import subprocess

context = pyudev.Context()
monitor = pyudev.Monitor.from_netlink(context)
monitor.filter_by(subsystem='usb')

for device in iter(monitor.poll, None):
    if device.action == 'add':
        print("USB device connected!")
        # Execute your Python file here

In this solution, we create a pyudev.Context object and a pyudev.Monitor object to monitor USB devices. We filter the monitor to only listen for USB subsystem events. We then iterate over the monitor’s poll method, which blocks until a device event occurs. When a USB device is connected, we execute our Python file.

Solution 3: Using the psutil library

The third solution involves using the psutil library, which is a cross-platform library for retrieving information on running processes and system utilization. We can utilize this library to periodically check for connected USB devices and trigger the execution of our Python file.

import psutil
import subprocess
import time

def check_usb_devices():
    for device in psutil.disk_partitions():
        if 'removable' in device.opts:
            print("USB device connected!")
            # Execute your Python file here

while True:
    check_usb_devices()
    time.sleep(1)

In this solution, we define a function check_usb_devices that uses the psutil.disk_partitions method to retrieve information about connected disk partitions. We check if a partition is marked as removable, indicating a USB device, and execute our Python file accordingly. We then use a while True loop to periodically check for connected USB devices.

After exploring these three solutions, it is difficult to determine which one is better as it depends on the specific requirements and constraints of your project. Solution 1 using the watchdog library provides a more event-driven approach, while Solution 2 using the pyudev library is specific to Linux systems. Solution 3 using the psutil library is cross-platform but relies on periodic checks. Consider the specific needs of your project and choose the solution that best fits your requirements.