feat!: Implement step parameter space iteration for chunks

* Modify StepParameterSpaceIterator to handle parameter spaces that
  include a CHUNK[INT] parameter. The iteration pattern depends on the
  values in the 'chunks' object of the parameter definition.
   * If targetRuntimeSeconds is 0 or unspecified, split the CHUNK[INT]
     dimension into chunks, and then iterate over the whole space with
     that selection of chunks.
   * If targetRuntimeSeconds is a positive integer, move the CHUNK[INT]
     dimension to the innermost loop, and dynamically select the chunk
     each time it advances. Let the user of the iterator modify its
     chunks_default_task_count to adapt the chunk size over time.
   * The StepParameterSpaceIterator object behaved more like a
     pseudo-container than an iterator. Change it to act as the iterator
     itself (returning 'self' from __iter__() instead of a new object).
   * Changed how the special case zero-dimensional iteration works to be
     a Node/Iterator pair just like the others, for a more uniform
     interface.
* Changes to IntRangeExpr:
   * Fix a bug in IntRangeExpr.from_list that wasn't handling the end of a
     linear sequence correctly.
   * Change the string representation of IntRangeExpr to use "," instead of
     "-" when there are just two values.
* Add and update unit tests for all of the modifications.
* Update parameter space validation to ensure only one CHUNK[INT]
  parameter is defined.

Signed-off-by: Mark Wiebe <399551+mwiebe@users.noreply.github.com>

Author: mwiebe

src/openjd/model/_range_expr.py

@@ -54,7 +54,7 @@ def from_str(range_str: str) -> IntRangeExpr:
         return Parser().parse(range_str)
 
     @staticmethod
-    def from_list(values: list[int | str]) -> IntRangeExpr:
+    def from_list(values: list[int] | list[str] | list[int | str]) -> IntRangeExpr:
         """Creates a range expression object from a list of integers/strings containing integers."""
         if len(values) == 0:
             return IntRangeExpr([])
@@ -66,7 +66,7 @@ def from_list(values: list[int | str]) -> IntRangeExpr:
             values_as_int: list[int] = sorted({int(i) for i in values})
             # Find all the ranges, and concatenate them
             ranges = []
-            start = values_as_int[0]
+            start = end = values_as_int[0]
             step = None
 
             for value in values_as_int[1:]:
@@ -78,7 +78,7 @@ def from_list(values: list[int | str]) -> IntRangeExpr:
                         end = value
                     else:
                         ranges.append(IntRange(start, end, step))
-                        start = value
+                        start = end = value
                         step = None
             ranges.append(IntRange(start, end, step or 1))
             return IntRangeExpr(ranges)
@@ -183,8 +183,11 @@ def __init__(self, start: int, end: int, step: int = 1):
         self._validate()
 
     def __str__(self) -> str:
-        if len(self) == 1:
+        len_self = len(self)
+        if len_self == 1:
             return str(self._start)
+        elif len_self == 2:
+            return f"{self._start},{self._end}"
         elif self.step == 1:
             return f"{self._start}-{self._end}"
         else:

src/openjd/model/_step_param_space_iter.py

@@ -75,6 +75,8 @@ class ParameterValueType(str, Enum):
     INT = "INT"
     FLOAT = "FLOAT"
     PATH = "PATH"
+    # This type is only used for task parameters, not job parameters
+    CHUNK_INT = "CHUNK[INT]"
 
 
 @dataclass(frozen=True, **dataclass_kwargs)

src/openjd/model/_types.py

@@ -75,6 +75,7 @@
     StringRangeList,
     StringTaskParameterDefinition,
     TaskChunksDefinition,
+    TaskChunksRangeConstraint,
     TaskParameterList,
     TaskParameterStringValue,
     TaskParameterStringValueAsJob,
@@ -157,6 +158,7 @@
     "StringRangeList",
     "StringTaskParameterDefinition",
     "TaskChunksDefinition",
+    "TaskChunksRangeConstraint",
     "TaskParameterList",
     "TaskParameterStringValue",
     "TaskParameterStringValueAsJob",

src/openjd/model/v2023_09/__init__.py

@@ -584,6 +584,8 @@ def _validate_default_task_count(cls, value: Any) -> Any:
     @field_validator("targetRuntimeSeconds", mode="before")
     @classmethod
     def _validate_target_runtime_seconds(cls, value: Any) -> Any:
+        if value is None:
+            return value
         return validate_int_fmtstring_field(value, ge=0)
 
 
@@ -909,6 +911,9 @@ class StepParameterSpaceDefinition(OpenJDModel_v2023_09):
     @field_validator("taskParameterDefinitions")
     @classmethod
     def _validate_parameters(cls, v: TaskParameterList) -> TaskParameterList:
+        # Only one CHUNK[INT] parameter is permitted
+        if len([param for param in v if param.type == TaskParameterType.CHUNK_INT]) > 1:
+            raise ValueError("Only one CHUNK[INT] task parameter is permitted")
         # Must have a unique name for each Task parameter
         return validate_unique_elements(v, item_value=lambda v: v.name, property="name")
 

src/openjd/model/v2023_09/_model.py

@@ -128,7 +128,8 @@ def test_parse_one_positive_range_no_step(
         "range_expr,start,end,total_range,range_str",
         [
             pytest.param("1-100,101-200", 1, 200, 200, "1-200"),
-            pytest.param("0-1,3-4,7-9,10", 0, 10, 8, "0-1,3-4,7-10"),
+            pytest.param("0-1,3-4,7-9,10", 0, 10, 8, "0,1,3,4,7-10"),
+            pytest.param("0-3:3,5-10:5,12,13,14,15", 0, 15, 8, "0,3,5,10,12-15"),
             pytest.param("20-29,0-9,10-19", 0, 29, 30, "0-29"),
         ],
     )
@@ -208,6 +209,7 @@ def test_range_expr_from_str(self, range_input_str: str, range_str: str):
         "range_list,range_str",
         [
             pytest.param([5], "5", id="one int"),
+            pytest.param([1, 2, 3, 4, 5, 7], "1-5,7", id="two ranges"),
             pytest.param(["7"], "7", id="one int as a str"),
             pytest.param([9, 0, 3, 2, 8, 10, 1, 4, 7, 6, 5], "0-10", id="values 0-10 out of order"),
             pytest.param(

test/openjd/model/_internal/test_range_expr.py

@@ -12,14 +12,10 @@
     parse_model,
 )
 
-from openjd.model.v2023_09 import JobTemplate as JobTemplate_2023_09
 from openjd.model.v2023_09 import (
+    JobTemplate as JobTemplate_2023_09,
     RangeExpressionTaskParameterDefinition as RangeExpressionTaskParameterDefinition_2023_09,
-)
-from openjd.model.v2023_09 import (
     RangeListTaskParameterDefinition as RangeListTaskParameterDefinition_2023_09,
-)
-from openjd.model.v2023_09 import (
     StepParameterSpace as StepParameterSpace_2023_09,
 )
 
@@ -68,13 +64,14 @@ def test_no_param_iteration(self):
         job = create_job(job_template=job_template, job_parameter_values=dict())
 
         space = job.steps[0].parameterSpace
-        iterator = StepParameterSpaceIterator(space=space)
 
         # WHEN
-        result = list(iterator)
+        it = StepParameterSpaceIterator(space=space)
 
         # THEN
-        assert result == expected
+        assert list(it) == expected
+        it.reset_iter()
+        assert list(it) == expected
 
     def test_no_param_getelem(self):
         # GIVEN
@@ -90,16 +87,16 @@ def test_no_param_getelem(self):
         space = job.steps[0].parameterSpace
 
         # WHEN
-        result = StepParameterSpaceIterator(space=space)
+        it = StepParameterSpaceIterator(space=space)
 
         # THEN
         with pytest.raises(IndexError):
-            result[1]
+            it[1]
         with pytest.raises(IndexError):
-            result[-2]
+            it[-2]
         expected = {}
-        assert result[0] == expected
-        assert result[-1] == expected
+        assert it[0] == expected
+        assert it[-1] == expected
 
     @pytest.mark.parametrize(
         "range_int_param",
@@ -130,6 +127,9 @@ def test_single_param_iteration(self, range_int_param):
             } == next(it), f"i = {i}"
         with pytest.raises(StopIteration):
             next(it)
+        # The chunks parameter is only relevant when the parameter space is chunked
+        with pytest.raises(ValueError):
+            it.chunks_default_task_count = 1
 
     @pytest.mark.parametrize("param_range", [["10"], ["10", "11", "12", "13", "14", "15"]])
     def test_single_param_getelem(self, param_range):