o haA@sdZddlZddlZddlZddlZddlZddlZedZGddde Z Gddde Z Gdd d e Z e Z e jZdd d Zd dZdddZdddZddZddZddZdS)a Python job scheduling for humans. github.com/dbader/schedule 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(5).to(10).days.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] https://adam.herokuapp.com/past/2010/4/13/rethinking_cron/ [2] https://github.com/Rykian/clockwork [3] https://adam.herokuapp.com/past/2010/6/30/replace_cron_with_clockwork/ Nschedulec@seZdZdZdS) CancelJobz: Can be returned from a job to unschedule itself. N)__name__ __module__ __qualname____doc__rrC/var/www/html/env/lib/python3.10/site-packages/schedule/__init__.pyr2src@sfeZdZdZddZddZdddZdd d Zd d ZdddZ ddZ e ddZ e ddZ d S) Schedulerz Objects instantiated by the :class:`Scheduler ` are factories to create jobs, keep record of scheduled jobs and handle their execution. cCs g|_dSNjobsselfrrr __init__?s zScheduler.__init__cCs,dd|jD}t|D]}||q dS)at 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. css|]}|jr|VqdSr ) should_run.0jobrrr Lsz(Scheduler.run_pending..N)r sorted_run_job)r runnable_jobsrrrr run_pendingBs  zScheduler.run_pendingrcCs@tdt|j||jddD] }||t|qdS)a4 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. :param delay_seconds: A delay added between every executed job z.Running *all* %i jobs with %is delay inbetweenN)loggerinfolenr rtimesleep)r delay_secondsrrrr run_allPs   zScheduler.run_allNcs:dur |jdd=dSfdd|jD|jdd<dS)z Deletes scheduled jobs marked with the given tag, or all jobs if tag is omitted. :param tag: An identifier used to identify a subset of jobs to delete Nc3s|] }|jvr|VqdSr )tagsrtagrr rksz"Scheduler.clear..r )rr#rr"r clear`s"zScheduler.clearcCs(z |j|WdStyYdSw)zX Delete a scheduled job. :param job: The job to be unscheduled N)r remove ValueError)rrrrr cancel_jobms  zScheduler.cancel_jobcCst||}|S)z Schedule a new periodic job. :param interval: A quantity of a certain time unit :return: An unconfigured :class:`Job ` )Job)rintervalrrrr everyxs zScheduler.everycCs,|}t|ts |tur||dSdSr )run isinstancerr')rrretrrr rszScheduler._run_jobcCs|jsdSt|jjS)zo Datetime when the next job should run. :return: A :class:`~datetime.datetime` object N)r minnext_runrrrr r0s zScheduler.next_runcCs|jtjS)zj :return: Number of seconds until :meth:`next_run `. )r0datetimenow total_secondsrrrr idle_secondsszScheduler.idle_secondsrr r()rrrrrrr r$r'r+rpropertyr0r4rrrr r 9s      r c@s2eZdZdZd9ddZddZddZed d Zed d Z ed dZ eddZ eddZ eddZ eddZeddZeddZeddZeddZedd Zed!d"Zed#d$Zed%d&Zed'd(Zed)d*Zd+d,Zd-d.Zd/d0Zd1d2Zed3d4Zd5d6Zd7d8ZdS):r)aW A periodic job as used by :class:`Scheduler`. :param interval: A quantity of a certain time unit :param scheduler: The :class:`Scheduler ` instance that this job will register itself with once it has been fully configured in :meth:`Job.do()`. Every job runs at a given fixed time interval that is defined by: * a :meth:`time unit ` * a quantity of `time units` defined by `interval` A job is usually created and returned by :meth:`Scheduler.every` method, which also defines its `interval`. NcCsH||_d|_d|_d|_d|_d|_d|_d|_d|_t |_ ||_ dSr ) r*latestjob_funcunitat_timelast_runr0period start_daysetr! scheduler)rr*r@rrr rs z Job.__init__cCs |j|jkS)z^ PeriodicJobs are sortable based on the scheduled time they run next. )r0)rotherrrr __lt__s z Job.__lt__cCs dd}d||j||jf}t|jdr|jj}nt|j}dd|jjD}dd|jjD}|dd ||d }|j dur^d |j |j d krU|j dd n|j |j ||fSd|j durfdndd}|t|j |j |j d kr}|j dd n|j ||dS)NcSs|r|dSdS)Nz%Y-%m-%d %H:%M:%Sz[never])strftime)trrr format_timesz!Job.__repr__..format_timez(last run: %s, next run: %s)rcSsg|]}t|qSrrepr)rxrrr sz Job.__repr__..cSs g|] \}}d|t|fqS)z%s=%srF)rkvrrr rIs(z, )zEvery %s %s at %s do %s %sr(zEvery %(interval)s zto %(latest)s z'%(unit)s do %(call_repr)s %(timestats)s)r*r8r: call_repr timestats)r<r0hasattrr9rrGargskeywordsitemsjoinr;r*r:r8dict)rrErQ job_func_namerSkwargsrPfmtrrr __repr__s>     z Job.__repr__cC|jdks Jd|jS)Nr(zUse seconds instead of second)r*secondsrrrr secondz Job.secondcC d|_|S)Nr]r:rrrr r]z Job.secondscCr\)Nr(zUse minutes instead of minute)r*minutesrrrr minuter_z Job.minutecCr`)Nrcrarrrr rcrbz Job.minutescCr\)Nr(zUse hours instead of hour)r*hoursrrrr hourr_zJob.hourcCr`)Nrerarrrr rerbz Job.hourscCr\)Nr(zUse days instead of day)r*daysrrrr dayr_zJob.daycCr`)Nrgrarrrr rgrbzJob.dayscCr\)Nr(zUse weeks instead of week)r*weeksrrrr week r_zJob.weekcCr`)Nrirarrrr rirbz Job.weekscC|jdks Jdd|_|jS)Nr(zUse mondays instead of mondaymondayr*r>rirrrr rlz Job.mondaycCrk)Nr(zUse tuesdays instead of tuesdaytuesdayrmrrrr rornz Job.tuesdaycCrk)Nr(z"Use wedesdays instead of wednesday wednesdayrmrrrr rp"rnz Job.wednesdaycCrk)Nr(z Use thursday instead of thursdaythursdayrmrrrr rq(rnz Job.thursdaycCrk)Nr(zUse fridays instead of fridayfridayrmrrrr rr.rnz Job.fridaycCrk)Nr(z!Use saturdays instead of saturdaysaturdayrmrrrr rs4rnz Job.saturdaycCrk)Nr(zUse sundays instead of sundaysundayrmrrrr rt:rnz Job.sundaycGsDtdd|Dr tdtdd|Dstd|j||S)z Tags the job with one or more unique indentifiers. Tags must be hashable. Duplicate tags are discarded. :param tags: A unique list of ``Hashable`` tags. :return: The invoked job instance cSsg|] }t|tj qSrr- collectionsHashablerr#rrr rIIszJob.tag..zEvery tag should be hashablecss|] }t|tjVqdSr rurxrrr rLszJob.tag..zTags must be hashable)any TypeErrorallr!update)rr!rrr r#@s   zJob.tagcCs|jdvs |js J|d\}}t|}|jdks|jr0t|}d|kr,dks/JJn|jdkr7d}d|krBdksEJJt|||_|S)z Schedule the job every day at a specific time. Calling this is only valid for jobs scheduled to run every N day(s). :param time_str: A string in `XX:YY` format. :return: The invoked job instance rgre:rgrre;)r:r>splitintr1rr;)rtime_strrfrdrrr atQs  zJob.atcCs ||_|S)a Schedule the job to run at an irregular (randomized) interval. The job's interval will randomly vary from the value given to `every` to `latest`. The range defined is inclusive on both ends. For example, `every(A).to(B).seconds` executes the job function every N seconds such that A <= N <= B. :param latest: Maximum interval between randomized job runs :return: The invoked job instance )r8)rr8rrr togs zJob.tocOsZtj|g|Ri||_z t|j|Wn tyYnw||jj||S)a 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. :param job_func: The function to be scheduled :return: The invoked job instance ) functoolspartialr9update_wrapperAttributeError_schedule_next_runr@r append)rr9rSrYrrr dovs  zJob.docCstj|jkS)zA :return: ``True`` if the job should be run now. )r1r2r0rrrr rszJob.should_runcCs,td||}tj|_||S)zz Run the job and immediately reschedule it. :return: The return value returned by the `job_func` zRunning job %s)rrr9r1r2r<r)rr.rrr r,s  zJob.runcCs|jdvsJ|jdur|j|jksJt|j|j}n|j}tjdi|j|i|_tj|j|_ |j durl|jdksAJd}|j |vsJJ| |j }||j }|dkr_|d7}|j t||j7_ |j dur|jdvs}|j dus}J|j j|j jdd}|jd ks|j dur|j j|d <|j jdi||_ |jstj}|jd kr|j |kr|jd kr|j tjd d |_ n|jd kr|j j|jkr|j tjd d|_ |j dur|j dur|j tjjdkr|j |j8_ dSdSdSdS)zD Compute the instant when this job should run next. )r]rcrergriNri)rlrorprqrrrsrtrr})rdr^ microsecondrgrfr()rgre)rer)r:r8r*randomrandintr1 timedeltar=r2r0r>indexweekdayr;rdr^rfreplacer<rrg)rr*weekdaysr days_aheadrYr2rrr rsJ       zJob._schedule_next_runr ) rrrrrrBr[r7r^r]rdrcrfrerhrgrjrirlrorprqrrrsrtr#rrrrr,rrrrr r)s^  $                   r)r(cCs t|S)zmCalls :meth:`every ` on the :data:`default scheduler instance `. )default_schedulerr+)r*rrr r+s r+cCs tdS)zyCalls :meth:`run_pending ` on the :data:`default scheduler instance `. N)rrrrrr rs rcCstj|ddS)zqCalls :meth:`run_all ` on the :data:`default scheduler instance `. rN)rr rrrr r sr cCt|dS)zmCalls :meth:`clear ` on the :data:`default scheduler instance `. N)rr$r"rrr r$r$cCr)zwCalls :meth:`cancel_job ` on the :data:`default scheduler instance `. N)rr')rrrr r'rr'cCtjS)zsCalls :meth:`next_run ` on the :data:`default scheduler instance `. )rr0rrrr r0r0cCr)z{Calls :meth:`idle_seconds ` on the :data:`default scheduler instance `. )rr4rrrr r4 rr4r6r5r )rrvr1rloggingrr getLoggerrobjectrr r)rr r+rr r$r'r0r4rrrr s,' bC