arctrl 3.0.0__py3-none-any.whl

arctrl/py/CWL/workflow_steps.py

@@ -0,0 +1,354 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from ..fable_modules.dynamic_obj.dynamic_obj import (DynamicObj, DynamicObj_reflection)
+from ..fable_modules.fable_library.option import to_array
+from ..fable_modules.fable_library.reflection import (TypeInfo, union_type, string_type, array_type, option_type, bool_type, record_type, obj_type, class_type)
+from ..fable_modules.fable_library.seq import (filter, iterate, try_find_index)
+from ..fable_modules.fable_library.types import (Array, Union, Record)
+from ..fable_modules.yamlicious.yamlicious_types import (YAMLElement, YAMLElement_reflection)
+from .requirements import (Requirement, HintEntry)
+
+def _expr760() -> TypeInfo:
+    return union_type("ARCtrl.CWL.LinkMergeMethod", [], LinkMergeMethod, lambda: [[], []])
+
+
+class LinkMergeMethod(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["MergeNested", "MergeFlattened"]
+
+    @property
+    def AsCwlString(self, __unit: None=None) -> str:
+        this: LinkMergeMethod = self
+        return "merge_flattened" if (this.tag == 1) else "merge_nested"
+
+    @staticmethod
+    def try_parse(value: str) -> LinkMergeMethod | None:
+        return LinkMergeMethod(0) if (value == "merge_nested") else (LinkMergeMethod(1) if (value == "merge_flattened") else None)
+
+
+LinkMergeMethod_reflection = _expr760
+
+def _expr761() -> TypeInfo:
+    return union_type("ARCtrl.CWL.PickValueMethod", [], PickValueMethod, lambda: [[], [], []])
+
+
+class PickValueMethod(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["FirstNonNull", "TheOnlyNonNull", "AllNonNull"]
+
+    @property
+    def AsCwlString(self, __unit: None=None) -> str:
+        this: PickValueMethod = self
+        if this.tag == 1:
+            return "the_only_non_null"
+
+        elif this.tag == 2:
+            return "all_non_null"
+
+        else: 
+            return "first_non_null"
+
+
+    @staticmethod
+    def try_parse(value: str) -> PickValueMethod | None:
+        return PickValueMethod(0) if (value == "first_non_null") else (PickValueMethod(1) if (value == "the_only_non_null") else (PickValueMethod(2) if (value == "all_non_null") else None))
+
+
+PickValueMethod_reflection = _expr761
+
+def _expr762() -> TypeInfo:
+    return union_type("ARCtrl.CWL.ScatterMethod", [], ScatterMethod, lambda: [[], [], []])
+
+
+class ScatterMethod(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["DotProduct", "NestedCrossProduct", "FlatCrossProduct"]
+
+    @property
+    def AsCwlString(self, __unit: None=None) -> str:
+        this: ScatterMethod = self
+        if this.tag == 1:
+            return "nested_crossproduct"
+
+        elif this.tag == 2:
+            return "flat_crossproduct"
+
+        else: 
+            return "dotproduct"
+
+
+    @staticmethod
+    def try_parse(value: str) -> ScatterMethod | None:
+        return ScatterMethod(0) if (value == "dotproduct") else (ScatterMethod(1) if (value == "nested_crossproduct") else (ScatterMethod(2) if (value == "flat_crossproduct") else None))
+
+
+ScatterMethod_reflection = _expr762
+
+def _expr763() -> TypeInfo:
+    return record_type("ARCtrl.CWL.StepInput", [], StepInput, lambda: [("Id", string_type), ("Source", option_type(array_type(string_type))), ("DefaultValue", option_type(YAMLElement_reflection())), ("ValueFrom", option_type(string_type)), ("LinkMerge", option_type(LinkMergeMethod_reflection())), ("PickValue", option_type(PickValueMethod_reflection())), ("Doc", option_type(string_type)), ("LoadContents", option_type(bool_type)), ("LoadListing", option_type(string_type)), ("Label", option_type(string_type))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class StepInput(Record):
+    Id: str
+    Source: Array[str] | None
+    DefaultValue: YAMLElement | None
+    ValueFrom: str | None
+    LinkMerge: LinkMergeMethod | None
+    PickValue: PickValueMethod | None
+    Doc: str | None
+    LoadContents: bool | None
+    LoadListing: str | None
+    Label: str | None
+    @staticmethod
+    def create(id: str, source: Array[str] | None=None, default_value: YAMLElement | None=None, value_from: str | None=None, link_merge: LinkMergeMethod | None=None, pick_value: PickValueMethod | None=None, doc: str | None=None, load_contents: bool | None=None, load_listing: str | None=None, label: str | None=None) -> StepInput:
+        return StepInput(id, source, default_value, value_from, link_merge, pick_value, doc, load_contents, load_listing, label)
+
+    @staticmethod
+    def update_at(index: int, f: Callable[[StepInput], StepInput], inputs: Array[StepInput]) -> None:
+        if True if (index < 0) else (index >= len(inputs)):
+            raise Exception(((("StepInput index " + str(index)) + " is out of range.") + "\\nParameter name: ") + "index")
+
+        inputs[index] = f(inputs[index])
+
+
+StepInput_reflection = _expr763
+
+def _expr764() -> TypeInfo:
+    return record_type("ARCtrl.CWL.StepOutputParameter", [], StepOutputParameter, lambda: [("Id", string_type)])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class StepOutputParameter(Record):
+    Id: str
+    @staticmethod
+    def create(id: str) -> StepOutputParameter:
+        return StepOutputParameter(id)
+
+
+StepOutputParameter_reflection = _expr764
+
+def _expr765() -> TypeInfo:
+    return union_type("ARCtrl.CWL.StepOutput", [], StepOutput, lambda: [[("Item", string_type)], [("Item", StepOutputParameter_reflection())]])
+
+
+class StepOutput(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["StepOutputString", "StepOutputRecord"]
+
+
+StepOutput_reflection = _expr765
+
+def _expr766() -> TypeInfo:
+    return union_type("ARCtrl.CWL.WorkflowStepRun", [], WorkflowStepRun, lambda: [[("Item", string_type)], [("Item", obj_type)], [("Item", obj_type)], [("Item", obj_type)], [("Item", obj_type)]])
+
+
+class WorkflowStepRun(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["RunString", "RunCommandLineTool", "RunWorkflow", "RunExpressionTool", "RunOperation"]
+
+
+WorkflowStepRun_reflection = _expr766
+
+def _expr767() -> TypeInfo:
+    return class_type("ARCtrl.CWL.WorkflowStep", None, WorkflowStep, DynamicObj_reflection())
+
+
+class WorkflowStep(DynamicObj):
+    def __init__(self, id: str, in_: Array[StepInput], out_: Array[StepOutput], run: WorkflowStepRun, label: str | None=None, doc: str | None=None, scatter: Array[str] | None=None, scatter_method: ScatterMethod | None=None, when_: str | None=None, requirements: Array[Requirement] | None=None, hints: Array[HintEntry] | None=None) -> None:
+        super().__init__()
+        self._id: str = id
+        self._in: Array[StepInput] = in_
+        self._out: Array[StepOutput] = out_
+        self._run: WorkflowStepRun = run
+        self._label: str | None = label
+        self._doc: str | None = doc
+        self._scatter: Array[str] | None = scatter
+        self._scatterMethod: ScatterMethod | None = scatter_method
+        self._when: str | None = when_
+        self._requirements: Array[Requirement] | None = requirements
+        self._hints: Array[HintEntry] | None = hints
+
+    @property
+    def Id(self, __unit: None=None) -> str:
+        this: WorkflowStep = self
+        return this._id
+
+    @Id.setter
+    def Id(self, id: str) -> None:
+        this: WorkflowStep = self
+        this._id = id
+
+    @property
+    def In(self, __unit: None=None) -> Array[StepInput]:
+        this: WorkflowStep = self
+        return this._in
+
+    @In.setter
+    def In(self, in_: Array[StepInput]) -> None:
+        this: WorkflowStep = self
+        this._in = in_
+
+    @property
+    def Out(self, __unit: None=None) -> Array[StepOutput]:
+        this: WorkflowStep = self
+        return this._out
+
+    @Out.setter
+    def Out(self, out_: Array[StepOutput]) -> None:
+        this: WorkflowStep = self
+        this._out = out_
+
+    @property
+    def Run(self, __unit: None=None) -> WorkflowStepRun:
+        this: WorkflowStep = self
+        return this._run
+
+    @Run.setter
+    def Run(self, run: WorkflowStepRun) -> None:
+        this: WorkflowStep = self
+        this._run = run
+
+    @property
+    def Label(self, __unit: None=None) -> str | None:
+        this: WorkflowStep = self
+        return this._label
+
+    @Label.setter
+    def Label(self, label: str | None=None) -> None:
+        this: WorkflowStep = self
+        this._label = label
+
+    @property
+    def Doc(self, __unit: None=None) -> str | None:
+        this: WorkflowStep = self
+        return this._doc
+
+    @Doc.setter
+    def Doc(self, doc: str | None=None) -> None:
+        this: WorkflowStep = self
+        this._doc = doc
+
+    @property
+    def Scatter(self, __unit: None=None) -> Array[str] | None:
+        this: WorkflowStep = self
+        return this._scatter
+
+    @Scatter.setter
+    def Scatter(self, scatter: Array[str] | None=None) -> None:
+        this: WorkflowStep = self
+        this._scatter = scatter
+
+    @property
+    def ScatterMethod(self, __unit: None=None) -> ScatterMethod | None:
+        this: WorkflowStep = self
+        return this._scatterMethod
+
+    @ScatterMethod.setter
+    def ScatterMethod(self, scatter_method: ScatterMethod | None=None) -> None:
+        this: WorkflowStep = self
+        this._scatterMethod = scatter_method
+
+    @property
+    def When_(self, __unit: None=None) -> str | None:
+        this: WorkflowStep = self
+        return this._when
+
+    @When_.setter
+    def When_(self, when_: str | None=None) -> None:
+        this: WorkflowStep = self
+        this._when = when_
+
+    @property
+    def Requirements(self, __unit: None=None) -> Array[Requirement] | None:
+        this: WorkflowStep = self
+        return this._requirements
+
+    @Requirements.setter
+    def Requirements(self, requirements: Array[Requirement] | None=None) -> None:
+        this: WorkflowStep = self
+        this._requirements = requirements
+
+    @property
+    def Hints(self, __unit: None=None) -> Array[HintEntry] | None:
+        this: WorkflowStep = self
+        return this._hints
+
+    @Hints.setter
+    def Hints(self, hints: Array[HintEntry] | None=None) -> None:
+        this: WorkflowStep = self
+        this._hints = hints
+
+    @staticmethod
+    def from_run_path(id: str, in_: Array[StepInput], out_: Array[StepOutput], run_path: str, label: str | None=None, doc: str | None=None, scatter: Array[str] | None=None, scatter_method: ScatterMethod | None=None, when_: str | None=None, requirements: Array[Requirement] | None=None, hints: Array[HintEntry] | None=None) -> WorkflowStep:
+        return WorkflowStep(id, in_, out_, WorkflowStepRun(0, run_path), label, doc, scatter, scatter_method, when_, requirements, hints)
+
+    @staticmethod
+    def update_input_at(index: int, f: Callable[[StepInput], StepInput], step: WorkflowStep) -> None:
+        inputs: Array[StepInput] = step.In
+        StepInput.update_at(index, f, inputs)
+
+    @staticmethod
+    def add_input(input: StepInput, step: WorkflowStep) -> None:
+        (step.In.append(input))
+
+    @staticmethod
+    def remove_inputs_by_id(id: str, step: WorkflowStep) -> None:
+        def predicate(i: StepInput) -> bool:
+            return i.Id != id
+
+        remaining: Array[StepInput] = list(filter(predicate, step.In))
+        step.In = remaining
+
+    @staticmethod
+    def update_input_by_id(id: str, f: Callable[[StepInput], StepInput], step: WorkflowStep) -> None:
+        def action(i_1: int) -> None:
+            inputs: Array[StepInput] = step.In
+            StepInput.update_at(i_1, f, inputs)
+
+        def predicate(i: StepInput) -> bool:
+            return i.Id == id
+
+        iterate(action, to_array(try_find_index(predicate, step.In)))
+
+
+WorkflowStep_reflection = _expr767
+
+def WorkflowStep__ctor_Z76380C57(id: str, in_: Array[StepInput], out_: Array[StepOutput], run: WorkflowStepRun, label: str | None=None, doc: str | None=None, scatter: Array[str] | None=None, scatter_method: ScatterMethod | None=None, when_: str | None=None, requirements: Array[Requirement] | None=None, hints: Array[HintEntry] | None=None) -> WorkflowStep:
+    return WorkflowStep(id, in_, out_, run, label, doc, scatter, scatter_method, when_, requirements, hints)
+
+
+__all__ = ["LinkMergeMethod_reflection", "PickValueMethod_reflection", "ScatterMethod_reflection", "StepInput_reflection", "StepOutputParameter_reflection", "StepOutput_reflection", "WorkflowStepRun_reflection", "WorkflowStep_reflection"]
+

arctrl/py/Contract/arc.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+from ..fable_modules.fable_library.types import Array
+from ..FileSystem.path import split as split_1
+from .arc_assay import _007CAssayPath_007C__007C
+from .arc_investigation import _007CInvestigationPath_007C__007C
+from .arc_run import (_007CRunPath_007C__007C, _007CRunCWLPath_007C__007C, _007CRunYMLPath_007C__007C)
+from .arc_study import _007CStudyPath_007C__007C
+from .arc_workflow import (_007CWorkflowPath_007C__007C, _007CWorkflowCWLPath_007C__007C)
+from .contract import (Contract, DTOType)
+from .datamap import _007CDatamapPath_007C__007C
+from .license import LicenseContractExtensions__007CLicensePath_007C__007C
+
+def try_isaread_contract_from_path(path: str) -> Contract | None:
+    split: Array[str] = split_1(path)
+    active_pattern_result: str | None = _007CInvestigationPath_007C__007C(split)
+    if active_pattern_result is not None:
+        p: str = active_pattern_result
+        return Contract.create_read(p, DTOType(4))
+
+    else: 
+        active_pattern_result_1: str | None = _007CAssayPath_007C__007C(split)
+        if active_pattern_result_1 is not None:
+            p_1: str = active_pattern_result_1
+            return Contract.create_read(p_1, DTOType(0))
+
+        else: 
+            active_pattern_result_2: str | None = _007CStudyPath_007C__007C(split)
+            if active_pattern_result_2 is not None:
+                p_2: str = active_pattern_result_2
+                return Contract.create_read(p_2, DTOType(1))
+
+            else: 
+                active_pattern_result_3: str | None = _007CWorkflowPath_007C__007C(split)
+                if active_pattern_result_3 is not None:
+                    p_3: str = active_pattern_result_3
+                    return Contract.create_read(p_3, DTOType(2))
+
+                else: 
+                    active_pattern_result_4: str | None = _007CWorkflowCWLPath_007C__007C(split)
+                    if active_pattern_result_4 is not None:
+                        p_4: str = active_pattern_result_4
+                        return Contract.create_read(p_4, DTOType(8))
+
+                    else: 
+                        active_pattern_result_5: str | None = _007CRunPath_007C__007C(split)
+                        if active_pattern_result_5 is not None:
+                            p_5: str = active_pattern_result_5
+                            return Contract.create_read(p_5, DTOType(3))
+
+                        else: 
+                            active_pattern_result_6: str | None = _007CRunCWLPath_007C__007C(split)
+                            if active_pattern_result_6 is not None:
+                                p_6: str = active_pattern_result_6
+                                return Contract.create_read(p_6, DTOType(8))
+
+                            else: 
+                                active_pattern_result_7: str | None = _007CRunYMLPath_007C__007C(split)
+                                if active_pattern_result_7 is not None:
+                                    p_7: str = active_pattern_result_7
+                                    return Contract.create_read(p_7, DTOType(9))
+
+                                else: 
+                                    active_pattern_result_8: str | None = _007CDatamapPath_007C__007C(split)
+                                    if active_pattern_result_8 is not None:
+                                        p_8: str = active_pattern_result_8
+                                        return Contract.create_read(p_8, DTOType(5))
+
+                                    else: 
+                                        active_pattern_result_9: str | None = LicenseContractExtensions__007CLicensePath_007C__007C(split)
+                                        if active_pattern_result_9 is not None:
+                                            p_9: str = active_pattern_result_9
+                                            return Contract.create_read(p_9, DTOType(10))
+
+                                        else: 
+                                            return None
+
+
+
+
+
+
+
+
+
+
+
+
+__all__ = ["try_isaread_contract_from_path"]
+

arctrl/py/Contract/arc_assay.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+from typing import Any
+from ..fable_modules.fable_library.array_ import equals_with
+from ..fable_modules.fable_library.option import default_arg
+from ..fable_modules.fable_library.seq import (to_array, delay, append, collect, singleton, empty)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import IEnumerable_1
+from ..Core.arc_types import ArcAssay
+from ..Core.Helper.identifier import Assay_fileNameFromIdentifier
+from ..FileSystem.file_system_tree import FileSystemTree
+from ..FileSystem.path import (combine_many, get_assay_folder_path)
+from ..Spreadsheet.arc_assay import (ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F, ARCtrl_ArcAssay__ArcAssay_fromFsWorkbook_Static_32154C9D)
+from .contract import (Contract, DTOType, DTO)
+
+def _007CAssayPath_007C__007C(input: Array[str]) -> str | None:
+    (pattern_matching_result,) = (None,)
+    def _arrow4139(x: str, y: str, input: Any=input) -> bool:
+        return x == y
+
+    if (len(input) == 3) if (not equals_with(_arrow4139, input, None)) else False:
+        if input[0] == "assays":
+            if input[2] == "isa.assay.xlsx":
+                pattern_matching_result = 0
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+
+    else: 
+        pattern_matching_result = 1
+
+    if pattern_matching_result == 0:
+        any_assay_name: str = input[1]
+        return combine_many(input)
+
+    elif pattern_matching_result == 1:
+        return None
+
+
+
+def ARCtrl_ArcAssay__ArcAssay_ToCreateContract_6FCE9E49(this: ArcAssay, WithFolder: bool | None=None) -> Array[Contract]:
+    with_folder: bool = default_arg(WithFolder, False)
+    path: str = Assay_fileNameFromIdentifier(this.Identifier)
+    c: Contract = Contract.create_create(path, DTOType(0), DTO(0, ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F(this)))
+    def _arrow4143(__unit: None=None, this: Any=this, WithFolder: Any=WithFolder) -> IEnumerable_1[Contract]:
+        def _arrow4141(__unit: None=None) -> IEnumerable_1[Contract]:
+            folder_fs: FileSystemTree = FileSystemTree.create_assays_folder([FileSystemTree.create_assay_folder(this.Identifier)])
+            def _arrow4140(p: str) -> IEnumerable_1[Contract]:
+                return singleton(Contract.create_create(p, DTOType(10))) if ((p != "assays/.gitkeep") if (p != path) else False) else empty()
+
+            return collect(_arrow4140, folder_fs.ToFilePaths(False))
+
+        def _arrow4142(__unit: None=None) -> IEnumerable_1[Contract]:
+            return singleton(c)
+
+        return append(_arrow4141() if with_folder else empty(), delay(_arrow4142))
+
+    return to_array(delay(_arrow4143))
+
+
+def ARCtrl_ArcAssay__ArcAssay_ToUpdateContract(this: ArcAssay) -> Contract:
+    path: str = Assay_fileNameFromIdentifier(this.Identifier)
+    return Contract.create_update(path, DTOType(0), DTO(0, ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F(this)))
+
+
+def ARCtrl_ArcAssay__ArcAssay_ToDeleteContract(this: ArcAssay) -> Contract:
+    path: str = get_assay_folder_path(this.Identifier)
+    return Contract.create_delete(path)
+
+
+def ARCtrl_ArcAssay__ArcAssay_toDeleteContract_Static_1501C0F8(assay: ArcAssay) -> Contract:
+    return ARCtrl_ArcAssay__ArcAssay_ToDeleteContract(assay)
+
+
+def ARCtrl_ArcAssay__ArcAssay_toCreateContract_Static_Z2508BE4F(assay: ArcAssay, WithFolder: bool | None=None) -> Array[Contract]:
+    return ARCtrl_ArcAssay__ArcAssay_ToCreateContract_6FCE9E49(assay, WithFolder)
+
+
+def ARCtrl_ArcAssay__ArcAssay_toUpdateContract_Static_1501C0F8(assay: ArcAssay) -> Contract:
+    return ARCtrl_ArcAssay__ArcAssay_ToUpdateContract(assay)
+
+
+def ARCtrl_ArcAssay__ArcAssay_tryFromReadContract_Static_7570923F(c: Contract) -> ArcAssay | None:
+    (pattern_matching_result, fsworkbook) = (None, None)
+    if c.Operation == "READ":
+        if c.DTOType is not None:
+            if c.DTOType.tag == 0:
+                if c.DTO is not None:
+                    if c.DTO.tag == 0:
+                        pattern_matching_result = 0
+                        fsworkbook = 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
+
+    if pattern_matching_result == 0:
+        return ARCtrl_ArcAssay__ArcAssay_fromFsWorkbook_Static_32154C9D(fsworkbook)
+
+    elif pattern_matching_result == 1:
+        return None
+
+
+
+__all__ = ["_007CAssayPath_007C__007C", "ARCtrl_ArcAssay__ArcAssay_ToCreateContract_6FCE9E49", "ARCtrl_ArcAssay__ArcAssay_ToUpdateContract", "ARCtrl_ArcAssay__ArcAssay_ToDeleteContract", "ARCtrl_ArcAssay__ArcAssay_toDeleteContract_Static_1501C0F8", "ARCtrl_ArcAssay__ArcAssay_toCreateContract_Static_Z2508BE4F", "ARCtrl_ArcAssay__ArcAssay_toUpdateContract_Static_1501C0F8", "ARCtrl_ArcAssay__ArcAssay_tryFromReadContract_Static_7570923F"]
+

arctrl/py/Contract/arc_investigation.py

@@ -0,0 +1,88 @@
+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 ..Core.arc_types import ArcInvestigation
+from ..FileSystem.path import combine_many
+from ..Spreadsheet.arc_investigation import (ARCtrl_ArcInvestigation__ArcInvestigation_toFsWorkbook_Static_Z720BD3FF, ARCtrl_ArcInvestigation__ArcInvestigation_fromFsWorkbook_Static_32154C9D)
+from .contract import (Contract, DTOType, DTO)
+
+def _007CInvestigationPath_007C__007C(input: Array[str]) -> str | None:
+    (pattern_matching_result,) = (None,)
+    def _arrow4169(x: str, y: str, input: Any=input) -> bool:
+        return x == y
+
+    if (len(input) == 1) if (not equals_with(_arrow4169, input, None)) else False:
+        if input[0] == "isa.investigation.xlsx":
+            pattern_matching_result = 0
+
+        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_ArcInvestigation__ArcInvestigation_ToCreateContract(this: ArcInvestigation) -> Contract:
+    return Contract.create_create("isa.investigation.xlsx", DTOType(4), DTO(0, ARCtrl_ArcInvestigation__ArcInvestigation_toFsWorkbook_Static_Z720BD3FF(this)))
+
+
+def ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract(this: ArcInvestigation) -> Contract:
+    return Contract.create_update("isa.investigation.xlsx", DTOType(4), DTO(0, ARCtrl_ArcInvestigation__ArcInvestigation_toFsWorkbook_Static_Z720BD3FF(this)))
+
+
+def ARCtrl_ArcInvestigation__ArcInvestigation_toCreateContract_Static_Z720BD3FF(inv: ArcInvestigation) -> Contract:
+    return ARCtrl_ArcInvestigation__ArcInvestigation_ToCreateContract(inv)
+
+
+def ARCtrl_ArcInvestigation__ArcInvestigation_toUpdateContract_Static_Z720BD3FF(inv: ArcInvestigation) -> Contract:
+    return ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract(inv)
+
+
+def ARCtrl_ArcInvestigation__ArcInvestigation_tryFromReadContract_Static_7570923F(c: Contract) -> ArcInvestigation | None:
+    (pattern_matching_result, fsworkbook) = (None, None)
+    if c.Operation == "READ":
+        if c.DTOType is not None:
+            if c.DTOType.tag == 4:
+                if c.DTO is not None:
+                    if c.DTO.tag == 0:
+                        pattern_matching_result = 0
+                        fsworkbook = 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
+
+    if pattern_matching_result == 0:
+        return ARCtrl_ArcInvestigation__ArcInvestigation_fromFsWorkbook_Static_32154C9D(fsworkbook)
+
+    elif pattern_matching_result == 1:
+        return None
+
+
+
+__all__ = ["_007CInvestigationPath_007C__007C", "ARCtrl_ArcInvestigation__ArcInvestigation_ToCreateContract", "ARCtrl_ArcInvestigation__ArcInvestigation_ToUpdateContract", "ARCtrl_ArcInvestigation__ArcInvestigation_toCreateContract_Static_Z720BD3FF", "ARCtrl_ArcInvestigation__ArcInvestigation_toUpdateContract_Static_Z720BD3FF", "ARCtrl_ArcInvestigation__ArcInvestigation_tryFromReadContract_Static_7570923F"]
+