Schedule calculation exactly at every 15 mins using Python

Question

I have followed the example which is shown here.

It is working as expected, but with a small problem. If the do_job() method takes more than a minute to finish. It's waiting for another 1 min from end of the do_job() method and scheduling another calculation.

But I want it to start timings 1 min from the start of execution time. Is there a possibility to do that?

EDIT

import schedule
import time

def job():
    print("Process triggered at:", time.strftime("%Y-%m-%d %H:%M:%S"))
    time.sleep(30)
    print("Process ended at:", time.strftime("%Y-%m-%d %H:%M:%S"))

# Define the frequency (in seconds) at which the process should be triggered
frequency_seconds = 60  # Trigger every 60 seconds

# Schedule the job to run at the specified frequency
schedule.every(frequency_seconds).seconds.do(job)

# Main loop to keep the script running
while True:
    schedule.run_pending()
    time.sleep(1)  # Sleep for 1 second to avoid high CPU usage

In the above code , the output generated is as below :

Process triggered at: 2024-03-25 06:57:23
Process ended at: 2024-03-25 06:57:53
Process triggered at: 2024-03-25 06:58:54
Process ended at: 2024-03-25 06:59:24

It is observed that the next process is triggered after the first process has ended. The time difference between first process end time and second process start time is 60 seconds.

But my expectation is the time difference between first process trigger time and second process trigger time should be 60 seconds. 60 seconds should not be calculation from process end time. job() should be called exactly at 60 seconds interval. So the expected output will look like this :

Process triggered at: 2024-03-25 06:57:23
Process ended at: 2024-03-25 06:57:53
Process triggered at: 2024-03-25 06:58:23
Process ended at: 2024-03-25 06:58:53

If do_job() takes longer than a minute to run, you're not going to be able to successfully schedule it to run every minute. That aside, there's a library called schedule that might meet your needs. — Ouroborus
– Ouroborus, Commented Mar 25, 2024 at 5:40
@Ouroborus Yes , I'm using the schedule library as you mentioned. But It is not scheduling the frequency from start of the calculation . The time difference is calculated from end of the execution time of do_job() which is not I want. Also I'm making sure that do_job() finished with in 1 min , or else I'm killing the process. — CrazyCoder
– CrazyCoder, Commented Mar 25, 2024 at 6:03
schedule.every().minute.at(":00").do(job) may work better. Also, the docs say "Schedule does not account for the time it takes for the job function to execute. To guarantee a stable execution schedule you need to move long-running jobs off the main-thread (where the scheduler runs). See Parallel execution for a sample implementation." — Ouroborus
– Ouroborus, Commented Mar 25, 2024 at 16:31

Mark Setchell · Accepted Answer · 2024-03-25 10:29:06Z

If your objective is to start jobs a given number of seconds since the start of the previous job rather than since the end of the previous job, you can use the following code:

#!/usr/bin/env python3

import sched, time

# Define the frequency (in seconds) at which the process should be triggered
frequency_seconds = 60  # Trigger every 60 seconds
priority = 1

# Create a scheduler
s = sched.scheduler(time.time, time.sleep)

def job():
    # Reschedule ourselves for next run
    s.enterabs(time.time() + frequency_seconds, priority, job)

    print("Process triggered at:", time.strftime("%Y-%m-%d %H:%M:%S"))
    time.sleep(25)
    print("Process ended at:", time.strftime("%Y-%m-%d %H:%M:%S"))

# Start first job immediately, i.e. delay=0
s.enter(0, priority, job)

# Keep running future jobs
s.run()

If your concern is that new jobs cannot be started while previous jobs are still running. i.e. that you want to start new jobs every minute even if they take 90 seconds to run, you may have to use threads. Please say if that is the issue.

101 · Accepted Answer · 2024-03-26 10:02:06Z

1

The timed-count package makes that pretty simple.

It won't suffer from lag over time, and it can also optionally raise an error if your job takes too long.

from timed_count import timed_count

for _ in timed_count(period=60, error_on_missed=True):
    job()

edited Mar 26, 2024 at 10:02

answered Mar 25, 2024 at 21:19

101

9,0576 gold badges47 silver badges71 bronze badges

Collectives™ on Stack Overflow

Schedule calculation exactly at every 15 mins using Python

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related