Zeiten für Skripte beginnen auf einen bestimmten Zeitraum in Python laufen basiert

Question

Ich versuche, einige zufällig ausgesät Zeiten zu erzeugen, mein Skript zu sagen, wenn jedes der Skripte aus einem Haupt-Skript zu schießen.

ich einen Zeitrahmen von einstellen wollen:

START_TIME = "02:00" 
END_TIME = "03:00" 

Wenn es um die Startzeit erreicht, muss es an, wie viele Skripte suchen wir laufen müssen:

script1.do_proc() 
script2.alter() 
script3.noneex() 

In diesem Fall gibt es 3 zu laufen, so braucht es drei randomisierten Zeiten zu erzeugen, um diese Skripte mit einer Minimum Trennung von 5 Minuten zwischen jedem Skript zu starten, aber die Zeiten innerhalb der Zeit in START_TIME und END_TIME eingestellt sein muss

Aber es muss auch wissen, dass script1.main immer das erste Skript zu schießen, können andere Skripte um (random) gemischt werden

So konnten wir möglicherweise script1 um 01:43 Uhr laufen und dann script3 läuft an 01.55 und dann script2 könnte um 02:59

laufen möglicherweise script3 läuft script1 um 01:35 Uhr läuft und dann um 01:45 Uhr und dann script2 könnte um 01:45 Uhr Wir könnten auch haben laufen, die auch in Ordnung ist.

Mein Skript so weit unten zu finden:

import random 
import pytz 
from time import sleep 
from datetime import datetime 

import script1 
import script2 
import script3 

START_TIME = "01:21" 
END_TIME = "03:00" 

while 1: 
    try: 

     # Set current time & dates for GMT, London 
     CURRENT_GMTTIME = datetime.now(pytz.timezone('Europe/London')).strftime("%H%M") 
     CURRENT_GMTDAY = datetime.now(pytz.timezone('Europe/London')).strftime("%d%m%Y") 
     sleep(5) 

     # Grab old day for comparisons 
     try: 
      with open("DATECHECK.txt", 'rb') as DATECHECK: 
       OLD_DAY = DATECHECK.read() 
     except IOError: 
      with open("DATECHECK.txt", 'wb') as DATECHECK: 
       DATECHECK.write("0") 
       OLD_DAY = 0 

     # Check for new day, if it's a new day do more 
     if int(CURRENT_GMTDAY) != int(OLD_DAY): 
      print "New Day" 

      # Check that we are in the correct period of time to start running 
      if int(CURRENT_GMTTIME) <= int(START_TIME.replace(":", "")) and int(CURRENT_GMTTIME) >= int(END_TIME.replace(":", "")): 
       print "Correct time, starting" 

       # Unsure how to seed the start times for the scripts below 

       script1.do_proc() 
       script2.alter() 
       script3.noneex() 

       # Unsure how to seed the start times for above 

       # Save the current day to prevent it from running again today. 
       with open("DATECHECK.txt", 'wb') as DATECHECK: 
        DATECHECK.write(CURRENT_GMTDAY) 

       print "Completed" 

      else: 
       pass 
     else: 
      pass 

    except Exception: 
     print "Error..." 
     sleep(60) 

EDIT 31/03/2016

Lasst uns sagen, dass ich hinzufügen, die folgende

SCRIPTS = ["script1.test()", "script2.test()", "script3.test()"] 
MAIN_SCRIPT = "script1.test()" 
TIME_DIFFERENCE = datetime.strptime(END_TIME, "%H:%M") - datetime.strptime(START_TIME, "%H:%M") 
TIME_DIFFERENCE = TIME_DIFFERENCE.seconds 

• Wir haben jetzt die die Anzahl der Skripte
• Wir haben die Liste des Skript ausführen zu laufen.
• wir den Namen des Haupt-Skript haben, auf die eine erste laufen.
• Wir haben die Zeit in Sekunden, wie viel Zeit wir in alle Skripte auszuführen haben insgesamt zu zeigen.

Sicherlich gibt es einen Weg, eine Art Schleife nur anschließen kann, um sie zu machen alles tun ..

• for i in range(len(SCRIPTS)), die
3fache
• 3 Samen erzeugen, wobei das Minimum um sicherzustellen, Es ist von 300 und alle zusammen die drei Samen darf nicht mehr als TIME_DIFFERENCE
• die Startzeit auf RUN_TIME = START_TIME Basis erstellen und dann RUN_TIME = RUN_TIME + SEED[i]
• Erste Schleife woul d überprüfe, dass MAIN_SCRIPT innerhalb SCRIPTS existiert, wenn es dann das Skript zuerst ausführen würde, lösche es sich von SCRIPTS und dann auf nächsten Schleifen, da es in SCRIPTS nicht existiert, würde es wahllos auf eines der anderen Skripte wechseln.obwohl

die Zeiten Seeding

Die folgende scheint zu funktionieren, könnte es einen einfacheren Weg, dies zu tun sein.

CALCULATE_SEEDS = 0 
NEW_SEED = 0 
SEEDS_SUCESSS = False 
SEEDS = [] 

while SEEDS_SUCESSS == False: 
    # Generate a new seed number 
    NEW_SEED = random.randrange(0, TIME_DIFFERENCE) 

    # Make sure the seed is above the minimum number 
    if NEW_SEED > 300: 
     SEEDS.append(NEW_SEED) 

    # Make sure we have the same amount of seeds as scripts before continuing. 
    if len(SEEDS) == len(SCRIPTS): 

     # Calculate all of the seeds together 
     for SEED in SEEDS: 
      CALCULATE_SEEDS += SEED 
     # Make sure the calculated seeds added together is smaller than the total time difference 
     if CALCULATE_SEEDS >= TIME_DIFFERENCE: 
      # Reset and try again if it's not below the number 
      SEEDS = [] 
     else: 
      # Exit while loop if we have a correct amount of seeds with minimum times. 
      SEEDS_SUCESSS = True 

Answer 1

Verwenden datetime.timedelta Zeitdifferenzen zu berechnen. Dieser Code geht davon alle drei Prozesse am selben Tag laufen

from datetime import datetime, timedelta 
from random import randint 

YR, MO, DY = 2016, 3, 30 
START_TIME = datetime(YR, MO, DY, 1, 21, 00) # "01:21" 
END_TIME = datetime(YR, MO, DY, 3, 0, 0)  # "3:00" 
duration_all = (END_TIME - START_TIME).seconds 
d1 = (duration_all - 600) // 3   
#  
rnd1 = randint(0,d1) 
rnd2 = rnd1 + 300 + randint(0,d1) 
rnd3 = rnd2 + 300 + randint(0,d1) 
#  
time1 = START_TIME + timedelta(seconds=rnd1) 
time2 = START_TIME + timedelta(seconds=rnd2) 
time3 = START_TIME + timedelta(seconds=rnd3) 
# 
print (time1) 
print (time2) 
print (time3) 

Werte von rnd1, rnd2 und rnd3 sind mindestens 5 Minuten (300 Sekunden) auseinander.

Werte von rnd3 können nicht größer sein als das Gesamtintervall (3 * d1 + 600). Also treten alle drei Male innerhalb des Intervalls auf.

Hinweis: Sie haben nicht angegeben, wie lange jedes Skript ausgeführt wird. Deshalb habe ich time.sleep nicht verwendet. Eine mögliche Option wäre threading.Timer (siehe Python-Dokumentation).

Answer 2

Angenommen, Sie speichern alle Methoden.func() in einem Array, und nachfolgende Skripts müssen mindestens 5 Minuten nach script1 liegen. Sie können nach dem Zufallsprinzip ausgeführt werden, sodass wir mehrere Prozesse starten und sie für einen bestimmten Zeitraum schlafen lassen können, bevor sie automatisch gestartet werden können. (Timing ist in Sekunden)

from multiprocessing import Process 
import os 
import random 
import time 
#store all scripts you want to execute here 
eval_scripts = ["script1.test()","script2.test()", "script3.test()"] 

#run job on different processes. non-blocking 
def run_job(eval_string,time_sleep): 
    #print out script + time to test 
    print eval_string + " " + str(time_sleep) 
    time.sleep(time_sleep) #wait to be executed 
    #time to start 
    eval(eval_string) 


def do_my_jobs(): 
    start_time = [] 
    #assume the duration between start_time and end_time is 60 mins, leave some time for other jobs after the first job (5-10 mins). This is just to be careful in case random.randrange returns the largest number 
    #adjust this according to the duration between start_time and end_time since calculating (end_time - star_time) is trivial. 
    proc1_start_time = random.randrange(60*60 - 10*60) 
    start_time.append(proc1_start_time) 
    #randomize timing for other procs != first script 
    for i in range(len(eval_scripts)-1): 
      #randomize time from (proc1_start_time + 5 mins) to (end_time - star_time) 
      start_time.append(random.randint(proc1_start_time+5*60, 60*60)) 

    for i in range(len(eval_scripts)): 
      p_t = Process(target = run_job, args = (eval_scripts[i],start_time[i],)) 
      p_t.start() 
      p_t.join() 

Alles was Sie jetzt tun müssen, ist do_my_jobs() aufzurufen, nur einmal am START_TIME jeden Tag.