arctrl 3.0.0__py3-none-any.whl

arctrl/py/ValidationPackages/validation_packages_config.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.array_ import sort_by
+from ..fable_modules.fable_library.option import value
+from ..fable_modules.fable_library.range import range_big_int
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.seq import (to_list, delay, append, singleton, empty, map, length, fold, item)
+from ..fable_modules.fable_library.string_ import join
+from ..fable_modules.fable_library.types import (Array, to_string)
+from ..fable_modules.fable_library.util import (IEnumerable_1, compare_arrays, equals)
+from ..Core.Helper.hash_codes import (box_hash_array, box_hash_option, box_hash_seq)
+from .validation_package import ValidationPackage
+
+def _expr3951() -> TypeInfo:
+    return class_type("ARCtrl.ValidationPackages.ValidationPackagesConfig", None, ValidationPackagesConfig)
+
+
+class ValidationPackagesConfig:
+    def __init__(self, validation_packages: Array[ValidationPackage], arc_specification: str | None=None) -> None:
+        self._arc_specification: str | None = arc_specification
+        self._validation_packages: Array[ValidationPackage] = validation_packages
+
+    @property
+    def ValidationPackages(self, __unit: None=None) -> Array[ValidationPackage]:
+        this: ValidationPackagesConfig = self
+        return this._validation_packages
+
+    @ValidationPackages.setter
+    def ValidationPackages(self, validation_packages: Array[ValidationPackage]) -> None:
+        this: ValidationPackagesConfig = self
+        this._validation_packages = validation_packages
+
+    @property
+    def ARCSpecification(self, __unit: None=None) -> str | None:
+        this: ValidationPackagesConfig = self
+        return this._arc_specification
+
+    @ARCSpecification.setter
+    def ARCSpecification(self, arc_specification: str | None=None) -> None:
+        this: ValidationPackagesConfig = self
+        this._arc_specification = arc_specification
+
+    @staticmethod
+    def make(validation_packages: Array[ValidationPackage], arc_specification: str | None=None) -> ValidationPackagesConfig:
+        return ValidationPackagesConfig(validation_packages, arc_specification)
+
+    def Copy(self, __unit: None=None) -> ValidationPackagesConfig:
+        this: ValidationPackagesConfig = self
+        validation_packages: Array[ValidationPackage] = this.ValidationPackages
+        arc_specification: str | None = this.ARCSpecification
+        return ValidationPackagesConfig.make(validation_packages, arc_specification)
+
+    def __str__(self, __unit: None=None) -> str:
+        this: ValidationPackagesConfig = self
+        def _arrow3947(__unit: None=None) -> IEnumerable_1[str]:
+            def _arrow3946(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow3945(__unit: None=None) -> IEnumerable_1[str]:
+                    def _arrow3944(__unit: None=None) -> IEnumerable_1[str]:
+                        def _arrow3943(__unit: None=None) -> IEnumerable_1[str]:
+                            def _arrow3942(__unit: None=None) -> IEnumerable_1[str]:
+                                return singleton("}")
+
+                            return append(singleton("]"), delay(_arrow3942))
+
+                        return append(singleton(join((";" + "\n") + "", map(to_string, this.ValidationPackages))), delay(_arrow3943))
+
+                    return append(singleton(" ValidationPackages = ["), delay(_arrow3944))
+
+                return append(singleton((" ARCSpecification = " + value(this.ARCSpecification)) + "") if (this.ARCSpecification is not None) else empty(), delay(_arrow3945))
+
+            return append(singleton("{"), delay(_arrow3946))
+
+        return join("\n", to_list(delay(_arrow3947)))
+
+    def StructurallyEquals(self, other: ValidationPackagesConfig) -> bool:
+        this: ValidationPackagesConfig = self
+        def sort(arg: Array[ValidationPackage]) -> Array[ValidationPackage]:
+            def projection(vp: ValidationPackage, arg: Any=arg) -> tuple[str, str | None]:
+                return (vp.Name, vp.Version)
+
+            class ObjectExpr3948:
+                @property
+                def Compare(self) -> Callable[[tuple[str, str | None], tuple[str, str | None]], int]:
+                    return compare_arrays
+
+            return sort_by(projection, list(arg), ObjectExpr3948())
+
+        if equals(this.ARCSpecification, other.ARCSpecification):
+            a: IEnumerable_1[ValidationPackage] = sort(this.ValidationPackages)
+            b: IEnumerable_1[ValidationPackage] = sort(other.ValidationPackages)
+            def folder(acc: bool, e: bool) -> bool:
+                if acc:
+                    return e
+
+                else: 
+                    return False
+
+
+            def _arrow3950(__unit: None=None) -> IEnumerable_1[bool]:
+                def _arrow3949(i: int) -> bool:
+                    return equals(item(i, a), item(i, b))
+
+                return map(_arrow3949, range_big_int(0, 1, length(a) - 1))
+
+            return fold(folder, True, to_list(delay(_arrow3950))) if (length(a) == length(b)) else False
+
+        else: 
+            return False
+
+
+    def ReferenceEquals(self, other: ValidationPackagesConfig) -> bool:
+        this: ValidationPackagesConfig = self
+        return this is other
+
+    def __eq__(self, other: Any=None) -> bool:
+        this: ValidationPackagesConfig = self
+        return this.StructurallyEquals(other) if isinstance(other, ValidationPackagesConfig) else False
+
+    def __hash__(self, __unit: None=None) -> Any:
+        this: ValidationPackagesConfig = self
+        return box_hash_array([box_hash_option(this.ARCSpecification), box_hash_seq(this.ValidationPackages)])
+
+
+ValidationPackagesConfig_reflection = _expr3951
+
+def ValidationPackagesConfig__ctor_376974AD(validation_packages: Array[ValidationPackage], arc_specification: str | None=None) -> ValidationPackagesConfig:
+    return ValidationPackagesConfig(validation_packages, arc_specification)
+
+
+__all__ = ["ValidationPackagesConfig_reflection"]
+

arctrl/py/WebRequest/web_request.py

@@ -0,0 +1,9 @@
+from ..fable_modules.fable_library.async_builder import Async
+from .web_request_py import download_file as download_file_1
+
+def download_file(url: str) -> Async[str]:
+    return download_file_1(url)
+
+
+__all__ = ["download_file"]
+

arctrl/py/WebRequest/web_request_py.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+from abc import abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass
+import requests
+from typing import (Any, Protocol)
+from ..fable_modules.fable_library.async_builder import (singleton as singleton_1, Async)
+from ..fable_modules.fable_library.map import of_list
+from ..fable_modules.fable_library.option import map
+from ..fable_modules.fable_library.reflection import (TypeInfo, int32_type, string_type, class_type, record_type)
+from ..fable_modules.fable_library.seq import (to_list, delay, map as map_1, collect, singleton)
+from ..fable_modules.fable_library.types import Record
+from ..fable_modules.fable_library.util import (create_obj, IEnumerable_1, compare_primitives)
+
+class InteropResponseType(Protocol):
+    @property
+    @abstractmethod
+    def encoding(self) -> str:
+        ...
+
+    @property
+    @abstractmethod
+    def headers(self) -> Any:
+        ...
+
+    @property
+    @abstractmethod
+    def status_code(self) -> int:
+        ...
+
+    @property
+    @abstractmethod
+    def text(self) -> str:
+        ...
+
+
+def _expr4457() -> TypeInfo:
+    return record_type("ARCtrl.WebRequestHelpers.Py.Response", [], Response, lambda: [("status_code", int32_type), ("text", string_type), ("headers", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type])), ("encoding", string_type)])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class Response(Record):
+    status_code: int
+    text: str
+    headers: Any
+    encoding: str
+
+Response_reflection = _expr4457
+
+def _expr4458() -> TypeInfo:
+    return class_type("ARCtrl.WebRequestHelpers.Py.Requests", None, Requests)
+
+
+class Requests:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+
+Requests_reflection = _expr4458
+
+def Requests__ctor(__unit: None=None) -> Requests:
+    return Requests(__unit)
+
+
+def Requests_createHeadersDict_9F3777D(headers: Any | None=None) -> Any | None:
+    def mapping(values: Any, headers: Any=headers) -> Any:
+        def _arrow4460(__unit: None=None, values: Any=values) -> IEnumerable_1[tuple[str, Any]]:
+            def _arrow4459(pair: Any) -> tuple[str, Any]:
+                return (pair[0], pair[1])
+
+            return map_1(_arrow4459, values)
+
+        return create_obj(to_list(delay(_arrow4460)))
+
+    return map(mapping, headers)
+
+
+def Requests_mapResponseType_Z730CA7D4(response: InteropResponseType) -> Response:
+    status_code: int = response.status_code or 0
+    text: str = response.text
+    encoding: str = response.text
+    def _arrow4462(__unit: None=None, response: Any=response) -> IEnumerable_1[tuple[str, str]]:
+        def _arrow4461(header_name: str) -> IEnumerable_1[tuple[str, str]]:
+            return singleton((header_name, response.headers[header_name]))
+
+        return collect(_arrow4461, list(response.headers.keys()))
+
+    class ObjectExpr4463:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    return Response(status_code, text, of_list(to_list(delay(_arrow4462)), ObjectExpr4463()), encoding)
+
+
+def Requests_get_43A074E6(url: str, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.get(url, headers=headers_dict))
+
+
+def Requests_post_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.post(url, data=data, headers=headers_dict))
+
+
+def Requests_put_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.put(url, data=data, headers=headers_dict))
+
+
+def Requests_delete_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.delete(url, data=data, headers=headers_dict))
+
+
+def Requests_head_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.head(url, data=data, headers=headers_dict))
+
+
+def Requests_options_147AE53E(url: str, data: str | None=None, headers: Any | None=None) -> Response:
+    headers_dict: Any | None = Requests_createHeadersDict_9F3777D(headers)
+    return Requests_mapResponseType_Z730CA7D4(requests.head(url, data=data, headers=headers_dict))
+
+
+def download_file(url: str) -> Async[str]:
+    def _arrow4464(__unit: None=None, url: Any=url) -> Async[str]:
+        response: Response = Requests_get_43A074E6(url)
+        return singleton_1.Return(response.text)
+
+    return singleton_1.Delay(_arrow4464)
+
+
+__all__ = ["Response_reflection", "Requests_reflection", "Requests_createHeadersDict_9F3777D", "Requests_mapResponseType_Z730CA7D4", "Requests_get_43A074E6", "Requests_post_147AE53E", "Requests_put_147AE53E", "Requests_delete_147AE53E", "Requests_head_147AE53E", "Requests_options_147AE53E", "download_file"]
+

arctrl/py/WorkflowGraph/adapters.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.map import (of_seq, empty as empty_1, is_empty, try_find)
+from ..fable_modules.fable_library.result import FSharpResult_2
+from ..fable_modules.fable_library.seq import (map, delay, append, collect, empty, singleton)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import (IEnumerable_1, compare_primitives, get_enumerator, dispose)
+from ..Core.arc_types import (ArcInvestigation, ArcWorkflow, ArcRun)
+from ..Core.Helper.identifier import (Workflow_cwlFileNameFromIdentifier, Run_cwlFileNameFromIdentifier)
+from ..CWL.cwlprocessing_unit import CWLProcessingUnit
+from ..FileSystem.path import normalize_path_key
+from .builder import build_with
+from .build_options import (WorkflowGraphBuildOptions, WorkflowGraphBuildOptionsModule_withRootScope, WorkflowGraphBuildOptionsModule_defaultOptions, WorkflowGraphBuildOptionsModule_withRootWorkflowFilePath, WorkflowGraphBuildOptionsModule_withTryResolveRunPath)
+from .graph_types import (GraphBuildIssue_create_Z2F3B511A, GraphIssueKind, GraphBuildIssue, WorkflowGraph, WorkflowGraphIndex_create_56E060E0, WorkflowGraphIndex)
+
+def create_cwl_lookup_from_investigation(investigation: ArcInvestigation | None=None) -> Any:
+    if investigation is not None:
+        inv: ArcInvestigation = investigation
+        def mapping(tupled_arg: tuple[str, CWLProcessingUnit], investigation: Any=investigation) -> tuple[str, CWLProcessingUnit]:
+            return (normalize_path_key(tupled_arg[0]), tupled_arg[1])
+
+        def _arrow1333(__unit: None=None, investigation: Any=investigation) -> IEnumerable_1[tuple[str, CWLProcessingUnit]]:
+            def _arrow1330(workflow: ArcWorkflow) -> IEnumerable_1[tuple[str, CWLProcessingUnit]]:
+                match_value: CWLProcessingUnit | None = workflow.CWLDescription
+                if match_value is None:
+                    return empty()
+
+                else: 
+                    cwl: CWLProcessingUnit = match_value
+                    return singleton((Workflow_cwlFileNameFromIdentifier(workflow.Identifier), cwl))
+
+
+            def _arrow1332(__unit: None=None) -> IEnumerable_1[tuple[str, CWLProcessingUnit]]:
+                def _arrow1331(run: ArcRun) -> IEnumerable_1[tuple[str, CWLProcessingUnit]]:
+                    match_value_1: CWLProcessingUnit | None = run.CWLDescription
+                    if match_value_1 is None:
+                        return empty()
+
+                    else: 
+                        cwl_1: CWLProcessingUnit = match_value_1
+                        return singleton((Run_cwlFileNameFromIdentifier(run.Identifier), cwl_1))
+
+
+                return collect(_arrow1331, inv.Runs)
+
+            return append(collect(_arrow1330, inv.Workflows), delay(_arrow1332))
+
+        class ObjectExpr1334:
+            @property
+            def Compare(self) -> Callable[[str, str], int]:
+                return compare_primitives
+
+        return of_seq(map(mapping, delay(_arrow1333)), ObjectExpr1334())
+
+    else: 
+        class ObjectExpr1335:
+            @property
+            def Compare(self) -> Callable[[str, str], int]:
+                return compare_primitives
+
+        return empty_1(ObjectExpr1335())
+
+
+
+def create_resolver(lookup: Any) -> Callable[[str], CWLProcessingUnit | None] | None:
+    if is_empty(lookup):
+        return None
+
+    else: 
+        def _arrow1336(path: str, lookup: Any=lookup) -> CWLProcessingUnit | None:
+            return try_find(normalize_path_key(path), lookup)
+
+        return _arrow1336
+
+
+
+def create_missing_description_error(identifier: str, scope_type: Any) -> GraphBuildIssue:
+    return GraphBuildIssue_create_Z2F3B511A(GraphIssueKind(4), ((("No CWLDescription available for " + str(scope_type)) + " \'") + identifier) + "\'.", identifier)
+
+
+def of_workflow(workflow: ArcWorkflow) -> FSharpResult_2[WorkflowGraph, GraphBuildIssue]:
+    match_value: CWLProcessingUnit | None = workflow.CWLDescription
+    if match_value is not None:
+        processing_unit: CWLProcessingUnit = match_value
+        def _arrow1337(__unit: None=None, workflow: Any=workflow) -> WorkflowGraphBuildOptions:
+            options_2: WorkflowGraphBuildOptions
+            options_1: WorkflowGraphBuildOptions = WorkflowGraphBuildOptionsModule_withRootScope(workflow.Identifier, WorkflowGraphBuildOptionsModule_defaultOptions)
+            options_2 = WorkflowGraphBuildOptionsModule_withRootWorkflowFilePath(Workflow_cwlFileNameFromIdentifier(workflow.Identifier), options_1)
+            return WorkflowGraphBuildOptionsModule_withTryResolveRunPath(create_resolver(create_cwl_lookup_from_investigation(workflow.Investigation)), options_2)
+
+        return FSharpResult_2(0, build_with(_arrow1337(), processing_unit))
+
+    else: 
+        return FSharpResult_2(1, create_missing_description_error(workflow.Identifier, "workflow"))
+
+
+
+def of_run(run: ArcRun) -> FSharpResult_2[WorkflowGraph, GraphBuildIssue]:
+    match_value: CWLProcessingUnit | None = run.CWLDescription
+    if match_value is not None:
+        processing_unit: CWLProcessingUnit = match_value
+        def _arrow1338(__unit: None=None, run: Any=run) -> WorkflowGraphBuildOptions:
+            options_2: WorkflowGraphBuildOptions
+            options_1: WorkflowGraphBuildOptions = WorkflowGraphBuildOptionsModule_withRootScope(run.Identifier, WorkflowGraphBuildOptionsModule_defaultOptions)
+            options_2 = WorkflowGraphBuildOptionsModule_withRootWorkflowFilePath(Run_cwlFileNameFromIdentifier(run.Identifier), options_1)
+            return WorkflowGraphBuildOptionsModule_withTryResolveRunPath(create_resolver(create_cwl_lookup_from_investigation(run.Investigation)), options_2)
+
+        return FSharpResult_2(0, build_with(_arrow1338(), processing_unit))
+
+    else: 
+        return FSharpResult_2(1, create_missing_description_error(run.Identifier, "run"))
+
+
+
+def of_investigation(investigation: ArcInvestigation) -> WorkflowGraphIndex:
+    workflow_graphs: Array[tuple[str, FSharpResult_2[WorkflowGraph, GraphBuildIssue]]] = []
+    run_graphs: Array[tuple[str, FSharpResult_2[WorkflowGraph, GraphBuildIssue]]] = []
+    enumerator: Any = get_enumerator(investigation.Workflows)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            workflow: ArcWorkflow = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            (workflow_graphs.append((workflow.Identifier, of_workflow(workflow))))
+
+    finally: 
+        dispose(enumerator)
+
+    enumerator_1: Any = get_enumerator(investigation.Runs)
+    try: 
+        while enumerator_1.System_Collections_IEnumerator_MoveNext():
+            run: ArcRun = enumerator_1.System_Collections_Generic_IEnumerator_1_get_Current()
+            (run_graphs.append((run.Identifier, of_run(run))))
+
+    finally: 
+        dispose(enumerator_1)
+
+    return WorkflowGraphIndex_create_56E060E0(workflow_graphs, run_graphs)
+
+
+__all__ = ["create_cwl_lookup_from_investigation", "create_resolver", "create_missing_description_error", "of_workflow", "of_run", "of_investigation"]
+

arctrl/py/WorkflowGraph/build_options.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from ..fable_modules.fable_library.reflection import (TypeInfo, string_type, option_type, lambda_type, bool_type, record_type)
+from ..fable_modules.fable_library.types import Record
+from ..CWL.cwlprocessing_unit import (CWLProcessingUnit, CWLProcessingUnit_reflection)
+
+def _expr1328() -> TypeInfo:
+    return record_type("ARCtrl.WorkflowGraph.WorkflowGraphBuildOptions", [], WorkflowGraphBuildOptions, lambda: [("RootScope", string_type), ("RootWorkflowFilePath", option_type(string_type)), ("TryResolveRunPath", option_type(lambda_type(string_type, option_type(CWLProcessingUnit_reflection())))), ("StrictUnresolvedRunReferences", bool_type), ("ExpandNestedWorkflows", bool_type)])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class WorkflowGraphBuildOptions(Record):
+    RootScope: str
+    RootWorkflowFilePath: str | None
+    TryResolveRunPath: Callable[[str], CWLProcessingUnit | None] | None
+    StrictUnresolvedRunReferences: bool
+    ExpandNestedWorkflows: bool
+
+WorkflowGraphBuildOptions_reflection = _expr1328
+
+WorkflowGraphBuildOptionsModule_defaultOptions: WorkflowGraphBuildOptions = WorkflowGraphBuildOptions("root", None, None, False, True)
+
+def WorkflowGraphBuildOptionsModule_withRootScope(root_scope: str, options: WorkflowGraphBuildOptions) -> WorkflowGraphBuildOptions:
+    return WorkflowGraphBuildOptions(root_scope, options.RootWorkflowFilePath, options.TryResolveRunPath, options.StrictUnresolvedRunReferences, options.ExpandNestedWorkflows)
+
+
+def WorkflowGraphBuildOptionsModule_withRootWorkflowFilePath(root_workflow_file_path: str | None, options: WorkflowGraphBuildOptions) -> WorkflowGraphBuildOptions:
+    return WorkflowGraphBuildOptions(options.RootScope, root_workflow_file_path, options.TryResolveRunPath, options.StrictUnresolvedRunReferences, options.ExpandNestedWorkflows)
+
+
+def WorkflowGraphBuildOptionsModule_withTryResolveRunPath(try_resolve_run_path: Callable[[str], CWLProcessingUnit | None] | None, options: WorkflowGraphBuildOptions) -> WorkflowGraphBuildOptions:
+    return WorkflowGraphBuildOptions(options.RootScope, options.RootWorkflowFilePath, try_resolve_run_path, options.StrictUnresolvedRunReferences, options.ExpandNestedWorkflows)
+
+
+def WorkflowGraphBuildOptionsModule_withStrictUnresolvedRunReferences(strict: bool, options: WorkflowGraphBuildOptions) -> WorkflowGraphBuildOptions:
+    return WorkflowGraphBuildOptions(options.RootScope, options.RootWorkflowFilePath, options.TryResolveRunPath, strict, options.ExpandNestedWorkflows)
+
+
+def WorkflowGraphBuildOptionsModule_withExpandNestedWorkflows(expand_nested_workflows: bool, options: WorkflowGraphBuildOptions) -> WorkflowGraphBuildOptions:
+    return WorkflowGraphBuildOptions(options.RootScope, options.RootWorkflowFilePath, options.TryResolveRunPath, options.StrictUnresolvedRunReferences, expand_nested_workflows)
+
+
+__all__ = ["WorkflowGraphBuildOptions_reflection", "WorkflowGraphBuildOptionsModule_defaultOptions", "WorkflowGraphBuildOptionsModule_withRootScope", "WorkflowGraphBuildOptionsModule_withRootWorkflowFilePath", "WorkflowGraphBuildOptionsModule_withTryResolveRunPath", "WorkflowGraphBuildOptionsModule_withStrictUnresolvedRunReferences", "WorkflowGraphBuildOptionsModule_withExpandNestedWorkflows"]
+