def __init__(self,
dep_section,
context_start_point=None,
context_end_point=None):
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
recurrence_syntax = convert_old_cycler_syntax(
dep_section, start_point=self.context_start_point)
if not recurrence_syntax:
raise ValueError("ERROR: bad cycling sequence syntax: %s" %
dep_section)
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = recurrence_syntax
self.custom_point_parse_function = None
if SuiteSpecifics.DUMP_FORMAT == PREV_DATE_TIME_FORMAT:
self.custom_point_parse_function = point_parse
self.abbrev_util = CylcTimeParser(
self.context_start_point,
self.context_end_point,
num_expanded_year_digits=SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS,
dump_format=SuiteSpecifics.DUMP_FORMAT,
custom_point_parse_function=self.custom_point_parse_function,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE)
self.recurrence, excl_point = self.abbrev_util.parse_recurrence(
recurrence_syntax)
self.exclusion = ISO8601Point.from_nonstandard_string(
str(excl_point)) if excl_point else None
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
if self.exclusion:
self.value += '!' + str(self.exclusion)
def setUp(self):
self._start_point = "19991226T0930Z"
# Note: the following timezone will be Z-ified *after* truncation
# or offsets are applied.
self._end_point = "20010506T1200+0200"
self._parsers = {
0:
CylcTimeParser(
self._start_point, self._end_point,
CylcTimeParser.initiate_parsers(
assumed_time_zone=UTC_UTC_OFFSET_HOURS_MINUTES)),
2:
CylcTimeParser(
self._start_point, self._end_point,
CylcTimeParser.initiate_parsers(
num_expanded_year_digits=2,
assumed_time_zone=UTC_UTC_OFFSET_HOURS_MINUTES))
}
def init(num_expanded_year_digits=0, custom_dump_format=None, time_zone=None,
assume_utc=False, cycling_mode=None):
"""Initialise suite-setup-specific information."""
if cycling_mode in Calendar.default().MODES:
Calendar.default().set_mode(cycling_mode)
if time_zone is None:
if assume_utc:
time_zone = "Z"
time_zone_hours_minutes = (0, 0)
else:
time_zone = get_local_time_zone_format(TimeZoneFormatMode.reduced)
time_zone_hours_minutes = get_local_time_zone()
else:
time_zone_hours_minutes = TimePointDumper().get_time_zone(time_zone)
SuiteSpecifics.ASSUMED_TIME_ZONE = time_zone_hours_minutes
SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS = num_expanded_year_digits
if custom_dump_format is None:
if num_expanded_year_digits > 0:
SuiteSpecifics.DUMP_FORMAT = EXPANDED_DATE_TIME_FORMAT + time_zone
else:
SuiteSpecifics.DUMP_FORMAT = DATE_TIME_FORMAT + time_zone
else:
SuiteSpecifics.DUMP_FORMAT = custom_dump_format
if u"+X" not in custom_dump_format and num_expanded_year_digits:
raise IllegalValueError(
'cycle point format',
('cylc', 'cycle point format'),
SuiteSpecifics.DUMP_FORMAT
)
SuiteSpecifics.iso8601_parsers = CylcTimeParser.initiate_parsers(
dump_format=SuiteSpecifics.DUMP_FORMAT,
num_expanded_year_digits=num_expanded_year_digits,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE
)
(SuiteSpecifics.point_parser,
SuiteSpecifics.interval_parser,
SuiteSpecifics.recurrence_parser) = SuiteSpecifics.iso8601_parsers
SuiteSpecifics.abbrev_util = CylcTimeParser(
None, None, SuiteSpecifics.iso8601_parsers
)
def setUp(self):
self._start_point = "19991226T0930Z"
# Note: the following timezone will be Z-ified *after* truncation
# or offsets are applied.
self._end_point = "20010506T1200+0200"
self._parsers = {
0: CylcTimeParser(
self._start_point, self._end_point,
CylcTimeParser.initiate_parsers(
assumed_time_zone=UTC_UTC_OFFSET_HOURS_MINUTES
)
),
2: CylcTimeParser(
self._start_point, self._end_point,
CylcTimeParser.initiate_parsers(
num_expanded_year_digits=2,
assumed_time_zone=UTC_UTC_OFFSET_HOURS_MINUTES
)
)
}
def __init__(self,
dep_section,
context_start_point=None,
context_end_point=None):
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = dep_section
self.abbrev_util = CylcTimeParser(
self.context_start_point,
self.context_end_point,
num_expanded_year_digits=SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS,
dump_format=SuiteSpecifics.DUMP_FORMAT,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE)
self.recurrence, excl_point = self.abbrev_util.parse_recurrence(
dep_section)
self.exclusion = ISO8601Point.from_nonstandard_string(
str(excl_point)) if excl_point else None
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
if self.exclusion:
self.value += '!' + str(self.exclusion)
def init(num_expanded_year_digits=0,
custom_dump_format=None,
time_zone=None,
assume_utc=False,
cycling_mode=None):
"""Initialise suite-setup-specific information."""
SuiteSpecifics.interval_parser = DurationParser()
if cycling_mode in Calendar.default().MODES:
Calendar.default().set_mode(cycling_mode)
if time_zone is None:
if assume_utc:
time_zone = "Z"
time_zone_hours_minutes = (0, 0)
else:
time_zone = get_local_time_zone_format(reduced_mode=True)
time_zone_hours_minutes = get_local_time_zone()
else:
time_zone_hours_minutes = TimePointDumper().get_time_zone(time_zone)
SuiteSpecifics.ASSUMED_TIME_ZONE = time_zone_hours_minutes
SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS = num_expanded_year_digits
if custom_dump_format is None:
if num_expanded_year_digits > 0:
SuiteSpecifics.DUMP_FORMAT = EXPANDED_DATE_TIME_FORMAT + time_zone
else:
SuiteSpecifics.DUMP_FORMAT = DATE_TIME_FORMAT + time_zone
else:
SuiteSpecifics.DUMP_FORMAT = custom_dump_format
if u"+X" not in custom_dump_format and num_expanded_year_digits:
raise IllegalValueError('cycle point format',
('cylc', 'cycle point format'),
SuiteSpecifics.DUMP_FORMAT)
SuiteSpecifics.point_parser = TimePointParser(
allow_only_basic=False,
allow_truncated=True,
num_expanded_year_digits=SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS,
dump_format=SuiteSpecifics.DUMP_FORMAT,
assumed_time_zone=time_zone_hours_minutes)
custom_point_parse_function = None
if SuiteSpecifics.DUMP_FORMAT == PREV_DATE_TIME_FORMAT:
custom_point_parse_function = point_parse
SuiteSpecifics.abbrev_util = CylcTimeParser(
None,
None,
num_expanded_year_digits=SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS,
dump_format=SuiteSpecifics.DUMP_FORMAT,
custom_point_parse_function=custom_point_parse_function,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE)
def __init__(self, dep_section, context_start_point=None,
context_end_point=None):
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
recurrence_syntax = convert_old_cycler_syntax(
dep_section, start_point=self.context_start_point)
if not recurrence_syntax:
raise ValueError(
"ERROR: bad cycling sequence syntax: %s" % dep_section)
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = recurrence_syntax
self.custom_point_parse_function = None
if SuiteSpecifics.DUMP_FORMAT == PREV_DATE_TIME_FORMAT:
self.custom_point_parse_function = point_parse
self.abbrev_util = CylcTimeParser(
self.context_start_point, self.context_end_point,
num_expanded_year_digits=SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS,
dump_format=SuiteSpecifics.DUMP_FORMAT,
custom_point_parse_function=self.custom_point_parse_function,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE
)
self.recurrence, excl_point = self.abbrev_util.parse_recurrence(
recurrence_syntax)
self.exclusion = ISO8601Point.from_nonstandard_string(
str(excl_point)) if excl_point else None
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
if self.exclusion:
self.value += '!' + str(self.exclusion)
def init(num_expanded_year_digits=0, custom_dump_format=None, time_zone=None,
assume_utc=False, cycling_mode=None):
"""Initialise suite-setup-specific information."""
if cycling_mode in Calendar.default().MODES:
Calendar.default().set_mode(cycling_mode)
if time_zone is None:
if assume_utc:
time_zone = "Z"
time_zone_hours_minutes = (0, 0)
else:
time_zone = get_local_time_zone_format(TimeZoneFormatMode.reduced)
time_zone_hours_minutes = get_local_time_zone()
else:
time_zone_hours_minutes = TimePointDumper().get_time_zone(time_zone)
SuiteSpecifics.ASSUMED_TIME_ZONE = time_zone_hours_minutes
SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS = num_expanded_year_digits
if custom_dump_format is None:
if num_expanded_year_digits > 0:
SuiteSpecifics.DUMP_FORMAT = EXPANDED_DATE_TIME_FORMAT + time_zone
else:
SuiteSpecifics.DUMP_FORMAT = DATE_TIME_FORMAT + time_zone
else:
SuiteSpecifics.DUMP_FORMAT = custom_dump_format
if u"+X" not in custom_dump_format and num_expanded_year_digits:
raise IllegalValueError(
'cycle point format',
('cylc', 'cycle point format'),
SuiteSpecifics.DUMP_FORMAT
)
SuiteSpecifics.iso8601_parsers = CylcTimeParser.initiate_parsers(
dump_format=SuiteSpecifics.DUMP_FORMAT,
num_expanded_year_digits=num_expanded_year_digits,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE
)
(SuiteSpecifics.point_parser,
SuiteSpecifics.interval_parser,
SuiteSpecifics.recurrence_parser) = SuiteSpecifics.iso8601_parsers
SuiteSpecifics.abbrev_util = CylcTimeParser(
None, None, SuiteSpecifics.iso8601_parsers
)
def __init__(self, dep_section, context_start_point=None,
context_end_point=None):
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = dep_section
self.abbrev_util = CylcTimeParser(
self.context_start_point, self.context_end_point,
num_expanded_year_digits=SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS,
dump_format=SuiteSpecifics.DUMP_FORMAT,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE
)
self.recurrence, excl_point = self.abbrev_util.parse_recurrence(
dep_section)
self.exclusion = ISO8601Point.from_nonstandard_string(
str(excl_point)) if excl_point else None
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
if self.exclusion:
self.value += '!' + str(self.exclusion)
class ISO8601Sequence(SequenceBase):
"""A sequence of ISO8601 date time points separated by an interval."""
TYPE = CYCLER_TYPE_ISO8601
TYPE_SORT_KEY = CYCLER_TYPE_SORT_KEY_ISO8601
_MAX_CACHED_POINTS = 100
@classmethod
def get_async_expr(cls, start_point=None):
"""Express a one-off sequence at the initial cycle point."""
if start_point is None:
return "R1"
return "R1/" + str(start_point)
def __init__(self, dep_section, context_start_point=None,
context_end_point=None):
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
recurrence_syntax = convert_old_cycler_syntax(
dep_section, start_point=self.context_start_point)
if not recurrence_syntax:
raise ValueError(
"ERROR: bad cycling sequence syntax: %s" % dep_section)
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = recurrence_syntax
self.custom_point_parse_function = None
if SuiteSpecifics.DUMP_FORMAT == PREV_DATE_TIME_FORMAT:
self.custom_point_parse_function = point_parse
self.abbrev_util = CylcTimeParser(
self.context_start_point, self.context_end_point,
num_expanded_year_digits=SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS,
dump_format=SuiteSpecifics.DUMP_FORMAT,
custom_point_parse_function=self.custom_point_parse_function,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE
)
self.recurrence = self.abbrev_util.parse_recurrence(recurrence_syntax)
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
def get_interval(self):
"""Return the interval between points in this sequence."""
return self.step
def get_offset(self):
"""Deprecated: return the offset used for this sequence."""
return self.offset
def set_offset(self, offset):
"""Deprecated: alter state to offset the entire sequence."""
if self.recurrence.start_point is not None:
self.recurrence.start_point += interval_parse(str(offset))
if self.recurrence.end_point is not None:
self.recurrence.end_point += interval_parse(str(offset))
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.value = str(self.recurrence)
def is_on_sequence(self, point):
"""Return True if point is on-sequence."""
# Iterate starting at recent valid points, for speed.
for valid_point in reversed(self._cached_recent_valid_points):
if valid_point == point:
return True
if valid_point > point:
continue
next_point = valid_point
while next_point is not None and next_point < point:
next_point = self.get_next_point_on_sequence(next_point)
if next_point is None:
continue
if next_point == point:
return True
return self.recurrence.get_is_valid(point_parse(point.value))
def is_valid(self, point):
"""Return True if point is on-sequence and in-bounds."""
try:
return self._cached_valid_point_booleans[point.value]
except KeyError:
is_valid = self.is_on_sequence(point)
if (len(self._cached_valid_point_booleans) >
self._MAX_CACHED_POINTS):
self._cached_valid_point_booleans.popitem()
self._cached_valid_point_booleans[point.value] = is_valid
return is_valid
def get_prev_point(self, point):
"""Return the previous point < point, or None if out of bounds."""
# may be None if out of the recurrence bounds
res = None
prev_point = self.recurrence.get_prev(point_parse(point.value))
if prev_point:
res = ISO8601Point(str(prev_point))
if res == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
res, point)
return res
def get_nearest_prev_point(self, point):
"""Return the largest point < some arbitrary point."""
if self.is_on_sequence(point):
return self.get_prev_point(point)
p_iso_point = point_parse(point.value)
prev_iso_point = None
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point > p_iso_point:
# Technically, >=, but we already test for this above.
break
prev_iso_point = recurrence_iso_point
if prev_iso_point is None:
return None
nearest_point = ISO8601Point(str(prev_iso_point))
if nearest_point == point:
raise SequenceDegenerateError(
self.recurrence, SuiteSpecifics.DUMP_FORMAT,
nearest_point, point
)
return nearest_point
def get_next_point(self, point):
"""Return the next point > p, or None if out of bounds."""
try:
return ISO8601Point(self._cached_next_point_values[point.value])
except KeyError:
pass
# Iterate starting at recent valid points, for speed.
for valid_point in reversed(self._cached_recent_valid_points):
if valid_point >= point:
continue
next_point = valid_point
while next_point is not None and next_point <= point:
next_point = self.get_next_point_on_sequence(next_point)
if next_point is not None:
self._check_and_cache_next_point(point, next_point)
return next_point
# Iterate starting at the beginning.
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point > p_iso_point:
next_point = ISO8601Point(str(recurrence_iso_point))
self._check_and_cache_next_point(point, next_point)
return next_point
return None
def _check_and_cache_next_point(self, point, next_point):
"""Verify and cache the get_next_point return info."""
# Verify next_point != point.
if next_point == point:
raise SequenceDegenerateError(
self.recurrence, SuiteSpecifics.DUMP_FORMAT,
next_point, point
)
# Cache the answer for point -> next_point.
if (len(self._cached_next_point_values) >
self._MAX_CACHED_POINTS):
self._cached_next_point_values.popitem()
self._cached_next_point_values[point.value] = next_point.value
# Cache next_point as a valid starting point for this recurrence.
if (len(self._cached_next_point_values) >
self._MAX_CACHED_POINTS):
self._cached_recent_valid_points.pop(0)
self._cached_recent_valid_points.append(next_point)
def get_next_point_on_sequence(self, point):
"""Return the on-sequence point > point assuming that point is
on-sequence, or None if out of bounds."""
result = None
next_point = self.recurrence.get_next(point_parse(point.value))
if next_point:
result = ISO8601Point(str(next_point))
if result == point:
raise SequenceDegenerateError(
self.recurrence, SuiteSpecifics.DUMP_FORMAT,
point, result
)
return result
def get_first_point(self, point):
"""Return the first point >= to point, or None if out of bounds."""
try:
return ISO8601Point(self._cached_first_point_values[point.value])
except KeyError:
pass
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point >= p_iso_point:
first_point_value = str(recurrence_iso_point)
if (len(self._cached_first_point_values) >
self._MAX_CACHED_POINTS):
self._cached_first_point_values.popitem()
self._cached_first_point_values[point.value] = (
first_point_value)
return ISO8601Point(first_point_value)
return None
def get_start_point(self):
"""Return the first point in this sequence, or None."""
for recurrence_iso_point in self.recurrence:
return ISO8601Point(str(recurrence_iso_point))
return None
def get_stop_point(self):
"""Return the last point in this sequence, or None if unbounded."""
if (self.recurrence.repetitions is not None or (
(self.recurrence.start_point is not None or
self.recurrence.min_point is not None) and
(self.recurrence.end_point is not None or
self.recurrence.max_point is not None))):
for recurrence_iso_point in self.recurrence:
pass
return ISO8601Point(str(recurrence_iso_point))
return None
def __eq__(self, other):
# Return True if other (sequence) is equal to self.
if self.TYPE != other.TYPE:
return False
if self.value == other.value:
return True
return False
def __str__(self):
return self.value
class ISO8601Sequence(SequenceBase):
"""A sequence of ISO8601 date time points separated by an interval."""
TYPE = CYCLER_TYPE_ISO8601
TYPE_SORT_KEY = CYCLER_TYPE_SORT_KEY_ISO8601
_MAX_CACHED_POINTS = 100
@classmethod
def get_async_expr(cls, start_point=None):
"""Express a one-off sequence at the initial cycle point."""
if start_point is None:
return "R1"
return "R1/" + str(start_point)
def __init__(self,
dep_section,
context_start_point=None,
context_end_point=None):
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = dep_section
self.abbrev_util = CylcTimeParser(
self.context_start_point,
self.context_end_point,
num_expanded_year_digits=SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS,
dump_format=SuiteSpecifics.DUMP_FORMAT,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE)
self.recurrence, excl_point = self.abbrev_util.parse_recurrence(
dep_section)
self.exclusion = ISO8601Point.from_nonstandard_string(
str(excl_point)) if excl_point else None
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
if self.exclusion:
self.value += '!' + str(self.exclusion)
def get_interval(self):
"""Return the interval between points in this sequence."""
return self.step
def get_offset(self):
"""Deprecated: return the offset used for this sequence."""
return self.offset
def set_offset(self, offset):
"""Deprecated: alter state to offset the entire sequence."""
if self.recurrence.start_point is not None:
self.recurrence.start_point += interval_parse(str(offset))
if self.recurrence.end_point is not None:
self.recurrence.end_point += interval_parse(str(offset))
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.value = str(self.recurrence) + '!' + str(self.exclusion)
if self.exclusion:
self.value += '!' + str(self.exclusion)
def is_on_sequence(self, point):
"""Return True if point is on-sequence."""
# Iterate starting at recent valid points, for speed.
if self.exclusion and point == self.exclusion:
return False
for valid_point in reversed(self._cached_recent_valid_points):
if valid_point == point:
return True
if valid_point > point:
continue
next_point = valid_point
while next_point is not None and next_point < point:
next_point = self.get_next_point_on_sequence(next_point)
if next_point is None:
continue
if next_point == point:
return True
return self.recurrence.get_is_valid(point_parse(point.value))
def is_valid(self, point):
"""Return True if point is on-sequence and in-bounds."""
try:
return self._cached_valid_point_booleans[point.value]
except KeyError:
is_valid = self.is_on_sequence(point)
if (len(self._cached_valid_point_booleans) >
self._MAX_CACHED_POINTS):
self._cached_valid_point_booleans.popitem()
self._cached_valid_point_booleans[point.value] = is_valid
return is_valid
def get_prev_point(self, point):
"""Return the previous point < point, or None if out of bounds."""
# may be None if out of the recurrence bounds
res = None
prev_point = self.recurrence.get_prev(point_parse(point.value))
if prev_point:
res = ISO8601Point(str(prev_point))
if res == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT, res,
point)
if self.exclusion and res == self.exclusion:
return self.get_prev_point(res)
return res
def get_nearest_prev_point(self, point):
"""Return the largest point < some arbitrary point."""
if self.is_on_sequence(point):
return self.get_prev_point(point)
p_iso_point = point_parse(point.value)
p_iso_excl = None
if self.exclusion:
p_iso_excl = point_parse(self.exclusion.value)
prev_iso_point = None
for recurrence_iso_point in self.recurrence:
if (recurrence_iso_point > p_iso_point
or (p_iso_excl and recurrence_iso_point == p_iso_excl)):
# Technically, >=, but we already test for this above.
break
prev_iso_point = recurrence_iso_point
if prev_iso_point is None:
return None
nearest_point = ISO8601Point(str(prev_iso_point))
if nearest_point == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
nearest_point, point)
if self.exclusion and nearest_point == self.exclusion:
return self.get_prev_point(nearest_point)
return nearest_point
def get_next_point(self, point):
"""Return the next point > p, or None if out of bounds."""
try:
return ISO8601Point(self._cached_next_point_values[point.value])
except KeyError:
pass
# Iterate starting at recent valid points, for speed.
for valid_point in reversed(self._cached_recent_valid_points):
if valid_point >= point:
continue
next_point = valid_point
excluded = False
while next_point is not None and (next_point <= point or excluded):
excluded = False
next_point = self.get_next_point_on_sequence(next_point)
if next_point and next_point == self.exclusion:
excluded = True
if next_point is not None:
self._check_and_cache_next_point(point, next_point)
return next_point
# Iterate starting at the beginning.
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point > p_iso_point:
next_point = ISO8601Point(str(recurrence_iso_point))
if next_point and next_point == self.exclusion:
continue
self._check_and_cache_next_point(point, next_point)
return next_point
return None
def _check_and_cache_next_point(self, point, next_point):
"""Verify and cache the get_next_point return info."""
# Verify next_point != point.
if next_point == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
next_point, point)
# Cache the answer for point -> next_point.
if (len(self._cached_next_point_values) > self._MAX_CACHED_POINTS):
self._cached_next_point_values.popitem()
self._cached_next_point_values[point.value] = next_point.value
# Cache next_point as a valid starting point for this recurrence.
if (len(self._cached_next_point_values) > self._MAX_CACHED_POINTS):
self._cached_recent_valid_points.pop(0)
self._cached_recent_valid_points.append(next_point)
def get_next_point_on_sequence(self, point):
"""Return the on-sequence point > point assuming that point is
on-sequence, or None if out of bounds."""
result = None
next_point = self.recurrence.get_next(point_parse(point.value))
if next_point:
result = ISO8601Point(str(next_point))
if result == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
point, result)
if result and result == self.exclusion:
return self.get_next_point_on_sequence(result)
return result
def get_first_point(self, point):
"""Return the first point >= to point, or None if out of bounds."""
try:
return ISO8601Point(self._cached_first_point_values[point.value])
except KeyError:
pass
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point >= p_iso_point:
first_point_value = str(recurrence_iso_point)
ret = ISO8601Point(first_point_value)
if ret and ret == self.exclusion:
return self.get_next_point_on_sequence(ret)
if (len(self._cached_first_point_values) >
self._MAX_CACHED_POINTS):
self._cached_first_point_values.popitem()
self._cached_first_point_values[point.value] = (
first_point_value)
return ret
return None
def get_start_point(self):
"""Return the first point in this sequence, or None."""
for recurrence_iso_point in self.recurrence:
point = ISO8601Point(str(recurrence_iso_point))
if not self.exclusion or point != self.exclusion:
return point
return None
def get_stop_point(self):
"""Return the last point in this sequence, or None if unbounded."""
if (self.recurrence.repetitions is not None
or ((self.recurrence.start_point is not None
or self.recurrence.min_point is not None) and
(self.recurrence.end_point is not None
or self.recurrence.max_point is not None))):
curr = None
prev = None
for recurrence_iso_point in self.recurrence:
prev = curr
curr = recurrence_iso_point
ret = ISO8601Point(str(recurrence_iso_point))
if self.exclusion and ret == self.exclusion:
return ISO8601Point(str(prev))
return ret
return None
def __eq__(self, other):
# Return True if other (sequence) is equal to self.
if self.TYPE != other.TYPE:
return False
if self.value == other.value:
return True
return False
def __str__(self):
return self.value
def __init__(self,
dep_section,
context_start_point=None,
context_end_point=None):
SequenceBase.__init__(self, dep_section, context_start_point,
context_end_point)
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
elif isinstance(context_start_point, ISO8601Point):
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
elif isinstance(context_end_point, ISO8601Point):
self.context_end_point = context_end_point
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = dep_section
self.abbrev_util = CylcTimeParser(self.context_start_point,
self.context_end_point,
SuiteSpecifics.iso8601_parsers)
# Parse_recurrence returns an isodatetime TimeRecurrence object
# and a list of exclusion strings.
self.recurrence, excl_points = self.abbrev_util.parse_recurrence(
dep_section)
# Determine the exclusion start point and end point
try:
exclusion_start_point = ISO8601Point.from_nonstandard_string(
str(self.recurrence.start_point))
except ValueError:
exclusion_start_point = self.context_start_point
try:
exclusion_end_point = ISO8601Point.from_nonstandard_string(
str(self.recurrence.end_point))
except ValueError:
exclusion_end_point = self.context_end_point
self.exclusions = []
# Creating an exclusions object instead
if excl_points:
try:
self.exclusions = ISO8601Exclusions(excl_points,
exclusion_start_point,
exclusion_end_point)
except AttributeError:
pass
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
# Concatenate the strings in exclusion list
if self.exclusions:
self.value += '!' + str(self.exclusions)
class ISO8601Sequence(SequenceBase):
"""A sequence of ISO8601 date time points separated by an interval.
Note that an ISO8601Sequence object (may) contain
ISO8601ExclusionSequences"""
TYPE = CYCLER_TYPE_ISO8601
TYPE_SORT_KEY = CYCLER_TYPE_SORT_KEY_ISO8601
_MAX_CACHED_POINTS = 100
__slots__ = ('dep_section', 'context_start_point', 'context_end_point',
'offset', '_cached_first_point_values',
'_cached_next_point_values', '_cached_valid_point_booleans',
'_cached_recent_valid_points', 'spec', 'abbrev_util',
'recurrence', 'exclusions', 'step', 'value')
@classmethod
def get_async_expr(cls, start_point=None):
"""Express a one-off sequence at the initial cycle point."""
if start_point is None:
return "R1"
return "R1/" + str(start_point)
def __init__(self,
dep_section,
context_start_point=None,
context_end_point=None):
SequenceBase.__init__(self, dep_section, context_start_point,
context_end_point)
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
elif isinstance(context_start_point, ISO8601Point):
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
elif isinstance(context_end_point, ISO8601Point):
self.context_end_point = context_end_point
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = dep_section
self.abbrev_util = CylcTimeParser(self.context_start_point,
self.context_end_point,
SuiteSpecifics.iso8601_parsers)
# Parse_recurrence returns an isodatetime TimeRecurrence object
# and a list of exclusion strings.
self.recurrence, excl_points = self.abbrev_util.parse_recurrence(
dep_section)
# Determine the exclusion start point and end point
try:
exclusion_start_point = ISO8601Point.from_nonstandard_string(
str(self.recurrence.start_point))
except ValueError:
exclusion_start_point = self.context_start_point
try:
exclusion_end_point = ISO8601Point.from_nonstandard_string(
str(self.recurrence.end_point))
except ValueError:
exclusion_end_point = self.context_end_point
self.exclusions = []
# Creating an exclusions object instead
if excl_points:
try:
self.exclusions = ISO8601Exclusions(excl_points,
exclusion_start_point,
exclusion_end_point)
except AttributeError:
pass
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
# Concatenate the strings in exclusion list
if self.exclusions:
self.value += '!' + str(self.exclusions)
def get_interval(self):
"""Return the interval between points in this sequence."""
return self.step
def get_offset(self):
"""Deprecated: return the offset used for this sequence."""
return self.offset
def set_offset(self, i_offset):
"""Deprecated: alter state to i_offset the entire sequence."""
if self.recurrence.start_point is not None:
self.recurrence.start_point += interval_parse(str(i_offset))
if self.recurrence.end_point is not None:
self.recurrence.end_point += interval_parse(str(i_offset))
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.value = str(self.recurrence) + '!' + str(self.exclusions)
if self.exclusions:
self.value += '!' + str(self.exclusions)
def is_on_sequence(self, point):
"""Return True if point is on-sequence."""
# Iterate starting at recent valid points, for speed.
if self.exclusions and point in self.exclusions:
return False
for valid_point in reversed(self._cached_recent_valid_points):
if valid_point == point:
return True
if valid_point > point:
continue
next_point = valid_point
while next_point is not None and next_point < point:
next_point = self.get_next_point_on_sequence(next_point)
if next_point is None:
continue
if next_point == point:
return True
return self.recurrence.get_is_valid(point_parse(point.value))
def is_valid(self, point):
"""Return True if point is on-sequence and in-bounds."""
try:
return self._cached_valid_point_booleans[point.value]
except KeyError:
is_valid = self.is_on_sequence(point)
if (len(self._cached_valid_point_booleans) >
self._MAX_CACHED_POINTS):
self._cached_valid_point_booleans.popitem()
self._cached_valid_point_booleans[point.value] = is_valid
return is_valid
def get_prev_point(self, point):
"""Return the previous point < point, or None if out of bounds."""
# may be None if out of the recurrence bounds
res = None
prev_point = self.recurrence.get_prev(point_parse(point.value))
if prev_point:
res = ISO8601Point(str(prev_point))
if res == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT, res,
point)
# Check if res point is in the list of exclusions
# If so, check the previous point by recursion.
# Once you have found a point that is *not* in the exclusion
# list, you can return it.
if self.exclusions and res in self.exclusions:
return self.get_prev_point(res)
return res
def get_nearest_prev_point(self, point):
"""Return the largest point < some arbitrary point."""
if self.is_on_sequence(point):
return self.get_prev_point(point)
p_iso_point = point_parse(point.value)
prev_cycle_point = None
for recurrence_iso_point in self.recurrence:
# Is recurrence point greater than arbitrary point?
if recurrence_iso_point > p_iso_point:
break
recurrence_cycle_point = ISO8601Point(str(recurrence_iso_point))
if self.exclusions and recurrence_cycle_point in self.exclusions:
break
prev_cycle_point = recurrence_cycle_point
if prev_cycle_point is None:
return None
if prev_cycle_point == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
prev_cycle_point, point)
# Check all exclusions
if self.exclusions and prev_cycle_point in self.exclusions:
return self.get_prev_point(prev_cycle_point)
return prev_cycle_point
def get_next_point(self, point):
"""Return the next point > p, or None if out of bounds."""
try:
return ISO8601Point(self._cached_next_point_values[point.value])
except KeyError:
pass
# Iterate starting at recent valid points, for speed.
for valid_point in reversed(self._cached_recent_valid_points):
if valid_point >= point:
continue
next_point = valid_point
excluded = False
while next_point is not None and (next_point <= point or excluded):
excluded = False
next_point = self.get_next_point_on_sequence(next_point)
if next_point and next_point in self.exclusions:
excluded = True
if next_point is not None:
self._check_and_cache_next_point(point, next_point)
return next_point
# Iterate starting at the beginning.
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point > p_iso_point:
next_point = ISO8601Point(str(recurrence_iso_point))
if next_point and next_point in self.exclusions:
continue
self._check_and_cache_next_point(point, next_point)
return next_point
return None
def _check_and_cache_next_point(self, point, next_point):
"""Verify and cache the get_next_point return info."""
# Verify next_point != point.
if next_point == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
next_point, point)
# Cache the answer for point -> next_point.
if (len(self._cached_next_point_values) > self._MAX_CACHED_POINTS):
self._cached_next_point_values.popitem()
self._cached_next_point_values[point.value] = next_point.value
# Cache next_point as a valid starting point for this recurrence.
if (len(self._cached_next_point_values) > self._MAX_CACHED_POINTS):
self._cached_recent_valid_points.pop(0)
self._cached_recent_valid_points.append(next_point)
def get_next_point_on_sequence(self, point):
"""Return the on-sequence point > point assuming that point is
on-sequence, or None if out of bounds."""
result = None
next_point = self.recurrence.get_next(point_parse(point.value))
if next_point:
result = ISO8601Point(str(next_point))
if result == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
point, result)
# Check it is in the exclusions list now
if result and result in self.exclusions:
return self.get_next_point_on_sequence(result)
return result
def get_first_point(self, point):
"""Return the first point >= to point, or None if out of bounds."""
try:
return ISO8601Point(self._cached_first_point_values[point.value])
except KeyError:
pass
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point >= p_iso_point:
first_point_value = str(recurrence_iso_point)
ret = ISO8601Point(first_point_value)
# Check multiple exclusions
if ret and ret in self.exclusions:
return self.get_next_point_on_sequence(ret)
if (len(self._cached_first_point_values) >
self._MAX_CACHED_POINTS):
self._cached_first_point_values.popitem()
self._cached_first_point_values[point.value] = (
first_point_value)
return ret
return None
def get_start_point(self):
"""Return the first point in this sequence, or None."""
for recurrence_iso_point in self.recurrence:
point = ISO8601Point(str(recurrence_iso_point))
# Check for multiple exclusions
if not self.exclusions or point not in self.exclusions:
return point
return None
def get_stop_point(self):
"""Return the last point in this sequence, or None if unbounded."""
if (self.recurrence.repetitions is not None
or ((self.recurrence.start_point is not None
or self.recurrence.min_point is not None) and
(self.recurrence.end_point is not None
or self.recurrence.max_point is not None))):
curr = None
prev = None
for recurrence_iso_point in self.recurrence:
prev = curr
curr = recurrence_iso_point
ret = ISO8601Point(str(curr))
if self.exclusions and ret in self.exclusions:
return ISO8601Point(str(prev))
return ret
return None
def __eq__(self, other):
# Return True if other (sequence) is equal to self.
if self.TYPE != other.TYPE:
return False
if self.value == other.value:
return True
return False
def __lt__(self, other):
return self.value < other.value
def __str__(self):
return self.value
def __hash__(self):
return hash(self.value)
class ISO8601Sequence(SequenceBase):
"""A sequence of ISO8601 date time points separated by an interval."""
TYPE = CYCLER_TYPE_ISO8601
TYPE_SORT_KEY = CYCLER_TYPE_SORT_KEY_ISO8601
_MAX_CACHED_POINTS = 100
@classmethod
def get_async_expr(cls, start_point=None):
"""Express a one-off sequence at the initial cycle point."""
if start_point is None:
return "R1"
return "R1/" + str(start_point)
def __init__(self,
dep_section,
context_start_point=None,
context_end_point=None):
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
recurrence_syntax = convert_old_cycler_syntax(
dep_section, start_point=self.context_start_point)
if not recurrence_syntax:
raise ValueError("ERROR: bad cycling sequence syntax: %s" %
dep_section)
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self.spec = recurrence_syntax
self.custom_point_parse_function = None
if SuiteSpecifics.DUMP_FORMAT == PREV_DATE_TIME_FORMAT:
self.custom_point_parse_function = point_parse
self.abbrev_util = CylcTimeParser(
self.context_start_point,
self.context_end_point,
num_expanded_year_digits=SuiteSpecifics.NUM_EXPANDED_YEAR_DIGITS,
dump_format=SuiteSpecifics.DUMP_FORMAT,
custom_point_parse_function=self.custom_point_parse_function,
assumed_time_zone=SuiteSpecifics.ASSUMED_TIME_ZONE)
self.recurrence = self.abbrev_util.parse_recurrence(recurrence_syntax)
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
def get_interval(self):
"""Return the interval between points in this sequence."""
return self.step
def get_offset(self):
"""Deprecated: return the offset used for this sequence."""
return self.offset
def set_offset(self, offset):
"""Deprecated: alter state to offset the entire sequence."""
if self.recurrence.start_point is not None:
self.recurrence.start_point += interval_parse(str(offset))
if self.recurrence.end_point is not None:
self.recurrence.end_point += interval_parse(str(offset))
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self.value = str(self.recurrence)
def is_on_sequence(self, point):
"""Return True if point is on-sequence."""
return self.recurrence.get_is_valid(point_parse(point.value))
def is_valid(self, point):
"""Return True if point is on-sequence and in-bounds."""
try:
return self._cached_valid_point_booleans[point.value]
except KeyError:
is_valid = self.is_on_sequence(point)
if (len(self._cached_valid_point_booleans) >
self._MAX_CACHED_POINTS):
self._cached_valid_point_booleans.popitem()
self._cached_valid_point_booleans[point.value] = is_valid
return is_valid
def get_prev_point(self, point):
"""Return the previous point < point, or None if out of bounds."""
# may be None if out of the recurrence bounds
res = None
prev_point = self.recurrence.get_prev(point_parse(point.value))
if prev_point:
res = ISO8601Point(str(prev_point))
if res == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT, res,
point)
return res
def get_nearest_prev_point(self, point):
"""Return the largest point < some arbitrary point."""
if self.is_on_sequence(point):
return self.get_prev_point(point)
p_iso_point = point_parse(point.value)
prev_iso_point = None
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point > p_iso_point:
# Technically, >=, but we already test for this above.
break
prev_iso_point = recurrence_iso_point
if prev_iso_point is None:
return None
nearest_point = ISO8601Point(str(prev_iso_point))
if nearest_point == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
nearest_point, point)
return nearest_point
def get_next_point(self, point):
"""Return the next point > p, or None if out of bounds."""
try:
return ISO8601Point(self._cached_next_point_values[point.value])
except KeyError:
pass
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point > p_iso_point:
next_point_value = str(recurrence_iso_point)
if (len(self._cached_next_point_values) >
self._MAX_CACHED_POINTS):
self._cached_next_point_values.popitem()
self._cached_next_point_values[point.value] = next_point_value
next_point = ISO8601Point(next_point_value)
if next_point == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
nearest_point, point)
return next_point
return None
def get_next_point_on_sequence(self, point):
"""Return the on-sequence point > point assuming that point is
on-sequence, or None if out of bounds."""
result = None
next_point = self.recurrence.get_next(point_parse(point.value))
if next_point:
result = ISO8601Point(str(next_point))
if result == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
point, result)
return result
def get_first_point(self, point):
"""Return the first point >= to point, or None if out of bounds."""
try:
return ISO8601Point(self._cached_first_point_values[point.value])
except KeyError:
pass
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point >= p_iso_point:
first_point_value = str(recurrence_iso_point)
if (len(self._cached_first_point_values) >
self._MAX_CACHED_POINTS):
self._cached_first_point_values.popitem()
self._cached_first_point_values[point.value] = (
first_point_value)
return ISO8601Point(first_point_value)
return None
def get_start_point(self):
"""Return the first point in this sequence, or None."""
for recurrence_iso_point in self.recurrence:
return ISO8601Point(str(recurrence_iso_point))
return None
def get_stop_point(self):
"""Return the last point in this sequence, or None if unbounded."""
if (self.recurrence.repetitions is not None
or ((self.recurrence.start_point is not None
or self.recurrence.min_point is not None) and
(self.recurrence.end_point is not None
or self.recurrence.max_point is not None))):
for recurrence_iso_point in self.recurrence:
pass
return ISO8601Point(str(recurrence_iso_point))
return None
def __eq__(self, other):
# Return True if other (sequence) is equal to self.
if self.TYPE != other.TYPE:
return False
if self.value == other.value:
return True
return False
def __str__(self):
return self.value
def __init__(self, dep_section, context_start_point=None,
context_end_point=None):
SequenceBase.__init__(
self, dep_section, context_start_point, context_end_point)
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
elif isinstance(context_start_point, ISO8601Point):
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
elif isinstance(context_end_point, ISO8601Point):
self.context_end_point = context_end_point
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = dep_section
self.abbrev_util = CylcTimeParser(self.context_start_point,
self.context_end_point,
SuiteSpecifics.iso8601_parsers)
# Parse_recurrence returns an isodatetime TimeRecurrence object
# and a list of exclusion strings.
self.recurrence, excl_points = self.abbrev_util.parse_recurrence(
dep_section)
# Determine the exclusion start point and end point
try:
exclusion_start_point = ISO8601Point.from_nonstandard_string(
str(self.recurrence.start_point))
except ValueError:
exclusion_start_point = self.context_start_point
try:
exclusion_end_point = ISO8601Point.from_nonstandard_string(
str(self.recurrence.end_point))
except ValueError:
exclusion_end_point = self.context_end_point
self.exclusions = []
# Creating an exclusions object instead
if excl_points:
try:
self.exclusions = ISO8601Exclusions(
excl_points,
exclusion_start_point,
exclusion_end_point)
except AttributeError:
pass
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
# Concatenate the strings in exclusion list
if self.exclusions:
self.value += '!' + str(self.exclusions)
class ISO8601Sequence(SequenceBase):
"""A sequence of ISO8601 date time points separated by an interval.
Note that an ISO8601Sequence object (may) contain
ISO8601ExclusionSequences"""
TYPE = CYCLER_TYPE_ISO8601
TYPE_SORT_KEY = CYCLER_TYPE_SORT_KEY_ISO8601
_MAX_CACHED_POINTS = 100
__slots__ = ('dep_section', 'context_start_point', 'context_end_point',
'offset', '_cached_first_point_values',
'_cached_next_point_values', '_cached_valid_point_booleans',
'_cached_recent_valid_points', 'spec', 'abbrev_util',
'recurrence', 'exclusions', 'step', 'value')
@classmethod
def get_async_expr(cls, start_point=None):
"""Express a one-off sequence at the initial cycle point."""
if start_point is None:
return "R1"
return "R1/" + str(start_point)
def __init__(self, dep_section, context_start_point=None,
context_end_point=None):
SequenceBase.__init__(
self, dep_section, context_start_point, context_end_point)
self.dep_section = dep_section
if context_start_point is None:
self.context_start_point = context_start_point
elif isinstance(context_start_point, ISO8601Point):
self.context_start_point = context_start_point
else:
self.context_start_point = ISO8601Point.from_nonstandard_string(
context_start_point)
if context_end_point is None:
self.context_end_point = None
elif isinstance(context_end_point, ISO8601Point):
self.context_end_point = context_end_point
else:
self.context_end_point = ISO8601Point.from_nonstandard_string(
context_end_point)
self.offset = ISO8601Interval.get_null()
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.spec = dep_section
self.abbrev_util = CylcTimeParser(self.context_start_point,
self.context_end_point,
SuiteSpecifics.iso8601_parsers)
# Parse_recurrence returns an isodatetime TimeRecurrence object
# and a list of exclusion strings.
self.recurrence, excl_points = self.abbrev_util.parse_recurrence(
dep_section)
# Determine the exclusion start point and end point
try:
exclusion_start_point = ISO8601Point.from_nonstandard_string(
str(self.recurrence.start_point))
except ValueError:
exclusion_start_point = self.context_start_point
try:
exclusion_end_point = ISO8601Point.from_nonstandard_string(
str(self.recurrence.end_point))
except ValueError:
exclusion_end_point = self.context_end_point
self.exclusions = []
# Creating an exclusions object instead
if excl_points:
try:
self.exclusions = ISO8601Exclusions(
excl_points,
exclusion_start_point,
exclusion_end_point)
except AttributeError:
pass
self.step = ISO8601Interval(str(self.recurrence.duration))
self.value = str(self.recurrence)
# Concatenate the strings in exclusion list
if self.exclusions:
self.value += '!' + str(self.exclusions)
def get_interval(self):
"""Return the interval between points in this sequence."""
return self.step
def get_offset(self):
"""Deprecated: return the offset used for this sequence."""
return self.offset
def set_offset(self, i_offset):
"""Deprecated: alter state to i_offset the entire sequence."""
if self.recurrence.start_point is not None:
self.recurrence.start_point += interval_parse(str(i_offset))
if self.recurrence.end_point is not None:
self.recurrence.end_point += interval_parse(str(i_offset))
self._cached_first_point_values = {}
self._cached_next_point_values = {}
self._cached_valid_point_booleans = {}
self._cached_recent_valid_points = []
self.value = str(self.recurrence) + '!' + str(self.exclusions)
if self.exclusions:
self.value += '!' + str(self.exclusions)
def is_on_sequence(self, point):
"""Return True if point is on-sequence."""
# Iterate starting at recent valid points, for speed.
if self.exclusions and point in self.exclusions:
return False
for valid_point in reversed(self._cached_recent_valid_points):
if valid_point == point:
return True
if valid_point > point:
continue
next_point = valid_point
while next_point is not None and next_point < point:
next_point = self.get_next_point_on_sequence(next_point)
if next_point is None:
continue
if next_point == point:
return True
return self.recurrence.get_is_valid(point_parse(point.value))
def is_valid(self, point):
"""Return True if point is on-sequence and in-bounds."""
try:
return self._cached_valid_point_booleans[point.value]
except KeyError:
is_valid = self.is_on_sequence(point)
if (len(self._cached_valid_point_booleans) >
self._MAX_CACHED_POINTS):
self._cached_valid_point_booleans.popitem()
self._cached_valid_point_booleans[point.value] = is_valid
return is_valid
def get_prev_point(self, point):
"""Return the previous point < point, or None if out of bounds."""
# may be None if out of the recurrence bounds
res = None
prev_point = self.recurrence.get_prev(point_parse(point.value))
if prev_point:
res = ISO8601Point(str(prev_point))
if res == point:
raise SequenceDegenerateError(self.recurrence,
SuiteSpecifics.DUMP_FORMAT,
res, point)
# Check if res point is in the list of exclusions
# If so, check the previous point by recursion.
# Once you have found a point that is *not* in the exclusion
# list, you can return it.
if self.exclusions and res in self.exclusions:
return self.get_prev_point(res)
return res
def get_nearest_prev_point(self, point):
"""Return the largest point < some arbitrary point."""
if self.is_on_sequence(point):
return self.get_prev_point(point)
p_iso_point = point_parse(point.value)
prev_cycle_point = None
for recurrence_iso_point in self.recurrence:
# Is recurrence point greater than arbitrary point?
if recurrence_iso_point > p_iso_point:
break
recurrence_cycle_point = ISO8601Point(str(recurrence_iso_point))
if self.exclusions and recurrence_cycle_point in self.exclusions:
break
prev_cycle_point = recurrence_cycle_point
if prev_cycle_point is None:
return None
if prev_cycle_point == point:
raise SequenceDegenerateError(
self.recurrence, SuiteSpecifics.DUMP_FORMAT,
prev_cycle_point, point
)
# Check all exclusions
if self.exclusions and prev_cycle_point in self.exclusions:
return self.get_prev_point(prev_cycle_point)
return prev_cycle_point
def get_next_point(self, point):
"""Return the next point > p, or None if out of bounds."""
try:
return ISO8601Point(self._cached_next_point_values[point.value])
except KeyError:
pass
# Iterate starting at recent valid points, for speed.
for valid_point in reversed(self._cached_recent_valid_points):
if valid_point >= point:
continue
next_point = valid_point
excluded = False
while next_point is not None and (next_point <= point or excluded):
excluded = False
next_point = self.get_next_point_on_sequence(next_point)
if next_point and next_point in self.exclusions:
excluded = True
if next_point is not None:
self._check_and_cache_next_point(point, next_point)
return next_point
# Iterate starting at the beginning.
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point > p_iso_point:
next_point = ISO8601Point(str(recurrence_iso_point))
if next_point and next_point in self.exclusions:
continue
self._check_and_cache_next_point(point, next_point)
return next_point
return None
def _check_and_cache_next_point(self, point, next_point):
"""Verify and cache the get_next_point return info."""
# Verify next_point != point.
if next_point == point:
raise SequenceDegenerateError(
self.recurrence, SuiteSpecifics.DUMP_FORMAT,
next_point, point
)
# Cache the answer for point -> next_point.
if (len(self._cached_next_point_values) >
self._MAX_CACHED_POINTS):
self._cached_next_point_values.popitem()
self._cached_next_point_values[point.value] = next_point.value
# Cache next_point as a valid starting point for this recurrence.
if (len(self._cached_next_point_values) >
self._MAX_CACHED_POINTS):
self._cached_recent_valid_points.pop(0)
self._cached_recent_valid_points.append(next_point)
def get_next_point_on_sequence(self, point):
"""Return the on-sequence point > point assuming that point is
on-sequence, or None if out of bounds."""
result = None
next_point = self.recurrence.get_next(point_parse(point.value))
if next_point:
result = ISO8601Point(str(next_point))
if result == point:
raise SequenceDegenerateError(
self.recurrence, SuiteSpecifics.DUMP_FORMAT,
point, result
)
# Check it is in the exclusions list now
if result and result in self.exclusions:
return self.get_next_point_on_sequence(result)
return result
def get_first_point(self, point):
"""Return the first point >= to point, or None if out of bounds."""
try:
return ISO8601Point(self._cached_first_point_values[point.value])
except KeyError:
pass
p_iso_point = point_parse(point.value)
for recurrence_iso_point in self.recurrence:
if recurrence_iso_point >= p_iso_point:
first_point_value = str(recurrence_iso_point)
ret = ISO8601Point(first_point_value)
# Check multiple exclusions
if ret and ret in self.exclusions:
return self.get_next_point_on_sequence(ret)
if (len(self._cached_first_point_values) >
self._MAX_CACHED_POINTS):
self._cached_first_point_values.popitem()
self._cached_first_point_values[point.value] = (
first_point_value)
return ret
return None
def get_start_point(self):
"""Return the first point in this sequence, or None."""
for recurrence_iso_point in self.recurrence:
point = ISO8601Point(str(recurrence_iso_point))
# Check for multiple exclusions
if not self.exclusions or point not in self.exclusions:
return point
return None
def get_stop_point(self):
"""Return the last point in this sequence, or None if unbounded."""
if (self.recurrence.repetitions is not None or (
(self.recurrence.start_point is not None or
self.recurrence.min_point is not None) and
(self.recurrence.end_point is not None or
self.recurrence.max_point is not None))):
curr = None
prev = None
for recurrence_iso_point in self.recurrence:
prev = curr
curr = recurrence_iso_point
ret = ISO8601Point(str(curr))
if self.exclusions and ret in self.exclusions:
return ISO8601Point(str(prev))
return ret
return None
def __eq__(self, other):
# Return True if other (sequence) is equal to self.
if self.TYPE != other.TYPE:
return False
if self.value == other.value:
return True
return False
def __str__(self):
return self.value
