arctrl 3.0.0b6__tar.gz → 3.0.0b7__tar.gz

{arctrl-3.0.0b6 → arctrl-3.0.0b7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arctrl
-Version: 3.0.0b6
+Version: 3.0.0b7
 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.0b6 → arctrl-3.0.0b7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arctrl"
-version = "3.0.0b6"
+version = "3.0.0b7"
 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.0b6 → arctrl-3.0.0b7}/src/ARCtrl/py/CWL/tool_description.py

@@ -7,7 +7,7 @@ from .inputs import CWLInput
 from .outputs import CWLOutput
 from .requirements import Requirement
 
-def _expr3492() -> TypeInfo:
+def _expr3371() -> TypeInfo:
     return class_type("ARCtrl.CWL.CWLToolDescription", None, CWLToolDescription, DynamicObj_reflection())
 
 
@@ -93,7 +93,7 @@ class CWLToolDescription(DynamicObj):
         this._metadata = metadata
 
 
-CWLToolDescription_reflection = _expr3492
+CWLToolDescription_reflection = _expr3371
 
 def CWLToolDescription__ctor_Z3224DB85(outputs: Array[CWLOutput], cwl_version: str | None=None, base_command: Array[str] | None=None, requirements: Array[Requirement] | None=None, hints: Array[Requirement] | None=None, inputs: Array[CWLInput] | None=None, metadata: DynamicObj | None=None) -> CWLToolDescription:
     return CWLToolDescription(outputs, cwl_version, base_command, requirements, hints, inputs, metadata)

{arctrl-3.0.0b6 → arctrl-3.0.0b7}/src/ARCtrl/py/CWL/workflow_description.py

@@ -8,7 +8,7 @@ from .outputs import CWLOutput
 from .requirements import Requirement
 from .workflow_steps import WorkflowStep
 
-def _expr3493() -> TypeInfo:
+def _expr3447() -> TypeInfo:
     return class_type("ARCtrl.CWL.CWLWorkflowDescription", None, CWLWorkflowDescription, DynamicObj_reflection())
 
 
@@ -94,7 +94,7 @@ class CWLWorkflowDescription(DynamicObj):
         this._metadata = metadata
 
 
-CWLWorkflowDescription_reflection = _expr3493
+CWLWorkflowDescription_reflection = _expr3447
 
 def CWLWorkflowDescription__ctor_704BBD06(steps: Array[WorkflowStep], inputs: Array[CWLInput], outputs: Array[CWLOutput], cwl_version: str | None=None, requirements: Array[Requirement] | None=None, hints: Array[Requirement] | None=None, metadata: DynamicObj | None=None) -> CWLWorkflowDescription:
     return CWLWorkflowDescription(steps, inputs, outputs, cwl_version, requirements, hints, metadata)

{arctrl-3.0.0b6 → arctrl-3.0.0b7}/src/ARCtrl/py/CWL/workflow_steps.py

@@ -5,7 +5,7 @@ from ..fable_modules.fable_library.reflection import (TypeInfo, string_type, opt
 from ..fable_modules.fable_library.types import (Record, Array)
 from .requirements import Requirement
 
-def _expr3376() -> TypeInfo:
+def _expr3342() -> TypeInfo:
     return record_type("ARCtrl.CWL.StepInput", [], StepInput, lambda: [("Id", string_type), ("Source", option_type(string_type)), ("DefaultValue", option_type(string_type)), ("ValueFrom", option_type(string_type))])
 
 
@@ -16,9 +16,9 @@ class StepInput(Record):
     DefaultValue: str | None
     ValueFrom: str | None
 
-StepInput_reflection = _expr3376
+StepInput_reflection = _expr3342
 
-def _expr3385() -> TypeInfo:
+def _expr3343() -> TypeInfo:
     return record_type("ARCtrl.CWL.StepOutput", [], StepOutput, lambda: [("Id", array_type(string_type))])
 
 
@@ -26,9 +26,9 @@ def _expr3385() -> TypeInfo:
 class StepOutput(Record):
     Id: Array[str]
 
-StepOutput_reflection = _expr3385
+StepOutput_reflection = _expr3343
 
-def _expr3399() -> TypeInfo:
+def _expr3344() -> TypeInfo:
     return class_type("ARCtrl.CWL.WorkflowStep", None, WorkflowStep, DynamicObj_reflection())
 
 
@@ -103,7 +103,7 @@ class WorkflowStep(DynamicObj):
         this._hints = hints
 
 
-WorkflowStep_reflection = _expr3399
+WorkflowStep_reflection = _expr3344
 
 def WorkflowStep__ctor_4159DCB0(id: str, in_: Array[StepInput], out_: StepOutput, run: str, requirements: Array[Requirement] | None=None, hints: Array[Requirement] | None=None) -> WorkflowStep:
     return WorkflowStep(id, in_, out_, run, requirements, hints)

{arctrl-3.0.0b6 → arctrl-3.0.0b7}/src/ARCtrl/py/Contract/datamap.py

@@ -12,10 +12,10 @@ from .contract import (Contract, DTOType, DTO)
 
 def _007CDatamapPath_007C__007C(input: Array[str]) -> str | None:
     (pattern_matching_result,) = (None,)
-    def _arrow3611(x: str, y: str, input: Any=input) -> bool:
+    def _arrow3612(x: str, y: str, input: Any=input) -> bool:
         return x == y
 
-    if (len(input) == 3) if (not equals_with(_arrow3611, input, None)) else False:
+    if (len(input) == 3) if (not equals_with(_arrow3612, input, None)) else False:
         if input[0] == "assays":
             if input[2] == "isa.datamap.xlsx":
                 pattern_matching_result = 0
@@ -68,17 +68,17 @@ def ARCtrl_DataMap__DataMap_ToDeleteContractForAssay_Z721C83C5(this: DataMap, as
 
 
 def ARCtrl_DataMap__DataMap_toDeleteContractForAssay_Static_Z721C83C5(assay_identifier: str) -> Callable[[DataMap], Contract]:
-    def _arrow3612(data_map: DataMap, assay_identifier: Any=assay_identifier) -> Contract:
+    def _arrow3614(data_map: DataMap, assay_identifier: Any=assay_identifier) -> Contract:
         return ARCtrl_DataMap__DataMap_ToDeleteContractForAssay_Z721C83C5(data_map, assay_identifier)
 
-    return _arrow3612
+    return _arrow3614
 
 
 def ARCtrl_DataMap__DataMap_toUpdateContractForAssay_Static_Z721C83C5(assay_identifier: str) -> Callable[[DataMap], Contract]:
-    def _arrow3613(data_map: DataMap, assay_identifier: Any=assay_identifier) -> Contract:
+    def _arrow3615(data_map: DataMap, assay_identifier: Any=assay_identifier) -> Contract:
         return ARCtrl_DataMap__DataMap_ToUpdateContractForAssay_Z721C83C5(data_map, assay_identifier)
 
-    return _arrow3613
+    return _arrow3615
 
 
 def ARCtrl_DataMap__DataMap_tryFromReadContractForAssay_Static(assay_identifier: str, c: Contract) -> DataMap | None:
@@ -89,11 +89,11 @@ def ARCtrl_DataMap__DataMap_tryFromReadContractForAssay_Static(assay_identifier:
             if c.DTOType.tag == 5:
                 if c.DTO is not None:
                     if c.DTO.tag == 0:
-                        def _arrow3614(__unit: None=None, assay_identifier: Any=assay_identifier, c: Any=c) -> bool:
+                        def _arrow3616(__unit: None=None, assay_identifier: Any=assay_identifier, c: Any=c) -> bool:
                             fsworkbook: Any = c.DTO.fields[0]
                             return c.Path == path
 
-                        if _arrow3614():
+                        if _arrow3616():
                             pattern_matching_result = 0
                             fsworkbook_1 = c.DTO.fields[0]
                             p_1 = c.Path
@@ -147,17 +147,17 @@ def ARCtrl_DataMap__DataMap_ToDeleteContractForStudy_Z721C83C5(this: DataMap, st
 
 
 def ARCtrl_DataMap__DataMap_toDeleteContractForStudy_Static_Z721C83C5(study_identifier: str) -> Callable[[DataMap], Contract]:
-    def _arrow3616(data_map: DataMap, study_identifier: Any=study_identifier) -> Contract:
+    def _arrow3617(data_map: DataMap, study_identifier: Any=study_identifier) -> Contract:
         return ARCtrl_DataMap__DataMap_ToDeleteContractForStudy_Z721C83C5(data_map, study_identifier)
 
-    return _arrow3616
+    return _arrow3617
 
 
 def ARCtrl_DataMap__DataMap_toUpdateContractForStudy_Static_Z721C83C5(study_identifier: str) -> Callable[[DataMap], Contract]:
-    def _arrow3617(data_map: DataMap, study_identifier: Any=study_identifier) -> Contract:
+    def _arrow3618(data_map: DataMap, study_identifier: Any=study_identifier) -> Contract:
         return ARCtrl_DataMap__DataMap_ToUpdateContractForStudy_Z721C83C5(data_map, study_identifier)
 
-    return _arrow3617
+    return _arrow3618
 
 
 def ARCtrl_DataMap__DataMap_tryFromReadContractForStudy_Static(study_identifier: str, c: Contract) -> DataMap | None:

{arctrl-3.0.0b6 → arctrl-3.0.0b7}/src/ARCtrl/py/Contract/validation_packages_config.py

@@ -13,10 +13,10 @@ ValidationPackagesConfigHelper_ReadContract: Contract = Contract("READ", Validat
 
 def ValidationPackagesConfigExtensions__007CValidationPackagesYamlPath_007C__007C(input: Array[str]) -> str | None:
     (pattern_matching_result,) = (None,)
-    def _arrow3615(x: str, y: str, input: Any=input) -> bool:
+    def _arrow3611(x: str, y: str, input: Any=input) -> bool:
         return x == y
 
-    if (len(input) == 2) if (not equals_with(_arrow3615, input, None)) else False:
+    if (len(input) == 2) if (not equals_with(_arrow3611, input, None)) else False:
         if input[0] == ".arc":
             if input[1] == "validation_packages.yml":
                 pattern_matching_result = 0
@@ -63,11 +63,11 @@ def ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig
             if c.DTOType.tag == 9:
                 if c.DTO is not None:
                     if c.DTO.tag == 1:
-                        def _arrow3618(__unit: None=None, c: Any=c) -> bool:
+                        def _arrow3613(__unit: None=None, c: Any=c) -> bool:
                             yaml: str = c.DTO.fields[0]
                             return c.Path == ValidationPackagesConfigHelper_ConfigFilePath
 
-                        if _arrow3618():
+                        if _arrow3613():
                             pattern_matching_result = 0
                             p_1 = c.Path
                             yaml_1 = c.DTO.fields[0]

{arctrl-3.0.0b6 → arctrl-3.0.0b7}/src/ARCtrl/py/ContractIO/contract_io.py

@@ -15,14 +15,14 @@ from .file_system_helper import (read_file_xlsx_async, read_file_text_async, ens
 
 def fulfill_read_contract_async(base_path: str, c: Contract) -> Async[FSharpResult_2[Contract, str]]:
     def f(e_1: Exception, base_path: Any=base_path, c: Any=c) -> FSharpResult_2[Contract, str]:
-        def _arrow3807(__unit: None=None, e_1: Any=e_1) -> str:
+        def _arrow3809(__unit: None=None, e_1: Any=e_1) -> str:
             arg_4: str = str(e_1)
             return to_text(printf("Error reading contract %s: %s"))(c.Path)(arg_4)
 
-        return FSharpResult_2(1, _arrow3807())
+        return FSharpResult_2(1, _arrow3809())
 
-    def _arrow3813(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
-        def _arrow3810(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+    def _arrow3815(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3812(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
             match_value: DTOType | None = c.DTOType
             (pattern_matching_result,) = (None,)
             if match_value is not None:
@@ -56,37 +56,37 @@ def fulfill_read_contract_async(base_path: str, c: Contract) -> Async[FSharpResu
 
             if pattern_matching_result == 0:
                 path: str = combine(base_path, c.Path)
-                def _arrow3808(_arg: FsWorkbook) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3810(_arg: FsWorkbook) -> Async[FSharpResult_2[Contract, str]]:
                     return singleton.Return(FSharpResult_2(0, Contract(c.Operation, c.Path, c.DTOType, DTO_2(0, _arg))))
 
-                return singleton.Bind(read_file_xlsx_async(path), _arrow3808)
+                return singleton.Bind(read_file_xlsx_async(path), _arrow3810)
 
             elif pattern_matching_result == 1:
                 path_1: str = combine(base_path, c.Path)
-                def _arrow3809(_arg_1: str) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3811(_arg_1: str) -> Async[FSharpResult_2[Contract, str]]:
                     return singleton.Return(FSharpResult_2(0, Contract(c.Operation, c.Path, c.DTOType, DTO_2(1, _arg_1))))
 
-                return singleton.Bind(read_file_text_async(path_1), _arrow3809)
+                return singleton.Bind(read_file_text_async(path_1), _arrow3811)
 
             elif pattern_matching_result == 2:
                 return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is neither an ISA nor a freetext contract"))(c.Path)))
 
 
-        def _arrow3812(_arg_2: Exception) -> Async[FSharpResult_2[Contract, str]]:
-            def _arrow3811(__unit: None=None) -> str:
+        def _arrow3814(_arg_2: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3813(__unit: None=None) -> str:
                 arg_2: str = str(_arg_2)
                 return to_text(printf("Error reading contract %s: %s"))(c.Path)(arg_2)
 
-            return singleton.Return(FSharpResult_2(1, _arrow3811()))
+            return singleton.Return(FSharpResult_2(1, _arrow3813()))
 
-        return singleton.TryWith(singleton.Delay(_arrow3810), _arrow3812)
+        return singleton.TryWith(singleton.Delay(_arrow3812), _arrow3814)
 
-    return catch_with(f, singleton.Delay(_arrow3813))
+    return catch_with(f, singleton.Delay(_arrow3815))
 
 
 def fullfill_contract_batch_async_by(contract_f: Callable[[str, Contract], Async[FSharpResult_2[Contract, str]]], base_path: str, cs: Array[Contract]) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
-    def _arrow3815(__unit: None=None, contract_f: Any=contract_f, base_path: Any=base_path, cs: Any=cs) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
-        def _arrow3814(_arg: Array[FSharpResult_2[Contract, str]]) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
+    def _arrow3817(__unit: None=None, contract_f: Any=contract_f, base_path: Any=base_path, cs: Any=cs) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
+        def _arrow3816(_arg: Array[FSharpResult_2[Contract, str]]) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
             def folder(acc: FSharpResult_2[Array[Contract], Array[str]], cr: FSharpResult_2[Contract, str]) -> FSharpResult_2[Array[Contract], Array[str]]:
                 copy_of_struct: FSharpResult_2[Array[Contract], Array[str]] = acc
                 if copy_of_struct.tag == 1:
@@ -111,136 +111,136 @@ def fullfill_contract_batch_async_by(contract_f: Callable[[str, Contract], Async
             res: FSharpResult_2[Array[Contract], Array[str]] = fold(folder, FSharpResult_2(0, []), _arg)
             return singleton.Return(res)
 
-        return singleton.Bind(start_sequential(curry2(contract_f)(base_path), cs), _arrow3814)
+        return singleton.Bind(start_sequential(curry2(contract_f)(base_path), cs), _arrow3816)
 
-    return singleton.Delay(_arrow3815)
+    return singleton.Delay(_arrow3817)
 
 
 def fulfill_write_contract_async(base_path: str, c: Contract) -> Async[FSharpResult_2[Contract, str]]:
     def f(e_1: Exception, base_path: Any=base_path, c: Any=c) -> FSharpResult_2[Contract, str]:
-        def _arrow3816(__unit: None=None, e_1: Any=e_1) -> str:
+        def _arrow3818(__unit: None=None, e_1: Any=e_1) -> str:
             arg_4: str = str(e_1)
             return to_text(printf("Error writing contract %s: %s"))(c.Path)(arg_4)
 
-        return FSharpResult_2(1, _arrow3816())
+        return FSharpResult_2(1, _arrow3818())
 
-    def _arrow3826(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
-        def _arrow3823(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+    def _arrow3828(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3825(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
             match_value: DTO_2 | None = c.DTO
             if match_value is None:
                 path_2: str = combine(base_path, c.Path)
-                def _arrow3818(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3817(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3820(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3819(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3817)
+                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3819)
 
-                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3818)
+                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3820)
 
             elif match_value.tag == 1:
                 t: str = match_value.fields[0]
                 path: str = combine(base_path, c.Path)
-                def _arrow3820(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3819(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3822(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3821(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_text_async(path, t), _arrow3819)
+                    return singleton.Bind(write_file_text_async(path, t), _arrow3821)
 
-                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3820)
+                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3822)
 
             elif match_value.tag == 0:
                 wb: Any = match_value.fields[0]
                 path_1: str = combine(base_path, c.Path)
-                def _arrow3822(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3821(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3824(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3823(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_xlsx_async(path_1, wb), _arrow3821)
+                    return singleton.Bind(write_file_xlsx_async(path_1, wb), _arrow3823)
 
-                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3822)
+                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3824)
 
             else: 
                 return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is not an ISA contract"))(c.Path)))
 
 
-        def _arrow3825(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
-            def _arrow3824(__unit: None=None) -> str:
+        def _arrow3827(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3826(__unit: None=None) -> str:
                 arg_2: str = str(_arg_6)
                 return to_text(printf("Error writing contract %s: %s"))(c.Path)(arg_2)
 
-            return singleton.Return(FSharpResult_2(1, _arrow3824()))
+            return singleton.Return(FSharpResult_2(1, _arrow3826()))
 
-        return singleton.TryWith(singleton.Delay(_arrow3823), _arrow3825)
+        return singleton.TryWith(singleton.Delay(_arrow3825), _arrow3827)
 
-    return catch_with(f, singleton.Delay(_arrow3826))
+    return catch_with(f, singleton.Delay(_arrow3828))
 
 
 def fulfill_update_contract_async(base_path: str, c: Contract) -> Async[FSharpResult_2[Contract, str]]:
     def f(e_1: Exception, base_path: Any=base_path, c: Any=c) -> FSharpResult_2[Contract, str]:
-        def _arrow3827(__unit: None=None, e_1: Any=e_1) -> str:
+        def _arrow3829(__unit: None=None, e_1: Any=e_1) -> str:
             arg_4: str = str(e_1)
             return to_text(printf("Error updating contract %s: %s"))(c.Path)(arg_4)
 
-        return FSharpResult_2(1, _arrow3827())
+        return FSharpResult_2(1, _arrow3829())
 
-    def _arrow3837(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
-        def _arrow3834(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+    def _arrow3839(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3836(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
             match_value: DTO_2 | None = c.DTO
             if match_value is None:
                 path_2: str = combine(base_path, c.Path)
-                def _arrow3829(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3828(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3831(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3830(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3828)
+                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3830)
 
-                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3829)
+                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3831)
 
             elif match_value.tag == 1:
                 t: str = match_value.fields[0]
                 path: str = combine(base_path, c.Path)
-                def _arrow3831(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3830(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3833(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3832(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_text_async(path, t), _arrow3830)
+                    return singleton.Bind(write_file_text_async(path, t), _arrow3832)
 
-                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3831)
+                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3833)
 
             elif match_value.tag == 0:
                 wb: Any = match_value.fields[0]
                 path_1: str = combine(base_path, c.Path)
-                def _arrow3833(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
-                    def _arrow3832(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                def _arrow3835(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3834(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
                         return singleton.Return(FSharpResult_2(0, c))
 
-                    return singleton.Bind(write_file_xlsx_async(path_1, wb), _arrow3832)
+                    return singleton.Bind(write_file_xlsx_async(path_1, wb), _arrow3834)
 
-                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3833)
+                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3835)
 
             else: 
                 return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is not an ISA contract"))(c.Path)))
 
 
-        def _arrow3836(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
-            def _arrow3835(__unit: None=None) -> str:
+        def _arrow3838(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3837(__unit: None=None) -> str:
                 arg_2: str = str(_arg_6)
                 return to_text(printf("Error updating contract %s: %s"))(c.Path)(arg_2)
 
-            return singleton.Return(FSharpResult_2(1, _arrow3835()))
+            return singleton.Return(FSharpResult_2(1, _arrow3837()))
 
-        return singleton.TryWith(singleton.Delay(_arrow3834), _arrow3836)
+        return singleton.TryWith(singleton.Delay(_arrow3836), _arrow3838)
 
-    return catch_with(f, singleton.Delay(_arrow3837))
+    return catch_with(f, singleton.Delay(_arrow3839))
 
 
 def fullfill_rename_contract_async(base_path: str, c: Contract) -> Async[FSharpResult_2[Contract, str]]:
     def f(e_1: Exception, base_path: Any=base_path, c: Any=c) -> FSharpResult_2[Contract, str]:
-        def _arrow3838(__unit: None=None, e_1: Any=e_1) -> str:
+        def _arrow3840(__unit: None=None, e_1: Any=e_1) -> str:
             arg_5: str = str(e_1)
             return to_text(printf("Error renaming contract %s: %s"))(c.Path)(arg_5)
 
-        return FSharpResult_2(1, _arrow3838())
+        return FSharpResult_2(1, _arrow3840())
 
     def _arrow3845(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
         def _arrow3842(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:

{arctrl-3.0.0b6 → arctrl-3.0.0b7}/src/ARCtrl/py/Core/Process/factor_value.py

@@ -150,7 +150,7 @@ def FactorValue__MapCategory_658CFBF6(this: FactorValue, f: Callable[[OntologyAn
 
 
 def FactorValue__SetCategory_ZDED3A0F(this: FactorValue, c: OntologyAnnotation) -> FactorValue:
-    def _arrow583(__unit: None=None, this: Any=this, c: Any=c) -> Factor | None:
+    def _arrow584(__unit: None=None, this: Any=this, c: Any=c) -> Factor | None:
         match_value: Factor | None = this.Category
         if match_value is None:
             return Factor.create(None, c)
@@ -160,7 +160,7 @@ def FactorValue__SetCategory_ZDED3A0F(this: FactorValue, c: OntologyAnnotation)
             return p.SetCategory(c)
 
 
-    return FactorValue(this.ID, _arrow583(), this.Value, this.Unit)
+    return FactorValue(this.ID, _arrow584(), this.Value, this.Unit)
 
 
 def FactorValue_getNameAsString_7105C732(fv: FactorValue) -> str:

{arctrl-3.0.0b6 → arctrl-3.0.0b7}/src/ARCtrl/py/Core/Process/material_attribute.py

@@ -9,7 +9,7 @@ from ..comment import Comment
 from ..Helper.collections_ import Option_fromValueWithDefault
 from ..ontology_annotation import (OntologyAnnotation, OntologyAnnotation_reflection)
 
-def _expr584() -> TypeInfo:
+def _expr583() -> TypeInfo:
     return record_type("ARCtrl.Process.MaterialAttribute", [], MaterialAttribute, lambda: [("ID", option_type(string_type)), ("CharacteristicType", option_type(OntologyAnnotation_reflection()))])
 
 
@@ -26,7 +26,7 @@ class MaterialAttribute(Record):
         return "OA " + MaterialAttribute__get_NameText(this)
 
 
-MaterialAttribute_reflection = _expr584
+MaterialAttribute_reflection = _expr583
 
 def MaterialAttribute_make(id: str | None=None, characteristic_type: OntologyAnnotation | None=None) -> MaterialAttribute:
     return MaterialAttribute(id, characteristic_type)