arctrl 3.0.0__py3-none-any.whl

arctrl/py/CWL/expression_tool_description.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+from ..fable_modules.dynamic_obj.dynamic_obj import (DynamicObj, DynamicObj_reflection)
+from ..fable_modules.fable_library.option import default_arg
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.types import Array
+from .inputs import CWLInput
+from .outputs import CWLOutput
+from .requirements import (Requirement, HintEntry)
+
+def _expr770() -> TypeInfo:
+    return class_type("ARCtrl.CWL.CWLExpressionToolDescription", None, CWLExpressionToolDescription, DynamicObj_reflection())
+
+
+class CWLExpressionToolDescription(DynamicObj):
+    def __init__(self, outputs: Array[CWLOutput], expression: str, cwl_version: str | None=None, requirements: Array[Requirement] | None=None, hints: Array[HintEntry] | None=None, intent: Array[str] | None=None, inputs: Array[CWLInput] | None=None, metadata: DynamicObj | None=None, label: str | None=None, doc: str | None=None) -> None:
+        super().__init__()
+        self._cwlVersion: str = default_arg(cwl_version, "v1.2")
+        self._outputs: Array[CWLOutput] = outputs
+        self._expression: str = expression
+        self._requirements: Array[Requirement] | None = requirements
+        self._hints: Array[HintEntry] | None = hints
+        self._intent: Array[str] | None = intent
+        self._inputs: Array[CWLInput] | None = inputs
+        self._metadata: DynamicObj | None = metadata
+        self._label: str | None = label
+        self._doc: str | None = doc
+
+    @property
+    def CWLVersion(self, __unit: None=None) -> str:
+        this: CWLExpressionToolDescription = self
+        return this._cwlVersion
+
+    @CWLVersion.setter
+    def CWLVersion(self, version: str) -> None:
+        this: CWLExpressionToolDescription = self
+        this._cwlVersion = version
+
+    @property
+    def Outputs(self, __unit: None=None) -> Array[CWLOutput]:
+        this: CWLExpressionToolDescription = self
+        return this._outputs
+
+    @Outputs.setter
+    def Outputs(self, outputs: Array[CWLOutput]) -> None:
+        this: CWLExpressionToolDescription = self
+        this._outputs = outputs
+
+    @property
+    def Expression(self, __unit: None=None) -> str:
+        this: CWLExpressionToolDescription = self
+        return this._expression
+
+    @Expression.setter
+    def Expression(self, expression: str) -> None:
+        this: CWLExpressionToolDescription = self
+        this._expression = expression
+
+    @property
+    def Requirements(self, __unit: None=None) -> Array[Requirement] | None:
+        this: CWLExpressionToolDescription = self
+        return this._requirements
+
+    @Requirements.setter
+    def Requirements(self, requirements: Array[Requirement] | None=None) -> None:
+        this: CWLExpressionToolDescription = self
+        this._requirements = requirements
+
+    @property
+    def Hints(self, __unit: None=None) -> Array[HintEntry] | None:
+        this: CWLExpressionToolDescription = self
+        return this._hints
+
+    @Hints.setter
+    def Hints(self, hints: Array[HintEntry] | None=None) -> None:
+        this: CWLExpressionToolDescription = self
+        this._hints = hints
+
+    @property
+    def Intent(self, __unit: None=None) -> Array[str] | None:
+        this: CWLExpressionToolDescription = self
+        return this._intent
+
+    @Intent.setter
+    def Intent(self, intent: Array[str] | None=None) -> None:
+        this: CWLExpressionToolDescription = self
+        this._intent = intent
+
+    @property
+    def Inputs(self, __unit: None=None) -> Array[CWLInput] | None:
+        this: CWLExpressionToolDescription = self
+        return this._inputs
+
+    @Inputs.setter
+    def Inputs(self, inputs: Array[CWLInput] | None=None) -> None:
+        this: CWLExpressionToolDescription = self
+        this._inputs = inputs
+
+    @property
+    def Metadata(self, __unit: None=None) -> DynamicObj | None:
+        this: CWLExpressionToolDescription = self
+        return this._metadata
+
+    @Metadata.setter
+    def Metadata(self, metadata: DynamicObj | None=None) -> None:
+        this: CWLExpressionToolDescription = self
+        this._metadata = metadata
+
+    @property
+    def Label(self, __unit: None=None) -> str | None:
+        this: CWLExpressionToolDescription = self
+        return this._label
+
+    @Label.setter
+    def Label(self, label: str | None=None) -> None:
+        this: CWLExpressionToolDescription = self
+        this._label = label
+
+    @property
+    def Doc(self, __unit: None=None) -> str | None:
+        this: CWLExpressionToolDescription = self
+        return this._doc
+
+    @Doc.setter
+    def Doc(self, doc: str | None=None) -> None:
+        this: CWLExpressionToolDescription = self
+        this._doc = doc
+
+    @staticmethod
+    def get_inputs_or_empty(tool: CWLExpressionToolDescription) -> Array[CWLInput]:
+        return default_arg(tool.Inputs, [])
+
+    @staticmethod
+    def get_outputs(tool: CWLExpressionToolDescription) -> Array[CWLOutput]:
+        return tool.Outputs
+
+    @staticmethod
+    def get_or_create_inputs(tool: CWLExpressionToolDescription) -> Array[CWLInput]:
+        match_value: Array[CWLInput] | None = tool.Inputs
+        if match_value is None:
+            inputs_1: Array[CWLInput] = []
+            tool.Inputs = inputs_1
+            return inputs_1
+
+        else: 
+            return match_value
+
+
+    @staticmethod
+    def get_requirements_or_empty(tool: CWLExpressionToolDescription) -> Array[Requirement]:
+        return default_arg(tool.Requirements, [])
+
+    @staticmethod
+    def get_hints_or_empty(tool: CWLExpressionToolDescription) -> Array[HintEntry]:
+        return default_arg(tool.Hints, [])
+
+    @staticmethod
+    def get_intent_or_empty(tool: CWLExpressionToolDescription) -> Array[str]:
+        return default_arg(tool.Intent, [])
+
+    @staticmethod
+    def get_or_create_hints(tool: CWLExpressionToolDescription) -> Array[HintEntry]:
+        match_value: Array[HintEntry] | None = tool.Hints
+        if match_value is None:
+            hints_1: Array[HintEntry] = []
+            tool.Hints = hints_1
+            return hints_1
+
+        else: 
+            return match_value
+
+
+    @staticmethod
+    def get_or_create_intent(tool: CWLExpressionToolDescription) -> Array[str]:
+        match_value: Array[str] | None = tool.Intent
+        if match_value is None:
+            intent_1: Array[str] = []
+            tool.Intent = intent_1
+            return intent_1
+
+        else: 
+            return match_value
+
+
+
+CWLExpressionToolDescription_reflection = _expr770
+
+def CWLExpressionToolDescription__ctor_444EA890(outputs: Array[CWLOutput], expression: str, cwl_version: str | None=None, requirements: Array[Requirement] | None=None, hints: Array[HintEntry] | None=None, intent: Array[str] | None=None, inputs: Array[CWLInput] | None=None, metadata: DynamicObj | None=None, label: str | None=None, doc: str | None=None) -> CWLExpressionToolDescription:
+    return CWLExpressionToolDescription(outputs, expression, cwl_version, requirements, hints, intent, inputs, metadata, label, doc)
+
+
+__all__ = ["CWLExpressionToolDescription_reflection"]
+

arctrl/py/CWL/hash_helpers.py

@@ -0,0 +1,60 @@
+from typing import (Any, TypeVar)
+from ..fable_modules.fable_library.array_ import fold
+from ..fable_modules.fable_library.date import (year, month, day, hour, minute, second)
+from ..fable_modules.fable_library.option import value as value_1
+from ..fable_modules.fable_library.seq import fold as fold_1
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import (identity_hash, number_hash, IEnumerable_1)
+
+__A = TypeVar("__A")
+
+_A = TypeVar("_A")
+
+def merge_hashes(hash1: int, hash2: int) -> int:
+    return ((-1640531527 + hash2) + (hash1 << 6)) + (hash1 >> 2)
+
+
+def hash_date_time(dt: Any) -> int:
+    acc: int = 0
+    acc = merge_hashes(acc, year(dt)) or 0
+    acc = merge_hashes(acc, month(dt)) or 0
+    acc = merge_hashes(acc, day(dt)) or 0
+    acc = merge_hashes(acc, hour(dt)) or 0
+    acc = merge_hashes(acc, minute(dt)) or 0
+    acc = merge_hashes(acc, second(dt)) or 0
+    return acc
+
+
+def hash_1(obj: Any | None=None) -> int:
+    copy_of_struct: __A = obj
+    return identity_hash(copy_of_struct)
+
+
+def box_hash_option(a: Any | None=None) -> Any:
+    def _arrow695(__unit: None=None, a: Any=a) -> int:
+        copy_of_struct: _A = value_1(a)
+        return identity_hash(copy_of_struct)
+
+    def _arrow696(__unit: None=None, a: Any=a) -> int:
+        copy_of_struct_1: int = 0
+        return number_hash(copy_of_struct_1)
+
+    return _arrow695() if (a is not None) else _arrow696()
+
+
+def box_hash_array(a: Array[Any]) -> Any:
+    def folder(acc: int, o: _A, a: Any=a) -> int:
+        return merge_hashes(acc, hash_1(o))
+
+    return fold(folder, 0, a)
+
+
+def box_hash_seq(a: IEnumerable_1[Any]) -> Any:
+    def folder(acc: int, o: _A, a: Any=a) -> int:
+        return merge_hashes(acc, hash_1(o))
+
+    return fold_1(folder, 0, a)
+
+
+__all__ = ["merge_hashes", "hash_date_time", "hash_1", "box_hash_option", "box_hash_array", "box_hash_seq"]
+

arctrl/py/CWL/inputs.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+from ..fable_modules.dynamic_obj.dynamic_obj import (DynamicObj, DynamicObj_reflection)
+from ..fable_modules.dynamic_obj.dyn_obj import (remove_property, set_property, set_optional_property)
+from ..fable_modules.fable_library.option import value as value_1
+from ..fable_modules.fable_library.reflection import (TypeInfo, string_type, option_type, int32_type, bool_type, record_type, class_type)
+from ..fable_modules.fable_library.types import (Record, FSharpRef)
+from .cwltypes import CWLType
+
+def _expr757() -> TypeInfo:
+    return record_type("ARCtrl.CWL.InputBinding", [], InputBinding, lambda: [("Prefix", option_type(string_type)), ("Position", option_type(int32_type)), ("ItemSeparator", option_type(string_type)), ("Separate", option_type(bool_type))])
+
+
+@dataclass(eq = False, repr = False, slots = True)
+class InputBinding(Record):
+    Prefix: str | None
+    Position: int | None
+    ItemSeparator: str | None
+    Separate: bool | None
+
+InputBinding_reflection = _expr757
+
+def InputBinding_create_ZAC0108A(prefix: str | None=None, position: int | None=None, item_separator: str | None=None, separate: bool | None=None) -> InputBinding:
+    return InputBinding(prefix, position, item_separator, separate)
+
+
+def _expr758() -> TypeInfo:
+    return class_type("ARCtrl.CWL.CWLInput", None, CWLInput, DynamicObj_reflection())
+
+
+class CWLInput(DynamicObj):
+    def __init__(self, name: str, type_: CWLType | None=None, input_binding: InputBinding | None=None, optional: bool | None=None) -> None:
+        super().__init__()
+        this: FSharpRef[CWLInput] = FSharpRef(None)
+        self.name: str = name
+        this.contents = self
+        self.init_004031: int = 1
+        set_optional_property("type", type_, this.contents)
+        set_optional_property("inputBinding", input_binding, this.contents)
+        set_optional_property("optional", optional, this.contents)
+
+    @property
+    def Name(self, __unit: None=None) -> str:
+        this: CWLInput = self
+        return this.name
+
+    @property
+    def Type_(self, __unit: None=None) -> CWLType | None:
+        this: CWLInput = self
+        match_value: Any | None = this.TryGetPropertyValue("type")
+        if match_value is not None:
+            o: Any = value_1(match_value)
+            return o if isinstance(o, CWLType) else None
+
+        else: 
+            return None
+
+
+    @Type_.setter
+    def Type_(self, value: CWLType | None=None) -> None:
+        this: CWLInput = self
+        if value is None:
+            remove_property("type", this)
+
+        else: 
+            set_property("type", value, this)
+
+
+    @property
+    def InputBinding(self, __unit: None=None) -> InputBinding | None:
+        this: CWLInput = self
+        match_value: Any | None = this.TryGetPropertyValue("inputBinding")
+        if match_value is not None:
+            o: Any = value_1(match_value)
+            return o if isinstance(o, InputBinding) else None
+
+        else: 
+            return None
+
+
+    @InputBinding.setter
+    def InputBinding(self, value: InputBinding | None=None) -> None:
+        this: CWLInput = self
+        if value is None:
+            remove_property("inputBinding", this)
+
+        else: 
+            set_property("inputBinding", value, this)
+
+
+    @property
+    def Optional(self, __unit: None=None) -> bool | None:
+        this: CWLInput = self
+        match_value: Any | None = this.TryGetPropertyValue("optional")
+        if match_value is not None:
+            o: Any = value_1(match_value)
+            return o if (str(type(o)) == "<class \'bool\'>") else None
+
+        else: 
+            return None
+
+
+    @Optional.setter
+    def Optional(self, value: bool | None=None) -> None:
+        this: CWLInput = self
+        if value is None:
+            remove_property("optional", this)
+
+        else: 
+            set_property("optional", value, this)
+
+
+
+CWLInput_reflection = _expr758
+
+def CWLInput__ctor_Z3A15BEDB(name: str, type_: CWLType | None=None, input_binding: InputBinding | None=None, optional: bool | None=None) -> CWLInput:
+    return CWLInput(name, type_, input_binding, optional)
+
+
+__all__ = ["InputBinding_reflection", "InputBinding_create_ZAC0108A", "CWLInput_reflection"]
+

arctrl/py/CWL/operation_description.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+from ..fable_modules.dynamic_obj.dynamic_obj import (DynamicObj, DynamicObj_reflection)
+from ..fable_modules.fable_library.option import default_arg
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.types import Array
+from .inputs import CWLInput
+from .outputs import CWLOutput
+from .requirements import (Requirement, HintEntry)
+
+def _expr771() -> TypeInfo:
+    return class_type("ARCtrl.CWL.CWLOperationDescription", None, CWLOperationDescription, DynamicObj_reflection())
+
+
+class CWLOperationDescription(DynamicObj):
+    def __init__(self, inputs: Array[CWLInput], outputs: Array[CWLOutput], cwl_version: str | None=None, requirements: Array[Requirement] | None=None, hints: Array[HintEntry] | None=None, intent: Array[str] | None=None, metadata: DynamicObj | None=None, label: str | None=None, doc: str | None=None) -> None:
+        super().__init__()
+        self._cwlVersion: str = default_arg(cwl_version, "v1.2")
+        self._inputs: Array[CWLInput] = inputs
+        self._outputs: Array[CWLOutput] = outputs
+        self._requirements: Array[Requirement] | None = requirements
+        self._hints: Array[HintEntry] | None = hints
+        self._intent: Array[str] | None = intent
+        self._metadata: DynamicObj | None = metadata
+        self._label: str | None = label
+        self._doc: str | None = doc
+
+    @property
+    def CWLVersion(self, __unit: None=None) -> str:
+        this: CWLOperationDescription = self
+        return this._cwlVersion
+
+    @CWLVersion.setter
+    def CWLVersion(self, value: str) -> None:
+        this: CWLOperationDescription = self
+        this._cwlVersion = value
+
+    @property
+    def Inputs(self, __unit: None=None) -> Array[CWLInput]:
+        this: CWLOperationDescription = self
+        return this._inputs
+
+    @Inputs.setter
+    def Inputs(self, value: Array[CWLInput]) -> None:
+        this: CWLOperationDescription = self
+        this._inputs = value
+
+    @property
+    def Outputs(self, __unit: None=None) -> Array[CWLOutput]:
+        this: CWLOperationDescription = self
+        return this._outputs
+
+    @Outputs.setter
+    def Outputs(self, value: Array[CWLOutput]) -> None:
+        this: CWLOperationDescription = self
+        this._outputs = value
+
+    @property
+    def Requirements(self, __unit: None=None) -> Array[Requirement] | None:
+        this: CWLOperationDescription = self
+        return this._requirements
+
+    @Requirements.setter
+    def Requirements(self, value: Array[Requirement] | None=None) -> None:
+        this: CWLOperationDescription = self
+        this._requirements = value
+
+    @property
+    def Hints(self, __unit: None=None) -> Array[HintEntry] | None:
+        this: CWLOperationDescription = self
+        return this._hints
+
+    @Hints.setter
+    def Hints(self, value: Array[HintEntry] | None=None) -> None:
+        this: CWLOperationDescription = self
+        this._hints = value
+
+    @property
+    def Intent(self, __unit: None=None) -> Array[str] | None:
+        this: CWLOperationDescription = self
+        return this._intent
+
+    @Intent.setter
+    def Intent(self, value: Array[str] | None=None) -> None:
+        this: CWLOperationDescription = self
+        this._intent = value
+
+    @property
+    def Metadata(self, __unit: None=None) -> DynamicObj | None:
+        this: CWLOperationDescription = self
+        return this._metadata
+
+    @Metadata.setter
+    def Metadata(self, value: DynamicObj | None=None) -> None:
+        this: CWLOperationDescription = self
+        this._metadata = value
+
+    @property
+    def Label(self, __unit: None=None) -> str | None:
+        this: CWLOperationDescription = self
+        return this._label
+
+    @Label.setter
+    def Label(self, value: str | None=None) -> None:
+        this: CWLOperationDescription = self
+        this._label = value
+
+    @property
+    def Doc(self, __unit: None=None) -> str | None:
+        this: CWLOperationDescription = self
+        return this._doc
+
+    @Doc.setter
+    def Doc(self, value: str | None=None) -> None:
+        this: CWLOperationDescription = self
+        this._doc = value
+
+    @staticmethod
+    def get_inputs(operation: CWLOperationDescription) -> Array[CWLInput]:
+        return operation.Inputs
+
+    @staticmethod
+    def get_outputs(operation: CWLOperationDescription) -> Array[CWLOutput]:
+        return operation.Outputs
+
+    @staticmethod
+    def get_requirements_or_empty(operation: CWLOperationDescription) -> Array[Requirement]:
+        return default_arg(operation.Requirements, [])
+
+    @staticmethod
+    def get_hints_or_empty(operation: CWLOperationDescription) -> Array[HintEntry]:
+        return default_arg(operation.Hints, [])
+
+    @staticmethod
+    def get_intent_or_empty(operation: CWLOperationDescription) -> Array[str]:
+        return default_arg(operation.Intent, [])
+
+    @staticmethod
+    def get_or_create_hints(operation: CWLOperationDescription) -> Array[HintEntry]:
+        match_value: Array[HintEntry] | None = operation.Hints
+        if match_value is None:
+            hints_1: Array[HintEntry] = []
+            operation.Hints = hints_1
+            return hints_1
+
+        else: 
+            return match_value
+
+
+    @staticmethod
+    def get_or_create_intent(operation: CWLOperationDescription) -> Array[str]:
+        match_value: Array[str] | None = operation.Intent
+        if match_value is None:
+            intent_1: Array[str] = []
+            operation.Intent = intent_1
+            return intent_1
+
+        else: 
+            return match_value
+
+
+
+CWLOperationDescription_reflection = _expr771
+
+def CWLOperationDescription__ctor_58E129C8(inputs: Array[CWLInput], outputs: Array[CWLOutput], cwl_version: str | None=None, requirements: Array[Requirement] | None=None, hints: Array[HintEntry] | None=None, intent: Array[str] | None=None, metadata: DynamicObj | None=None, label: str | None=None, doc: str | None=None) -> CWLOperationDescription:
+    return CWLOperationDescription(inputs, outputs, cwl_version, requirements, hints, intent, metadata, label, doc)
+
+
+__all__ = ["CWLOperationDescription_reflection"]
+