def test_match(self): self.assertTrue( croniter.match("0 0 * * *", datetime(2019, 1, 14, 0, 0, 0, 0))) self.assertFalse( croniter.match("0 0 * * *", datetime(2019, 1, 14, 0, 1, 0, 0))) self.assertTrue( croniter.match("31 * * * *", datetime(2019, 1, 14, 1, 31, 0, 0)))
def test_match(self): self.assertTrue( croniter.match("0 0 * * *", datetime(2019, 1, 14, 0, 0, 0, 0))) self.assertFalse( croniter.match("0 0 * * *", datetime(2019, 1, 14, 0, 1, 0, 0))) self.assertTrue( croniter.match("31 * * * *", datetime(2019, 1, 14, 1, 31, 0, 0))) self.assertTrue( croniter.match("0 0 10 * wed", datetime(2020, 6, 10, 0, 0, 0, 0), day_or=True)) self.assertTrue( croniter.match("0 0 10 * fri", datetime(2020, 6, 10, 0, 0, 0, 0), day_or=True)) self.assertTrue( croniter.match("0 0 10 * fri", datetime(2020, 6, 12, 0, 0, 0, 0), day_or=True)) self.assertTrue( croniter.match("0 0 10 * wed", datetime(2020, 6, 10, 0, 0, 0, 0), day_or=False)) self.assertFalse( croniter.match("0 0 10 * fri", datetime(2020, 6, 10, 0, 0, 0, 0), day_or=False)) self.assertFalse( croniter.match("0 0 10 * fri", datetime(2020, 6, 12, 0, 0, 0, 0), day_or=False))
def check(self, text_preprocessing_result: BaseTextPreprocessingResult, user: BaseUser, params: Dict[str, Any] = None) -> bool: message_time_dict = user.message.payload['meta']['time'] message_timestamp_sec = message_time_dict['timestamp'] // 1000 message_datetime = datetime.fromtimestamp(message_timestamp_sec) return croniter.match(self.match_cron, message_datetime)
async def tick(self): current = self._now() for k, v in self.userdata.items(): if croniter.match(v["schedule"], current): cmd = v["command"] ch = self.bot.get_channel(v["channel_id"]) await ch.send(f"{cmd}") logger.debug(f"Runned `{cmd}`.") presence_type = ActivityType.listening await self.bot.change_presence(activity=Activity(type=presence_type, name="Cron"), status=None) logger.debug("tick")
def timer_active_check(cls, time_spec, now): """Check if the given time matches the time specification.""" results = {"+": [], "-": []} for entry in time_spec if isinstance(time_spec, list) else [time_spec]: this_match = False negate = False active_str = entry.strip() if active_str.startswith("not"): negate = True active_str = active_str.replace("not ", "") cron_match = re.match(r"cron\((?P<cron_expr>.*)\)", active_str) range_expr = re.match(r"range\(([^,]+),\s?([^,]+)\)", active_str) if cron_match: if not croniter.is_valid(cron_match.group("cron_expr")): _LOGGER.error("Invalid cron expression: %s", cron_match) return False this_match = croniter.match(cron_match.group("cron_expr"), now) elif range_expr: try: dt_start, dt_end = range_expr.groups() except ValueError as exc: _LOGGER.error("Invalid range expression: %s", exc) return False start = cls.parse_date_time(dt_start.strip(), 0, now) end = cls.parse_date_time(dt_end.strip(), 0, start) if start < end: this_match = start <= now <= end else: # Over midnight this_match = now >= start or now <= end if negate: results["-"].append(not this_match) else: results["+"].append(this_match) # An empty spec, or only neg specs, is True result = any( results["+"]) if results["+"] else True and all(results["-"]) return result
def execution_time_iterator(self, start_timestamp): check.float_param(start_timestamp, "start_timestamp") timezone_str = ( self.execution_timezone if self.execution_timezone else pendulum.now().timezone.name ) start_datetime = pendulum.from_timestamp(start_timestamp, tz=timezone_str) date_iter = croniter(self.cron_schedule, start_datetime) # Go back one iteration so that the next iteration is the first time that is >= start_datetime # and matches the cron schedule date_iter.get_prev(datetime.datetime) while True: next_date = pendulum.instance(date_iter.get_next(datetime.datetime)).in_tz(timezone_str) # During DST transitions, croniter returns datetimes that don't actually match the # cron schedule, so add a guard here if croniter.match(self.cron_schedule, next_date): yield next_date
def handle(self, *args, **options): # wait until :00 second now = timezone.localtime() wait_secs = 59 - now.second print('Current time: %s, wait for %s seconds' % (now.isoformat(), wait_secs)) sleep(wait_secs) while True: # query every minute now = timezone.localtime() print('Current time: %s, check tasks..' % now.isoformat()) tasks = Task.objects.filter(enabled=True) for task in tasks: if croniter.match(task.cron, now): # play task print(' task %s (%s) matches, text=%s' % (task.id, task.cron, task.text)) play_mp3(task.voice_file()) sleep(60)
def launch_scheduled_runs_for_schedule( instance, logger, schedule_state, repo_location, end_datetime_utc, max_catchup_runs, debug_crash_flags=None, ): check.inst_param(instance, "instance", DagsterInstance) check.inst_param(schedule_state, "schedule_state", ScheduleState) check.inst_param(end_datetime_utc, "end_datetime_utc", datetime.datetime) check.inst_param(repo_location, "repo_location", RepositoryLocation) latest_tick = instance.get_latest_tick(schedule_state.schedule_origin_id) if not latest_tick: start_timestamp_utc = schedule_state.start_timestamp elif latest_tick.status == ScheduleTickStatus.STARTED: # Scheduler was interrupted while performing this tick, re-do it start_timestamp_utc = latest_tick.timestamp else: start_timestamp_utc = latest_tick.timestamp + 1 schedule_name = schedule_state.name repo_dict = repo_location.get_repositories() check.invariant( len(repo_dict) == 1, "Reconstructed repository location should have exactly one repository", ) external_repo = next(iter(repo_dict.values())) external_schedule = external_repo.get_external_schedule(schedule_name) timezone_str = external_schedule.execution_timezone if not timezone_str: logger.error( "Scheduler could not run for {schedule_name} as it did not specify " "an execution_timezone in its definition.".format(schedule_name=schedule_name) ) return end_datetime = end_datetime_utc.in_tz(timezone_str) start_datetime = pendulum.from_timestamp(start_timestamp_utc, tz=timezone_str) date_iter = croniter(external_schedule.cron_schedule, start_datetime) tick_times = [] # Go back one iteration so that the next iteration is the first time that is >= start_datetime # and matches the cron schedule date_iter.get_prev(datetime.datetime) while True: next_date = pendulum.instance(date_iter.get_next(datetime.datetime)).in_tz(timezone_str) if next_date.timestamp() > end_datetime.timestamp(): break # During DST transitions, croniter returns datetimes that don't actually match the # cron schedule, so add a guard here if croniter.match(external_schedule.cron_schedule, next_date): tick_times.append(next_date) if not tick_times: logger.info("No new runs for {schedule_name}".format(schedule_name=schedule_name)) return if len(tick_times) > max_catchup_runs: logger.warn( "{schedule_name} has fallen behind, only launching {max_catchup_runs} runs".format( schedule_name=schedule_name, max_catchup_runs=max_catchup_runs ) ) tick_times = tick_times[-max_catchup_runs:] if len(tick_times) == 1: logger.info( "Launching run for {schedule_name} at {time}".format( schedule_name=schedule_name, time=tick_times[0].strftime(_SCHEDULER_DATETIME_FORMAT), ) ) else: logger.info( "Launching {num_runs} runs for {schedule_name} at the following times: {times}".format( num_runs=len(tick_times), schedule_name=schedule_name, times=", ".join([time.strftime(_SCHEDULER_DATETIME_FORMAT) for time in tick_times]), ) ) for tick_time in tick_times: schedule_time = pendulum.instance(tick_time).in_tz(timezone_str) schedule_timestamp = schedule_time.timestamp() if latest_tick and latest_tick.timestamp == schedule_timestamp: tick = latest_tick logger.info("Resuming previously interrupted schedule execution") else: tick = instance.create_schedule_tick( ScheduleTickData( schedule_origin_id=external_schedule.get_origin_id(), schedule_name=schedule_name, timestamp=schedule_timestamp, cron_schedule=external_schedule.cron_schedule, status=ScheduleTickStatus.STARTED, ) ) _check_for_debug_crash(debug_crash_flags, "TICK_CREATED") with ScheduleTickHolder(tick, instance, logger) as tick_holder: _check_for_debug_crash(debug_crash_flags, "TICK_HELD") _schedule_run_at_time( instance, logger, repo_location, external_repo, external_schedule, schedule_time, tick_holder, debug_crash_flags, )
def test_issue151(self): """.""" self.assertTrue( croniter.match("* * * * *", datetime(2019, 1, 14, 11, 0, 59, 999999)))
def should_execute(self): if not self.is_active: return False return croniter.match(self.schedule, datetime.utcnow())
def matchCron(t, cron): return croniter.match(cron, t)