ARCtrl 2.2.1__tar.gz → 2.2.3__tar.gz

{arctrl-2.2.1 → arctrl-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ARCtrl
-Version: 2.2.1
+Version: 2.2.3
 Summary: Library for management of Annotated Research Contexts (ARCs) using an in-memory representation and runtimer agnostic contract systems.
 Home-page: https://github.com/nfdi4plants/ARCtrl
 Keywords: arc,annotated research context,isa,research data,multi platform
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: requests (==2.28.1)
+Requires-Dist: requests (>=2.28.1,<3.0.0)
 Project-URL: Repository, https://github.com/nfdi4plants/ARCtrl
 Description-Content-Type: text/markdown
 

{arctrl-2.2.1 → arctrl-2.2.3}/arctrl/CWL/cwltypes.py

@@ -6,7 +6,7 @@ from ..fable_modules.dynamic_obj.dyn_obj import set_property
 from ..fable_modules.fable_library.reflection import (TypeInfo, class_type, string_type, option_type, bool_type, record_type, union_type, array_type)
 from ..fable_modules.fable_library.types import (Record, Array, Union, FSharpRef)
 
-def _expr447() -> TypeInfo:
+def _expr451() -> TypeInfo:
     return class_type("ARCtrl.CWL.FileInstance", None, FileInstance, DynamicObj_reflection())
 
 
@@ -16,13 +16,13 @@ class FileInstance(DynamicObj):
         pass
 
 
-FileInstance_reflection = _expr447
+FileInstance_reflection = _expr451
 
 def FileInstance__ctor(__unit: None=None) -> FileInstance:
     return FileInstance(__unit)
 
 
-def _expr449() -> TypeInfo:
+def _expr452() -> TypeInfo:
     return class_type("ARCtrl.CWL.DirectoryInstance", None, DirectoryInstance, DynamicObj_reflection())
 
 
@@ -32,13 +32,13 @@ class DirectoryInstance(DynamicObj):
         pass
 
 
-DirectoryInstance_reflection = _expr449
+DirectoryInstance_reflection = _expr452
 
 def DirectoryInstance__ctor(__unit: None=None) -> DirectoryInstance:
     return DirectoryInstance(__unit)
 
 
-def _expr452() -> TypeInfo:
+def _expr454() -> TypeInfo:
     return record_type("ARCtrl.CWL.DirentInstance", [], DirentInstance, lambda: [("Entry", string_type), ("Entryname", option_type(string_type)), ("Writable", option_type(bool_type))])
 
 
@@ -48,9 +48,9 @@ class DirentInstance(Record):
     Entryname: str | None
     Writable: bool | None
 
-DirentInstance_reflection = _expr452
+DirentInstance_reflection = _expr454
 
-def _expr458() -> TypeInfo:
+def _expr455() -> TypeInfo:
     return union_type("ARCtrl.CWL.CWLType", [], CWLType, lambda: [[("Item", FileInstance_reflection())], [("Item", DirectoryInstance_reflection())], [("Item", DirentInstance_reflection())], [], [], [], [], [], [], [], [], [("Item", CWLType_reflection())]])
 
 
@@ -65,9 +65,9 @@ class CWLType(Union):
         return ["File", "Directory", "Dirent", "String", "Int", "Long", "Float", "Double", "Boolean", "Stdout", "Null", "Array"]
 
 
-CWLType_reflection = _expr458
+CWLType_reflection = _expr455
 
-def _expr460() -> TypeInfo:
+def _expr456() -> TypeInfo:
     return class_type("ARCtrl.CWL.InputRecordSchema", None, InputRecordSchema, DynamicObj_reflection())
 
 
@@ -77,13 +77,13 @@ class InputRecordSchema(DynamicObj):
         pass
 
 
-InputRecordSchema_reflection = _expr460
+InputRecordSchema_reflection = _expr456
 
 def InputRecordSchema__ctor(__unit: None=None) -> InputRecordSchema:
     return InputRecordSchema(__unit)
 
 
-def _expr461() -> TypeInfo:
+def _expr458() -> TypeInfo:
     return class_type("ARCtrl.CWL.InputEnumSchema", None, InputEnumSchema, DynamicObj_reflection())
 
 
@@ -93,13 +93,13 @@ class InputEnumSchema(DynamicObj):
         pass
 
 
-InputEnumSchema_reflection = _expr461
+InputEnumSchema_reflection = _expr458
 
 def InputEnumSchema__ctor(__unit: None=None) -> InputEnumSchema:
     return InputEnumSchema(__unit)
 
 
-def _expr462() -> TypeInfo:
+def _expr459() -> TypeInfo:
     return class_type("ARCtrl.CWL.InputArraySchema", None, InputArraySchema, DynamicObj_reflection())
 
 
@@ -109,7 +109,7 @@ class InputArraySchema(DynamicObj):
         pass
 
 
-InputArraySchema_reflection = _expr462
+InputArraySchema_reflection = _expr459
 
 def InputArraySchema__ctor(__unit: None=None) -> InputArraySchema:
     return InputArraySchema(__unit)

{arctrl-2.2.1 → arctrl-2.2.3}/arctrl/CWL/decode.py

@@ -340,43 +340,43 @@ def _arrow527(value_1: YAMLElement) -> tuple[CWLType, bool]:
 
 Decode_cwlTypeDecoder: Callable[[YAMLElement], tuple[CWLType, bool]] = _arrow527
 
-def _arrow537(value_2: YAMLElement) -> Array[CWLOutput]:
+def _arrow534(value_2: YAMLElement) -> Array[CWLOutput]:
     def getter(get: IGetters) -> Array[CWLOutput]:
         dict_1: Any = get.Overflow.FieldList(empty())
-        def _arrow536(__unit: None=None, get: Any=get) -> IEnumerable_1[CWLOutput]:
-            def _arrow535(key: str) -> IEnumerable_1[CWLOutput]:
+        def _arrow533(__unit: None=None, get: Any=get) -> IEnumerable_1[CWLOutput]:
+            def _arrow532(key: str) -> IEnumerable_1[CWLOutput]:
                 value: YAMLElement = get_item_from_dict(dict_1, key)
                 output_binding: OutputBinding | None = Decode_outputBindingDecoder(value)
                 output_source: str | None
                 object_arg: IOptionalGetter = get.Optional
                 output_source = object_arg.Field("outputSource", string)
                 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 _expr531():
+                def _expr528():
                     set_optional_property("outputBinding", output_binding, output)
                     return empty_1()
 
-                def _arrow534(__unit: None=None) -> IEnumerable_1[CWLOutput]:
-                    def _expr532():
+                def _arrow531(__unit: None=None) -> IEnumerable_1[CWLOutput]:
+                    def _expr529():
                         set_optional_property("outputSource", output_source, output)
                         return empty_1()
 
-                    def _arrow533(__unit: None=None) -> IEnumerable_1[CWLOutput]:
+                    def _arrow530(__unit: None=None) -> IEnumerable_1[CWLOutput]:
                         return singleton(output)
 
-                    return append(_expr532() if (output_source is not None) else empty_1(), delay(_arrow533))
+                    return append(_expr529() if (output_source is not None) else empty_1(), delay(_arrow530))
 
-                return append(_expr531() if (output_binding is not None) else empty_1(), delay(_arrow534))
+                return append(_expr528() if (output_binding is not None) else empty_1(), delay(_arrow531))
 
-            return collect(_arrow535, dict_1.keys())
+            return collect(_arrow532, dict_1.keys())
 
-        return list(to_array(delay(_arrow536)))
+        return list(to_array(delay(_arrow533)))
 
     return object(getter, value_2)
 
 
-Decode_outputArrayDecoder: Callable[[YAMLElement], Array[CWLOutput]] = _arrow537
+Decode_outputArrayDecoder: Callable[[YAMLElement], Array[CWLOutput]] = _arrow534
 
-def _arrow538(value: YAMLElement) -> Array[CWLOutput]:
+def _arrow535(value: YAMLElement) -> Array[CWLOutput]:
     def getter(get: IGetters) -> Array[CWLOutput]:
         object_arg: IRequiredGetter = get.Required
         return object_arg.Field("outputs", Decode_outputArrayDecoder)
@@ -384,31 +384,31 @@ def _arrow538(value: YAMLElement) -> Array[CWLOutput]:
     return object(getter, value)
 
 
-Decode_outputsDecoder: Callable[[YAMLElement], Array[CWLOutput]] = _arrow538
+Decode_outputsDecoder: Callable[[YAMLElement], Array[CWLOutput]] = _arrow535
 
 def Decode_dockerRequirementDecoder(get: IGetters) -> DockerRequirement:
-    def _arrow539(__unit: None=None, get: Any=get) -> str | None:
+    def _arrow536(__unit: None=None, get: Any=get) -> str | None:
         object_arg: IOptionalGetter = get.Optional
         return object_arg.Field("dockerPull", string)
 
-    def _arrow541(__unit: None=None, get: Any=get) -> Any | None:
+    def _arrow538(__unit: None=None, get: Any=get) -> Any | None:
         object_arg_1: IOptionalGetter = get.Optional
         def arg_3(value_1: YAMLElement) -> Any:
             def key_decoder(x: str, value_1: Any=value_1) -> str:
                 return x
 
-            def _arrow540(value_2: YAMLElement, value_1: Any=value_1) -> str:
+            def _arrow537(value_2: YAMLElement, value_1: Any=value_1) -> str:
                 return string(value_2)
 
-            return map_1(key_decoder, _arrow540, value_1)
+            return map_1(key_decoder, _arrow537, value_1)
 
         return object_arg_1.Field("dockerFile", arg_3)
 
-    def _arrow542(__unit: None=None, get: Any=get) -> str | None:
+    def _arrow539(__unit: None=None, get: Any=get) -> str | None:
         object_arg_2: IOptionalGetter = get.Optional
         return object_arg_2.Field("dockerImageId", string)
 
-    return DockerRequirement(_arrow539(), _arrow541(), _arrow542())
+    return DockerRequirement(_arrow536(), _arrow538(), _arrow539())
 
 
 def Decode_envVarRequirementDecoder(get: IGetters) -> Array[EnvironmentDef]:
@@ -416,15 +416,15 @@ def Decode_envVarRequirementDecoder(get: IGetters) -> Array[EnvironmentDef]:
     def arg_1(value_3: YAMLElement, get: Any=get) -> Array[EnvironmentDef]:
         def decoder(value_2: YAMLElement, value_3: Any=value_3) -> EnvironmentDef:
             def getter(get2: IGetters, value_2: Any=value_2) -> EnvironmentDef:
-                def _arrow543(__unit: None=None, get2: Any=get2) -> str:
+                def _arrow540(__unit: None=None, get2: Any=get2) -> str:
                     object_arg_1: IRequiredGetter = get2.Required
                     return object_arg_1.Field("envName", string)
 
-                def _arrow544(__unit: None=None, get2: Any=get2) -> str:
+                def _arrow541(__unit: None=None, get2: Any=get2) -> str:
                     object_arg_2: IRequiredGetter = get2.Required
                     return object_arg_2.Field("envValue", string)
 
-                return EnvironmentDef(_arrow543(), _arrow544())
+                return EnvironmentDef(_arrow540(), _arrow541())
 
             return object(getter, value_2)
 
@@ -438,31 +438,31 @@ def Decode_softwareRequirementDecoder(get: IGetters) -> Array[SoftwarePackage]:
     def arg_1(value_6: YAMLElement, get: Any=get) -> Array[SoftwarePackage]:
         def decoder(value_5: YAMLElement, value_6: Any=value_6) -> SoftwarePackage:
             def getter(get2: IGetters, value_5: Any=value_5) -> SoftwarePackage:
-                def _arrow545(__unit: None=None, get2: Any=get2) -> str:
+                def _arrow542(__unit: None=None, get2: Any=get2) -> str:
                     object_arg_1: IRequiredGetter = get2.Required
                     return object_arg_1.Field("package", string)
 
-                def _arrow547(__unit: None=None, get2: Any=get2) -> Array[str] | None:
+                def _arrow544(__unit: None=None, get2: Any=get2) -> Array[str] | None:
                     object_arg_2: IOptionalGetter = get2.Optional
                     def arg_5(value_1: YAMLElement) -> Array[str]:
-                        def _arrow546(value_2: YAMLElement, value_1: Any=value_1) -> str:
+                        def _arrow543(value_2: YAMLElement, value_1: Any=value_1) -> str:
                             return string(value_2)
 
-                        return resizearray(_arrow546, value_1)
+                        return resizearray(_arrow543, value_1)
 
                     return object_arg_2.Field("version", arg_5)
 
-                def _arrow549(__unit: None=None, get2: Any=get2) -> Array[str] | None:
+                def _arrow547(__unit: None=None, get2: Any=get2) -> Array[str] | None:
                     object_arg_3: IOptionalGetter = get2.Optional
                     def arg_7(value_3: YAMLElement) -> Array[str]:
-                        def _arrow548(value_4: YAMLElement, value_3: Any=value_3) -> str:
+                        def _arrow546(value_4: YAMLElement, value_3: Any=value_3) -> str:
                             return string(value_4)
 
-                        return resizearray(_arrow548, value_3)
+                        return resizearray(_arrow546, value_3)
 
                     return object_arg_3.Field("specs", arg_7)
 
-                return SoftwarePackage(_arrow545(), _arrow547(), _arrow549())
+                return SoftwarePackage(_arrow542(), _arrow544(), _arrow547())
 
             return object(getter, value_5)
 
@@ -480,86 +480,86 @@ def Decode_initialWorkDirRequirementDecoder(get: IGetters) -> Array[CWLType]:
 
 
 def Decode_resourceRequirementDecoder(get: IGetters) -> ResourceRequirementInstance:
-    def _arrow550(__unit: None=None, get: Any=get) -> YAMLElement | None:
+    def _arrow548(__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("coresMin", arg_1)
 
-    def _arrow551(__unit: None=None, get: Any=get) -> YAMLElement | None:
+    def _arrow549(__unit: None=None, get: Any=get) -> YAMLElement | None:
         object_arg_1: IOptionalGetter = get.Optional
         def arg_3(x_1: YAMLElement) -> YAMLElement:
             return x_1
 
         return object_arg_1.Field("coresMax", arg_3)
 
-    def _arrow552(__unit: None=None, get: Any=get) -> YAMLElement | None:
+    def _arrow550(__unit: None=None, get: Any=get) -> YAMLElement | None:
         object_arg_2: IOptionalGetter = get.Optional
         def arg_5(x_2: YAMLElement) -> YAMLElement:
             return x_2
 
         return object_arg_2.Field("ramMin", arg_5)
 
-    def _arrow553(__unit: None=None, get: Any=get) -> YAMLElement | None:
+    def _arrow551(__unit: None=None, get: Any=get) -> YAMLElement | None:
         object_arg_3: IOptionalGetter = get.Optional
         def arg_7(x_3: YAMLElement) -> YAMLElement:
             return x_3
 
         return object_arg_3.Field("ramMax", arg_7)
 
-    def _arrow554(__unit: None=None, get: Any=get) -> YAMLElement | None:
+    def _arrow552(__unit: None=None, get: Any=get) -> YAMLElement | None:
         object_arg_4: IOptionalGetter = get.Optional
         def arg_9(x_4: YAMLElement) -> YAMLElement:
             return x_4
 
         return object_arg_4.Field("tmpdirMin", arg_9)
 
-    def _arrow555(__unit: None=None, get: Any=get) -> YAMLElement | None:
+    def _arrow553(__unit: None=None, get: Any=get) -> YAMLElement | None:
         object_arg_5: IOptionalGetter = get.Optional
         def arg_11(x_5: YAMLElement) -> YAMLElement:
             return x_5
 
         return object_arg_5.Field("tmpdirMax", arg_11)
 
-    def _arrow556(__unit: None=None, get: Any=get) -> YAMLElement | None:
+    def _arrow554(__unit: None=None, get: Any=get) -> YAMLElement | None:
         object_arg_6: IOptionalGetter = get.Optional
         def arg_13(x_6: YAMLElement) -> YAMLElement:
             return x_6
 
         return object_arg_6.Field("outdirMin", arg_13)
 
-    def _arrow557(__unit: None=None, get: Any=get) -> YAMLElement | None:
+    def _arrow555(__unit: None=None, get: Any=get) -> YAMLElement | None:
         object_arg_7: IOptionalGetter = get.Optional
         def arg_15(x_7: YAMLElement) -> YAMLElement:
             return x_7
 
         return object_arg_7.Field("outdirMax", arg_15)
 
-    return ResourceRequirementInstance__ctor_D76FC00(some(_arrow550()), some(_arrow551()), some(_arrow552()), some(_arrow553()), some(_arrow554()), some(_arrow555()), some(_arrow556()), some(_arrow557()))
+    return ResourceRequirementInstance__ctor_D76FC00(some(_arrow548()), some(_arrow549()), some(_arrow550()), some(_arrow551()), some(_arrow552()), some(_arrow553()), some(_arrow554()), some(_arrow555()))
 
 
 def Decode_schemaDefRequirementDecoder(get: IGetters) -> Array[SchemaDefRequirementType]:
     def f(m: Any, get: Any=get) -> SchemaDefRequirementType:
         return SchemaDefRequirementType__ctor_541DA560(item(0, FSharpMap__get_Keys(m)), item(0, FSharpMap__get_Values(m)))
 
-    def _arrow559(__unit: None=None, get: Any=get) -> Array[Any]:
+    def _arrow557(__unit: None=None, get: Any=get) -> Array[Any]:
         object_arg: IRequiredGetter = get.Required
         def arg_1(value_2: YAMLElement) -> Array[Any]:
             def decoder(value: YAMLElement, value_2: Any=value_2) -> Any:
                 def key_decoder(x: str, value: Any=value) -> str:
                     return x
 
-                def _arrow558(value_1: YAMLElement, value: Any=value) -> str:
+                def _arrow556(value_1: YAMLElement, value: Any=value) -> str:
                     return string(value_1)
 
-                return map_1(key_decoder, _arrow558, value)
+                return map_1(key_decoder, _arrow556, value)
 
             return resizearray(decoder, value_2)
 
         return object_arg.Field("types", arg_1)
 
-    return ResizeArray_map(f, _arrow559())
+    return ResizeArray_map(f, _arrow557())
 
 
 def Decode_toolTimeLimitRequirementDecoder(get: IGetters) -> float:
@@ -570,7 +570,7 @@ def Decode_toolTimeLimitRequirementDecoder(get: IGetters) -> float:
     return object_arg.Field("timelimit", arg_1)
 
 
-def _arrow560(value_2: YAMLElement) -> Array[Requirement]:
+def _arrow558(value_2: YAMLElement) -> Array[Requirement]:
     def decoder(value_1: YAMLElement) -> Requirement:
         def getter(get: IGetters, value_1: Any=value_1) -> Requirement:
             cls: str
@@ -636,9 +636,9 @@ def _arrow560(value_2: YAMLElement) -> Array[Requirement]:
     return resizearray(decoder, value_2)
 
 
-Decode_requirementArrayDecoder: Callable[[YAMLElement], Array[Requirement]] = _arrow560
+Decode_requirementArrayDecoder: Callable[[YAMLElement], Array[Requirement]] = _arrow558
 
-def _arrow561(value: YAMLElement) -> Array[Requirement] | None:
+def _arrow559(value: YAMLElement) -> Array[Requirement] | None:
     def getter(get: IGetters) -> Array[Requirement] | None:
         object_arg: IOptionalGetter = get.Optional
         return object_arg.Field("requirements", Decode_requirementArrayDecoder)
@@ -646,9 +646,9 @@ def _arrow561(value: YAMLElement) -> Array[Requirement] | None:
     return object(getter, value)
 
 
-Decode_requirementsDecoder: Callable[[YAMLElement], Array[Requirement] | None] = _arrow561
+Decode_requirementsDecoder: Callable[[YAMLElement], Array[Requirement] | None] = _arrow559
 
-def _arrow562(value: YAMLElement) -> Array[Requirement] | None:
+def _arrow560(value: YAMLElement) -> Array[Requirement] | None:
     def getter(get: IGetters) -> Array[Requirement] | None:
         object_arg: IOptionalGetter = get.Optional
         return object_arg.Field("hints", Decode_requirementArrayDecoder)
@@ -656,14 +656,14 @@ def _arrow562(value: YAMLElement) -> Array[Requirement] | None:
     return object(getter, value)
 
 
-Decode_hintsDecoder: Callable[[YAMLElement], Array[Requirement] | None] = _arrow562
+Decode_hintsDecoder: Callable[[YAMLElement], Array[Requirement] | None] = _arrow560
 
 def _arrow567(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 _arrow563(__unit: None=None, get_0027: Any=get_0027) -> str | None:
+                def _arrow561(__unit: None=None, get_0027: Any=get_0027) -> str | None:
                     object_arg_1: IOptionalGetter = get_0027.Optional
                     return object_arg_1.Field("prefix", string)
 
@@ -679,7 +679,7 @@ def _arrow567(value_5: YAMLElement) -> InputBinding | None:
                     object_arg_4: IOptionalGetter = get_0027.Optional
                     return object_arg_4.Field("separate", bool_1)
 
-                return InputBinding(_arrow563(), _arrow564(), _arrow565(), _arrow566())
+                return InputBinding(_arrow561(), _arrow564(), _arrow565(), _arrow566())
 
             return object(getter, value_4)
 

{arctrl-2.2.1 → arctrl-2.2.3}/arctrl/Core/Helper/hash_codes.py

@@ -31,15 +31,15 @@ def hash_1(obj: Any | None=None) -> int:
 
 
 def box_hash_option(a: Any | None=None) -> Any:
-    def _arrow529(__unit: None=None, a: Any=a) -> int:
+    def _arrow562(__unit: None=None, a: Any=a) -> int:
         copy_of_struct: _A = value_1(a)
         return identity_hash(copy_of_struct)
 
-    def _arrow530(__unit: None=None, a: Any=a) -> int:
+    def _arrow563(__unit: None=None, a: Any=a) -> int:
         copy_of_struct_1: int = 0
         return number_hash(copy_of_struct_1)
 
-    return _arrow529() if (a is not None) else _arrow530()
+    return _arrow562() if (a is not None) else _arrow563()
 
 
 def box_hash_array(a: Array[Any]) -> Any:

{arctrl-2.2.1 → arctrl-2.2.3}/arctrl/Core/Helper/identifier.py

@@ -23,11 +23,11 @@ def check_valid_characters(identifier: str) -> None:
 
 
 def create_missing_identifier(__unit: None=None) -> str:
-    def _arrow528(__unit: None=None) -> str:
+    def _arrow545(__unit: None=None) -> str:
         copy_of_struct: str = new_guid()
         return str(copy_of_struct)
 
-    return "MISSING_IDENTIFIER_" + _arrow528()
+    return "MISSING_IDENTIFIER_" + _arrow545()
 
 
 def is_missing_identifier(str_1: str) -> bool:

{arctrl-2.2.1 → arctrl-2.2.3}/arctrl/Core/conversion.py

@@ -46,12 +46,12 @@ Person_orcidKey: str = "ORCID"
 
 Person_AssayIdentifierPrefix: str = "performer (ARC:00000168)"
 
-def _arrow1094(__unit: None=None) -> Callable[[str], str]:
+def _arrow1087(__unit: None=None) -> Callable[[str], str]:
     clo_1: Callable[[str], str] = to_text(printf("%s %s"))(Person_AssayIdentifierPrefix)
     return clo_1
 
 
-Person_createAssayIdentifierKey: Callable[[str], str] = _arrow1094()
+Person_createAssayIdentifierKey: Callable[[str], str] = _arrow1087()
 
 def Person_setSourceAssayComment(person: Person, assay_identifier: str) -> Person:
     person_1: Person = person.Copy()
@@ -414,10 +414,10 @@ def ProcessParsing_tryComponentGetter(general_i: int, value_i: int, value_header
         new_oa: OntologyAnnotation = value_header.fields[0].Copy()
         ARCtrl_OntologyAnnotation__OntologyAnnotation_SetColumnIndex_Z524259A4(new_oa, value_i)
         def Value(matrix: Any, general_i: Any=general_i, value_i: Any=value_i, value_header: Any=value_header) -> Callable[[int], Component]:
-            def _arrow1102(i: int, matrix: Any=matrix) -> Component:
+            def _arrow1101(i: int, matrix: Any=matrix) -> Component:
                 return JsonTypes_composeComponent(CompositeHeader(0, new_oa), get_item_from_dict(matrix, (general_i, i)))
 
-            return _arrow1102
+            return _arrow1101
 
         return Value
 
@@ -446,10 +446,10 @@ def ProcessParsing_tryFactorGetter(general_i: int, value_i: int, value_header: C
     if value_header.tag == 2:
         cat: CompositeHeader = CompositeHeader(2, ARCtrl_OntologyAnnotation__OntologyAnnotation_setColumnIndex_Static(value_i, value_header.fields[0]))
         def Value(matrix: Any, general_i: Any=general_i, value_i: Any=value_i, value_header: Any=value_header) -> Callable[[int], FactorValue]:
-            def _arrow1105(i_1: int, matrix: Any=matrix) -> FactorValue:
+            def _arrow1104(i_1: int, matrix: Any=matrix) -> FactorValue:
                 return JsonTypes_composeFactorValue(cat, get_item_from_dict(matrix, (general_i, i_1)))
 
-            return _arrow1105
+            return _arrow1104
 
         return Value
 
@@ -462,10 +462,10 @@ def ProcessParsing_tryCharacteristicGetter(general_i: int, value_i: int, value_h
     if value_header.tag == 1:
         cat: CompositeHeader = CompositeHeader(1, ARCtrl_OntologyAnnotation__OntologyAnnotation_setColumnIndex_Static(value_i, value_header.fields[0]))
         def Value(matrix: Any, general_i: Any=general_i, value_i: Any=value_i, value_header: Any=value_header) -> Callable[[int], MaterialAttributeValue]:
-            def _arrow1108(i_1: int, matrix: Any=matrix) -> MaterialAttributeValue:
+            def _arrow1105(i_1: int, matrix: Any=matrix) -> MaterialAttributeValue:
                 return JsonTypes_composeCharacteristicValue(cat, get_item_from_dict(matrix, (general_i, i_1)))
 
-            return _arrow1108
+            return _arrow1105
 
         return Value
 
@@ -477,10 +477,10 @@ def ProcessParsing_tryCharacteristicGetter(general_i: int, value_i: int, value_h
 def ProcessParsing_tryGetProtocolTypeGetter(general_i: int, header: CompositeHeader) -> Callable[[Any, int], OntologyAnnotation] | None:
     if header.tag == 4:
         def Value(matrix: Any, general_i: Any=general_i, header: Any=header) -> Callable[[int], OntologyAnnotation]:
-            def _arrow1109(i: int, matrix: Any=matrix) -> OntologyAnnotation:
+            def _arrow1107(i: int, matrix: Any=matrix) -> OntologyAnnotation:
                 return get_item_from_dict(matrix, (general_i, i)).AsTerm
 
-            return _arrow1109
+            return _arrow1107
 
         return Value
 
@@ -492,10 +492,10 @@ def ProcessParsing_tryGetProtocolTypeGetter(general_i: int, header: CompositeHea
 def ProcessParsing_tryGetProtocolREFGetter(general_i: int, header: CompositeHeader) -> Callable[[Any, int], str] | None:
     if header.tag == 8:
         def Value(matrix: Any, general_i: Any=general_i, header: Any=header) -> Callable[[int], str]:
-            def _arrow1112(i: int, matrix: Any=matrix) -> str:
+            def _arrow1108(i: int, matrix: Any=matrix) -> str:
                 return get_item_from_dict(matrix, (general_i, i)).AsFreeText
 
-            return _arrow1112
+            return _arrow1108
 
         return Value
 
@@ -507,10 +507,10 @@ def ProcessParsing_tryGetProtocolREFGetter(general_i: int, header: CompositeHead
 def ProcessParsing_tryGetProtocolDescriptionGetter(general_i: int, header: CompositeHeader) -> Callable[[Any, int], str] | None:
     if header.tag == 5:
         def Value(matrix: Any, general_i: Any=general_i, header: Any=header) -> Callable[[int], str]:
-            def _arrow1113(i: int, matrix: Any=matrix) -> str:
+            def _arrow1110(i: int, matrix: Any=matrix) -> str:
                 return get_item_from_dict(matrix, (general_i, i)).AsFreeText
 
-            return _arrow1113
+            return _arrow1110
 
         return Value
 
@@ -522,10 +522,10 @@ def ProcessParsing_tryGetProtocolDescriptionGetter(general_i: int, header: Compo
 def ProcessParsing_tryGetProtocolURIGetter(general_i: int, header: CompositeHeader) -> Callable[[Any, int], str] | None:
     if header.tag == 6:
         def Value(matrix: Any, general_i: Any=general_i, header: Any=header) -> Callable[[int], str]:
-            def _arrow1114(i: int, matrix: Any=matrix) -> str:
+            def _arrow1112(i: int, matrix: Any=matrix) -> str:
                 return get_item_from_dict(matrix, (general_i, i)).AsFreeText
 
-            return _arrow1114
+            return _arrow1112
 
         return Value
 
@@ -537,10 +537,10 @@ def ProcessParsing_tryGetProtocolURIGetter(general_i: int, header: CompositeHead
 def ProcessParsing_tryGetProtocolVersionGetter(general_i: int, header: CompositeHeader) -> Callable[[Any, int], str] | None:
     if header.tag == 7:
         def Value(matrix: Any, general_i: Any=general_i, header: Any=header) -> Callable[[int], str]:
-            def _arrow1115(i: int, matrix: Any=matrix) -> str:
+            def _arrow1113(i: int, matrix: Any=matrix) -> str:
                 return get_item_from_dict(matrix, (general_i, i)).AsFreeText
 
-            return _arrow1115
+            return _arrow1113
 
         return Value
 
@@ -552,10 +552,10 @@ def ProcessParsing_tryGetProtocolVersionGetter(general_i: int, header: Composite
 def ProcessParsing_tryGetInputGetter(general_i: int, header: CompositeHeader) -> Callable[[Any, int], ProcessInput] | None:
     if header.tag == 11:
         def Value(matrix: Any, general_i: Any=general_i, header: Any=header) -> Callable[[int], ProcessInput]:
-            def _arrow1116(i: int, matrix: Any=matrix) -> ProcessInput:
+            def _arrow1114(i: int, matrix: Any=matrix) -> ProcessInput:
                 return JsonTypes_composeProcessInput(header, get_item_from_dict(matrix, (general_i, i)))
 
-            return _arrow1116
+            return _arrow1114
 
         return Value
 
@@ -582,10 +582,10 @@ def ProcessParsing_tryGetOutputGetter(general_i: int, header: CompositeHeader) -
 def ProcessParsing_tryGetCommentGetter(general_i: int, header: CompositeHeader) -> Callable[[Any, int], Comment] | None:
     if header.tag == 14:
         def Value(matrix: Any, general_i: Any=general_i, header: Any=header) -> Callable[[int], Comment]:
-            def _arrow1119(i: int, matrix: Any=matrix) -> Comment:
+            def _arrow1118(i: int, matrix: Any=matrix) -> Comment:
                 return Comment(header.fields[0], get_item_from_dict(matrix, (general_i, i)).AsFreeText)
 
-            return _arrow1119
+            return _arrow1118
 
         return Value
 
@@ -650,16 +650,16 @@ def ProcessParsing_getProcessGetter(process_name_root: str, headers: IEnumerable
 
     match_value: Callable[[Any, int], ProcessInput] | None = try_pick(chooser_10, headers_1)
     if match_value is None:
-        def _arrow1129(matrix_1: Any, process_name_root: Any=process_name_root, headers: Any=headers) -> Callable[[int], FSharpList[ProcessInput]]:
-            def _arrow1128(i_1: int) -> FSharpList[ProcessInput]:
+        def _arrow1126(matrix_1: Any, process_name_root: Any=process_name_root, headers: Any=headers) -> Callable[[int], FSharpList[ProcessInput]]:
+            def _arrow1124(i_1: int) -> FSharpList[ProcessInput]:
                 def mapping_1(f_1: Callable[[Any, int], MaterialAttributeValue]) -> MaterialAttributeValue:
                     return f_1(matrix_1)(i_1)
 
                 return singleton(ProcessInput(0, Source_create_Z5CA08497(None, ((("" + process_name_root) + "_Input_") + str(i_1)) + "", to_list(map_1(mapping_1, char_getters)))))
 
-            return _arrow1128
+            return _arrow1124
 
-        input_getter_1 = _arrow1129
+        input_getter_1 = _arrow1126
 
     else: 
         input_getter: Callable[[Any, int], ProcessInput] = match_value