Размышляем на тему Python + Cron

Пока я не придумал ничего лучше, чем Cron. И, дабы не переписывать расписание, настроенного под Linux на Windows, меня устроила бы обертка того и другого..., например python-crontab.
Всего здесь с десяток ссылок ...для дальнейших размышлений...

schedule 0.3.1
Frequently asked questions on the usage of schedule
15.3. time — Time access and conversions
8.1. datetime — Basic date and time types
8.2. calendar — General calendar-related functions
Advanced Python Scheduler Among other things, APScheduler can be used as a cross-platform, application specific replacement to platform specific schedulers, such as the cron daemon or the Windows task scheduler.
CronHowto
11 Cron Scheduling Task Examples in Linux
A visual crontab utility
python-crontab 1.9.3 - Crontab module for read and writing crontab files and accessing the system cron automatically and simply using a direct API.

Python job scheduling for humans.

An in-process scheduler for periodic jobs that uses the builder pattern for configuration. Schedule lets you run Python functions (or any other callable) periodically at pre-determined intervals using a simple, human-friendly syntax.

In [ ]:

pip install schedule

In [3]:

import schedule
import time

In [5]:

time.clock()

Out[5]:

0.58

In [ ]:

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)
schedule.every().monday.do(job)
schedule.every().wednesday.at("13:15").do(job)

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

In [10]:

!crontab -help

crontab: invalid option -- 'h'
crontab: usage error: unrecognized option
usage: crontab [-u user] file
 crontab [ -u user ] [ -i ] { -e | -l | -r }
  (default operation is replace, per 1003.2)
 -e (edit user's crontab)
 -l (list user's crontab)
 -r (delete user's crontab)
 -i (prompt before deleting user's crontab)

In [11]:

!crontab -l

no crontab for kiss

In [ ]:

!man crontab

In [ ]:

CRONTAB(1)                                                          CRONTAB(1)

NAME
       crontab - maintain crontab files for individual users (Vixie Cron)

SYNOPSIS
       crontab [ -u user ] file
       crontab [ -u user ] [ -i ] { -e | -l | -r }

DESCRIPTION
       crontab  is  the  program used to install, deinstall or list the tables
       used to drive the cron(8) daemon in Vixie Cron.   Each  user  can  have
       their    own    crontab,    and    though    these    are    files   in
       /var/spool/cron/crontabs, they are not intended to be edited directly.

       If the /etc/cron.allow file exists, then you must be listed  (one  user
       per  line)  therein in order to be allowed to use this command.  If the
       /etc/cron.allow file does not exist but the  /etc/cron.deny  file  does
       exist,  then you must not be listed in the /etc/cron.deny file in order
       to use this command.

       If neither of these files exists, then depending on site-dependent con‐
       figuration  parameters, only the super user will be allowed to use this
       command, or all users will be able to use this command.

       If both files exist then /etc/cron.allow takes precedence. Which  means
       that  /etc/cron.deny  is not considered and your user must be listed in
       /etc/cron.allow in order to be able to use the crontab.

       Regardless of the existance of any of these files, the root administra‐
       tive  user  is  always allowed to setup a crontab.  For standard Debian
       systems, all users may use this command.

       If the -u option is given, it specifies the  name  of  the  user  whose
       crontab  is  to  be  used (when listing) or modified (when editing). If
       this option is not given, crontab examines "your"  crontab,  i.e.,  the
       crontab  of the person executing the command.  Note that su(8) can con‐
       fuse crontab and that if you are running inside  of  su(8)  you  should
       always use the -u option for safety's sake.
    
 The  first  form  of this command is used to install a new crontab from
       some named file or standard  input  if  the  pseudo-filename  ``-''  is
       given.

       The  -l  option  causes the current crontab to be displayed on standard
       output. See the note under DEBIAN SPECIFIC below.

       The -r option causes the current crontab to be removed.

       The -e option is used to edit the  current  crontab  using  the  editor
       specified  by  the  VISUAL  or EDITOR environment variables.  After you
       exit from the editor, the modified crontab will be installed  automati‐
       cally.  If  neither  of  the environment variables is defined, then the
       default editor /usr/bin/editor is used.

       The -i option modifies the -r option to prompt the  user  for  a  'y/Y'
       response before actually removing the crontab.

DEBIAN SPECIFIC
       The  "out-of-the-box"  behaviour for crontab -l is to display the three
       line "DO NOT EDIT THIS FILE" header that is placed at the beginning  of
       the  crontab  when  it  is  installed. The problem is that it makes the
       sequence

       crontab -l | crontab -

       non-idempotent -- you keep adding copies of  the  header.  This  causes
       pain  to scripts that use sed to edit a crontab. Therefore, the default
       behaviour of the -l option has been changed to not output such  header.
       You  may obtain the original behaviour by setting the environment vari‐
       able CRONTAB_NOHEADER to 'N', which will cause the crontab  -l  command
       to emit the extraneous header.

SEE ALSO
       crontab(5), cron(8)
FILES
       /etc/cron.allow
       /etc/cron.deny
       /var/spool/cron/crontabs

       There    is    one   file   for   each   user's   crontab   under   the
       /var/spool/cron/crontabs directory. Users are not allowed to  edit  the
       files  under  that directory directly to ensure that only users allowed
       by the system to run periodic tasks can add them,  and  only  syntacti‐
       cally correct crontabs will be written there.  This is enforced by hav‐
       ing the directory writable only by the crontab  group  and  configuring
       crontab command with the setgid bid set for that specific group.

STANDARDS
       The  crontab command conforms to IEEE Std1003.2-1992 (``POSIX'').  This
       new command syntax differs from previous versions  of  Vixie  Cron,  as
       well as from the classic SVR3 syntax.

DIAGNOSTICS
       A  fairly  informative  usage  message appears if you run it with a bad
       command line.

       cron requires that each entry in a crontab end in a newline  character.
       If  the  last entry in a crontab is missing the newline, cron will con‐
       sider the crontab (at least partially) broken and refuse to install it.

AUTHOR
       Paul Vixie <paul@vix.com> is the author of cron and original creator of
       this  manual page. This page has also been modified for Debian by Steve
       Greenland, Javier Fernandez-Sanguino and Christian Kastner.

4th Berkeley Distribution        19 April 2010                      CRONTAB(1)
 Manual page crontab(1) line 70/114 (END) (press h for help or q to quit)

In [2]:

help(schedule)

Help on package schedule:

NAME
    schedule - Python job scheduling for humans.

FILE
    /usr/local/lib/python2.7/dist-packages/schedule/__init__.py

DESCRIPTION
    An in-process scheduler for periodic jobs that uses the builder pattern
    for configuration. Schedule lets you run Python functions (or any other
    callable) periodically at pre-determined intervals using a simple,
    human-friendly syntax.
    
    Inspired by Addam Wiggins' article "Rethinking Cron" [1] and the
    "clockwork" Ruby module [2][3].
    
    Features:
        - A simple to use API for scheduling jobs.
        - Very lightweight and no external dependencies.
        - Excellent test coverage.
        - Works with Python 2.7 and 3.3
    
    Usage:
        >>> import schedule
        >>> import time
    
        >>> def job(message='stuff'):
        >>>     print("I'm working on:", message)
    
        >>> schedule.every(10).minutes.do(job)
        >>> schedule.every().hour.do(job, message='things')
        >>> schedule.every().day.at("10:30").do(job)
    
        >>> while True:
        >>>     schedule.run_pending()
        >>>     time.sleep(1)
    
    [1] http://adam.heroku.com/past/2010/4/13/rethinking_cron/
    [2] https://github.com/tomykaira/clockwork
    [3] http://adam.heroku.com/past/2010/6/30/replace_cron_with_clockwork/

PACKAGE CONTENTS


CLASSES
    __builtin__.object
        CancelJob
        Job
        Scheduler
    
    class CancelJob(__builtin__.object)
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class Job(__builtin__.object)
     |  A periodic job as used by `Scheduler`.
     |  
     |  Methods defined here:
     |  
     |  __init__(self, interval)
     |  
     |  __lt__(self, other)
     |      PeriodicJobs are sortable based on the scheduled time
     |      they run next.
     |  
     |  __repr__(self)
     |  
     |  at(self, time_str)
     |      Schedule the job every day at a specific time.
     |      
     |      Calling this is only valid for jobs scheduled to run every
     |      N day(s).
     |  
     |  do(self, job_func, *args, **kwargs)
     |      Specifies the job_func that should be called every time the
     |      job runs.
     |      
     |      Any additional arguments are passed on to job_func when
     |      the job runs.
     |  
     |  run(self)
     |      Run the job and immediately reschedule it.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  day
     |  
     |  days
     |  
     |  friday
     |  
     |  hour
     |  
     |  hours
     |  
     |  minute
     |  
     |  minutes
     |  
     |  monday
     |  
     |  saturday
     |  
     |  second
     |  
     |  seconds
     |  
     |  should_run
     |      True if the job should be run now.
     |  
     |  sunday
     |  
     |  thursday
     |  
     |  tuesday
     |  
     |  wednesday
     |  
     |  week
     |  
     |  weeks
    
    class Scheduler(__builtin__.object)
     |  Methods defined here:
     |  
     |  __init__(self)
     |  
     |  cancel_job(self, job)
     |      Delete a scheduled job.
     |  
     |  clear(self)
     |      Deletes all scheduled jobs.
     |  
     |  every(self, interval=1)
     |      Schedule a new periodic job.
     |  
     |  run_all(self, delay_seconds=0)
     |      Run all jobs regardless if they are scheduled to run or not.
     |      
     |      A delay of `delay` seconds is added between each job. This helps
     |      distribute system load generated by the jobs more evenly
     |      over time.
     |  
     |  run_pending(self)
     |      Run all jobs that are scheduled to run.
     |      
     |      Please note that it is *intended behavior that tick() does not
     |      run missed jobs*. For example, if you've registered a job that
     |      should run every minute and you only call tick() in one hour
     |      increments then your job won't be run 60 times in between but
     |      only once.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  idle_seconds
     |      Number of seconds until `next_run`.
     |  
     |  next_run
     |      Datetime when the next job should run.

FUNCTIONS
    cancel_job(job)
        Delete a scheduled job.
    
    clear()
        Deletes all scheduled jobs.
    
    every(interval=1)
        Schedule a new periodic job.
    
    idle_seconds()
        Number of seconds until `next_run`.
    
    next_run()
        Datetime when the next job should run.
    
    run_all(delay_seconds=0)
        Run all jobs regardless if they are scheduled to run or not.
        
        A delay of `delay` seconds is added between each job. This can help
        to distribute the system load generated by the jobs more evenly over
        time.
    
    run_pending()
        Run all jobs that are scheduled to run.
        
        Please note that it is *intended behavior that run_pending()
        does not run missed jobs*. For example, if you've registered a job
        that should run every minute and you only call run_pending()
        in one hour increments then your job won't be run 60 times in
        between but only once.

DATA
    default_scheduler = <schedule.Scheduler object>
    jobs = []
    logger = <logging.Logger object>

Посты чуть ниже также могут вас заинтересовать