Comment puis-je obtenir un Cron comme planificateur en Python?

Si vous êtes à la recherche de quelque chose de léger, la caisse l'annexe:

import schedule
import time

def job():
    print("I'm working...")

schedule.every(10).minutes.do(job)
schedule.every().hour.do(job)
schedule.every().day.at("10:30").do(job)

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

Divulgation: je suis l'auteur de la bibliothèque.

OriginalL'auteur dbader

peut-être que c'est seulement après que la question a été posée; j'ai pensé que je viens de mentionner par souci d'exhaustivité: https://apscheduler.readthedocs.org/en/latest/

OriginalL'auteur ssc

"... Crontab module pour la lecture et l'écriture de fichiers crontab et de l'accès au système de cron automatiquement et simplement à l'aide directe de l'API. ..."

http://pypi.python.org/pypi/python-crontab

et aussi APScheduler, un paquet python. Déjà écrit & débogué.

http://packages.python.org/APScheduler/cronschedule.html

OriginalL'auteur bootload

Plus ou moins la même que ci-dessus mais simultanées à l'aide de gevent 🙂

"""Gevent based crontab implementation"""
from datetime import datetime, timedelta
import gevent
# Some utility classes /functions first
def conv_to_set(obj):
"""Converts to set allowing single integer to be provided"""
if isinstance(obj, (int, long)):
return set([obj])  # Single item
if not isinstance(obj, set):
obj = set(obj)
return obj
class AllMatch(set):
"""Universal set - match everything"""
def __contains__(self, item): 
return True
allMatch = AllMatch()
class Event(object):
"""The Actual Event Class"""
def __init__(self, action, minute=allMatch, hour=allMatch, 
day=allMatch, month=allMatch, daysofweek=allMatch, 
args=(), kwargs={}):
self.mins = conv_to_set(minute)
self.hours = conv_to_set(hour)
self.days = conv_to_set(day)
self.months = conv_to_set(month)
self.daysofweek = conv_to_set(daysofweek)
self.action = action
self.args = args
self.kwargs = kwargs
def matchtime(self, t1):
"""Return True if this event should trigger at the specified datetime"""
return ((t1.minute     in self.mins) and
(t1.hour       in self.hours) and
(t1.day        in self.days) and
(t1.month      in self.months) and
(t1.weekday()  in self.daysofweek))
def check(self, t):
"""Check and run action if needed"""
if self.matchtime(t):
self.action(*self.args, **self.kwargs)
class CronTab(object):
"""The crontab implementation"""
def __init__(self, *events):
self.events = events
def _check(self):
"""Check all events in separate greenlets"""
t1 = datetime(*datetime.now().timetuple()[:5])
for event in self.events:
gevent.spawn(event.check, t1)
t1 += timedelta(minutes=1)
s1 = (t1 - datetime.now()).seconds + 1
print "Checking again in %s seconds" % s1
job = gevent.spawn_later(s1, self._check)
def run(self):
"""Run the cron forever"""
self._check()
while True:
gevent.sleep(60)
import os 
def test_task():
"""Just an example that sends a bell and asd to all terminals"""
os.system('echo asd | wall')  
cron = CronTab(
Event(test_task, 22, 1 ),
Event(test_task, 0, range(9,18,2), daysofweek=range(0,5)),
)
cron.run()

OriginalL'auteur Hackeron

Aucun de la liste des solutions de même tenter d'analyser un complexe cron planifier chaîne. Donc, voici ma version, à l'aide de croniter. Base résumé:

schedule = "*/5 * * * *" # Run every five minutes
nextRunTime = getNextCronRunTime(schedule)
while True:
roundedDownTime = roundDownTime()
if (roundedDownTime == nextRunTime):
####################################
### Do your periodic thing here. ###
####################################
nextRunTime = getNextCronRunTime(schedule)
elif (roundedDownTime > nextRunTime):
# We missed an execution. Error. Re initialize.
nextRunTime = getNextCronRunTime(schedule)
sleepTillTopOfNextMinute()

Routines d'assistance:

from croniter import croniter
from datetime import datetime, timedelta
# Round time down to the top of the previous minute
def roundDownTime(dt=None, dateDelta=timedelta(minutes=1)):
roundTo = dateDelta.total_seconds()
if dt == None : dt = datetime.now()
seconds = (dt - dt.min).seconds
rounding = (seconds+roundTo/2) // roundTo * roundTo
return dt + timedelta(0,rounding-seconds,-dt.microsecond)
# Get next run time from now, based on schedule specified by cron string
def getNextCronRunTime(schedule):
return croniter(schedule, datetime.now()).get_next(datetime)
# Sleep till the top of the next minute
def sleepTillTopOfNextMinute():
t = datetime.utcnow()
sleeptime = 60 - (t.second + t.microsecond/1000000.0)
time.sleep(sleeptime)

OriginalL'auteur rouble

J'ai une correction mineure pour la CronTab de la classe de la méthode proposée par Brian.

Le timing était par une seconde conduisant à une seconde, dur boucle à la fin de chaque minute.

class CronTab(object):
def __init__(self, *events):
self.events = events
def run(self):
t=datetime(*datetime.now().timetuple()[:5])
while 1:
for e in self.events:
e.check(t)
t += timedelta(minutes=1)
n = datetime.now()
while n < t:
s = (t - n).seconds + 1
time.sleep(s)
n = datetime.now()

OriginalL'auteur benc

Il n'y a pas un "pur python" façon de le faire, parce que certains processus aurait pour lancer python pour exécuter votre solution. Chaque plate-forme aura un ou vingt différentes façons de lancer des processus et de surveiller leurs progrès. Sur les plates-formes unix, cron est l'ancienne norme. Sur Mac OS X, il est également launchd, qui combine cron-lancement avec le chien de garde de la fonctionnalité qui permet de garder vos processus en vie si c'est ce que vous voulez. Une fois que python est en cours d'exécution, vous pouvez utiliser le sched module pour planifier des tâches.

OriginalL'auteur Nick

Brian solution fonctionne assez bien. Cependant, comme d'autres l'ont souligné, il existe une subtile bug dans le code d'exécution. Aussi je l'ai trouvé trop compliqué pour les besoins.

Voici mon plus simple et fonctionnelle alternative pour les exécuter du code dans le cas où quelqu'un en a besoin:

def run(self):
while 1:
t = datetime.now()
for e in self.events:
e.check(t)
time.sleep(60 - t.second - t.microsecond / 1000000.0)

OriginalL'auteur raph.amiard

Si vous êtes à la recherche d'un distribué planificateur, vous pouvez consulter https://github.com/sherinkurian/mani - il ne faut redis si donc peut-être pas ce que vous cherchez. (notez que je suis l'auteur)
cela a été construit pour assurer la tolérance aux pannes par avoir de l'horloge fonctionner sur plus d'un nœud.

OriginalL'auteur shrnkrn

J'ai pris de Brian solution, a fait quelques changements, ajouté les débuts d'une norme crontab d'un analyseur de fichier, et de le mettre à https://bitbucket.org/dbenamy/devcron.

OriginalL'auteur Dan Benamy

Si le script que vous souhaitez exécuter sur le web, vous pourriez envisager d'utiliser un 3e tiers de services, tels que crono, à configurer par programmation de vos travaux.

OriginalL'auteur gduverger

Méthode de Crontab sur le Serveur.

Python nom de fichier hello.py

Etape 1: Créer un fichier sh laisser donner le nom s.sh

python3 /home/ubuntu/Shaurya/Folder/hello.py > /home/ubuntu/Shaurya/Folder/log.txt 2>,&1

Etape 2: Ouvrez Le Crontab De L'Éditeur

crontab -e

Etape 3: Ajouter Le Temps D'Horaire

Utilisation Crontab Mise En Forme

2 * * * * sudo sh /home/ubuntu/Shaurya/Folder/s.sh

Ce cron se lancer “À la minute 2.”

OriginalL'auteur shaurya uppal