cylc
diff --git a/‎changes.d/5090.feat.md‎
Lines changed: 2 additions & 0 deletions b/‎changes.d/5090.feat.md‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎cylc/flow/config.py‎
Lines changed: 45 additions & 12 deletions b/‎cylc/flow/config.py‎
Lines changed: 45 additions & 12 deletions
diff --git a/‎cylc/flow/cycling/__init__.py‎
Lines changed: 5 additions & 1 deletion b/‎cylc/flow/cycling/__init__.py‎
Lines changed: 5 additions & 1 deletion
diff --git a/‎cylc/flow/cycling/integer.py‎
Lines changed: 6 additions & 1 deletion b/‎cylc/flow/cycling/integer.py‎
Lines changed: 6 additions & 1 deletion
diff --git a/‎cylc/flow/cycling/loader.py‎
Lines changed: 3 additions & 1 deletion b/‎cylc/flow/cycling/loader.py‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎cylc/flow/cycling/nocycle.py‎
Lines changed: 245 additions & 0 deletions b/‎cylc/flow/cycling/nocycle.py‎
Lines changed: 245 additions & 0 deletions
@@ -0,0 +1,2 @@
+Distinct initial and final graphs, separated from the main cycling graph,
+to make it easier to configure special behaviour at startup and shutdown.
@@ -54,6 +54,11 @@
     get_sequence, get_sequence_cls, init_cyclers, get_dump_format,
     INTEGER_CYCLING_TYPE, ISO8601_CYCLING_TYPE
 )
+from cylc.flow.cycling.nocycle import (
+    NocycleSequence,
+    NOCYCLE_SEQ_ALPHA,
+    NOCYCLE_SEQ_OMEGA
+)
 from cylc.flow.id import Tokens
 from cylc.flow.cycling.integer import IntegerInterval
 from cylc.flow.cycling.iso8601 import ingest_time, ISO8601Interval
@@ -270,6 +275,7 @@ def __init__(
         self.start_point: 'PointBase'
         self.stop_point: Optional['PointBase'] = None
         self.final_point: Optional['PointBase'] = None
+        self.nocycle_sequences: Set['NocycleSequence'] = set()
         self.sequences: List['SequenceBase'] = []
         self.actual_first_point: Optional['PointBase'] = None
         self._start_point_for_actual_first_point: Optional['PointBase'] = None
@@ -604,8 +610,13 @@ def _warn_if_queues_have_implicit_tasks(
             )
 
     def prelim_process_graph(self) -> None:
-        """Ensure graph is not empty; set integer cycling mode and icp/fcp = 1
-        for simplest "R1 = foo" type graphs.
+        """Error if graph empty; set integer cycling and icp/fcp = 1,
+        if those settings are omitted and the graph is acyclic graphs.
+
+        Somewhat relevant notes:
+         - The default (if not set) cycling mode, gregorian, requires an ICP.
+         - cycling mode is not stored in the DB, so recompute for restarts.
+
         """
         graphdict = self.cfg['scheduling']['graph']
         if not any(graphdict.values()):
@@ -614,9 +625,21 @@ def prelim_process_graph(self) -> None:
         if (
             'cycling mode' not in self.cfg['scheduling'] and
             self.cfg['scheduling'].get('initial cycle point', '1') == '1' and
-            all(item in ['graph', '1', 'R1'] for item in graphdict)
+            all(
+                seq in [
+                    'R1',
+                    str(NOCYCLE_SEQ_ALPHA),
+                    str(NOCYCLE_SEQ_OMEGA),
+                    'graph',  # Cylc 7 back-compat
+                    '1'  # Cylc 7 back-compat?
+                ]
+                for seq in graphdict
+            )
         ):
             # Pure acyclic graph, assume integer cycling mode with '1' cycle
+            # Note typos in "alpha", "omega", or "R1" will appear as cyclic
+            # here, but will be fatal later during proper recurrance checking.
+
             self.cfg['scheduling']['cycling mode'] = INTEGER_CYCLING_TYPE
             for key in ('initial cycle point', 'final cycle point'):
                 if key not in self.cfg['scheduling']:
@@ -2249,15 +2272,25 @@ def load_graph(self):
             try:
                 seq = get_sequence(section, icp, fcp)
             except (AttributeError, TypeError, ValueError, CylcError) as exc:
-                if cylc.flow.flags.verbosity > 1:
-                    traceback.print_exc()
-                msg = 'Cannot process recurrence %s' % section
-                msg += ' (initial cycle point=%s)' % icp
-                msg += ' (final cycle point=%s)' % fcp
-                if isinstance(exc, CylcError):
-                    msg += ' %s' % exc.args[0]
-                raise WorkflowConfigError(msg) from None
-            self.sequences.append(seq)
+                try:
+                    # is it an alpha or omega graph?
+                    seq = NocycleSequence(section)
+                except ValueError:
+                    if cylc.flow.flags.verbosity > 1:
+                        traceback.print_exc()
+                    msg = (
+                        f"Cannot process recurrence {section}"
+                        f" (initial cycle point={icp})"
+                        f" (final cycle point={fcp})"
+                    )
+                    if isinstance(exc, CylcError):
+                        msg += ' %s' % exc.args[0]
+                    raise WorkflowConfigError(msg) from None
+                else:
+                    self.nocycle_sequences.add(seq)
+            else:
+                self.sequences.append(seq)
+
             parser = GraphParser(
                 family_map,
                 self.parameters,
 
@@ -349,7 +349,11 @@ def TYPE_SORT_KEY(self) -> int:
     @classmethod
     @abstractmethod  # Note: stacked decorator not strictly enforced in Py2.x
     def get_async_expr(cls, start_point=0):
-        """Express a one-off sequence at the initial cycle point."""
+        """Express a one-off sequence at the initial cycle point.
+
+        Note "async" has nothing to do with asyncio. It was a (bad)
+        name for one-off (non-cycling) graphs in early Cylc versions.
+        """
         pass
 
     @abstractmethod
 
@@ -21,7 +21,12 @@
 import re
 
 from cylc.flow.cycling import (
-    PointBase, IntervalBase, SequenceBase, ExclusionBase, parse_exclusion, cmp
+    PointBase,
+    IntervalBase,
+    SequenceBase,
+    ExclusionBase,
+    parse_exclusion,
+    cmp
 )
 from cylc.flow.exceptions import (
     CylcMissingContextPointError,
 
@@ -21,12 +21,14 @@
 
 from typing import Optional, Type, overload
 
-from cylc.flow.cycling import PointBase, integer, iso8601
+from cylc.flow.cycling import PointBase, integer, iso8601, nocycle
 from metomi.isodatetime.data import Calendar
 
 
 ISO8601_CYCLING_TYPE = iso8601.CYCLER_TYPE_ISO8601
 INTEGER_CYCLING_TYPE = integer.CYCLER_TYPE_INTEGER
+NOCYCLE_CYCLING_TYPE = nocycle.CYCLER_TYPE_NOCYCLE
+
 
 IS_OFFSET_ABSOLUTE_IMPLS = {
     INTEGER_CYCLING_TYPE: integer.is_offset_absolute,
 
@@ -0,0 +1,245 @@
+# THIS FILE IS PART OF THE CYLC WORKFLOW ENGINE.
+# Copyright (C) NIWA & British Crown (Met Office) & Contributors.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Cycling logic for isolated non-cycling startup and shutdown graphs.
+"""
+
+from cylc.flow.cycling import PointBase, SequenceBase
+
+# cycle point values
+NOCYCLE_PT_ALPHA = "alpha"
+NOCYCLE_PT_OMEGA = "omega"
+
+NOCYCLE_POINTS = (
+    NOCYCLE_PT_ALPHA,
+    NOCYCLE_PT_OMEGA
+)
+
+CYCLER_TYPE_NOCYCLE = "nocycle"
+CYCLER_TYPE_SORT_KEY_NOCYCLE = 1
+
+# Unused abstract methods below left to raise NotImplementedError.
+
+
+class NocyclePoint(PointBase):
+    """A non-advancing string-valued cycle point."""
+
+    TYPE = CYCLER_TYPE_NOCYCLE
+    TYPE_SORT_KEY = CYCLER_TYPE_SORT_KEY_NOCYCLE
+
+    __slots__ = ('value')
+
+    def __init__(self, value: str) -> None:
+        """Initialise a nocycle point.
+
+        >>> NocyclePoint(NOCYCLE_PT_ALPHA)
+        alpha
+        >>> NocyclePoint("beta")
+        Traceback (most recent call last):
+        ValueError: Illegal Nocycle value 'beta'
+        """
+        if value not in [NOCYCLE_PT_ALPHA, NOCYCLE_PT_OMEGA]:
+            raise ValueError(f"Illegal Nocycle value '{value}'")
+        self.value = value
+
+    def __hash__(self):
+        """Hash it.
+
+        >>> bool(hash(NocyclePoint(NOCYCLE_PT_ALPHA)))
+        True
+        """
+        return hash(self.value)
+
+    def __eq__(self, other):
+        """Equality.
+
+        >>> NocyclePoint(NOCYCLE_PT_ALPHA) == NocyclePoint(NOCYCLE_PT_ALPHA)
+        True
+        >>> NocyclePoint(NOCYCLE_PT_ALPHA) == NocyclePoint(NOCYCLE_PT_OMEGA)
+        False
+        """
+        return str(other) == str(self.value)
+
+    def __le__(self, other):
+        """Less than or equal (only if equal).
+
+        >>> NocyclePoint(NOCYCLE_PT_ALPHA) <= NocyclePoint(NOCYCLE_PT_ALPHA)
+        True
+        >>> NocyclePoint(NOCYCLE_PT_ALPHA) <= NocyclePoint(NOCYCLE_PT_OMEGA)
+        False
+        """
+        return str(other) == self.value
+
+    def __lt__(self, other):
+        """Less than (never).
+
+        >>> NocyclePoint(NOCYCLE_PT_ALPHA) < NocyclePoint(NOCYCLE_PT_ALPHA)
+        False
+        >>> NocyclePoint(NOCYCLE_PT_ALPHA) < NocyclePoint(NOCYCLE_PT_OMEGA)
+        False
+        """
+        return False
+
+    def __gt__(self, other):
+        """Greater than (never).
+        >>> NocyclePoint(NOCYCLE_PT_ALPHA) > NocyclePoint(NOCYCLE_PT_ALPHA)
+        False
+        >>> NocyclePoint(NOCYCLE_PT_ALPHA) > NocyclePoint(NOCYCLE_PT_OMEGA)
+        False
+        """
+        return False
+
+    def __str__(self):
+        """
+        >>> str(NocyclePoint(NOCYCLE_PT_ALPHA))
+        'alpha'
+        >>> str(NocyclePoint(NOCYCLE_PT_OMEGA))
+        'omega'
+        """
+        return self.value
+
+    def _cmp(self, other):
+        raise NotImplementedError
+
+    def add(self, other):
+        # Not used.
+        raise NotImplementedError
+
+    def sub(self, other):
+        # Not used.
+        raise NotImplementedError
+
+
+class NocycleSequence(SequenceBase):
+    """A single point sequence."""
+
+    def __init__(self, dep_section, p_context_start=None, p_context_stop=None):
+        """Workflow cycling context is ignored.
+
+        >>> NocycleSequence("alpha").point
+        alpha
+        """
+        self.point = NocyclePoint(dep_section)
+
+    def __hash__(self):
+        """Hash it.
+
+        >>> bool(hash(NocycleSequence("alpha")))
+        True
+        """
+        return hash(str(self.point))
+
+    def is_valid(self, point):
+        """Is point on-sequence and in-bounds?
+
+        >>> NocycleSequence("alpha").is_valid("alpha")
+        True
+        >>> NocycleSequence("alpha").is_valid("omega")
+        False
+        """
+        return str(point) == str(self.point)
+
+    def get_first_point(self, point):
+        """First point is the only point.
+
+        >>> NocycleSequence("alpha").get_first_point("omega")
+        alpha
+        """
+        return self.point
+
+    def get_start_point(self, point):
+        """First point is the only point."""
+        # Not used.
+        raise NotImplementedError
+        return self.point
+
+    def get_next_point(self, point):
+        """There is no next point.
+
+        >>> NocycleSequence("alpha").get_next_point("alpha")
+        """
+        return None
+
+    def get_next_point_on_sequence(self, point):
+        """There is no next point.
+
+        >>> NocycleSequence("alpha").get_next_point_on_sequence("alpha")
+        """
+        return None
+
+    def __eq__(self, other):
+        """Equality.
+
+        >>> NocycleSequence("alpha") == NocycleSequence("alpha")
+        True
+        >>> NocycleSequence("alpha") == NocycleSequence("omega")
+        False
+        """
+        try:
+            return str(other.point) == str(self.point)
+        except AttributeError:
+            # (other has not .point)
+            return False
+
+    def __str__(self):
+        """String.
+
+        >>> str(NocycleSequence("alpha"))
+        'alpha'
+        """
+        return str(self.point)
+
+    def TYPE(self):
+        raise NotImplementedError
+
+    def TYPE_SORT_KEY(self):
+        raise NotImplementedError
+
+    def get_async_expr(cls, start_point=0):
+        raise NotImplementedError
+
+    def get_interval(self):
+        """Return the cycling interval of this sequence."""
+        raise NotImplementedError
+
+    def get_offset(self):
+        """Deprecated: return the offset used for this sequence."""
+        raise NotImplementedError
+
+    def set_offset(self, i_offset):
+        """Deprecated: alter state to offset the entire sequence."""
+        raise NotImplementedError
+
+    def is_on_sequence(self, point):
+        """Is point on-sequence, disregarding bounds?"""
+        raise NotImplementedError
+
+    def get_prev_point(self, point):
+        """Return the previous point < point, or None if out of bounds."""
+        raise NotImplementedError
+
+    def get_nearest_prev_point(self, point):
+        """Return the largest point < some arbitrary point."""
+        raise NotImplementedError
+
+    def get_stop_point(self):
+        """Return the last point in this sequence, or None if unbounded."""
+        raise NotImplementedError
+
+
+NOCYCLE_SEQ_ALPHA = NocycleSequence(NOCYCLE_PT_ALPHA)
+NOCYCLE_SEQ_OMEGA = NocycleSequence(NOCYCLE_PT_OMEGA)
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+Distinct initial and final graphs, separated from the main cycling graph,`
	`2`	`+to make it easier to configure special behaviour at startup and shutdown.`