arctrl 3.0.0__py3-none-any.whl

arctrl/py/Contract/license.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.array_ import equals_with
+from ..fable_modules.fable_library.list import contains
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import string_hash
+from ..FileSystem.path import alternative_licensefile_names
+from .contract import (Contract, DTOType, DTO)
+
+def LicenseContractExtensions__007CLicensePath_007C__007C(input: Array[str]) -> str | None:
+    (pattern_matching_result,) = (None,)
+    def _arrow4127(x: str, y: str, input: Any=input) -> bool:
+        return x == y
+
+    if (len(input) == 1) if (not equals_with(_arrow4127, input, None)) else False:
+        if input[0] == "LICENSE":
+            pattern_matching_result = 0
+
+        else: 
+            class ObjectExpr4129:
+                @property
+                def Equals(self) -> Callable[[str, str], bool]:
+                    def _arrow4128(x_1: str, y_1: str) -> bool:
+                        return x_1 == y_1
+
+                    return _arrow4128
+
+                @property
+                def GetHashCode(self) -> Callable[[str], int]:
+                    return string_hash
+
+            if contains(input[0], alternative_licensefile_names, ObjectExpr4129()):
+                pattern_matching_result = 1
+
+            else: 
+                pattern_matching_result = 2
+
+
+
+    else: 
+        pattern_matching_result = 2
+
+    if pattern_matching_result == 0:
+        return "LICENSE"
+
+    elif pattern_matching_result == 1:
+        return input[0]
+
+    elif pattern_matching_result == 2:
+        return None
+
+
+
+License_defaultLicenseContract: Contract = Contract.create_create("LICENSE", DTOType(10), DTO(1, "ALL RIGHTS RESERVED BY THE AUTHORS"))
+
+__all__ = ["LicenseContractExtensions__007CLicensePath_007C__007C", "License_defaultLicenseContract"]
+

arctrl/py/Contract/validation_packages_config.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+from typing import Any
+from ..fable_modules.fable_library.array_ import equals_with
+from ..fable_modules.fable_library.types import Array
+from ..FileSystem.path import combine_many
+from ..ValidationPackages.validation_packages_config import ValidationPackagesConfig
+from ..Yaml.validation_packages_config import (ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toYamlString_Static_71136F3F, ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_fromYamlString_Static_Z721C83C5)
+from .contract import (DTOType as DTOType_1, Contract, DTO)
+
+ValidationPackagesConfigHelper_ConfigFilePath: str = combine_many([".arc", "validation_packages.yml"])
+
+ValidationPackagesConfigHelper_ReadContract: Contract = Contract("READ", ValidationPackagesConfigHelper_ConfigFilePath, DTOType_1(9), None)
+
+def ValidationPackagesConfigExtensions__007CValidationPackagesYamlPath_007C__007C(input: Array[str]) -> str | None:
+    (pattern_matching_result,) = (None,)
+    def _arrow4121(x: str, y: str, input: Any=input) -> bool:
+        return x == y
+
+    if (len(input) == 2) if (not equals_with(_arrow4121, input, None)) else False:
+        if input[0] == ".arc":
+            if input[1] == "validation_packages.yml":
+                pattern_matching_result = 0
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+
+    else: 
+        pattern_matching_result = 1
+
+    if pattern_matching_result == 0:
+        return combine_many(input)
+
+    elif pattern_matching_result == 1:
+        return None
+
+
+
+def ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToCreateContract(this: ValidationPackagesConfig) -> Contract:
+    return Contract.create_create(ValidationPackagesConfigHelper_ConfigFilePath, DTOType_1(9), DTO(1, ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toYamlString_Static_71136F3F()(this)))
+
+
+def ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToDeleteContract(this: ValidationPackagesConfig) -> Contract:
+    return Contract.create_delete(ValidationPackagesConfigHelper_ConfigFilePath)
+
+
+def ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toDeleteContract_Static_724DAE55(config: ValidationPackagesConfig) -> Contract:
+    return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToDeleteContract(config)
+
+
+def ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toCreateContract_Static_724DAE55(config: ValidationPackagesConfig) -> Contract:
+    return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToCreateContract(config)
+
+
+def ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_tryFromReadContract_Static_7570923F(c: Contract) -> ValidationPackagesConfig | None:
+    (pattern_matching_result, p_1, yaml_1) = (None, None, None)
+    if c.Operation == "READ":
+        if c.DTOType is not None:
+            if c.DTOType.tag == 9:
+                if c.DTO is not None:
+                    if c.DTO.tag == 1:
+                        def _arrow4122(__unit: None=None, c: Any=c) -> bool:
+                            yaml: str = c.DTO.fields[0]
+                            return c.Path == ValidationPackagesConfigHelper_ConfigFilePath
+
+                        if _arrow4122():
+                            pattern_matching_result = 0
+                            p_1 = c.Path
+                            yaml_1 = c.DTO.fields[0]
+
+                        else: 
+                            pattern_matching_result = 1
+
+
+                    else: 
+                        pattern_matching_result = 1
+
+
+                else: 
+                    pattern_matching_result = 1
+
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+
+    else: 
+        pattern_matching_result = 1
+
+    if pattern_matching_result == 0:
+        return ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_fromYamlString_Static_Z721C83C5(yaml_1)
+
+    elif pattern_matching_result == 1:
+        return None
+
+
+
+__all__ = ["ValidationPackagesConfigHelper_ConfigFilePath", "ValidationPackagesConfigHelper_ReadContract", "ValidationPackagesConfigExtensions__007CValidationPackagesYamlPath_007C__007C", "ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToCreateContract", "ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_ToDeleteContract", "ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toDeleteContract_Static_724DAE55", "ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_toCreateContract_Static_724DAE55", "ARCtrl_ValidationPackages_ValidationPackagesConfig__ValidationPackagesConfig_tryFromReadContract_Static_7570923F"]
+

arctrl/py/ContractIO/contract_io.py

@@ -0,0 +1,350 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..Contract.contract import (Contract, DTOType, DTO as DTO_2)
+from ..FileSystem.path import combine
+from ..cross_async import (catch_with, start_sequential)
+from ..fable_modules.fable_library.array_ import (fold, append)
+from ..fable_modules.fable_library.async_builder import (singleton, Async)
+from ..fable_modules.fable_library.result import FSharpResult_2
+from ..fable_modules.fable_library.string_ import (to_text, printf)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import curry2
+from ..fable_modules.fs_spreadsheet.fs_workbook import FsWorkbook
+from .file_system_helper import (read_file_xlsx_async, read_file_text_async, ensure_directory_of_file_async, write_file_text_async, write_file_xlsx_async, rename_file_or_directory_async, delete_file_or_directory_async)
+
+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 _arrow4467(__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, _arrow4467())
+
+    def _arrow4473(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow4470(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+            match_value: DTOType | None = c.DTOType
+            (pattern_matching_result,) = (None,)
+            if match_value is not None:
+                if match_value.tag == 0:
+                    pattern_matching_result = 0
+
+                elif match_value.tag == 4:
+                    pattern_matching_result = 0
+
+                elif match_value.tag == 1:
+                    pattern_matching_result = 0
+
+                elif match_value.tag == 2:
+                    pattern_matching_result = 0
+
+                elif match_value.tag == 3:
+                    pattern_matching_result = 0
+
+                elif match_value.tag == 5:
+                    pattern_matching_result = 0
+
+                elif match_value.tag == 10:
+                    pattern_matching_result = 1
+
+                elif match_value.tag == 8:
+                    pattern_matching_result = 1
+
+                elif match_value.tag == 9:
+                    pattern_matching_result = 1
+
+                else: 
+                    pattern_matching_result = 2
+
+
+            else: 
+                pattern_matching_result = 2
+
+            if pattern_matching_result == 0:
+                path: str = combine(base_path, c.Path)
+                def _arrow4468(_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), _arrow4468)
+
+            elif pattern_matching_result == 1:
+                path_1: str = combine(base_path, c.Path)
+                def _arrow4469(_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), _arrow4469)
+
+            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 _arrow4472(_arg_2: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow4471(__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, _arrow4471()))
+
+        return singleton.TryWith(singleton.Delay(_arrow4470), _arrow4472)
+
+    return catch_with(f, singleton.Delay(_arrow4473))
+
+
+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 _arrow4475(__unit: None=None, contract_f: Any=contract_f, base_path: Any=base_path, cs: Any=cs) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
+        def _arrow4474(_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:
+                    copy_of_struct_1: FSharpResult_2[Contract, str] = cr
+                    if copy_of_struct_1.tag == 1:
+                        return FSharpResult_2(1, append(copy_of_struct.fields[0], [copy_of_struct_1.fields[0]], None))
+
+                    else: 
+                        return FSharpResult_2(1, copy_of_struct.fields[0])
+
+
+                else: 
+                    copy_of_struct_2: FSharpResult_2[Contract, str] = cr
+                    if copy_of_struct_2.tag == 1:
+                        return FSharpResult_2(1, [copy_of_struct_2.fields[0]])
+
+                    else: 
+                        return FSharpResult_2(0, append(copy_of_struct.fields[0], [copy_of_struct_2.fields[0]], None))
+
+
+
+            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), _arrow4474)
+
+    return singleton.Delay(_arrow4475)
+
+
+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 _arrow4476(__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, _arrow4476())
+
+    def _arrow4486(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow4483(__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 _arrow4478(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow4477(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                        return singleton.Return(FSharpResult_2(0, c))
+
+                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow4477)
+
+                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow4478)
+
+            elif match_value.tag == 1:
+                t: str = match_value.fields[0]
+                path: str = combine(base_path, c.Path)
+                def _arrow4480(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow4479(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                        return singleton.Return(FSharpResult_2(0, c))
+
+                    return singleton.Bind(write_file_text_async(path, t), _arrow4479)
+
+                return singleton.Bind(ensure_directory_of_file_async(path), _arrow4480)
+
+            elif match_value.tag == 0:
+                wb: Any = match_value.fields[0]
+                path_1: str = combine(base_path, c.Path)
+                def _arrow4482(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow4481(__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), _arrow4481)
+
+                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow4482)
+
+            else: 
+                return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is not an ISA contract"))(c.Path)))
+
+
+        def _arrow4485(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow4484(__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, _arrow4484()))
+
+        return singleton.TryWith(singleton.Delay(_arrow4483), _arrow4485)
+
+    return catch_with(f, singleton.Delay(_arrow4486))
+
+
+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 _arrow4487(__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, _arrow4487())
+
+    def _arrow4497(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow4494(__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 _arrow4489(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow4488(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                        return singleton.Return(FSharpResult_2(0, c))
+
+                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow4488)
+
+                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow4489)
+
+            elif match_value.tag == 1:
+                t: str = match_value.fields[0]
+                path: str = combine(base_path, c.Path)
+                def _arrow4491(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow4490(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                        return singleton.Return(FSharpResult_2(0, c))
+
+                    return singleton.Bind(write_file_text_async(path, t), _arrow4490)
+
+                return singleton.Bind(ensure_directory_of_file_async(path), _arrow4491)
+
+            elif match_value.tag == 0:
+                wb: Any = match_value.fields[0]
+                path_1: str = combine(base_path, c.Path)
+                def _arrow4493(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow4492(__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), _arrow4492)
+
+                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow4493)
+
+            else: 
+                return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is not an ISA contract"))(c.Path)))
+
+
+        def _arrow4496(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow4495(__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, _arrow4495()))
+
+        return singleton.TryWith(singleton.Delay(_arrow4494), _arrow4496)
+
+    return catch_with(f, singleton.Delay(_arrow4497))
+
+
+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 _arrow4498(__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, _arrow4498())
+
+    def _arrow4503(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow4500(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+            match_value: DTO_2 | None = c.DTO
+            (pattern_matching_result, t_2) = (None, None)
+            if match_value is not None:
+                if match_value.tag == 1:
+                    if match_value.fields[0] == c.Path:
+                        pattern_matching_result = 0
+
+                    else: 
+                        pattern_matching_result = 1
+                        t_2 = match_value.fields[0]
+
+
+                else: 
+                    pattern_matching_result = 2
+
+
+            else: 
+                pattern_matching_result = 2
+
+            if pattern_matching_result == 0:
+                return singleton.Return(FSharpResult_2(1, to_text(printf("Rename Contract %s old and new Path are the same"))(c.Path)))
+
+            elif pattern_matching_result == 1:
+                new_path: str = combine(base_path, t_2)
+                old_path: str = combine(base_path, c.Path)
+                def _arrow4499(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    return singleton.Return(FSharpResult_2(0, c))
+
+                return singleton.Bind(rename_file_or_directory_async(old_path, new_path), _arrow4499)
+
+            elif pattern_matching_result == 2:
+                return singleton.Return(FSharpResult_2(1, to_text(printf("Rename Contract %s does not contain new Path"))(c.Path)))
+
+
+        def _arrow4502(_arg_1: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow4501(__unit: None=None) -> str:
+                arg_3: str = str(_arg_1)
+                return to_text(printf("Error renaming contract %s: %s"))(c.Path)(arg_3)
+
+            return singleton.Return(FSharpResult_2(1, _arrow4501()))
+
+        return singleton.TryWith(singleton.Delay(_arrow4500), _arrow4502)
+
+    return catch_with(f, singleton.Delay(_arrow4503))
+
+
+def fullfill_delete_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 _arrow4504(__unit: None=None, e_1: Any=e_1) -> str:
+            arg_3: str = str(e_1)
+            return to_text(printf("Error deleting contract %s: %s"))(c.Path)(arg_3)
+
+        return FSharpResult_2(1, _arrow4504())
+
+    def _arrow4509(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow4506(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+            path: str = combine(base_path, c.Path)
+            def _arrow4505(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                return singleton.Return(FSharpResult_2(0, c))
+
+            return singleton.Bind(delete_file_or_directory_async(path), _arrow4505)
+
+        def _arrow4508(_arg_1: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow4507(__unit: None=None) -> str:
+                arg_1: str = str(_arg_1)
+                return to_text(printf("Error deleting contract %s: %s"))(c.Path)(arg_1)
+
+            return singleton.Return(FSharpResult_2(1, _arrow4507()))
+
+        return singleton.TryWith(singleton.Delay(_arrow4506), _arrow4508)
+
+    return catch_with(f, singleton.Delay(_arrow4509))
+
+
+def full_fill_contract(base_path: str, c: Contract) -> Async[FSharpResult_2[Contract, str]]:
+    def f(e: Exception, base_path: Any=base_path, c: Any=c) -> FSharpResult_2[Contract, str]:
+        def _arrow4510(__unit: None=None, e: Any=e) -> str:
+            arg_2: str = str(e)
+            return to_text(printf("Error fulfilling contract %s: %s"))(c.Path)(arg_2)
+
+        return FSharpResult_2(1, _arrow4510())
+
+    def _arrow4511(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        match_value: str = c.Operation
+        return singleton.ReturnFrom(fulfill_read_contract_async(base_path, c)) if (match_value == "READ") else (singleton.ReturnFrom(fulfill_write_contract_async(base_path, c)) if (match_value == "CREATE") else (singleton.ReturnFrom(fulfill_update_contract_async(base_path, c)) if (match_value == "UPDATE") else (singleton.ReturnFrom(fullfill_delete_contract_async(base_path, c)) if (match_value == "DELETE") else (singleton.ReturnFrom(fullfill_rename_contract_async(base_path, c)) if (match_value == "RENAME") else singleton.Return(FSharpResult_2(1, to_text(printf("Operation %A not supported"))(c.Operation)))))))
+
+    return catch_with(f, singleton.Delay(_arrow4511))
+
+
+def full_fill_contract_batch_async(base_path: str, cs: Array[Contract]) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
+    def _arrow4512(base_path_1: str, c: Contract, base_path: Any=base_path, cs: Any=cs) -> Async[FSharpResult_2[Contract, str]]:
+        return full_fill_contract(base_path_1, c)
+
+    return fullfill_contract_batch_async_by(_arrow4512, base_path, cs)
+
+
+__all__ = ["fulfill_read_contract_async", "fullfill_contract_batch_async_by", "fulfill_write_contract_async", "fulfill_update_contract_async", "fullfill_rename_contract_async", "fullfill_delete_contract_async", "full_fill_contract", "full_fill_contract_batch_async"]
+