arctrl 3.0.0a3__py3-none-any.whl

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 _arrow3430(x: str, y: str, input: Any=input) -> bool:
+        return x == y
+
+    if (len(input) == 2) if (not equals_with(_arrow3430, 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 _arrow3431(__unit: None=None, c: Any=c) -> bool:
+                            yaml: str = c.DTO.fields[0]
+                            return c.Path == ValidationPackagesConfigHelper_ConfigFilePath
+
+                        if _arrow3431():
+                            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,344 @@
+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 _arrow3618(__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, _arrow3618())
+
+    def _arrow3624(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3621(__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
+
+                else: 
+                    pattern_matching_result = 2
+
+
+            else: 
+                pattern_matching_result = 2
+
+            if pattern_matching_result == 0:
+                path: str = combine(base_path, c.Path)
+                def _arrow3619(_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), _arrow3619)
+
+            elif pattern_matching_result == 1:
+                path_1: str = combine(base_path, c.Path)
+                def _arrow3620(_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), _arrow3620)
+
+            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 _arrow3623(_arg_2: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3622(__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, _arrow3622()))
+
+        return singleton.TryWith(singleton.Delay(_arrow3621), _arrow3623)
+
+    return catch_with(f, singleton.Delay(_arrow3624))
+
+
+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 _arrow3628(__unit: None=None, contract_f: Any=contract_f, base_path: Any=base_path, cs: Any=cs) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
+        def _arrow3627(_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), _arrow3627)
+
+    return singleton.Delay(_arrow3628)
+
+
+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 _arrow3629(__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, _arrow3629())
+
+    def _arrow3639(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3636(__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 _arrow3631(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3630(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                        return singleton.Return(FSharpResult_2(0, c))
+
+                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3630)
+
+                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3631)
+
+            elif match_value.tag == 1:
+                t: str = match_value.fields[0]
+                path: str = combine(base_path, c.Path)
+                def _arrow3633(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3632(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                        return singleton.Return(FSharpResult_2(0, c))
+
+                    return singleton.Bind(write_file_text_async(path, t), _arrow3632)
+
+                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3633)
+
+            elif match_value.tag == 0:
+                wb: Any = match_value.fields[0]
+                path_1: str = combine(base_path, c.Path)
+                def _arrow3635(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3634(__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), _arrow3634)
+
+                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3635)
+
+            else: 
+                return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is not an ISA contract"))(c.Path)))
+
+
+        def _arrow3638(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3637(__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, _arrow3637()))
+
+        return singleton.TryWith(singleton.Delay(_arrow3636), _arrow3638)
+
+    return catch_with(f, singleton.Delay(_arrow3639))
+
+
+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 _arrow3640(__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, _arrow3640())
+
+    def _arrow3650(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3647(__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 _arrow3642(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3641(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                        return singleton.Return(FSharpResult_2(0, c))
+
+                    return singleton.Bind(write_file_text_async(path_2, ""), _arrow3641)
+
+                return singleton.Bind(ensure_directory_of_file_async(path_2), _arrow3642)
+
+            elif match_value.tag == 1:
+                t: str = match_value.fields[0]
+                path: str = combine(base_path, c.Path)
+                def _arrow3644(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3643(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                        return singleton.Return(FSharpResult_2(0, c))
+
+                    return singleton.Bind(write_file_text_async(path, t), _arrow3643)
+
+                return singleton.Bind(ensure_directory_of_file_async(path), _arrow3644)
+
+            elif match_value.tag == 0:
+                wb: Any = match_value.fields[0]
+                path_1: str = combine(base_path, c.Path)
+                def _arrow3646(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                    def _arrow3645(__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), _arrow3645)
+
+                return singleton.Bind(ensure_directory_of_file_async(path_1), _arrow3646)
+
+            else: 
+                return singleton.Return(FSharpResult_2(1, to_text(printf("Contract %s is not an ISA contract"))(c.Path)))
+
+
+        def _arrow3649(_arg_6: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3648(__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, _arrow3648()))
+
+        return singleton.TryWith(singleton.Delay(_arrow3647), _arrow3649)
+
+    return catch_with(f, singleton.Delay(_arrow3650))
+
+
+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 _arrow3651(__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, _arrow3651())
+
+    def _arrow3656(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3653(__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 _arrow3652(__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), _arrow3652)
+
+            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 _arrow3655(_arg_1: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3654(__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, _arrow3654()))
+
+        return singleton.TryWith(singleton.Delay(_arrow3653), _arrow3655)
+
+    return catch_with(f, singleton.Delay(_arrow3656))
+
+
+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 _arrow3657(__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, _arrow3657())
+
+    def _arrow3662(__unit: None=None, base_path: Any=base_path, c: Any=c) -> Async[FSharpResult_2[Contract, str]]:
+        def _arrow3659(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+            path: str = combine(base_path, c.Path)
+            def _arrow3658(__unit: None=None) -> Async[FSharpResult_2[Contract, str]]:
+                return singleton.Return(FSharpResult_2(0, c))
+
+            return singleton.Bind(delete_file_or_directory_async(path), _arrow3658)
+
+        def _arrow3661(_arg_1: Exception) -> Async[FSharpResult_2[Contract, str]]:
+            def _arrow3660(__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, _arrow3660()))
+
+        return singleton.TryWith(singleton.Delay(_arrow3659), _arrow3661)
+
+    return catch_with(f, singleton.Delay(_arrow3662))
+
+
+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 _arrow3663(__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, _arrow3663())
+
+    def _arrow3664(__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(_arrow3664))
+
+
+def full_fill_contract_batch_async(base_path: str, cs: Array[Contract]) -> Async[FSharpResult_2[Array[Contract], Array[str]]]:
+    def _arrow3665(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(_arrow3665, 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"]
+