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 __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, 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 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, 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,
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, **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 test_text_timezone(self):
returned = convert_to_datetime('2009-8-1', 'UTC', None)
assert returned == datetime(2009, 8, 1, tzinfo=pytz.utc)
def __init__(self, run_date):
self.run_date = convert_to_datetime(run_date)
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 _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 __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 setUpClass(cls):
cls.datestr1 = '2017-10-30 12:03:36'
cls.date1 = convert_to_datetime(cls.datestr1, get_localzone(),
'run_date')
def setUpClass(cls):
cls.datestr1 = '2017-10-30 12:03:36'
cls.date1 = convert_to_datetime(cls.datestr1, get_localzone(), 'run_date')
