Python script that is executed every 5 minutes

Automation and task scheduling play a crucial role in streamlining repetitive tasks in software development. Imagine having a Python script that needs to be executed every 5 minutes, such as fetching data from an API, performing data processing, or sending regular updates. Manually running the script at such frequent intervals can be time-consuming and prone to errors. That's where task scheduling comes in.

In this tutorial, we will explore different approaches to schedule Python scripts to run automatically every 5 minutes, from simple loops to robust scheduling libraries.

Using the time.sleep() Function

One simple approach to running a Python script every 5 minutes is by utilizing the time.sleep() function, which allows us to introduce delays in our script's execution. By combining time.sleep() with a loop, we can create a recurring pattern of execution with a 5-minute interval.

Example

Here's an example of how this can be achieved ?

import time

while True:
    # Perform the desired operations here
    print("Executing the script...")
    
    # Delay execution for 5 minutes
    time.sleep(300)  # 300 seconds = 5 minutes

Executing the script...
(waits 5 minutes)
Executing the script...
(continues indefinitely)

In this example, we have a while True loop that ensures our script keeps running indefinitely. Inside the loop, we can place the operations that we want to perform every 5 minutes. The time.sleep(300) statement introduces a 5-minute delay between each iteration of the loop. The argument to time.sleep() is specified in seconds, so 300 seconds correspond to 5 minutes.

However, keep in mind that this approach ties up system resources and may not be the most efficient solution for long-running tasks or when precise timing is required.

Using the Schedule Library

While the time.sleep() approach works well for simple cases, the schedule library provides a more flexible and feature-rich solution for scheduling recurring tasks in Python. It allows us to define more complex schedules and provides additional functionalities such as error handling and logging.

To get started with the schedule library, you need to install it first using pip ?

pip install schedule

Once installed, you can import the library and define your scheduled tasks using its API ?

import schedule
import time

def task():
    # Perform the desired operations here
    print("Executing the script...")

# Schedule the task to run every 5 minutes
schedule.every(5).minutes.do(task)

# Run the scheduled tasks indefinitely
while True:
    schedule.run_pending()
    time.sleep(1)

Executing the script...
(waits 5 minutes)
Executing the script...
(continues indefinitely)

In this example, we define a task() function that represents the operations we want to perform every 5 minutes. We use the schedule.every(5).minutes.do(task) statement to schedule the task to run every 5 minutes.

The schedule.run_pending() function checks if there are any pending tasks to run and executes them. The time.sleep(1) statement introduces a 1-second delay between each iteration of the loop, reducing CPU usage and allowing the script to respond to signals promptly.

Advanced Features with Schedule Library

The schedule library offers advanced features that allow you to customize and handle various scenarios. Let's explore some of these features:

Error Handling

When running scheduled tasks, it's important to handle any exceptions that may occur ?

import schedule
import time

def task():
    try:
        # Perform the desired operations here
        print("Executing the script...")
        # Simulate potential error
        result = 10 / 0  # This will raise an exception
    except Exception as e:
        # Handle the exception here
        print(f"An error occurred: {str(e)}")

schedule.every(5).minutes.do(task)

while True:
    schedule.run_pending()
    time.sleep(1)

An error occurred: division by zero

Flexible Scheduling Options

The schedule library provides a wide range of scheduling options beyond simple time intervals ?

import schedule

def task():
    print("Task executed!")

# Schedule task to run every day at 8:30 AM
schedule.every().day.at("08:30").do(task)

# Schedule task to run on Mondays at 9:00 PM
schedule.every().monday.at("21:00").do(task)

# Schedule task to run every 2 hours
schedule.every(2).hours.do(task)

print("Scheduled tasks:")
for job in schedule.jobs:
    print(job)

Scheduled tasks:
Every 1 day at 08:30:00 do task() (last run: [never], next run: 2024-01-15 08:30:00)
Every 1 week at 21:00:00 do task() (last run: [never], next run: 2024-01-15 21:00:00)
Every 2 hours do task() (last run: [never], next run: 2024-01-14 16:30:00)

Best Practices

When running a Python script every 5 minutes, consider these best practices:

• Use Error Handling ? Include proper error handling to catch and manage exceptions gracefully
• Avoid Lengthy Execution ? Keep your script concise and ensure it completes within the 5-minute interval
• Implement Logging ? Use Python's logging module to track execution and debug issues
• Monitor System Resources ? Be mindful of CPU and memory usage to avoid system performance issues
• Prevent Overlapping Execution ? Ensure previous instances complete before starting new ones

Complete Example with Best Practices

Here's a complete example incorporating error handling, logging, and best practices ?

import schedule
import time
import logging
from datetime import datetime

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

def fetch_data():
    """Simulate fetching data from an API"""
    try:
        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        logging.info(f"Fetching data at {current_time}")
        
        # Your actual task logic here
        print(f"Data fetched successfully at {current_time}")
        
    except Exception as e:
        logging.error(f"Error in fetch_data: {str(e)}")

# Schedule the task every 5 minutes
schedule.every(5).minutes.do(fetch_data)

print("Scheduler started. Press Ctrl+C to stop.")

try:
    while True:
        schedule.run_pending()
        time.sleep(1)
except KeyboardInterrupt:
    logging.info("Scheduler stopped by user")
    print("Scheduler stopped.")

Scheduler started. Press Ctrl+C to stop.
2024-01-14 10:15:00,123 - INFO - Fetching data at 2024-01-14 10:15:00
Data fetched successfully at 2024-01-14 10:15:00

Comparison of Methods

Conclusion

Running Python scripts every 5 minutes can be achieved through multiple approaches. Use time.sleep() for simple cases, the schedule library for flexible scheduling with better control, or system-level schedulers for production environments. Always implement proper error handling and logging for robust automation.