arctrl 3.0.1__tar.gz → 3.0.2__tar.gz

{arctrl-3.0.1 → arctrl-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arctrl
-Version: 3.0.1
+Version: 3.0.2
 Summary: Library for management of Annotated Research Contexts (ARCs) using an in-memory representation and runtimer agnostic contract systems.
 License-File: LICENSE
 Keywords: arc,annotated research context,isa,research data,multi platform

{arctrl-3.0.1 → arctrl-3.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arctrl"
-version = "3.0.1"
+version = "3.0.2"
 description = "Library for management of Annotated Research Contexts (ARCs) using an in-memory representation and runtimer agnostic contract systems."
 authors = [
     { name = "Heinrich Lukas Weil", email = "weil@rptu.de" },

{arctrl-3.0.1 → arctrl-3.0.2}/src/ARCtrl/py/CWL/decode.py

@@ -1041,7 +1041,7 @@ def Decode_cwlTypeStringMatcher(t: str, get: IGetters) -> tuple[CWLType, bool]:
     return (CWLType(14, [CWLType(10), cwl_type]) if optional else cwl_type, optional)
 
 
-def _arrow900(value_1: YAMLElement) -> tuple[CWLType, bool]:
+def _arrow901(value_1: YAMLElement) -> tuple[CWLType, bool]:
     def getter(get: IGetters) -> tuple[CWLType, bool]:
         cwl_type: str | None
         object_arg: IRequiredGetter = get.Required
@@ -1085,11 +1085,11 @@ def _arrow900(value_1: YAMLElement) -> tuple[CWLType, bool]:
 
         cwl_type = object_arg.Field("type", arg_1)
         if cwl_type is None:
-            def _arrow899(__unit: None=None, get: Any=get) -> CWLType:
+            def _arrow900(__unit: None=None, get: Any=get) -> CWLType:
                 object_arg_1: IRequiredGetter = get.Required
                 return object_arg_1.Field("type", Decode_cwlTypeDecoder_0027)
 
-            return (_arrow899(), False)
+            return (_arrow900(), False)
 
         else: 
             return Decode_cwlTypeStringMatcher(cwl_type, get)
@@ -1098,23 +1098,23 @@ def _arrow900(value_1: YAMLElement) -> tuple[CWLType, bool]:
     return object(getter, value_1)
 
 
-Decode_cwlTypeDecoder: Callable[[YAMLElement], tuple[CWLType, bool]] = _arrow900
+Decode_cwlTypeDecoder: Callable[[YAMLElement], tuple[CWLType, bool]] = _arrow901
 
-def _arrow907(value_1: YAMLElement) -> Array[CWLOutput]:
+def _arrow910(value_1: YAMLElement) -> Array[CWLOutput]:
     def getter(get: IGetters) -> Array[CWLOutput]:
         dict_1: Any = get.Overflow.FieldList(empty())
-        def _arrow906(__unit: None=None, get: Any=get) -> IEnumerable_1[CWLOutput]:
-            def _arrow905(key: str) -> IEnumerable_1[CWLOutput]:
+        def _arrow909(__unit: None=None, get: Any=get) -> IEnumerable_1[CWLOutput]:
+            def _arrow908(key: str) -> IEnumerable_1[CWLOutput]:
                 value: YAMLElement = get_item_from_dict(dict_1, key)
                 output_binding: OutputBinding | None = Decode_outputBindingDecoder(value)
                 output_source_values: Array[str] | None = Decode_outputSourceDecoder(value)
                 output: CWLOutput = CWLOutput(key, (((Decode_cwlTypeStringMatcher(head(value.fields[0]).fields[0].Value, get)[0] if is_empty(tail(value.fields[0])) else Decode_cwlTypeDecoder(value)[0]) if (head(value.fields[0]).tag == 1) else Decode_cwlTypeDecoder(value)[0]) if (not is_empty(value.fields[0])) else Decode_cwlTypeDecoder(value)[0]) if (value.tag == 3) else Decode_cwlTypeDecoder(value)[0])
-                def _expr901():
+                def _expr904():
                     set_optional_property("outputBinding", output_binding, output)
                     return empty_1()
 
-                def _arrow904(__unit: None=None) -> IEnumerable_1[CWLOutput]:
-                    def _arrow902(__unit: None=None) -> IEnumerable_1[CWLOutput]:
+                def _arrow907(__unit: None=None) -> IEnumerable_1[CWLOutput]:
+                    def _arrow905(__unit: None=None) -> IEnumerable_1[CWLOutput]:
                         match_value: Array[str] | None = output_source_values
                         (pattern_matching_result, values_2, values_3) = (None, None, None)
                         if match_value is not None:
@@ -1145,23 +1145,23 @@ def _arrow907(value_1: YAMLElement) -> Array[CWLOutput]:
                             return empty_1()
 
 
-                    def _arrow903(__unit: None=None) -> IEnumerable_1[CWLOutput]:
+                    def _arrow906(__unit: None=None) -> IEnumerable_1[CWLOutput]:
                         return singleton(output)
 
-                    return append(_arrow902(), delay(_arrow903))
+                    return append(_arrow905(), delay(_arrow906))
 
-                return append(_expr901() if (output_binding is not None) else empty_1(), delay(_arrow904))
+                return append(_expr904() if (output_binding is not None) else empty_1(), delay(_arrow907))
 
-            return collect(_arrow905, dict_1.keys())
+            return collect(_arrow908, dict_1.keys())
 
-        return list(to_array(delay(_arrow906)))
+        return list(to_array(delay(_arrow909)))
 
     return object(getter, value_1)
 
 
-Decode_outputArrayDecoder: Callable[[YAMLElement], Array[CWLOutput]] = _arrow907
+Decode_outputArrayDecoder: Callable[[YAMLElement], Array[CWLOutput]] = _arrow910
 
-def _arrow908(value: YAMLElement) -> Array[CWLOutput]:
+def _arrow911(value: YAMLElement) -> Array[CWLOutput]:
     def getter(get: IGetters) -> Array[CWLOutput]:
         object_arg: IRequiredGetter = get.Required
         return object_arg.Field("outputs", Decode_outputArrayDecoder)
@@ -1169,41 +1169,41 @@ def _arrow908(value: YAMLElement) -> Array[CWLOutput]:
     return object(getter, value)
 
 
-Decode_outputsDecoder: Callable[[YAMLElement], Array[CWLOutput]] = _arrow908
+Decode_outputsDecoder: Callable[[YAMLElement], Array[CWLOutput]] = _arrow911
 
 def Decode_dockerRequirementDecoder(get: IGetters) -> DockerRequirement:
-    def _arrow909(y_ele: YAMLElement, get: Any=get) -> SchemaSaladString:
+    def _arrow912(y_ele: YAMLElement, get: Any=get) -> SchemaSaladString:
         return Decode_decodeSchemaSaladString(y_ele)
 
-    def _arrow910(__unit: None=None, get: Any=get) -> YAMLElement | None:
+    def _arrow913(__unit: None=None, get: Any=get) -> YAMLElement | None:
         object_arg: IOptionalGetter = get.Optional
         def arg_1(x: YAMLElement) -> YAMLElement:
             return x
 
         return object_arg.Field("dockerFile", arg_1)
 
-    docker_file: SchemaSaladString | None = map_1(_arrow909, _arrow910())
-    def _arrow911(__unit: None=None, get: Any=get) -> str | None:
+    docker_file: SchemaSaladString | None = map_1(_arrow912, _arrow913())
+    def _arrow914(__unit: None=None, get: Any=get) -> str | None:
         object_arg_1: IOptionalGetter = get.Optional
         return object_arg_1.Field("dockerPull", string)
 
-    def _arrow912(__unit: None=None, get: Any=get) -> str | None:
+    def _arrow915(__unit: None=None, get: Any=get) -> str | None:
         object_arg_2: IOptionalGetter = get.Optional
         return object_arg_2.Field("dockerImageId", string)
 
-    def _arrow913(__unit: None=None, get: Any=get) -> str | None:
+    def _arrow916(__unit: None=None, get: Any=get) -> str | None:
         object_arg_3: IOptionalGetter = get.Optional
         return object_arg_3.Field("dockerLoad", string)
 
-    def _arrow914(__unit: None=None, get: Any=get) -> str | None:
+    def _arrow917(__unit: None=None, get: Any=get) -> str | None:
         object_arg_4: IOptionalGetter = get.Optional
         return object_arg_4.Field("dockerImport", string)
 
-    def _arrow915(__unit: None=None, get: Any=get) -> str | None:
+    def _arrow918(__unit: None=None, get: Any=get) -> str | None:
         object_arg_5: IOptionalGetter = get.Optional
         return object_arg_5.Field("dockerOutputDirectory", string)
 
-    return DockerRequirement_create_Z14898805(_arrow911(), None, docker_file, _arrow912(), _arrow913(), _arrow914(), _arrow915())
+    return DockerRequirement_create_Z14898805(_arrow914(), None, docker_file, _arrow915(), _arrow916(), _arrow917(), _arrow918())
 
 
 def Decode_envVarRequirementDecoder(get: IGetters) -> Array[EnvironmentDef]:
@@ -1261,26 +1261,26 @@ def Decode_envVarRequirementDecoder(get: IGetters) -> Array[EnvironmentDef]:
         env_def_element = other
 
     if env_def_element.tag == 2:
-        def _arrow918(value_3: YAMLElement, get: Any=get) -> EnvironmentDef:
+        def _arrow921(value_3: YAMLElement, get: Any=get) -> EnvironmentDef:
             def getter(get2: IGetters) -> EnvironmentDef:
-                def _arrow916(__unit: None=None, get2: Any=get2) -> str:
+                def _arrow919(__unit: None=None, get2: Any=get2) -> str:
                     object_arg_1: IRequiredGetter = get2.Required
                     return object_arg_1.Field("envName", string)
 
-                def _arrow917(__unit: None=None, get2: Any=get2) -> str:
+                def _arrow920(__unit: None=None, get2: Any=get2) -> str:
                     object_arg_2: IRequiredGetter = get2.Required
                     return object_arg_2.Field("envValue", string)
 
-                return EnvironmentDef(_arrow916(), _arrow917())
+                return EnvironmentDef(_arrow919(), _arrow920())
 
             return object(getter, value_3)
 
-        return resizearray(_arrow918, env_def_element)
+        return resizearray(_arrow921, env_def_element)
 
     elif env_def_element.tag == 3:
         def chooser(_arg_2: YAMLElement, get: Any=get) -> EnvironmentDef | None:
             if _arg_2.tag == 0:
-                def _arrow919(__unit: None=None, _arg_2: Any=_arg_2) -> str:
+                def _arrow922(__unit: None=None, _arg_2: Any=_arg_2) -> str:
                     _arg_1: YAMLElement = _arg_2.fields[1]
                     (pattern_matching_result_1, value, other_1) = (None, None, None)
                     if _arg_1.tag == 1:
@@ -1320,7 +1320,7 @@ def Decode_envVarRequirementDecoder(get: IGetters) -> Array[EnvironmentDef]:
                         return Decode_decodeStringOrExpression(other_1)
 
 
-                return EnvironmentDef(_arg_2.fields[0].Value, _arrow919())
+                return EnvironmentDef(_arg_2.fields[0].Value, _arrow922())
 
             else: 
                 return None
@@ -1382,57 +1382,57 @@ def Decode_softwareRequirementDecoder(get: IGetters) -> Array[SoftwarePackage]:
             return other
 
 
-    def _arrow920(__unit: None=None, get: Any=get) -> YAMLElement:
+    def _arrow923(__unit: None=None, get: Any=get) -> YAMLElement:
         object_arg: IRequiredGetter = get.Required
         def arg_1(x: YAMLElement) -> YAMLElement:
             return x
 
         return object_arg.Field("packages", arg_1)
 
-    packages_element: YAMLElement = normalize_collection_element(_arrow920())
+    packages_element: YAMLElement = normalize_collection_element(_arrow923())
     def decode_specs_array(element: YAMLElement, get: Any=get) -> Array[str]:
-        def _arrow922(y_ele: YAMLElement, element: Any=element) -> str:
+        def _arrow924(y_ele: YAMLElement, element: Any=element) -> str:
             return Decode_decodeStringOrExpression(y_ele)
 
-        return resizearray(_arrow922, normalize_collection_element(element))
+        return resizearray(_arrow924, normalize_collection_element(element))
 
     if packages_element.tag == 2:
-        def _arrow928(value_5: YAMLElement, get: Any=get) -> SoftwarePackage:
+        def _arrow930(value_5: YAMLElement, get: Any=get) -> SoftwarePackage:
             def getter(get2: IGetters) -> SoftwarePackage:
-                def _arrow923(__unit: None=None, get2: Any=get2) -> str:
+                def _arrow925(__unit: None=None, get2: Any=get2) -> str:
                     object_arg_1: IRequiredGetter = get2.Required
                     return object_arg_1.Field("package", string)
 
-                def _arrow925(__unit: None=None, get2: Any=get2) -> Array[str] | None:
+                def _arrow927(__unit: None=None, get2: Any=get2) -> Array[str] | None:
                     object_arg_2: IOptionalGetter = get2.Optional
                     def arg_5(value_1: YAMLElement) -> Array[str]:
-                        def _arrow924(value_2: YAMLElement, value_1: Any=value_1) -> str:
+                        def _arrow926(value_2: YAMLElement, value_1: Any=value_1) -> str:
                             return string(value_2)
 
-                        return resizearray(_arrow924, value_1)
+                        return resizearray(_arrow926, value_1)
 
                     return object_arg_2.Field("version", arg_5)
 
-                def _arrow927(__unit: None=None, get2: Any=get2) -> Array[str] | None:
+                def _arrow929(__unit: None=None, get2: Any=get2) -> Array[str] | None:
                     object_arg_3: IOptionalGetter = get2.Optional
                     def arg_7(value_3: YAMLElement) -> Array[str]:
-                        def _arrow926(value_4: YAMLElement, value_3: Any=value_3) -> str:
+                        def _arrow928(value_4: YAMLElement, value_3: Any=value_3) -> str:
                             return string(value_4)
 
-                        return resizearray(_arrow926, value_3)
+                        return resizearray(_arrow928, value_3)
 
                     return object_arg_3.Field("specs", arg_7)
 
-                return SoftwarePackage(_arrow923(), _arrow925(), _arrow927())
+                return SoftwarePackage(_arrow925(), _arrow927(), _arrow929())
 
             return object(getter, value_5)
 
-        return resizearray(_arrow928, packages_element)
+        return resizearray(_arrow930, packages_element)
 
     elif packages_element.tag == 3:
         def chooser_2(_arg_3: YAMLElement, get: Any=get) -> SoftwarePackage | None:
             if _arg_3.tag == 0:
-                def _arrow929(__unit: None=None, _arg_3: Any=_arg_3) -> SoftwarePackage:
+                def _arrow931(__unit: None=None, _arg_3: Any=_arg_3) -> SoftwarePackage:
                     package_name: str = _arg_3.fields[0].Value
                     package_value: YAMLElement = _arg_3.fields[1]
                     normalized_package_value: YAMLElement = normalize_collection_element(package_value)
@@ -1482,7 +1482,7 @@ def Decode_softwareRequirementDecoder(get: IGetters) -> Array[SoftwarePackage]:
 
                     return (SoftwarePackage(package_name, None, None) if is_empty(normalized_package_value.fields[0]) else SoftwarePackage(package_name, try_pick(chooser, normalized_package_value.fields[0]), try_pick(chooser_1, normalized_package_value.fields[0]))) if (normalized_package_value.tag == 3) else (SoftwarePackage(package_name, None, decode_specs_array(normalized_package_value)) if (normalized_package_value.tag == 2) else SoftwarePackage(package_name, None, [Decode_decodeStringOrExpression(package_value)]))
 
-                return _arrow929()
+                return _arrow931()
 
             else: 
                 return None
@@ -1528,10 +1528,10 @@ def Decode_initialWorkDirRequirementDecoder(get: IGetters) -> Array[InitialWorkD
         pattern_matching_result = 1
 
     if pattern_matching_result == 0:
-        def _arrow930(value: YAMLElement, get: Any=get) -> InitialWorkDirEntry:
+        def _arrow932(value: YAMLElement, get: Any=get) -> InitialWorkDirEntry:
             return Decode_initialWorkDirEntryDecoder(value)
 
-        return resizearray(_arrow930, listing_element)
+        return resizearray(_arrow932, listing_element)
 
     elif pattern_matching_result == 1:
         return [Decode_initialWorkDirEntryDecoder(listing_element)]
@@ -1539,12 +1539,12 @@ def Decode_initialWorkDirRequirementDecoder(get: IGetters) -> Array[InitialWorkD
 
 
 def Decode_loadListingRequirementDecoder(get: IGetters) -> LoadListingRequirementValue:
-    def _arrow931(__unit: None=None, get: Any=get) -> str | None:
+    def _arrow933(__unit: None=None, get: Any=get) -> str | None:
         object_arg: IOptionalGetter = get.Optional
         return object_arg.Field("loadListing", string)
 
-    load_listing_value: str = default_arg(_arrow931(), "no_listing")
-    def _arrow932(__unit: None=None, get: Any=get) -> LoadListingEnum:
+    load_listing_value: str = default_arg(_arrow933(), "no_listing")
+    def _arrow934(__unit: None=None, get: Any=get) -> LoadListingEnum:
         match_value: LoadListingEnum | None = LoadListingEnum_tryParse_Z721C83C5(load_listing_value)
         if match_value is None:
             raise Exception(("Invalid loadListing value \'" + load_listing_value) + "\'. Expected one of: no_listing, shallow_listing, deep_listing.")
@@ -1553,7 +1553,7 @@ def Decode_loadListingRequirementDecoder(get: IGetters) -> LoadListingRequiremen
             return match_value
 
 
-    return LoadListingRequirementValue(_arrow932())
+    return LoadListingRequirementValue(_arrow934())
 
 
 def Decode_decodeResourceScalar(element: YAMLElement) -> Any:
@@ -1599,28 +1599,28 @@ def Decode_decodeResourceScalar(element: YAMLElement) -> Any:
         scalar_value: str = match_value
         match_value_1: tuple[bool, int64]
         out_arg: int64 = int64(0)
-        def _arrow933(__unit: None=None, element: Any=element) -> int64:
+        def _arrow935(__unit: None=None, element: Any=element) -> int64:
             return out_arg
 
-        def _arrow934(v: int64, element: Any=element) -> None:
+        def _arrow936(v: int64, element: Any=element) -> None:
             nonlocal out_arg
             out_arg = v
 
-        match_value_1 = (try_parse(scalar_value, 7, False, 64, FSharpRef(_arrow933, _arrow934)), out_arg)
+        match_value_1 = (try_parse(scalar_value, 7, False, 64, FSharpRef(_arrow935, _arrow936)), out_arg)
         if match_value_1[0]:
             return match_value_1[1]
 
         else: 
             match_value_2: tuple[bool, float]
             out_arg_1: float = 0.0
-            def _arrow935(__unit: None=None, element: Any=element) -> float:
+            def _arrow937(__unit: None=None, element: Any=element) -> float:
                 return out_arg_1
 
-            def _arrow937(v_1: float, element: Any=element) -> None:
+            def _arrow938(v_1: float, element: Any=element) -> None:
                 nonlocal out_arg_1
                 out_arg_1 = v_1
 
-            match_value_2 = (try_parse_1(scalar_value, FSharpRef(_arrow935, _arrow937)), out_arg_1)
+            match_value_2 = (try_parse_1(scalar_value, FSharpRef(_arrow937, _arrow938)), out_arg_1)
             if match_value_2[0]:
                 return match_value_2[1]
 
@@ -2877,7 +2877,7 @@ def _arrow1001(value_2: YAMLElement) -> Array[StepOutput]:
 
 Decode_outputStepsDecoder: Callable[[YAMLElement], Array[StepOutput]] = _arrow1001
 
-def _arrow1002(value_1: YAMLElement) -> str | None:
+def _arrow1003(value_1: YAMLElement) -> str | None:
     def getter(get: IGetters) -> str | None:
         object_arg: IOptionalGetter = get.Optional
         def arg_1(value: YAMLElement, get: Any=get) -> str:
@@ -2888,9 +2888,9 @@ def _arrow1002(value_1: YAMLElement) -> str | None:
     return object(getter, value_1)
 
 
-Decode_docDecoder: Callable[[YAMLElement], str | None] = _arrow1002
+Decode_docDecoder: Callable[[YAMLElement], str | None] = _arrow1003
 
-def _arrow1003(value_1: YAMLElement) -> str | None:
+def _arrow1004(value_1: YAMLElement) -> str | None:
     def getter(get: IGetters) -> str | None:
         object_arg: IOptionalGetter = get.Optional
         def arg_1(value: YAMLElement, get: Any=get) -> str:
@@ -2901,26 +2901,26 @@ def _arrow1003(value_1: YAMLElement) -> str | None:
     return object(getter, value_1)
 
 
-Decode_labelDecoder: Callable[[YAMLElement], str | None] = _arrow1003
+Decode_labelDecoder: Callable[[YAMLElement], str | None] = _arrow1004
 
-def _arrow1006(value_1: YAMLElement) -> Array[str] | None:
+def _arrow1007(value_1: YAMLElement) -> Array[str] | None:
     def getter(get: IGetters) -> Array[str] | None:
-        def _arrow1004(value: YAMLElement, get: Any=get) -> Array[str] | None:
+        def _arrow1005(value: YAMLElement, get: Any=get) -> Array[str] | None:
             return Decode_stringOrStringArrayDecoder(value)
 
-        def _arrow1005(__unit: None=None, get: Any=get) -> YAMLElement | None:
+        def _arrow1006(__unit: None=None, get: Any=get) -> YAMLElement | None:
             object_arg: IOptionalGetter = get.Optional
             def arg_1(x: YAMLElement) -> YAMLElement:
                 return x
 
             return object_arg.Field("intent", arg_1)
 
-        return bind(_arrow1004, _arrow1005())
+        return bind(_arrow1005, _arrow1006())
 
     return object(getter, value_1)
 
 
-Decode_intentDecoder: Callable[[YAMLElement], Array[str] | None] = _arrow1006
+Decode_intentDecoder: Callable[[YAMLElement], Array[str] | None] = _arrow1007
 
 def Decode_hasField(field_name: str, yaml_element: YAMLElement) -> bool:
     if yaml_element.tag == 3:
@@ -3017,19 +3017,19 @@ def Decode_workflowStepRunDecoder(default_cwl_version: str, run_value: YAMLEleme
 
 
 def Decode_decodeWorkflowStepFromValueWithId(default_cwl_version: str, step_id: str, value: YAMLElement) -> WorkflowStep:
-    def _arrow1007(get_0027: IGetters, default_cwl_version: Any=default_cwl_version, step_id: Any=step_id, value: Any=value) -> YAMLElement:
+    def _arrow1008(get_0027: IGetters, default_cwl_version: Any=default_cwl_version, step_id: Any=step_id, value: Any=value) -> YAMLElement:
         object_arg: IRequiredGetter = get_0027.Required
         def arg_1(x: YAMLElement) -> YAMLElement:
             return x
 
         return object_arg.Field("run", arg_1)
 
-    run: WorkflowStepRun = Decode_workflowStepRunDecoder(default_cwl_version, object(_arrow1007, value))
-    def _arrow1008(get_0027_1: IGetters, default_cwl_version: Any=default_cwl_version, step_id: Any=step_id, value: Any=value) -> Array[StepInput]:
+    run: WorkflowStepRun = Decode_workflowStepRunDecoder(default_cwl_version, object(_arrow1008, value))
+    def _arrow1009(get_0027_1: IGetters, default_cwl_version: Any=default_cwl_version, step_id: Any=step_id, value: Any=value) -> Array[StepInput]:
         object_arg_1: IRequiredGetter = get_0027_1.Required
         return object_arg_1.Field("in", Decode_inputStepDecoder)
 
-    inputs: Array[StepInput] = object(_arrow1008, value)
+    inputs: Array[StepInput] = object(_arrow1009, value)
     outputs: Array[StepOutput] = Decode_outputStepsDecoder(value)
     requirements: Array[Requirement] | None = Decode_requirementsDecoder(value)
     hints: Array[HintEntry] | None = Decode_hintsDecoder(value)
@@ -3083,22 +3083,22 @@ def Decode_stepArrayDecoderWithVersion(default_cwl_version: str, value: YAMLElem
         return list(map(mapping, items))
 
     elif pattern_matching_result == 1:
-        def _arrow1009(get: IGetters, default_cwl_version: Any=default_cwl_version, value: Any=value) -> Any:
+        def _arrow1010(get: IGetters, default_cwl_version: Any=default_cwl_version, value: Any=value) -> Any:
             return get.Overflow.FieldList(empty())
 
-        dict_1: Any = object(_arrow1009, value)
-        def _arrow1011(__unit: None=None, default_cwl_version: Any=default_cwl_version, value: Any=value) -> IEnumerable_1[WorkflowStep]:
-            def _arrow1010(key: str) -> WorkflowStep:
+        dict_1: Any = object(_arrow1010, value)
+        def _arrow1012(__unit: None=None, default_cwl_version: Any=default_cwl_version, value: Any=value) -> IEnumerable_1[WorkflowStep]:
+            def _arrow1011(key: str) -> WorkflowStep:
                 return Decode_decodeWorkflowStepFromValueWithId(default_cwl_version, key, get_item_from_dict(dict_1, key))
 
-            return map_2(_arrow1010, dict_1.keys())
+            return map_2(_arrow1011, dict_1.keys())
 
-        return list(to_array(delay(_arrow1011)))
+        return list(to_array(delay(_arrow1012)))
 
 
 
 def Decode_stepsDecoderWithVersion(default_cwl_version: str) -> Callable[[YAMLElement], Array[WorkflowStep]]:
-    def _arrow1012(value_1: YAMLElement, default_cwl_version: Any=default_cwl_version) -> Array[WorkflowStep]:
+    def _arrow1013(value_1: YAMLElement, default_cwl_version: Any=default_cwl_version) -> Array[WorkflowStep]:
         def getter(get: IGetters) -> Array[WorkflowStep]:
             object_arg: IRequiredGetter = get.Required
             def arg_1(value: YAMLElement, get: Any=get) -> Array[WorkflowStep]:
@@ -3108,7 +3108,7 @@ def Decode_stepsDecoderWithVersion(default_cwl_version: str) -> Callable[[YAMLEl
 
         return object(getter, value_1)
 
-    return _arrow1012
+    return _arrow1013
 
 
 def Decode_commandLineToolDecoder(yaml_cwl: YAMLElement) -> CWLToolDescription:
@@ -3169,11 +3169,11 @@ def Decode_expressionToolDecoder(yaml_cwl: YAMLElement) -> CWLExpressionToolDesc
     intent: Array[str] | None = Decode_intentDecoder(yaml_cwl)
     doc: str | None = Decode_docDecoder(yaml_cwl)
     label: str | None = Decode_labelDecoder(yaml_cwl)
-    def _arrow1013(get: IGetters, yaml_cwl: Any=yaml_cwl) -> str:
+    def _arrow1015(get: IGetters, yaml_cwl: Any=yaml_cwl) -> str:
         object_arg: IRequiredGetter = get.Required
         return object_arg.Field("expression", Decode_decodeStringOrExpression)
 
-    description: CWLExpressionToolDescription = CWLExpressionToolDescription(outputs, object(_arrow1013, yaml_cwl), cwl_version)
+    description: CWLExpressionToolDescription = CWLExpressionToolDescription(outputs, object(_arrow1015, yaml_cwl), cwl_version)
     metadata: DynamicObj
     md: DynamicObj = DynamicObj()
     def getter(get_1: IGetters, yaml_cwl: Any=yaml_cwl) -> DynamicObj:
@@ -3327,11 +3327,11 @@ def Decode_decodeCWLProcessingUnitElement(yaml_cwl: YAMLElement) -> CWLProcessin
 
 
 
-def _arrow1014(value: YAMLElement) -> Array[WorkflowStep]:
+def _arrow1017(value: YAMLElement) -> Array[WorkflowStep]:
     return Decode_stepArrayDecoderWithVersion("v1.2", value)
 
 
-Decode_stepArrayDecoder: Callable[[YAMLElement], Array[WorkflowStep]] = _arrow1014
+Decode_stepArrayDecoder: Callable[[YAMLElement], Array[WorkflowStep]] = _arrow1017
 
 Decode_stepsDecoder: Callable[[YAMLElement], Array[WorkflowStep]] = Decode_stepsDecoderWithVersion("v1.2")
 
@@ -3479,10 +3479,10 @@ def DecodeParameters_cwlParameterReferenceDecoder(get: IGetters, key: str, y_ele
 
 
             if not exists(predicate, mappings):
-                def _arrow1015(value: YAMLElement, get: Any=get, key: Any=key, y_ele: Any=y_ele) -> str:
+                def _arrow1018(value: YAMLElement, get: Any=get, key: Any=key, y_ele: Any=y_ele) -> str:
                     return string(value)
 
-                return CWLParameterReference(key, resizearray(_arrow1015, YAMLElement(2, s)))
+                return CWLParameterReference(key, resizearray(_arrow1018, YAMLElement(2, s)))
 
             else: 
                 def predicate_1(_arg_1: YAMLElement, get: Any=get, key: Any=key, y_ele: Any=y_ele) -> bool:
@@ -3560,10 +3560,10 @@ def DecodeParameters_cwlParameterReferenceDecoder(get: IGetters, key: str, y_ele
 
 
         elif pattern_matching_result_1 == 1:
-            def _arrow1016(value_1: YAMLElement, get: Any=get, key: Any=key, y_ele: Any=y_ele) -> str:
+            def _arrow1019(value_1: YAMLElement, get: Any=get, key: Any=key, y_ele: Any=y_ele) -> str:
                 return string(value_1)
 
-            return CWLParameterReference(key, resizearray(_arrow1016, YAMLElement(2, s)))
+            return CWLParameterReference(key, resizearray(_arrow1019, YAMLElement(2, s)))
 
 
     elif pattern_matching_result == 3:
@@ -3571,21 +3571,21 @@ def DecodeParameters_cwlParameterReferenceDecoder(get: IGetters, key: str, y_ele
 
 
 
-def _arrow1019(value: YAMLElement) -> Array[CWLParameterReference]:
+def _arrow1022(value: YAMLElement) -> Array[CWLParameterReference]:
     def getter(get: IGetters) -> Array[CWLParameterReference]:
         dict_1: Any = get.Overflow.FieldList(empty())
-        def _arrow1018(__unit: None=None, get: Any=get) -> IEnumerable_1[CWLParameterReference]:
-            def _arrow1017(ele: Any) -> CWLParameterReference:
+        def _arrow1021(__unit: None=None, get: Any=get) -> IEnumerable_1[CWLParameterReference]:
+            def _arrow1020(ele: Any) -> CWLParameterReference:
                 return DecodeParameters_cwlParameterReferenceDecoder(get, ele[0], ele[1])
 
-            return map_2(_arrow1017, dict_1)
+            return map_2(_arrow1020, dict_1)
 
-        return list(to_array(delay(_arrow1018)))
+        return list(to_array(delay(_arrow1021)))
 
     return object(getter, value)
 
 
-DecodeParameters_cwlparameterReferenceArrayDecoder: Callable[[YAMLElement], Array[CWLParameterReference]] = _arrow1019
+DecodeParameters_cwlparameterReferenceArrayDecoder: Callable[[YAMLElement], Array[CWLParameterReference]] = _arrow1022
 
 def DecodeParameters_decodeYAMLParameterFile(yaml: str) -> Array[CWLParameterReference]:
     return DecodeParameters_cwlparameterReferenceArrayDecoder(read(yaml))