def __init__(self, weeks=0, days=0, hours=0, minutes=0, seconds=0, start_date=None, end_date=None, timezone=None): self.interval = timedelta(weeks=weeks, days=days, hours=hours, minutes=minutes, seconds=seconds) self.interval_length = timedelta_seconds(self.interval) if self.interval_length == 0: self.interval = timedelta(seconds=1) self.interval_length = 1 if timezone: self.timezone = astimezone(timezone) elif start_date and start_date.tzinfo: self.timezone = start_date.tzinfo elif end_date and end_date.tzinfo: self.timezone = end_date.tzinfo else: self.timezone = get_localzone() start_date = start_date or (datetime.now(self.timezone) + self.interval) self.start_date = convert_to_datetime(start_date, self.timezone, 'start_date') self.end_date = convert_to_datetime(end_date, self.timezone, 'end_date')
def __init__(self, min_interval, max_interval=None, start_date=None): if not isinstance(min_interval, timedelta): raise TypeError('min_interval must be a timedelta') if max_interval and not isinstance(max_interval, timedelta): raise TypeError('max_interval must be a timedelta') if start_date: start_date = convert_to_datetime(start_date) self.min_interval = min_interval self.min_interval_length = timedelta_seconds(self.min_interval) if self.min_interval_length == 0: self.min_interval = timedelta(seconds=1) self.min_interval_length = 1 self.max_interval = max_interval self.max_interval_length = None if max_interval: self.max_interval_length = timedelta_seconds(self.max_interval) if self.max_interval_length == 0: self.max_interval = timedelta(seconds=1) self.max_interval_length = 1 if(self.max_interval and self.min_interval_length > self.max_interval_length): raise ValueError("min_interval < max_interval") self.next_max_date = None if start_date is None: self.next_min_date = datetime.now() if(self.max_interval): self.next_max_date = datetime.now() + self.max_interval else: self.next_min_date = convert_to_datetime(start_date) if(self.max_interval): self.next_max_date = self.next_min_date + self.max_interval
def __init__(self, year=None, month=None, day=None, week=None, day_of_week=None, hour=None, minute=None, second=None, start_date=None, end_date=None, timezone=None): if timezone: self.timezone = astimezone(timezone) elif start_date and start_date.tzinfo: self.timezone = start_date.tzinfo elif end_date and end_date.tzinfo: self.timezone = end_date.tzinfo else: self.timezone = get_localzone() self.start_date = convert_to_datetime(start_date, self.timezone, 'start_date') self.end_date = convert_to_datetime(end_date, self.timezone, 'end_date') values = dict((key, value) for (key, value) in six.iteritems(locals()) if key in self.FIELD_NAMES and value is not None) self.fields = [] assign_defaults = False for field_name in self.FIELD_NAMES: if field_name in values: exprs = values.pop(field_name) is_default = False assign_defaults = not values elif assign_defaults: exprs = DEFAULT_VALUES[field_name] is_default = True else: exprs = '*' is_default = True field_class = self.FIELDS_MAP[field_name] field = field_class(field_name, exprs, is_default) self.fields.append(field)
def __init__(self, min_interval, max_interval=None, start_date=None): if not isinstance(min_interval, timedelta): raise TypeError('min_interval must be a timedelta') if max_interval and not isinstance(max_interval, timedelta): raise TypeError('max_interval must be a timedelta') if start_date: start_date = convert_to_datetime(start_date) self.min_interval = min_interval self.min_interval_length = timedelta_seconds(self.min_interval) if self.min_interval_length == 0: self.min_interval = timedelta(seconds=1) self.min_interval_length = 1 self.max_interval = max_interval self.max_interval_length = None if max_interval: self.max_interval_length = timedelta_seconds(self.max_interval) if self.max_interval_length == 0: self.max_interval = timedelta(seconds=1) self.max_interval_length = 1 if (self.max_interval and self.min_interval_length > self.max_interval_length): raise ValueError("min_interval < max_interval") self.next_max_date = None if start_date is None: self.next_min_date = datetime.now() if (self.max_interval): self.next_max_date = datetime.now() + self.max_interval else: self.next_min_date = convert_to_datetime(start_date) if (self.max_interval): self.next_max_date = self.next_min_date + self.max_interval
def __init__(self, year=None, month=None, day=None, week=None, day_of_week=None, hour=None, minute=None, second=None, start_date=None, end_date=None, timezone=None): if timezone: self.timezone = astimezone(timezone) elif isinstance(start_date, datetime) and start_date.tzinfo: self.timezone = start_date.tzinfo elif isinstance(end_date, datetime) and end_date.tzinfo: self.timezone = end_date.tzinfo else: self.timezone = get_localzone() self.start_date = convert_to_datetime(start_date, self.timezone, 'start_date') self.end_date = convert_to_datetime(end_date, self.timezone, 'end_date') values = dict((key, value) for (key, value) in six.iteritems(locals()) if key in self.FIELD_NAMES and value is not None) self.fields = [] assign_defaults = False for field_name in self.FIELD_NAMES: if field_name in values: exprs = values.pop(field_name) is_default = False assign_defaults = not values elif assign_defaults: exprs = DEFAULT_VALUES[field_name] is_default = True else: exprs = '*' is_default = True field_class = self.FIELDS_MAP[field_name] field = field_class(field_name, exprs, is_default) self.fields.append(field)
def __init__(self, year=None, month=None, day=None, week=None, day_of_week=None, hour=None, minute=None, second=None, start_date=None, end_date=None, timezone=None, offset=None): if timezone: self.timezone = astimezone(timezone) elif isinstance(start_date, datetime) and start_date.tzinfo: self.timezone = start_date.tzinfo elif isinstance(end_date, datetime) and end_date.tzinfo: self.timezone = end_date.tzinfo else: self.timezone = get_localzone() self.start_date = convert_to_datetime(start_date, self.timezone, 'start_date') self.end_date = convert_to_datetime(end_date, self.timezone, 'end_date') if offset is None: self.offset = timedelta(seconds=0) elif isinstance(offset, timedelta): self.offset = offset elif isinstance(offset, six.integer_types): self.offset = timedelta(seconds=offset) else: try: self.offset = timedelta(seconds=int(offset)) except: raise TypeError('Invalid offset: {0!r}'.format(offset)) values = dict((key, value) for (key, value) in six.iteritems(locals()) if key in self.FIELD_NAMES and value is not None) self.fields = [] assign_defaults = False for field_name in self.FIELD_NAMES: if field_name in values: exprs = values.pop(field_name) is_default = False assign_defaults = not values elif assign_defaults: exprs = DEFAULT_VALUES[field_name] is_default = True else: exprs = '*' is_default = True field_class = self.FIELDS_MAP[field_name] field = field_class(field_name, exprs, is_default) self.fields.append(field)
def GetLocalDtRange(cls, schedule_mdl): local_start, local_stop = None, None if 'timezone' in schedule_mdl: tz_obj = pytz.timezone(schedule_mdl['timezone']) if 'local_start_time' in schedule_mdl: local_start = aps_util.convert_to_datetime( schedule_mdl['local_start_time'], tz_obj, '') if 'local_stop_time' in schedule_mdl: local_stop = aps_util.convert_to_datetime( schedule_mdl['local_stop_time'], tz_obj, '').replace(hour=23, minute=59, second=59) return local_start, local_stop
def __init__(self, interval, start_date=None): if not isinstance(interval, timedelta): raise TypeError('interval must be a timedelta') if start_date: start_date = convert_to_datetime(start_date) self.interval = interval self.interval_length = timedelta_seconds(self.interval) if self.interval_length == 0: self.interval = timedelta(seconds=1) self.interval_length = 1 if start_date is None: self.start_date = datetime.now() + self.interval else: self.start_date = convert_to_datetime(start_date)
def __init__(self, **values): self.start_date = values.pop('start_date', None) if self.start_date: self.start_date = convert_to_datetime(self.start_date) # Check field names and yank out all None valued fields for key, value in list(iteritems(values)): if key not in self.FIELD_NAMES: raise TypeError('Invalid field name: %s' % key) if value is None: del values[key] self.fields = [] assign_defaults = False for field_name in self.FIELD_NAMES: if field_name in values: exprs = values.pop(field_name) is_default = False assign_defaults = not values elif assign_defaults: exprs = DEFAULT_VALUES[field_name] is_default = True else: exprs = '*' is_default = True field_class = self.FIELDS_MAP[field_name] field = field_class(field_name, exprs, is_default) self.fields.append(field)
def test_date(self, timezone, input, expected): returned = convert_to_datetime(input, timezone, None) if expected is not None: assert isinstance(returned, datetime) expected = timezone.localize(expected) if not expected.tzinfo else expected assert returned == expected
def __init__(self, defaults, run_date, timezone=None): """ Triggers once on the given datetime. :param run_date: the date/time to run the job at :param timezone: time zone for ``run_date`` :type timezone: str or an instance of a :cls:`~datetime.tzinfo` subclass """ timezone = timezone or defaults['timezone'] self.run_date = convert_to_datetime(run_date, timezone, 'run_date')
def __init__(self, months=0, weeks=0, days=0, day=None, day_of_week=None, hour=0, minute=0, second=0, start_date=None, end_date=None, timezone=None, jitter=None): # Pre-requisites assert not (start_date is None) # Extract timezone info if timezone: self.timezone = timezone elif isinstance(start_date, datetime) and start_date.tzinfo: self.timezone = start_date.tzinfo elif isinstance(end_date, datetime) and end_date.tzinfo: self.timezone = end_date.tzinfo else: self.timezone = get_localzone() self.start_date = convert_to_datetime(start_date, self.timezone, 'start_date') self.end_date = convert_to_datetime(end_date, self.timezone, 'end_date') # Compute interval self.interval = relativedelta(months=months, weeks=weeks, days=days) # Cron trigger self.day = day self.day_of_week = day_of_week self.time = time(hour=hour, minute=minute, second=second) # Jitter will be applied on final output self.jitter = jitter
def __init__(self, **values): self.start_date = values.pop('start_date', None) if self.start_date: self.start_date = convert_to_datetime(self.start_date) self.fields = [] for field_name in self.FIELD_NAMES: if field_name in values: exprs = values.pop(field_name) is_default = False elif not values: exprs = DEFAULT_VALUES[field_name] is_default = True else: exprs = '*' is_default = True field_class = self.FIELDS_MAP[field_name] field = field_class(field_name, exprs, is_default) self.fields.append(field)
def __init__(self, defaults, year=None, month=None, day=None, week=None, day_of_week=None, hour=None, minute=None, second=None, start_date=None, timezone=None): """ Triggers when current time matches all specified time constraints, emulating the UNIX cron scheduler. :param year: year to run on :param month: month to run on :param day: day of month to run on :param week: week of the year to run on :param day_of_week: weekday to run on (0 = Monday) :param hour: hour to run on :param second: second to run on :param start_date: earliest possible date/time to trigger on :param timezone: time zone for ``start_date`` :type timezone: str or an instance of a :cls:`~datetime.tzinfo` subclass """ self.timezone = timezone or defaults['timezone'] self.start_date = convert_to_datetime(start_date, self.timezone, 'start_date') if start_date else None values = dict((key, value) for (key, value) in iteritems(locals()) if key in self.FIELD_NAMES and value is not None) self.fields = [] assign_defaults = False for field_name in self.FIELD_NAMES: if field_name in values: exprs = values.pop(field_name) is_default = False assign_defaults = not values elif assign_defaults: exprs = DEFAULT_VALUES[field_name] is_default = True else: exprs = '*' is_default = True field_class = self.FIELDS_MAP[field_name] field = field_class(field_name, exprs, is_default) self.fields.append(field)
def __init__(self, defaults, weeks=0, days=0, hours=0, minutes=0, seconds=0, start_date=None, timezone=None): """ Triggers on specified intervals. :param weeks: number of weeks to wait :param days: number of days to wait :param hours: number of hours to wait :param minutes: number of minutes to wait :param seconds: number of seconds to wait :param start_date: when to first execute the job and start the counter (default is after the given interval) :param timezone: time zone for ``start_date`` :type timezone: str or an instance of a :cls:`~datetime.tzinfo` subclass """ timezone = timezone or defaults['timezone'] self.interval = timedelta(weeks=weeks, days=days, hours=hours, minutes=minutes, seconds=seconds) self.interval_length = timedelta_seconds(self.interval) if self.interval_length == 0: self.interval = timedelta(seconds=1) self.interval_length = 1 if start_date is None: self.start_date = datetime.now(timezone) + self.interval else: self.start_date = convert_to_datetime(start_date, timezone, 'start_date')
def __init__(self, run_date): self.run_date = convert_to_datetime(run_date)
def test_text_timezone(self): returned = convert_to_datetime('2009-8-1', 'UTC', None) assert returned == datetime(2009, 8, 1, tzinfo=pytz.utc)
def _modify(self, **changes): """ Validates the changes to the Job and makes the modifications if and only if all of them validate. """ approved = {} if 'id' in changes: value = changes.pop('id') if not isinstance(value, six.string_types): raise TypeError("id must be a nonempty string") if hasattr(self, 'id'): raise ValueError('The job ID may not be changed') approved['id'] = value if 'func' in changes or 'args' in changes or 'kwargs' in changes: func = changes.pop('func') if 'func' in changes else self.func args = changes.pop('args') if 'args' in changes else self.args kwargs = changes.pop( 'kwargs') if 'kwargs' in changes else self.kwargs if isinstance(func, six.string_types): func_ref = func func = ref_to_obj(func) elif callable(func): try: func_ref = obj_to_ref(func) except ValueError: # If this happens, this Job won't be serializable func_ref = None else: raise TypeError( 'func must be a callable or a textual reference to one') if not hasattr(self, 'name') and changes.get('name', None) is None: changes['name'] = get_callable_name(func) if isinstance(args, six.string_types) or not isinstance(args, Iterable): raise TypeError('args must be a non-string iterable') if isinstance(kwargs, six.string_types) or not isinstance(kwargs, Mapping): raise TypeError('kwargs must be a dict-like object') check_callable_args(func, args, kwargs) approved['func'] = func approved['func_ref'] = func_ref approved['args'] = args approved['kwargs'] = kwargs if 'name' in changes: value = changes.pop('name') if not value or not isinstance(value, six.string_types): raise TypeError("name must be a nonempty string") approved['name'] = value if 'misfire_grace_time' in changes: value = changes.pop('misfire_grace_time') if value is not None and (not isinstance(value, six.integer_types) or value <= 0): raise TypeError( 'misfire_grace_time must be either None or a positive integer' ) approved['misfire_grace_time'] = value if 'coalesce' in changes: value = bool(changes.pop('coalesce')) approved['coalesce'] = value if 'max_instances' in changes: value = changes.pop('max_instances') if not isinstance(value, six.integer_types) or value <= 0: raise TypeError('max_instances must be a positive integer') approved['max_instances'] = value if 'trigger' in changes: trigger = changes.pop('trigger') if not isinstance(trigger, BaseTrigger): raise TypeError('Expected a trigger instance, got %s instead' % trigger.__class__.__name__) approved['trigger'] = trigger if 'executor' in changes: value = changes.pop('executor') if not isinstance(value, six.string_types): raise TypeError('executor must be a string') approved['executor'] = value if 'next_run_time' in changes: value = changes.pop('next_run_time') approved['next_run_time'] = convert_to_datetime( value, self._scheduler.timezone, 'next_run_time') if 'ip' in changes: value = changes.pop('ip') if not isinstance(value, six.string_types): raise TypeError('ip must be a string') approved['ip'] = value if changes: raise AttributeError( 'The following are not modifiable attributes of Job: %s' % ', '.join(changes)) for key, value in six.iteritems(approved): setattr(self, key, value)
def __init__(self, run_date=None, timezone=None): timezone = astimezone(timezone) or get_localzone() if run_date is not None: self.run_date = convert_to_datetime(run_date, timezone, 'run_date') else: self.run_date = datetime.now(timezone)
def __init__(self, run_date=None, timezone=None): timezone = astimezone(timezone) or get_localzone() self.run_date = convert_to_datetime(run_date or datetime.now(), timezone, 'run_date')
def _modify(self, **changes): """Validates the changes to the Job and makes the modifications if and only if all of them validate.""" approved = {} if 'id' in changes: value = changes.pop('id') if not isinstance(value, six.string_types): raise TypeError("id must be a nonempty string") if hasattr(self, 'id'): raise ValueError('The job ID may not be changed') approved['id'] = value if 'func' in changes or 'args' in changes or 'kwargs' in changes: func = changes.pop('func') if 'func' in changes else self.func args = changes.pop('args') if 'args' in changes else self.args kwargs = changes.pop('kwargs') if 'kwargs' in changes else self.kwargs if isinstance(func, str): func_ref = func func = ref_to_obj(func) elif callable(func): try: func_ref = obj_to_ref(func) except ValueError: # If this happens, this Job won't be serializable func_ref = None else: raise TypeError('func must be a callable or a textual reference to one') if not hasattr(self, 'name') and changes.get('name', None) is None: changes['name'] = get_callable_name(func) if isinstance(args, six.string_types) or not isinstance(args, Iterable): raise TypeError('args must be a non-string iterable') if isinstance(kwargs, six.string_types) or not isinstance(kwargs, Mapping): raise TypeError('kwargs must be a dict-like object') check_callable_args(func, args, kwargs) approved['func'] = func approved['func_ref'] = func_ref approved['args'] = args approved['kwargs'] = kwargs if 'name' in changes: value = changes.pop('name') if not value or not isinstance(value, six.string_types): raise TypeError("name must be a nonempty string") approved['name'] = value if 'misfire_grace_time' in changes: value = changes.pop('misfire_grace_time') if value is not None and (not isinstance(value, six.integer_types) or value <= 0): raise TypeError('misfire_grace_time must be either None or a positive integer') approved['misfire_grace_time'] = value if 'coalesce' in changes: value = bool(changes.pop('coalesce')) approved['coalesce'] = value if 'max_instances' in changes: value = changes.pop('max_instances') if not isinstance(value, six.integer_types) or value <= 0: raise TypeError('max_instances must be a positive integer') approved['max_instances'] = value if 'trigger' in changes: trigger = changes.pop('trigger') if not isinstance(trigger, BaseTrigger): raise TypeError('Expected a trigger instance, got %s instead' % trigger.__class__.__name__) approved['trigger'] = trigger if 'executor' in changes: value = changes.pop('executor') if not isinstance(value, six.string_types): raise TypeError('executor must be a string') approved['executor'] = value if 'next_run_time' in changes: value = changes.pop('next_run_time') approved['next_run_time'] = convert_to_datetime(value, self._scheduler.timezone, 'next_run_time') if changes: raise AttributeError('The following are not modifiable attributes of Job: %s' % ', '.join(changes)) for key, value in six.iteritems(approved): setattr(self, key, value)
def setUpClass(cls): cls.datestr1 = '2017-10-30 12:03:36' cls.date1 = convert_to_datetime(cls.datestr1, get_localzone(), 'run_date')