Python schedule.run_pending() Examples

def schedule_with_delay(self):
        for task in self.tasks:
            interval = task.get('interval')
            schedule.every(interval).minutes.do(self.schedule_task_with_lock, task)
        while True:
            schedule.run_pending()
            time.sleep(1) 

def run():
	# Load all modules and print active list
	feeds = objects.Feeds()
	exporters = objects.Exporters()
	processors = objects.Processors()
	print "Active Modules:"
	feeds.print_list()
	processors.print_list()	
	exporters.print_list()

	print "\nStarting..."

	feeds.start()

	while True:
		try:
			schedule.run_pending()
		except Exception, e:
			print "Excepion running pending: %s" % (e)
		time.sleep(10) 

def _run(self):
        if self.args.run_mode == 'job':
            schedule.every().day.at('00:00').do(self._build_report)
            while True:
                schedule.run_pending()
                time.sleep(1)
        else:
            self._build_report(self.args.date) 

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

def handle(self, args):
        logger = IngestLogger()
        logger.info(
            "Starting Baleen v{} ingestion service every hour.".format(baleen.get_version())
        )

        schedule.every().hour.do(partial(self.ingest, args))

        while True:
            try:
                schedule.run_pending()
                time.sleep(1)
            except (KeyboardInterrupt, SystemExit):
                logger.info("Graceful shutdown of Baleen ingestion service.")
                return ""
            except Exception as e:
                logger.critical(str(e))
                return str(e) 

def handle(self, *args, **kwargs):

        logger.info("%s - starting jobs schedule" % (__name__))
            
        try:
            '''            
            schedule.every().hour.do(job_update_entities)
            schedule.every().hour.do(job_update_clients)
            schedule.every().hour.do(job_update_checks)
            schedule.every().hour.do(job_update_trends)
            #schedule.every(10).minutes.do(job_update_events)
            '''
            
            schedule.every(settings.CACHE_ENTITY_TTL).seconds.do(job_update_entities)
            schedule.every(settings.CACHE_CLIENT_TTL).seconds.do(job_update_clients)
            schedule.every(settings.CACHE_TRENDS_TTL).seconds.do(job_update_trends)
            
            
            while True:
                schedule.run_pending()
                sleep(1)

        except KeyboardInterrupt:
            logger.info("%s - user signal exit!" % (__name__))
            exit(0) 

def run_continuously(self, interval=1):
        """
        https://raw.githubusercontent.com/mrhwick/schedule/master/schedule/__init__.py
        """
        print("Started to run continuously")
        cease_continuous_run = Event()

        class ScheduleThread(Thread):
            @classmethod
            def run(cls):
                while not cease_continuous_run.is_set():
                    schedule.run_pending()
                    time.sleep(interval)

        continuous_thread = ScheduleThread()
        continuous_thread.start()
        return cease_continuous_run 

def __non_threaded_polling(self, schedule, none_stop=False, interval=0, timeout=3):
        logger.info('Started polling.')
        self._TeleBot__stop_polling.clear()
        error_interval = .25

        while not self._TeleBot__stop_polling.wait(interval):
            try:
                schedule.run_pending()
                self._TeleBot__retrieve_updates(timeout)
                error_interval = .25
            except apihelper.ApiException as e:
                logger.error(e)
                if not none_stop:
                    self._TeleBot__stop_polling.set()
                    logger.info("Exception occurred. Stopping.")
                else:
                    logger.info("Waiting for {0} seconds until retry".format(error_interval))
                    time.sleep(error_interval)
                    error_interval *= 2
            except KeyboardInterrupt:
                logger.info("KeyboardInterrupt received.")
                self._TeleBot__stop_polling.set()
                break

        logger.info('Stopped polling.') 

def main():
    try:
        smart_module = SmartModule()
        smart_module.asset.load_asset_info()
        smart_module.load_site_data()
        smart_module.discover()
        smart_module.load_influx_settings()
    except Exception as excpt:
        Log.exception("Error initializing Smart Module. %s.", excpt)

    while 1:
        try:
            time.sleep(0.5)
            schedule.run_pending()
        except Exception as excpt:
            Log.exception("Error in Smart Module main loop. %s.", excpt)
            break 

def schedule_main():
    print "Convert directory: %s" % config.UPLOADED_FILES_DEST
    convert()
    schedule.every(5).minutes.do(convert)
    while True:
        # print "."
        schedule.run_pending()
        time.sleep(1) 

def run_scheduler(self, name):
        self.engine_running = True
        log.info("**** running - %s" % name)
        while 1:
            schedule.run_pending()
            time.sleep(1)
            if self.stop_engine:
                break
        self.engine_running = False
        log.info("**** exiting - %s" % name) 

def scheduler_init (parent):
    '''
        Schedule Init

        Start the main loop for the internal scheduler that
        ticks every second.

        --
        @param  parent:int  The PID of the parent.

        @return void
    '''

    # Define the jobs to run at which intervals
    schedule.every().minute.do(Reminder.run_remind_once)
    schedule.every().minute.do(Reminder.run_remind_recurring)

    # Start the main thread, polling the schedules
    # every second
    while True:

        # Check if the current parent pid matches the original
        # parent that started us. If not, we should end.
        if os.getppid() != parent:
            logger.error(
                'Killing scheduler as it has become detached from parent PID.')

            sys.exit(1)

        # Run the schedule
        schedule.run_pending()
        time.sleep(1)

    return 

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

def _loop(self):
        while True:
            schedule.run_pending()
            time.sleep(.2) 

def startScheduler():
	log( LOG_LEVEL_INFO, CHILD_DEVICE_SCHEDULER, MSG_SUBTYPE_TEXT, "Started" )
	while True:
		if holdControl.state == "normal":
			with scheduleLock:
				log( LOG_LEVEL_DEBUG, CHILD_DEVICE_SCHEDULER, MSG_SUBTYPE_TEXT, "Running pending" )
				schedule.run_pending()

		time.sleep( 10 ) 

def schedule_thread_worker(schedule):
    ''' schedule thread, takes care of running processes in the future '''
    global CTRL_C
    logger.debug('Starting thread_worker')
    while not CTRL_C['STOP']:
        sys.stdout.flush()
        schedule.run_pending()
        time.sleep(1)
    logger.debug('Threading stop:{0}'.format(
        threading.current_thread().getName()))
    sys.exit() 

def run(self):
        schedule.every().day.at("21:00").do(self.tradeFunc)
        schedule.every().day.at("09:00").do(self.tradeFunc)

        while True:
            schedule.run_pending()
            logging.info('WAIT {} sec'.format(schedule.idle_seconds()))
            sleep(max(schedule.idle_seconds(), 1)) 

def run(self):
        schedule.every().day.at("14:55").do(self.marketFunc)

        while True:
            schedule.run_pending()
            logging.info('WAIT {} sec'.format(schedule.idle_seconds()))
            time.sleep(max(schedule.idle_seconds(), 1)) 

def refresh_task(ver_interval, spider_interval):
    schedule.every(ver_interval).minutes.do(refresh_proxy)
    schedule.every(spider_interval).minutes.do(crawl_proxy)

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

def run(output_directory: str) -> int:
        tlscanary_binary = "tlscanary"

        output_directory = os.path.abspath(output_directory)
        logger.info("Output directory is `%s`" % output_directory)

        symantec = SymantecJob(tlscanary_binary, os.path.join(output_directory))
        tlsdeprecation = TLSDeprecationJob(tlscanary_binary, os.path.join(output_directory))
        srcupdate = SrcUpdateJob(tlscanary_binary)

        # ####################################################################
        # Here's the the actual schedule #####################################
        # ####################################################################
        schedule.every(60).minutes.do(Scheduler.log_alive)
        schedule.every().monday.at("00:00").do(symantec.run)
        schedule.every().wednesday.at("00:00").do(tlsdeprecation.run)
        schedule.every().saturday.at("00:00").do(srcupdate.run)

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

        except KeyboardInterrupt:
            logger.critical("\nUser interrupt. Quitting...")
            return 10 

def refresh_task():
    schedule.every(CONFIG.SCHEDULED_DICT['SPIDER_INTERVAL']).minutes.do(start_spider)
    # schedule.every(CONFIG.SCHEDULED_DICT['NOVELS_INTERVAL']).minutes.do(update_all_books_schedule)

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

def schedule_tasks():
    get_module_logger(__name__).info("schedule report")    
    log.info("schedule report")
    schedule.every(60*4).minutes.do(run_balance_report)    
    #schedule.every().day.at("10:30").do(run_balance_report)
    while True:
        schedule.run_pending()
        time.sleep(1)
    
    #schedule.every().hour.do(job) 

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

def squid_conf_update(usage, interval):
    """Timertask for updating proxies for squid config file"""
    # client_logger.info('the updating task is starting...')
    client = SquidClient(usage)
    client.update_conf()
    schedule.every(interval).minutes.do(client.update_conf)
    while True:
        schedule.run_pending()
        time.sleep(1) 

def schedule_coro():
    while True:
        schedule.run_pending()
        await asyncio.sleep(1) 

def run_monitor(self):
        self.__monitor_flag.set()
        while self.__monitor_flag.isSet():
            schedule.run_pending()
            time.sleep(1)
            # self.__monitor_flag.wait()
            if schedule.next_run is not None:
                self.auto_status.set(u'运行中...\n下次运行时间：\n %s\n当前时间:\n %s' % (schedule.next_run(), datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
            else:
                self.auto_status.set(u'状态：无任务')

        self.auto_status.set(u'状态：停止') 

def _watch_config(config_path: str, directory_path: str):
    LOGGER.info("Starting DNSroboCert.")

    with tempfile.TemporaryDirectory() as workspace:
        runtime_config_path = os.path.join(workspace, "dnsrobocert-runtime.yml")

        schedule.every().day.at("12:00").do(
            _renew_job, config_path=runtime_config_path, directory_path=directory_path
        )
        schedule.every().day.at("00:00").do(
            _renew_job, config_path=runtime_config_path, directory_path=directory_path
        )

        daemon = _Daemon()
        previous_digest = ""
        while not daemon.do_shutdown():
            schedule.run_pending()

            try:
                generated_config_path = legacy.migrate(config_path)
                effective_config_path = (
                    generated_config_path if generated_config_path else config_path
                )
                digest = utils.digest(effective_config_path)

                if digest != previous_digest:
                    previous_digest = digest
                    _process_config(
                        effective_config_path, directory_path, runtime_config_path
                    )
            except BaseException as error:
                LOGGER.error("An error occurred during DNSroboCert watch:")
                LOGGER.error(error)
                traceback.print_exc(file=sys.stderr)

            time.sleep(1)

    LOGGER.info("Exiting DNSroboCert.") 

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

def run_schedule(self):
        while 1:
            schedule.run_pending()
            time.sleep(1) 

def main():
    # width = pd.util.terminal.get_terminal_size() # find the width of the user's terminal window
    # rows, columns = os.popen('stty size', 'r').read().split()
    # pd.set_option('display.width', width[0]) # set that as the max width in Pandas
    # pd.set_option('display.width', int(columns)) # set that as the max width in Pandas

    set_schedule(config.strategy.portfolio_sync_time)

    if "--now" in sys.argv:
        sync_trades()

    if "--quit" not in sys.argv:
        while True:
            schedule.run_pending()
            sleep(1)