Timer for python functions

Question

I'm trying to do an automatic mouse clicker. My main issue now is how to do a timer for each function, for example, function 1 works for about 15 minutes, then function 2 after the 15 minutes starts to work just one time, then comeback to function 1. And i want to function4 Works independente from the others, i want it to click everytime even if the function 1 is running ( im not sure if this is possible) here is my code:

    import pyautogui, sys
pyautogui.size()
(1280, 800)

def function1():
        pyautogui.click(button='left', x=619, y=266) 
        pyautogui.PAUSE = 3.9
        pyautogui.click(button='left', x=617, y=475)

def function2():
        pyautogui.click(button='left', x=624, y=347)
        pyautogui.PAUSE = 5.0
        pyautogui.click(button='left', x=615, y=431)
        pyautogui.PAUSE = 5.0
        pyautogui.click(button='left', x=315, y=483)
        pyautogui.PAUSE = 5.0
        pyautogui.click(button='left', x=616, y=390)


def function3 ():
        pyautogui.click(button='left', x=617, y=522)
        pyautogui.PAUSE = 5.0


def function4():
        pyautogui.click(button='left', x=1257, y=432)

Thank you all :)

Answer 1

Because it is not easy to manage multiple functions with wait independently without introducing a signal and multi-thread, here is another way to manage multiple click() functions with the PyAutoGUI library.

The solution is a multi-sequencer class (called class TimerExec).

Step 1 - Use a class TimerSeq to store sequencer parameters

Only the constructor is needed

class TimerSeq:
    def __init__(self, iseq, tseq, bexe, bloop):    
        self.iseq = iseq
        self.tseq = tseq
        self.bexe = bexe
        self.bloop = bloop

Step 2 - Create a class TimerExec to manage a list of sequencers

The constructor create an empty list

class TimerExec:
    def __init__(self):
        self.list = [ ]
        self.stop = True
        self.chrono = -1
        self.delay = -1

A simple floating-point seconds value to int milliseconds

#
# convert float seconds to milliseconds
def tomilli(self, fsec):
    return int(round(fsec * 1000))

Add a new sequencer in the list

#
# append new sequences to the list
def append(self, func, loop=False):
    self.list.append([func, TimerSeq(-1, -1, False, loop)])
    print('list:',self.list)

Verify if the sequencer is complete or restart when loop

#
# check end of sequence or restart
def nextcheck(self, seq):
    if seq[1].iseq >= len(seq[0]):
        if seq[1].bloop:
            seq[1].iseq = 0 # restart
        return True
    return False

Compute parameters for the next sequence in the current sequencer

#
# switch to the next sequence
def nextstep(self, seq):
    if seq[1].iseq >= len(seq[0]):
        return True
    seq[1].iseq = seq[1].iseq+1
    seq[1].tseq = self.tomilli(time.time())
    seq[1].bexe = False
    return False

Manage the current sequencer and execute the current function then delay the next sequence

#
# explore sequence and execute when  
def exestep(self, seq):
    bseq = False
    if seq[1].tseq < 0:
        bseq = self.nextstep(seq)
    else:
        bseq = self.nextcheck(seq)
    if bseq:
        return True
    pseq = seq[0][seq[1].iseq]
    tnow = self.tomilli(time.time())
    tdel = self.tomilli(pseq[0])
    if seq[1].bexe == False:
        print('execute(%d):'% (tnow-self.chrono),pseq)
        # execute the selected function
        pseq[1](pseq[2],pseq[3],pseq[4])
        seq[1].bexe = True 
    tseq = seq[1].tseq
    if tnow > (tseq+tdel):
        bseq = self.nextstep(seq)
    return bseq

Main loop function to explore all sequencers until complete or max_delay

#
# loop to execute all sequences with max_delay (s)
def execute(self, max_delay):
    print('start:',time.strftime("%H:%M:%S", time.localtime()))
    self.stop = False
    self.delay = self.tomilli(max_delay)
    self.chrono = self.tomilli(time.time())
    while self.stop == False:
        tnow = self.tomilli(time.time())
        #if tnow > (self.chrono + self.delay):
        #    break
        bstop = True
        for seq in self.list:
            bseq = self.exestep(seq)
            bstop = bstop & bseq
        if bstop == True:
            self.stop = True    
    print('stop:',time.strftime("%H:%M:%S", time.localtime()),
          ((tnow-self.chrono)/1000.0))

Step 3 - declare your sequencer based to your declared function

For function1(), use a 2 steps sequencer:

def function1():
        pyautogui.click(button='left', x=619, y=266) 
        pyautogui.PAUSE = 3.9
        pyautogui.click(button='left', x=617, y=475)

The sequencer is:

fct1 = [
  # pyautogui.click(button='left', x=619, y=266) 
  [ 3.9, pyautogui.click, 'left', 619, 266 ],
  # pyautogui.click(button='left', x=617, y=475)
  [ 0.0, pyautogui.click, 'left', 617, 475 ]
]

Step 4 - Create TimerExec object, add sequencer then execute.

The duration is limited to 13.6 seconds maximum

tSeq = TimerExec()
tSeq.append(fct1)
tSeq.execute(13.6)