arctrl 3.0.5__tar.gz → 3.1.0__tar.gz

{arctrl-3.0.5 → arctrl-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arctrl
-Version: 3.0.5
+Version: 3.1.0
 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.5 → arctrl-3.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arctrl"
-version = "3.0.5"
+version = "3.1.0"
 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.5 → arctrl-3.1.0}/src/ARCtrl/__init__.py

@@ -20,4 +20,5 @@ from .py.FileSystem.file_system_tree import FileSystemTree
 from .py.json import JsonController
 from .py.yaml import YamlController
 from .py.xlsx import XlsxController
-from .py.arc import ARC
+from .py.arc import ARC
+from .py.fable_modules.fable_library.async_ import start_as_task

{arctrl-3.0.5 → arctrl-3.1.0}/src/ARCtrl/py/CWL/decode.py

@@ -1310,26 +1310,26 @@ def Decode_envVarRequirementDecoder(get: IGetters) -> Array[EnvironmentDef]:
         env_def_element = other
 
     if env_def_element.tag == 2:
-        def _arrow929(value_3: YAMLElement, get: Any=get) -> EnvironmentDef:
+        def _arrow928(value_3: YAMLElement, get: Any=get) -> EnvironmentDef:
             def getter(get2: IGetters) -> EnvironmentDef:
-                def _arrow927(__unit: None=None, get2: Any=get2) -> str:
+                def _arrow926(__unit: None=None, get2: Any=get2) -> str:
                     object_arg_1: IRequiredGetter = get2.Required
                     return object_arg_1.Field("envName", string)
 
-                def _arrow928(__unit: None=None, get2: Any=get2) -> str:
+                def _arrow927(__unit: None=None, get2: Any=get2) -> str:
                     object_arg_2: IRequiredGetter = get2.Required
                     return object_arg_2.Field("envValue", string)
 
-                return EnvironmentDef(_arrow927(), _arrow928())
+                return EnvironmentDef(_arrow926(), _arrow927())
 
             return object(getter, value_3)
 
-        return resizearray(_arrow929, env_def_element)
+        return resizearray(_arrow928, 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 _arrow930(__unit: None=None, _arg_2: Any=_arg_2) -> str:
+                def _arrow929(__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:
@@ -1369,7 +1369,7 @@ def Decode_envVarRequirementDecoder(get: IGetters) -> Array[EnvironmentDef]:
                         return Decode_decodeStringOrExpression(other_1)
 
 
-                return EnvironmentDef(_arg_2.fields[0].Value, _arrow930())
+                return EnvironmentDef(_arg_2.fields[0].Value, _arrow929())
 
             else: 
                 return None
@@ -1431,57 +1431,57 @@ def Decode_softwareRequirementDecoder(get: IGetters) -> Array[SoftwarePackage]:
             return other
 
 
-    def _arrow931(__unit: None=None, get: Any=get) -> YAMLElement:
+    def _arrow930(__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(_arrow931())
+    packages_element: YAMLElement = normalize_collection_element(_arrow930())
     def decode_specs_array(element: YAMLElement, get: Any=get) -> Array[str]:
-        def _arrow932(y_ele: YAMLElement, element: Any=element) -> str:
+        def _arrow931(y_ele: YAMLElement, element: Any=element) -> str:
             return Decode_decodeStringOrExpression(y_ele)
 
-        return resizearray(_arrow932, normalize_collection_element(element))
+        return resizearray(_arrow931, normalize_collection_element(element))
 
     if packages_element.tag == 2:
-        def _arrow938(value_5: YAMLElement, get: Any=get) -> SoftwarePackage:
+        def _arrow937(value_5: YAMLElement, get: Any=get) -> SoftwarePackage:
             def getter(get2: IGetters) -> SoftwarePackage:
-                def _arrow933(__unit: None=None, get2: Any=get2) -> str:
+                def _arrow932(__unit: None=None, get2: Any=get2) -> str:
                     object_arg_1: IRequiredGetter = get2.Required
                     return object_arg_1.Field("package", string)
 
-                def _arrow935(__unit: None=None, get2: Any=get2) -> Array[str] | None:
+                def _arrow934(__unit: None=None, get2: Any=get2) -> Array[str] | None:
                     object_arg_2: IOptionalGetter = get2.Optional
                     def arg_5(value_1: YAMLElement) -> Array[str]:
-                        def _arrow934(value_2: YAMLElement, value_1: Any=value_1) -> str:
+                        def _arrow933(value_2: YAMLElement, value_1: Any=value_1) -> str:
                             return string(value_2)
 
-                        return resizearray(_arrow934, value_1)
+                        return resizearray(_arrow933, value_1)
 
                     return object_arg_2.Field("version", arg_5)
 
-                def _arrow937(__unit: None=None, get2: Any=get2) -> Array[str] | None:
+                def _arrow936(__unit: None=None, get2: Any=get2) -> Array[str] | None:
                     object_arg_3: IOptionalGetter = get2.Optional
                     def arg_7(value_3: YAMLElement) -> Array[str]:
-                        def _arrow936(value_4: YAMLElement, value_3: Any=value_3) -> str:
+                        def _arrow935(value_4: YAMLElement, value_3: Any=value_3) -> str:
                             return string(value_4)
 
-                        return resizearray(_arrow936, value_3)
+                        return resizearray(_arrow935, value_3)
 
                     return object_arg_3.Field("specs", arg_7)
 
-                return SoftwarePackage(_arrow933(), _arrow935(), _arrow937())
+                return SoftwarePackage(_arrow932(), _arrow934(), _arrow936())
 
             return object(getter, value_5)
 
-        return resizearray(_arrow938, packages_element)
+        return resizearray(_arrow937, packages_element)
 
     elif packages_element.tag == 3:
         def chooser_2(_arg_3: YAMLElement, get: Any=get) -> SoftwarePackage | None:
             if _arg_3.tag == 0:
-                def _arrow939(__unit: None=None, _arg_3: Any=_arg_3) -> SoftwarePackage:
+                def _arrow938(__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)
@@ -1531,7 +1531,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 _arrow939()
+                return _arrow938()
 
             else: 
                 return None
@@ -1577,10 +1577,10 @@ def Decode_initialWorkDirRequirementDecoder(get: IGetters) -> Array[InitialWorkD
         pattern_matching_result = 1
 
     if pattern_matching_result == 0:
-        def _arrow940(value: YAMLElement, get: Any=get) -> InitialWorkDirEntry:
+        def _arrow939(value: YAMLElement, get: Any=get) -> InitialWorkDirEntry:
             return Decode_initialWorkDirEntryDecoder(value)
 
-        return resizearray(_arrow940, listing_element)
+        return resizearray(_arrow939, listing_element)
 
     elif pattern_matching_result == 1:
         return [Decode_initialWorkDirEntryDecoder(listing_element)]
@@ -1588,12 +1588,12 @@ def Decode_initialWorkDirRequirementDecoder(get: IGetters) -> Array[InitialWorkD
 
 
 def Decode_loadListingRequirementDecoder(get: IGetters) -> LoadListingRequirementValue:
-    def _arrow941(__unit: None=None, get: Any=get) -> str | None:
+    def _arrow940(__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(_arrow941(), "no_listing")
-    def _arrow942(__unit: None=None, get: Any=get) -> LoadListingEnum:
+    load_listing_value: str = default_arg(_arrow940(), "no_listing")
+    def _arrow941(__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.")
@@ -1602,7 +1602,7 @@ def Decode_loadListingRequirementDecoder(get: IGetters) -> LoadListingRequiremen
             return match_value
 
 
-    return LoadListingRequirementValue(_arrow942())
+    return LoadListingRequirementValue(_arrow941())
 
 
 def Decode_decodeResourceScalar(element: YAMLElement) -> Any:
@@ -1648,28 +1648,28 @@ def Decode_decodeResourceScalar(element: YAMLElement) -> Any:
         scalar_value: str = match_value
         match_value_1: tuple[bool, int64]
         out_arg: int64 = int64(0)
-        def _arrow943(__unit: None=None, element: Any=element) -> int64:
+        def _arrow942(__unit: None=None, element: Any=element) -> int64:
             return out_arg
 
-        def _arrow944(v: int64, element: Any=element) -> None:
+        def _arrow943(v: int64, element: Any=element) -> None:
             nonlocal out_arg
             out_arg = v
 
-        match_value_1 = (try_parse(scalar_value, 7, False, 64, FSharpRef(_arrow943, _arrow944)), out_arg)
+        match_value_1 = (try_parse(scalar_value, 7, False, 64, FSharpRef(_arrow942, _arrow943)), 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 _arrow945(__unit: None=None, element: Any=element) -> float:
+            def _arrow944(__unit: None=None, element: Any=element) -> float:
                 return out_arg_1
 
-            def _arrow946(v_1: float, element: Any=element) -> None:
+            def _arrow945(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(_arrow945, _arrow946)), out_arg_1)
+            match_value_2 = (try_parse_1(scalar_value, FSharpRef(_arrow944, _arrow945)), out_arg_1)
             if match_value_2[0]:
                 return match_value_2[1]
 
@@ -1681,17 +1681,17 @@ def Decode_decodeResourceScalar(element: YAMLElement) -> Any:
 
 
 def Decode_optionalResourceField(get: IGetters, field_name: str) -> Any | None:
-    def _arrow947(element: YAMLElement, get: Any=get, field_name: Any=field_name) -> Any:
+    def _arrow946(element: YAMLElement, get: Any=get, field_name: Any=field_name) -> Any:
         return Decode_decodeResourceScalar(element)
 
-    def _arrow948(__unit: None=None, get: Any=get, field_name: Any=field_name) -> YAMLElement | None:
+    def _arrow947(__unit: None=None, get: Any=get, field_name: Any=field_name) -> YAMLElement | None:
         object_arg: IOptionalGetter = get.Optional
         def arg_1(x: YAMLElement) -> YAMLElement:
             return x
 
         return object_arg.Field(field_name, arg_1)
 
-    return map_1(_arrow947, _arrow948())
+    return map_1(_arrow946, _arrow947())
 
 
 def Decode_resourceRequirementDecoder(get: IGetters) -> ResourceRequirementInstance:
@@ -1699,10 +1699,10 @@ def Decode_resourceRequirementDecoder(get: IGetters) -> ResourceRequirementInsta
 
 
 def Decode_schemaDefRequirementTypeDecoder(value: YAMLElement) -> SchemaDefRequirementType:
-    def _arrow949(get: IGetters, value: Any=value) -> Any:
+    def _arrow948(get: IGetters, value: Any=value) -> Any:
         return get.Overflow.FieldList(empty())
 
-    dict_1: Any = object(_arrow949, value)
+    dict_1: Any = object(_arrow948, value)
     if "name" in dict_1:
         return SchemaDefRequirementType(Decode_decodeStringOrExpression(get_item_from_dict(dict_1, "name")), Decode_cwlTypeDecoder_0027(value))
 
@@ -1718,10 +1718,10 @@ def Decode_schemaDefRequirementTypeDecoder(value: YAMLElement) -> SchemaDefRequi
 def Decode_schemaDefRequirementDecoder(get: IGetters) -> Array[SchemaDefRequirementType]:
     object_arg: IRequiredGetter = get.Required
     def arg_1(value: YAMLElement, get: Any=get) -> Array[SchemaDefRequirementType]:
-        def _arrow950(value_1: YAMLElement, value: Any=value) -> SchemaDefRequirementType:
+        def _arrow949(value_1: YAMLElement, value: Any=value) -> SchemaDefRequirementType:
             return Decode_schemaDefRequirementTypeDecoder(value_1)
 
-        return resizearray(_arrow950, value)
+        return resizearray(_arrow949, value)
 
     return object_arg.Field("types", arg_1)
 
@@ -1816,11 +1816,11 @@ def Decode_networkAccessRequirementDecoder(get: IGetters) -> Requirement:
 
 
 def Decode_inplaceUpdateRequirementDecoder(get: IGetters) -> InplaceUpdateRequirementValue:
-    def _arrow953(__unit: None=None, get: Any=get) -> bool | None:
+    def _arrow950(__unit: None=None, get: Any=get) -> bool | None:
         object_arg: IOptionalGetter = get.Optional
         return object_arg.Field("inplaceUpdate", bool_1)
 
-    return InplaceUpdateRequirementValue(default_arg(_arrow953(), True))
+    return InplaceUpdateRequirementValue(default_arg(_arrow950(), True))
 
 
 def Decode_toolTimeLimitRequirementDecoder(get: IGetters) -> ToolTimeLimitValue:
@@ -1837,14 +1837,14 @@ def Decode_toolTimeLimitRequirementDecoder(get: IGetters) -> ToolTimeLimitValue:
     else: 
         match_value: tuple[bool, int64]
         out_arg: int64 = int64(0)
-        def _arrow954(__unit: None=None, get: Any=get) -> int64:
+        def _arrow951(__unit: None=None, get: Any=get) -> int64:
             return out_arg
 
-        def _arrow955(v: int64, get: Any=get) -> None:
+        def _arrow952(v: int64, get: Any=get) -> None:
             nonlocal out_arg
             out_arg = v
 
-        match_value = (try_parse(try_get_scalar_string, 7, False, 64, FSharpRef(_arrow954, _arrow955)), out_arg)
+        match_value = (try_parse(try_get_scalar_string, 7, False, 64, FSharpRef(_arrow951, _arrow952)), out_arg)
         if match_value[0]:
             if match_value[1] >= int64(0):
                 return ToolTimeLimitValue(0, match_value[1])
@@ -1860,11 +1860,11 @@ def Decode_toolTimeLimitRequirementDecoder(get: IGetters) -> ToolTimeLimitValue:
 
 
 def Decode_inlineJavascriptRequirementDecoder(get: IGetters) -> InlineJavascriptRequirementValue:
-    def _arrow956(__unit: None=None, get: Any=get) -> Array[str] | None:
+    def _arrow953(__unit: None=None, get: Any=get) -> Array[str] | None:
         object_arg: IOptionalGetter = get.Optional
         return object_arg.Field("expressionLib", Decode_decodeStringArrayOrScalar)
 
-    return InlineJavascriptRequirementValue(_arrow956())
+    return InlineJavascriptRequirementValue(_arrow953())
 
 
 def Decode_requirementFromTypeName(cls: str, get: IGetters) -> Requirement:
@@ -2018,28 +2018,28 @@ def Decode_requirementArrayDecoder(y_ele: YAMLElement) -> Array[Requirement]:
 
     if pattern_matching_result == 0:
         def decode_single_requirement_object(ele: YAMLElement, y_ele: Any=y_ele) -> Requirement:
-            def _arrow958(get: IGetters, ele: Any=ele) -> Requirement:
-                def _arrow957(__unit: None=None) -> str:
+            def _arrow955(get: IGetters, ele: Any=ele) -> Requirement:
+                def _arrow954(__unit: None=None) -> str:
                     object_arg: IRequiredGetter = get.Required
                     return object_arg.Field("class", string)
 
-                return Decode_requirementFromTypeName(_arrow957(), get)
+                return Decode_requirementFromTypeName(_arrow954(), get)
 
-            return object(_arrow958, ele)
+            return object(_arrow955, ele)
 
         return list(map(decode_single_requirement_object, items))
 
     elif pattern_matching_result == 1:
-        def _arrow960(get_1: IGetters, y_ele: Any=y_ele) -> Array[Requirement]:
+        def _arrow957(get_1: IGetters, y_ele: Any=y_ele) -> Array[Requirement]:
             def mapping(kv: Any) -> Requirement:
-                def _arrow959(get_2: IGetters, kv: Any=kv) -> Requirement:
+                def _arrow956(get_2: IGetters, kv: Any=kv) -> Requirement:
                     return Decode_requirementFromTypeName(kv[0], get_2)
 
-                return object(_arrow959, kv[1])
+                return object(_arrow956, kv[1])
 
             return list(map_2(mapping, get_1.Overflow.FieldList(empty())))
 
-        return object(_arrow960, y_ele)
+        return object(_arrow957, y_ele)
 
     elif pattern_matching_result == 2:
         raise Exception(("Invalid CWL requirements syntax: " + str(other)) + "")
@@ -2048,23 +2048,23 @@ def Decode_requirementArrayDecoder(y_ele: YAMLElement) -> Array[Requirement]:
 
 def Decode_tryDecodeKnownRequirementFromElement(element: YAMLElement) -> Requirement | None:
     try: 
-        def _arrow963(get: IGetters) -> Requirement:
-            def _arrow962(__unit: None=None) -> str:
+        def _arrow960(get: IGetters) -> Requirement:
+            def _arrow959(__unit: None=None) -> str:
                 object_arg: IRequiredGetter = get.Required
                 return object_arg.Field("class", string)
 
-            return Decode_requirementFromTypeName(_arrow962(), get)
+            return Decode_requirementFromTypeName(_arrow959(), get)
 
-        return object(_arrow963, element)
+        return object(_arrow960, element)
 
     except Exception as ex:
         hint_class: str | None
         try: 
-            def _arrow961(get_1: IGetters) -> str | None:
+            def _arrow958(get_1: IGetters) -> str | None:
                 object_arg_1: IOptionalGetter = get_1.Optional
                 return object_arg_1.Field("class", string)
 
-            hint_class = object(_arrow961, element)
+            hint_class = object(_arrow958, element)
 
         except Exception as match_value:
             hint_class = None
@@ -2082,19 +2082,19 @@ def Decode_tryDecodeKnownRequirementFromElement(element: YAMLElement) -> Require
 def Decode_decodeHintElement(element: YAMLElement) -> HintEntry:
     match_value: Requirement | None = Decode_tryDecodeKnownRequirementFromElement(element)
     if match_value is None:
-        def _arrow965(__unit: None=None, element: Any=element) -> str | None:
+        def _arrow962(__unit: None=None, element: Any=element) -> str | None:
             try: 
-                def _arrow964(get: IGetters) -> str | None:
+                def _arrow961(get: IGetters) -> str | None:
                     object_arg: IOptionalGetter = get.Optional
                     return object_arg.Field("class", string)
 
-                return object(_arrow964, element)
+                return object(_arrow961, element)
 
             except Exception as match_value_1:
                 return None
 
 
-        return HintEntry(1, HintUnknownValue(_arrow965(), element))
+        return HintEntry(1, HintUnknownValue(_arrow962(), element))
 
     else: 
         return HintEntry(0, match_value)
@@ -2131,15 +2131,15 @@ def Decode_hintArrayDecoder(y_ele: YAMLElement) -> Array[HintEntry]:
         other_1 = y_ele
 
     if pattern_matching_result == 0:
-        def _arrow966(element: YAMLElement, y_ele: Any=y_ele) -> HintEntry:
+        def _arrow963(element: YAMLElement, y_ele: Any=y_ele) -> HintEntry:
             return Decode_decodeHintElement(element)
 
-        return list(map(_arrow966, items))
+        return list(map(_arrow963, items))
 
     elif pattern_matching_result == 1:
-        def _arrow968(get: IGetters, y_ele: Any=y_ele) -> Array[HintEntry]:
+        def _arrow966(get: IGetters, y_ele: Any=y_ele) -> Array[HintEntry]:
             def mapping(kv: Any) -> HintEntry:
-                def _arrow967(__unit: None=None, kv: Any=kv) -> YAMLElement:
+                def _arrow965(__unit: None=None, kv: Any=kv) -> YAMLElement:
                     match_value: YAMLElement = kv[1]
                     if match_value.tag == 3:
                         mappings: FSharpList[YAMLElement] = match_value.fields[0]
@@ -2169,18 +2169,18 @@ def Decode_hintArrayDecoder(y_ele: YAMLElement) -> Array[HintEntry]:
                         return YAMLElement(3, of_array([YAMLElement(0, YAMLContent_create_Z1C3A29C9("class"), YAMLElement(3, singleton_1(YAMLElement(1, YAMLContent_create_Z1C3A29C9(kv[0]))))), YAMLElement(0, YAMLContent_create_Z1C3A29C9("value"), match_value)]))
 
 
-                return Decode_decodeHintElement(_arrow967())
+                return Decode_decodeHintElement(_arrow965())
 
             return list(map_2(mapping, get.Overflow.FieldList(empty())))
 
-        return object(_arrow968, y_ele)
+        return object(_arrow966, y_ele)
 
     elif pattern_matching_result == 2:
         raise Exception(("Invalid CWL hints syntax: " + str(other_1)) + "")
 
 
 
-def _arrow969(value: YAMLElement) -> Array[Requirement] | None:
+def _arrow967(value: YAMLElement) -> Array[Requirement] | None:
     def getter(get: IGetters) -> Array[Requirement] | None:
         object_arg: IOptionalGetter = get.Optional
         def arg_1(y_ele: YAMLElement, get: Any=get) -> Array[Requirement]:
@@ -2191,9 +2191,9 @@ def _arrow969(value: YAMLElement) -> Array[Requirement] | None:
     return object(getter, value)
 
 
-Decode_requirementsDecoder: Callable[[YAMLElement], Array[Requirement] | None] = _arrow969
+Decode_requirementsDecoder: Callable[[YAMLElement], Array[Requirement] | None] = _arrow967
 
-def _arrow970(value: YAMLElement) -> Array[HintEntry] | None:
+def _arrow968(value: YAMLElement) -> Array[HintEntry] | None:
     def getter(get: IGetters) -> Array[HintEntry] | None:
         object_arg: IOptionalGetter = get.Optional
         def arg_1(y_ele: YAMLElement, get: Any=get) -> Array[HintEntry]:
@@ -2204,30 +2204,30 @@ def _arrow970(value: YAMLElement) -> Array[HintEntry] | None:
     return object(getter, value)
 
 
-Decode_hintsDecoder: Callable[[YAMLElement], Array[HintEntry] | None] = _arrow970
+Decode_hintsDecoder: Callable[[YAMLElement], Array[HintEntry] | None] = _arrow968
 
-def _arrow975(value_5: YAMLElement) -> InputBinding | None:
+def _arrow974(value_5: YAMLElement) -> InputBinding | None:
     def getter_1(get: IGetters) -> InputBinding | None:
         object_arg: IOptionalGetter = get.Optional
         def arg_1(value_4: YAMLElement, get: Any=get) -> InputBinding:
             def getter(get_0027: IGetters, value_4: Any=value_4) -> InputBinding:
-                def _arrow971(__unit: None=None, get_0027: Any=get_0027) -> str | None:
+                def _arrow969(__unit: None=None, get_0027: Any=get_0027) -> str | None:
                     object_arg_1: IOptionalGetter = get_0027.Optional
                     return object_arg_1.Field("prefix", string)
 
-                def _arrow972(__unit: None=None, get_0027: Any=get_0027) -> int | None:
+                def _arrow970(__unit: None=None, get_0027: Any=get_0027) -> int | None:
                     object_arg_2: IOptionalGetter = get_0027.Optional
                     return object_arg_2.Field("position", int_1)
 
-                def _arrow973(__unit: None=None, get_0027: Any=get_0027) -> str | None:
+                def _arrow971(__unit: None=None, get_0027: Any=get_0027) -> str | None:
                     object_arg_3: IOptionalGetter = get_0027.Optional
                     return object_arg_3.Field("itemSeparator", string)
 
-                def _arrow974(__unit: None=None, get_0027: Any=get_0027) -> bool | None:
+                def _arrow973(__unit: None=None, get_0027: Any=get_0027) -> bool | None:
                     object_arg_4: IOptionalGetter = get_0027.Optional
                     return object_arg_4.Field("separate", bool_1)
 
-                return InputBinding(_arrow971(), _arrow972(), _arrow973(), _arrow974())
+                return InputBinding(_arrow969(), _arrow970(), _arrow971(), _arrow973())
 
             return object(getter, value_4)
 
@@ -2236,7 +2236,7 @@ def _arrow975(value_5: YAMLElement) -> InputBinding | None:
     return object(getter_1, value_5)
 
 
-Decode_inputBindingDecoder: Callable[[YAMLElement], InputBinding | None] = _arrow975
+Decode_inputBindingDecoder: Callable[[YAMLElement], InputBinding | None] = _arrow974
 
 def _arrow982(value_1: YAMLElement) -> Array[CWLInput]:
     def getter(get: IGetters) -> Array[CWLInput]: