arctrl 3.0.0__py3-none-any.whl

arctrl/py/cwlrun_resolver.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from .CWL.cwlprocessing_unit import (CWLProcessingUnit_reflection, CWLProcessingUnit, WorkflowStepRunOps_fromWorkflow, WorkflowStepRunOps_fromExpressionTool, WorkflowStepRunOps_fromOperation, WorkflowStepRunOps_fromTool, WorkflowStepRunOps_tryGetWorkflow)
+from .CWL.workflow_description import CWLWorkflowDescription
+from .CWL.workflow_steps import (WorkflowStepRun, WorkflowStep)
+from .FileSystem.path import (normalize_path_key, normalize, resolve_path_from_file)
+from .fable_modules.fable_library.array_ import (filter, map)
+from .fable_modules.fable_library.map import (FSharpMap__Add, FSharpMap__TryFind, empty)
+from .fable_modules.fable_library.reflection import (TypeInfo, string_type, class_type, record_type)
+from .fable_modules.fable_library.seq2 import Array_distinct
+from .fable_modules.fable_library.set import (FSharpSet__Contains, FSharpSet__Add, empty as empty_1)
+from .fable_modules.fable_library.string_ import (is_null_or_white_space, ends_with)
+from .fable_modules.fable_library.types import (Record, Array)
+from .fable_modules.fable_library.util import (string_hash, get_enumerator, dispose, compare_primitives)
+
+def path_key(path: str) -> str:
+    return normalize_path_key(path)
+
+
+def _expr4286() -> TypeInfo:
+    return record_type("ARCtrl.CWLRunResolver.RunResolutionState", [], RunResolutionState, lambda: [("Cache", class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, CWLProcessingUnit_reflection()]))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class RunResolutionState(Record):
+    Cache: Any
+
+RunResolutionState_reflection = _expr4286
+
+def get_run_node_candidates(workflow_file_path: str, run_path: str) -> Array[str]:
+    if is_null_or_white_space(run_path):
+        return []
+
+    else: 
+        trimmed_run_path: str = run_path.strip()
+        if not ends_with(trimmed_run_path, ".cwl", 5):
+            return []
+
+        else: 
+            normalized_run_path: str = normalize(trimmed_run_path)
+            run_path_in_workflow_directory: str = resolve_path_from_file(workflow_file_path, trimmed_run_path)
+            def predicate(p: str, workflow_file_path: Any=workflow_file_path, run_path: Any=run_path) -> bool:
+                return not is_null_or_white_space(p)
+
+            class ObjectExpr4288:
+                @property
+                def Equals(self) -> Callable[[str, str], bool]:
+                    def _arrow4287(x: str, y: str) -> bool:
+                        return x == y
+
+                    return _arrow4287
+
+                @property
+                def GetHashCode(self) -> Callable[[str], int]:
+                    return string_hash
+
+            return Array_distinct(filter(predicate, [trimmed_run_path, normalized_run_path, run_path_in_workflow_directory, normalize(run_path_in_workflow_directory)]), ObjectExpr4288())
+
+
+
+
+def cache_resolved_processing_unit(state: RunResolutionState, candidate_keys: Array[str], processing_unit: CWLProcessingUnit) -> None:
+    for idx in range(0, (len(candidate_keys) - 1) + 1, 1):
+        key: str = candidate_keys[idx]
+        state.Cache = FSharpMap__Add(state.Cache, key, processing_unit)
+
+
+def run_from_processing_unit(processing_unit: CWLProcessingUnit) -> WorkflowStepRun:
+    if processing_unit.tag == 1:
+        return WorkflowStepRunOps_fromWorkflow(processing_unit.fields[0])
+
+    elif processing_unit.tag == 2:
+        return WorkflowStepRunOps_fromExpressionTool(processing_unit.fields[0])
+
+    elif processing_unit.tag == 3:
+        return WorkflowStepRunOps_fromOperation(processing_unit.fields[0])
+
+    else: 
+        return WorkflowStepRunOps_fromTool(processing_unit.fields[0])
+
+
+
+def resolve_workflow_runs_recursive_with_resolver(workflow_file_path: str, active_path_keys: Any, state: RunResolutionState, workflow: CWLWorkflowDescription, try_resolve_run_path: Callable[[str], CWLProcessingUnit | None]) -> None:
+    enumerator: Any = get_enumerator(workflow.Steps)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            step: WorkflowStep = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            resolved_run: WorkflowStepRun = resolve_workflow_step_run_recursive_with_resolver(workflow_file_path, active_path_keys, state, step.Run, try_resolve_run_path)
+            step.Run = resolved_run
+
+    finally: 
+        dispose(enumerator)
+
+
+
+def resolve_workflow_step_run_recursive_with_resolver(workflow_file_path: str, active_path_keys: Any, state: RunResolutionState, run: WorkflowStepRun, try_resolve_run_path: Callable[[str], CWLProcessingUnit | None]) -> WorkflowStepRun:
+    if run.tag == 2:
+        match_value_2: CWLWorkflowDescription | None = WorkflowStepRunOps_tryGetWorkflow(run)
+        if match_value_2 is None:
+            return run
+
+        else: 
+            workflow_1: CWLWorkflowDescription = match_value_2
+            resolve_workflow_runs_recursive_with_resolver(workflow_file_path, active_path_keys, state, workflow_1, try_resolve_run_path)
+            return WorkflowStepRunOps_fromWorkflow(workflow_1)
+
+
+    elif run.tag == 1:
+        return run
+
+    elif run.tag == 3:
+        return run
+
+    elif run.tag == 4:
+        return run
+
+    else: 
+        run_path: str = run.fields[0]
+        candidates: Array[str] = get_run_node_candidates(workflow_file_path, run_path)
+        def _arrow4289(path: str, workflow_file_path: Any=workflow_file_path, active_path_keys: Any=active_path_keys, state: Any=state, run: Any=run, try_resolve_run_path: Any=try_resolve_run_path) -> str:
+            return path_key(path)
+
+        class ObjectExpr4291:
+            @property
+            def Equals(self) -> Callable[[str, str], bool]:
+                def _arrow4290(x: str, y: str) -> bool:
+                    return x == y
+
+                return _arrow4290
+
+            @property
+            def GetHashCode(self) -> Callable[[str], int]:
+                return string_hash
+
+        candidate_keys: Array[str] = Array_distinct(map(_arrow4289, candidates, None), ObjectExpr4291())
+        def try_resolve_candidate(index_mut: int, workflow_file_path: Any=workflow_file_path, active_path_keys: Any=active_path_keys, state: Any=state, run: Any=run, try_resolve_run_path: Any=try_resolve_run_path) -> WorkflowStepRun:
+            while True:
+                (index,) = (index_mut,)
+                if index >= len(candidates):
+                    return WorkflowStepRun(0, run_path)
+
+                else: 
+                    candidate: str = candidates[index]
+                    key: str = path_key(candidate)
+                    if FSharpSet__Contains(active_path_keys, key):
+                        index_mut = index + 1
+                        continue
+
+                    else: 
+                        match_value: CWLProcessingUnit | None = FSharpMap__TryFind(state.Cache, key)
+                        if match_value is None:
+                            match_value_1: CWLProcessingUnit | None = try_resolve_run_path(candidate)
+                            if match_value_1 is None:
+                                index_mut = index + 1
+                                continue
+
+                            elif match_value_1.tag == 1:
+                                workflow: CWLWorkflowDescription = match_value_1.fields[0]
+                                resolve_workflow_runs_recursive_with_resolver(candidate, FSharpSet__Add(active_path_keys, key), state, workflow, try_resolve_run_path)
+                                resolved: CWLProcessingUnit = CWLProcessingUnit(1, workflow)
+                                cache_resolved_processing_unit(state, candidate_keys, resolved)
+                                return run_from_processing_unit(resolved)
+
+                            else: 
+                                processing_unit: CWLProcessingUnit = match_value_1
+                                cache_resolved_processing_unit(state, candidate_keys, processing_unit)
+                                return run_from_processing_unit(processing_unit)
+
+
+                        else: 
+                            return run_from_processing_unit(match_value)
+
+
+
+                break
+
+        try_resolve_candidate: Callable[[int], WorkflowStepRun] = try_resolve_candidate
+        return try_resolve_candidate(0)
+
+
+
+def resolve_run_references_from_lookup(workflow_file_path: str, processing_unit: CWLProcessingUnit, try_resolve_run_path: Callable[[str], CWLProcessingUnit | None]) -> CWLProcessingUnit:
+    if processing_unit.tag == 0:
+        return processing_unit
+
+    elif processing_unit.tag == 2:
+        return processing_unit
+
+    elif processing_unit.tag == 3:
+        return processing_unit
+
+    else: 
+        workflow: CWLWorkflowDescription = processing_unit.fields[0]
+        class ObjectExpr4292:
+            @property
+            def Compare(self) -> Callable[[str, str], int]:
+                return compare_primitives
+
+        state: RunResolutionState = RunResolutionState(empty(ObjectExpr4292()))
+        class ObjectExpr4293:
+            @property
+            def Compare(self) -> Callable[[str, str], int]:
+                return compare_primitives
+
+        resolve_workflow_runs_recursive_with_resolver(workflow_file_path, empty_1(ObjectExpr4293()), state, workflow, try_resolve_run_path)
+        return CWLProcessingUnit(1, workflow)
+
+
+
+def resolve_workflow_step_run_from_lookup(workflow_file_path: str, run: WorkflowStepRun, try_resolve_run_path: Callable[[str], CWLProcessingUnit | None]) -> WorkflowStepRun:
+    class ObjectExpr4294:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    state: RunResolutionState = RunResolutionState(empty(ObjectExpr4294()))
+    class ObjectExpr4295:
+        @property
+        def Compare(self) -> Callable[[str, str], int]:
+            return compare_primitives
+
+    return resolve_workflow_step_run_recursive_with_resolver(workflow_file_path, empty_1(ObjectExpr4295()), state, run, try_resolve_run_path)
+
+
+__all__ = ["path_key", "RunResolutionState_reflection", "get_run_node_candidates", "cache_resolved_processing_unit", "run_from_processing_unit", "resolve_workflow_runs_recursive_with_resolver", "resolve_workflow_step_run_recursive_with_resolver", "resolve_run_references_from_lookup", "resolve_workflow_step_run_from_lookup"]
+

arctrl/py/fable_modules/dynamic_obj/dyn_obj.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ..fable_library.list import (FSharpList, is_empty, tail, head, of_seq as of_seq_1, empty, cons, reverse)
+from ..fable_library.option import value as value_1
+from ..fable_library.range import range_big_int
+from ..fable_library.seq import (to_list, delay, map)
+from ..fable_library.string_ import (join, to_console, printf)
+from ..fable_library.types import Array
+from ..fable_library.util import (IEnumerable_1, get_enumerator, ignore)
+from .dynamic_obj import (DynamicObj, CopyUtils_tryDeepCopyObj_75B3D832)
+from .property_helper import PropertyHelper
+
+_TPROPERTYVALUE = TypeVar("_TPROPERTYVALUE")
+
+_UPROPERTYVALUE = TypeVar("_UPROPERTYVALUE")
+
+def of_dict(dynamic_properties: Any) -> DynamicObj:
+    return DynamicObj.of_dict(dynamic_properties)
+
+
+def of_seq(dynamic_properties: IEnumerable_1[tuple[str, Any]]) -> DynamicObj:
+    dynamic_properties_1: Any = dict(dict(dynamic_properties))
+    return DynamicObj.of_dict(dynamic_properties_1)
+
+
+def of_list(dynamic_properties: FSharpList[tuple[str, Any]]) -> DynamicObj:
+    return of_seq(dynamic_properties)
+
+
+def of_array(dynamic_properties: Array[tuple[str, Any]]) -> DynamicObj:
+    return of_seq(dynamic_properties)
+
+
+def combine(first: DynamicObj, second: DynamicObj) -> DynamicObj:
+    with get_enumerator(second.GetProperties(True)) as enumerator:
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            kv: Any = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            match_value: Any = kv[1]
+            if isinstance(match_value, DynamicObj):
+                match_value_1: Any | None = first.TryGetPropertyValue(kv[0])
+                if match_value_1 is None:
+                    first.SetProperty(kv[0], match_value)
+
+                else: 
+                    tmp: DynamicObj = combine(value_1(match_value_1), match_value)
+                    first.SetProperty(kv[0], tmp)
+
+
+            else: 
+                first.SetProperty(kv[0], kv[1])
+
+    return first
+
+
+def set_property(property_name: str, property_value: Any, dyn_obj: DynamicObj) -> None:
+    dyn_obj.SetProperty(property_name, property_value)
+
+
+def set_optional_property(property_name: str, property_value: Any | None, dyn_obj: DynamicObj) -> None:
+    if property_value is None:
+        pass
+
+    else: 
+        set_property(property_name, value_1(property_value), dyn_obj)
+
+
+
+def set_optional_property_by(property_name: str, property_value: Any | None, mapping: Callable[[_TPROPERTYVALUE], _UPROPERTYVALUE], dyn_obj: DynamicObj) -> None:
+    if property_value is None:
+        pass
+
+    else: 
+        set_property(property_name, mapping(value_1(property_value)), dyn_obj)
+
+
+
+def try_get_property_value(property_name: str, dyn_obj: DynamicObj) -> Any | None:
+    return dyn_obj.TryGetPropertyValue(property_name)
+
+
+def remove_property(property_name: str, dyn_obj: DynamicObj) -> None:
+    ignore(dyn_obj.RemoveProperty(property_name))
+
+
+def format(dyn_obj: DynamicObj) -> str:
+    def loop(object_mut: DynamicObj, indentation_level_mut: int, members_left_mut: FSharpList[PropertyHelper], acc_mut: FSharpList[str], dyn_obj: Any=dyn_obj) -> str:
+        while True:
+            (object, indentation_level, members_left, acc) = (object_mut, indentation_level_mut, members_left_mut, acc_mut)
+            def _arrow24(__unit: None=None, object: Any=object, indentation_level: Any=indentation_level, members_left: Any=members_left, acc: Any=acc) -> IEnumerable_1[str]:
+                def _arrow23(i: int) -> str:
+                    return "    "
+
+                return map(_arrow23, range_big_int(0, 1, indentation_level - 1))
+
+            indent: str = join("", to_list(delay(_arrow24)))
+            if not is_empty(members_left):
+                rest: FSharpList[PropertyHelper] = tail(members_left)
+                m: PropertyHelper = head(members_left)
+                item: Any = m.GetValue(object)
+                dynamic_indicator: str = "?" if m.IsDynamic else ""
+                name: str = m.Name
+                if isinstance(item, DynamicObj):
+                    object_mut = object
+                    indentation_level_mut = indentation_level
+                    members_left_mut = rest
+                    acc_mut = cons(((((((((("" + indent) + "") + dynamic_indicator) + "") + name) + ":") + "\n") + "") + loop(item, indentation_level + 1, of_seq_1(item.GetPropertyHelpers(True)), empty())) + "", acc)
+                    continue
+
+                else: 
+                    object_mut = object
+                    indentation_level_mut = indentation_level
+                    members_left_mut = rest
+                    acc_mut = cons(((((((("" + indent) + "") + dynamic_indicator) + "") + name) + ": ") + str(item)) + "", acc)
+                    continue
+
+
+            else: 
+                return join("\n", reverse(acc))
+
+            break
+
+    return loop(dyn_obj, 0, of_seq_1(dyn_obj.GetPropertyHelpers(True)), empty())
+
+
+def print(dyn_obj: DynamicObj) -> None:
+    arg: str = format(dyn_obj)
+    to_console(printf("%s"))(arg)
+
+
+def try_deep_copy_obj(include_instance_properties: bool, o: DynamicObj) -> Any:
+    return CopyUtils_tryDeepCopyObj_75B3D832(o, include_instance_properties)
+
+
+__all__ = ["of_dict", "of_seq", "of_list", "of_array", "combine", "set_property", "set_optional_property", "set_optional_property_by", "try_get_property_value", "remove_property", "format", "print", "try_deep_copy_obj"]
+