Add execution state to sequence digest (#973)

* Add execution state to sequence digest

* mima

* rename

build.sbt

@@ -1,4 +1,4 @@
-ThisBuild / tlBaseVersion                         := "0.107"
+ThisBuild / tlBaseVersion                         := "0.108"
 ThisBuild / tlCiReleaseBranches                   := Seq("master")
 ThisBuild / githubWorkflowEnv += "MUNIT_FLAKY_OK" -> "true"
 

modules/core/shared/src/main/scala/lucuma/core/enums/ExecutionState.scala

@@ -0,0 +1,29 @@
+// Copyright (c) 2016-2023 Association of Universities for Research in Astronomy, Inc. (AURA)
+// For license information see LICENSE or https://opensource.org/licenses/BSD-3-Clause
+
+package lucuma.core.enums
+
+import lucuma.core.util.Enumerated
+
+/**
+ * The execution state of a sequence or observation.
+ */
+enum ExecutionState(val tag: String) derives Enumerated:
+
+  /**
+   * The observation isn't sufficiently defined, or there is a problem that
+   * must first be resolved before the execution state may be determined.
+   */
+  case NotDefined  extends ExecutionState("not_defined")
+
+  /** No execution visit has been recorded for this observation. */
+  case NotStarted  extends ExecutionState("not_started")
+
+  /**
+   * At least one visit was made for this observation, but the sequence or
+   * observation is not yet complete.
+   */
+  case Ongoing     extends ExecutionState("ongoing")
+
+  /** No more data is expected for this observation or sequence. */
+  case Completed   extends ExecutionState("completed")

modules/core/shared/src/main/scala/lucuma/core/model/sequence/SequenceDigest.scala

@@ -9,6 +9,7 @@ import cats.Order.catsKernelOrderingForOrder
 import cats.syntax.monoid.*
 import eu.timepit.refined.cats.*
 import eu.timepit.refined.types.numeric.NonNegInt
+import lucuma.core.enums.ExecutionState
 import lucuma.core.enums.ObserveClass
 import lucuma.core.math.Offset
 import monocle.Focus
@@ -19,18 +20,20 @@ import scala.collection.immutable.SortedSet
 /**
  * A compilation of attributes about a sequence computed from its atoms.
  *
- * @param observeClass ObserveClass of the sequence as a whole
- * @param plannedTime  expected execution time for the sequence
- * @param offsets      set of offsets that are expected over the course of the
- *                     sequence execution
- * @param atomCount    number of atoms in the sequence
+ * @param observeClass   ObserveClass of the sequence as a whole
+ * @param plannedTime    expected execution time for the sequence
+ * @param offsets        set of offsets that are expected over the course of the
+ *                       sequence execution
+ * @param atomCount      number of atoms in the sequence
+ * @param executionState completion state for this sequence
  */
 case class SequenceDigest(
-  observeClass: ObserveClass,
-  timeEstimate: CategorizedTime,
-  offsets:      SortedSet[Offset],
-  atomCount:    NonNegInt
-) {
+  observeClass:   ObserveClass,
+  timeEstimate:   CategorizedTime,
+  offsets:        SortedSet[Offset],
+  atomCount:      NonNegInt,
+  executionState: ExecutionState
+):
 
   def add(o: ObserveClass): SequenceDigest =
     SequenceDigest.observeClass.modify(_ |+| o)(this)
@@ -49,16 +52,15 @@ case class SequenceDigest(
         SequenceDigest.atomCount.replace(ac)(this)
       }
 
-}
-
-object SequenceDigest {
+object SequenceDigest:
 
   val Zero: SequenceDigest =
     SequenceDigest(
       Monoid[ObserveClass].empty,
       CategorizedTime.Zero,
       SortedSet.empty,
-      NonNegInt.unsafeFrom(0)
+      NonNegInt.unsafeFrom(0),
+      ExecutionState.NotStarted
     )
 
   /** @group Optics */
@@ -77,13 +79,16 @@ object SequenceDigest {
   val atomCount: Lens[SequenceDigest, NonNegInt] =
     Focus[SequenceDigest](_.atomCount)
 
-  given Eq[SequenceDigest] =
-    Eq.by { a => (
-      a.observeClass,
-      a.timeEstimate,
-      a.offsets,
-      a.atomCount
-    )}
-
-}
+  /** @group Optics */
+  val executionState: Lens[SequenceDigest, ExecutionState] =
+    Focus[SequenceDigest](_.executionState)
 
+  given Eq[SequenceDigest] =
+    Eq.by: a =>
+      (
+        a.observeClass,
+        a.timeEstimate,
+        a.offsets,
+        a.atomCount,
+        a.executionState
+      )

modules/testkit/src/main/scala/lucuma/core/model/sequence/arb/ArbSequenceDigest.scala

@@ -7,6 +7,7 @@ package arb
 import cats.Order.catsKernelOrderingForOrder
 import eu.timepit.refined.scalacheck.all.*
 import eu.timepit.refined.types.numeric.NonNegInt
+import lucuma.core.enums.ExecutionState
 import lucuma.core.enums.ObserveClass
 import lucuma.core.math.Offset
 import lucuma.core.math.arb.ArbOffset
@@ -17,34 +18,35 @@ import org.scalacheck.Cogen
 
 import scala.collection.immutable.SortedSet
 
-trait ArbSequenceDigest {
+trait ArbSequenceDigest:
   import ArbEnumerated.given
   import ArbCategorizedTime.given
   import ArbOffset.given
 
   given Arbitrary[SequenceDigest] =
-    Arbitrary {
-      for {
-        c  <- arbitrary[ObserveClass]
-        t  <- arbitrary[CategorizedTime]
-        o  <- arbitrary[SortedSet[Offset]]
-        n  <- arbitrary[NonNegInt]
-      } yield SequenceDigest(c, t, o, n)
-    }
+    Arbitrary:
+      for
+        c <- arbitrary[ObserveClass]
+        t <- arbitrary[CategorizedTime]
+        o <- arbitrary[SortedSet[Offset]]
+        n <- arbitrary[NonNegInt]
+        s <- arbitrary[ExecutionState]
+      yield SequenceDigest(c, t, o, n, s)
 
   given Cogen[SequenceDigest] =
     Cogen[(
       ObserveClass,
       CategorizedTime,
       Set[Offset],
-      NonNegInt
-    )].contramap { a => (
-      a.observeClass,
-      a.timeEstimate,
-      a.offsets,
-      a.atomCount
-    )}
-
-}
-
-object ArbSequenceDigest extends ArbSequenceDigest
+      NonNegInt,
+      ExecutionState
+    )].contramap: a =>
+      (
+        a.observeClass,
+        a.timeEstimate,
+        a.offsets,
+        a.atomCount,
+        a.executionState
+      )
+
+object ArbSequenceDigest extends ArbSequenceDigest