arctrl 3.0.0__py3-none-any.whl

arctrl/py/ROCrate/LDTypes/computer_language.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_modules.fable_library.option import (value, map)
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..ldcontext import LDContext
+from ..ldobject import (LDNode, LDRef)
+from .formal_parameter import LDFormalParameter
+
+def _expr2138() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDComputerLanguage", None, LDComputerLanguage)
+
+
+class LDComputerLanguage:
+    @staticmethod
+    def schema_type() -> str:
+        return "http://schema.org/ComputerLanguage"
+
+    @staticmethod
+    def name() -> str:
+        return "http://schema.org/name"
+
+    @staticmethod
+    def alternate_name() -> str:
+        return "http://schema.org/alternateName"
+
+    @staticmethod
+    def identifier() -> str:
+        return "http://schema.org/identifier"
+
+    @staticmethod
+    def url() -> str:
+        return "http://schema.org/url"
+
+    @staticmethod
+    def same_as() -> str:
+        return "http://schema.org/sameAs"
+
+    @staticmethod
+    def try_get_name_as_string(cl: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = cl.TryGetPropertyAsSingleton(LDFormalParameter.name(), context)
+        (pattern_matching_result, n) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                n = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return n
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def get_name_as_string(cl: LDNode, context: LDContext | None=None) -> str:
+        match_value: Any | None = cl.TryGetPropertyAsSingleton(LDComputerLanguage.name(), context)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                n: str = value(match_value)
+                return n
+
+            else: 
+                raise Exception(("Property of `name` of object with @id `" + cl.Id) + "` was not a string")
+
+
+        else: 
+            raise Exception(("Could not access property `name` of object with @id `" + cl.Id) + "`")
+
+
+    @staticmethod
+    def set_name_as_string(cl: LDNode, name: str, context: LDContext | None=None) -> Any:
+        return cl.SetProperty(LDComputerLanguage.name(), name, context)
+
+    @staticmethod
+    def try_get_alternate_name_as_string(cl: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = cl.TryGetPropertyAsSingleton(LDComputerLanguage.alternate_name(), context)
+        (pattern_matching_result, n) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                n = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return n
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def get_alternate_name_as_string(cl: LDNode, context: LDContext | None=None) -> str:
+        match_value: Any | None = cl.TryGetPropertyAsSingleton(LDComputerLanguage.alternate_name(), context)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                n: str = value(match_value)
+                return n
+
+            else: 
+                raise Exception(("Property of `alternateName` of object with @id `" + cl.Id) + "` was not a string")
+
+
+        else: 
+            raise Exception(("Could not access property `alternateName` of object with @id `" + cl.Id) + "`")
+
+
+    @staticmethod
+    def set_alternate_name_as_string(cl: LDNode, alternate_name: str, context: LDContext | None=None) -> Any:
+        return cl.SetProperty(LDComputerLanguage.alternate_name(), alternate_name, context)
+
+    @staticmethod
+    def try_get_identifier_as_ldref(cl: LDNode, context: LDContext | None=None) -> LDRef | None:
+        match_value: Any | None = cl.TryGetPropertyAsSingleton(LDComputerLanguage.identifier(), context)
+        (pattern_matching_result, id) = (None, None)
+        if match_value is not None:
+            if isinstance(value(match_value), LDRef):
+                pattern_matching_result = 0
+                id = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return id
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def get_identifier_as_ldref(cl: LDNode, context: LDContext | None=None) -> LDRef:
+        match_value: Any | None = cl.TryGetPropertyAsSingleton(LDComputerLanguage.identifier(), context)
+        if match_value is not None:
+            if isinstance(value(match_value), LDRef):
+                id: LDRef = value(match_value)
+                return id
+
+            else: 
+                raise Exception(("Property of `identifier` of object with @id `" + cl.Id) + "` was not a LDRef")
+
+
+        else: 
+            raise Exception(("Could not access property `identifier` of object with @id `" + cl.Id) + "`")
+
+
+    @staticmethod
+    def set_identifier_as_ldref(cl: LDNode, identifier: LDRef, context: LDContext | None=None) -> Any:
+        return cl.SetProperty(LDComputerLanguage.identifier(), identifier, context)
+
+    @staticmethod
+    def try_get_url_as_ldref(cl: LDNode, context: LDContext | None=None) -> LDRef | None:
+        match_value: Any | None = cl.TryGetPropertyAsSingleton(LDComputerLanguage.url(), context)
+        (pattern_matching_result, url) = (None, None)
+        if match_value is not None:
+            if isinstance(value(match_value), LDRef):
+                pattern_matching_result = 0
+                url = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return url
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def get_url_as_ldref(cl: LDNode, context: LDContext | None=None) -> LDRef:
+        match_value: Any | None = cl.TryGetPropertyAsSingleton(LDComputerLanguage.url(), context)
+        if match_value is not None:
+            if isinstance(value(match_value), LDRef):
+                url: LDRef = value(match_value)
+                return url
+
+            else: 
+                raise Exception(("Property of `url` of object with @id `" + cl.Id) + "` was not a LDRef")
+
+
+        else: 
+            raise Exception(("Could not access property `url` of object with @id `" + cl.Id) + "`")
+
+
+    @staticmethod
+    def set_url_as_ldref(cl: LDNode, url: LDRef, context: LDContext | None=None) -> Any:
+        return cl.SetProperty(LDComputerLanguage.url(), url, context)
+
+    @staticmethod
+    def validate(cl: LDNode, context: LDContext | None=None) -> bool:
+        return cl.HasType(LDComputerLanguage.schema_type(), context)
+
+    @staticmethod
+    def validate_cwl(cl: LDNode, context: LDContext | None=None) -> bool:
+        return (cl.Id == "https://w3id.org/workflowhub/workflow-ro-crate#cwl") if LDComputerLanguage.validate(cl, context) else False
+
+    @staticmethod
+    def validate_galaxy(cl: LDNode, context: LDContext | None=None) -> bool:
+        return (cl.Id == "https://w3id.org/workflowhub/workflow-ro-crate#galaxy") if LDComputerLanguage.validate(cl, context) else False
+
+    @staticmethod
+    def validate_knime(cl: LDNode, context: LDContext | None=None) -> bool:
+        return (cl.Id == "https://w3id.org/workflowhub/workflow-ro-crate#knime") if LDComputerLanguage.validate(cl, context) else False
+
+    @staticmethod
+    def validate_nextflow(cl: LDNode, context: LDContext | None=None) -> bool:
+        return (cl.Id == "https://w3id.org/workflowhub/workflow-ro-crate#nextflow") if LDComputerLanguage.validate(cl, context) else False
+
+    @staticmethod
+    def validate_snakemake(cl: LDNode, context: LDContext | None=None) -> bool:
+        return (cl.Id == "https://w3id.org/workflowhub/workflow-ro-crate#snakemake") if LDComputerLanguage.validate(cl, context) else False
+
+    @staticmethod
+    def create(id: str, name: str | None=None, alternate_name: str | None=None, identifier: str | None=None, url: str | None=None, context: LDContext | None=None) -> LDNode:
+        cl: LDNode = LDNode(id, [LDComputerLanguage.schema_type()], None, context)
+        identifier_1: LDRef | None = map(LDRef, identifier)
+        url_1: LDRef | None = map(LDRef, url)
+        cl.SetOptionalProperty(LDComputerLanguage.name(), name, context)
+        cl.SetOptionalProperty(LDComputerLanguage.alternate_name(), alternate_name, context)
+        cl.SetOptionalProperty(LDComputerLanguage.identifier(), identifier_1, context)
+        cl.SetOptionalProperty(LDComputerLanguage.url(), url_1, context)
+        return cl
+
+    @staticmethod
+    def create_cwl(context: LDContext | None=None) -> LDNode:
+        return LDComputerLanguage.create("https://w3id.org/workflowhub/workflow-ro-crate#cwl", "Common Workflow Language", "CWL", "https://w3id.org/cwl/v1.2/", "https://www.commonwl.org/", context)
+
+    @staticmethod
+    def create_galaxy(context: LDContext | None=None) -> LDNode:
+        return LDComputerLanguage.create("https://w3id.org/workflowhub/workflow-ro-crate#galaxy", "Galaxy", None, "https://galaxyproject.org/", "https://galaxyproject.org/", context)
+
+    @staticmethod
+    def create_knime(context: LDContext | None=None) -> LDNode:
+        return LDComputerLanguage.create("https://w3id.org/workflowhub/workflow-ro-crate#knime", "KNIME", None, "https://www.knime.com/", "https://www.knime.com/", context)
+
+    @staticmethod
+    def create_nextflow(context: LDContext | None=None) -> LDNode:
+        return LDComputerLanguage.create("https://w3id.org/workflowhub/workflow-ro-crate#nextflow", "Nextflow", None, "https://www.nextflow.io/", "https://www.nextflow.io/", context)
+
+    @staticmethod
+    def create_snakemake(context: LDContext | None=None) -> LDNode:
+        return LDComputerLanguage.create("https://w3id.org/workflowhub/workflow-ro-crate#snakemake", "Snakemake", None, "https://doi.org/10.1093/bioinformatics/bts480", "https://snakemake.readthedocs.io", context)
+
+
+LDComputerLanguage_reflection = _expr2138
+
+__all__ = ["LDComputerLanguage_reflection"]
+

arctrl/py/ROCrate/LDTypes/create_action.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+from datetime import datetime
+from typing import Any
+from ...fable_modules.fable_library.option import (value, default_arg)
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import Array
+from ...Core.Helper.collections_ import ResizeArray_map
+from ...Core.Helper.identifier import create_missing_identifier
+from ..helper import clean
+from ..ldcontext import LDContext
+from ..ldobject import (LDNode, LDGraph)
+from .computational_workflow import LDComputationalWorkflow
+from .file import LDFile
+from .person import LDPerson
+from .sample import LDSample
+
+def _expr2206() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDCreateAction", None, LDCreateAction)
+
+
+class LDCreateAction:
+    @staticmethod
+    def schema_type() -> str:
+        return "http://schema.org/CreateAction"
+
+    @staticmethod
+    def name() -> str:
+        return "http://schema.org/name"
+
+    @staticmethod
+    def instrument() -> str:
+        return "http://schema.org/instrument"
+
+    @staticmethod
+    def agent() -> str:
+        return "http://schema.org/agent"
+
+    @staticmethod
+    def object_() -> str:
+        return "http://schema.org/object"
+
+    @staticmethod
+    def result() -> str:
+        return "http://schema.org/result"
+
+    @staticmethod
+    def description() -> str:
+        return "http://schema.org/description"
+
+    @staticmethod
+    def end_time() -> str:
+        return "http://schema.org/endTime"
+
+    @staticmethod
+    def disambiguating_description() -> str:
+        return "http://schema.org/disambiguatingDescription"
+
+    @staticmethod
+    def try_get_name_as_string(ca: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = ca.TryGetPropertyAsSingleton(LDCreateAction.name(), context)
+        (pattern_matching_result, n) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                n = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return n
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def get_name_as_string(ca: LDNode, context: LDContext | None=None) -> str:
+        match_value: Any | None = ca.TryGetPropertyAsSingleton(LDCreateAction.name(), context)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                n: str = value(match_value)
+                return n
+
+            else: 
+                raise Exception(("property `name` of object with @id `" + ca.Id) + "` was not a string")
+
+
+        else: 
+            raise Exception(("Could not access property `name` of object with @id `" + ca.Id) + "`")
+
+
+    @staticmethod
+    def set_name_as_string(ca: LDNode, name: str, context: LDContext | None=None) -> Any:
+        return ca.SetProperty(LDCreateAction.name(), name, context)
+
+    @staticmethod
+    def get_instruments(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        return ca.GetPropertyNodes(LDCreateAction.instrument(), None, graph, context)
+
+    @staticmethod
+    def get_instruments_as_computational_workflow(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDComputationalWorkflow.validate(ld_object, context_1)
+
+        return ca.GetPropertyNodes(LDCreateAction.instrument(), filter, graph, context)
+
+    @staticmethod
+    def set_instruments(ca: LDNode, instruments: Array[LDNode], context: LDContext | None=None) -> Any:
+        return ca.SetProperty(LDCreateAction.instrument(), instruments, context)
+
+    @staticmethod
+    def try_get_agent(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> LDNode | None:
+        match_value: LDNode | None = ca.TryGetPropertyAsSingleNode(LDCreateAction.agent(), graph, context)
+        (pattern_matching_result, a_1) = (None, None)
+        if match_value is not None:
+            def _arrow2204(__unit: None=None) -> bool:
+                ld_object: LDNode = match_value
+                return LDPerson.validate(ld_object, context)
+
+            if _arrow2204():
+                pattern_matching_result = 0
+                a_1 = match_value
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return a_1
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def get_agent(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> LDNode:
+        match_value: LDNode | None = ca.TryGetPropertyAsSingleNode(LDCreateAction.agent(), graph, context)
+        if match_value is not None:
+            def _arrow2205(__unit: None=None) -> bool:
+                ld_object: LDNode = match_value
+                return LDPerson.validate(ld_object, context)
+
+            if _arrow2205():
+                a_1: LDNode = match_value
+                return a_1
+
+            else: 
+                raise Exception(("Property of `agent` of object with @id `" + ca.Id) + "` was not a valid Person")
+
+
+        else: 
+            raise Exception(("Could not access property `agent` of object with @id `" + ca.Id) + "`")
+
+
+    @staticmethod
+    def set_agent(ca: LDNode, agent: LDNode, context: LDContext | None=None) -> Any:
+        return ca.SetProperty(LDCreateAction.agent(), agent, context)
+
+    @staticmethod
+    def get_objects(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        return ca.GetPropertyNodes(LDCreateAction.object_(), None, graph, context)
+
+    @staticmethod
+    def get_objects_as_sample(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDSample.validate(ld_object, context_1)
+
+        return ca.GetPropertyNodes(LDCreateAction.object_(), filter, graph, context)
+
+    @staticmethod
+    def get_objects_as_data(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDFile.validate(ld_object, context_1)
+
+        return ca.GetPropertyNodes(LDCreateAction.object_(), filter, graph, context)
+
+    @staticmethod
+    def set_objects(ca: LDNode, objects: Array[LDNode], context: LDContext | None=None) -> Any:
+        return ca.SetProperty(LDCreateAction.object_(), objects, context)
+
+    @staticmethod
+    def get_results(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        return ca.GetPropertyNodes(LDCreateAction.result(), None, graph, context)
+
+    @staticmethod
+    def get_results_as_sample(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDSample.validate(ld_object, context_1)
+
+        return ca.GetPropertyNodes(LDCreateAction.result(), filter, graph, context)
+
+    @staticmethod
+    def get_results_as_data(ca: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDFile.validate(ld_object, context_1)
+
+        return ca.GetPropertyNodes(LDCreateAction.result(), filter, graph, context)
+
+    @staticmethod
+    def set_results(ca: LDNode, results: Array[LDNode], context: LDContext | None=None) -> Any:
+        return ca.SetProperty(LDCreateAction.result(), results, context)
+
+    @staticmethod
+    def try_get_description(ca: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = ca.TryGetPropertyAsSingleton(LDCreateAction.description(), context)
+        (pattern_matching_result, d) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                d = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return d
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def set_description(ca: LDNode, description: str, context: LDContext | None=None) -> Any:
+        return ca.SetProperty(LDCreateAction.description(), description, context)
+
+    @staticmethod
+    def try_get_end_time(ca: LDNode, context: LDContext | None=None) -> Any | None:
+        match_value: Any | None = ca.TryGetPropertyAsSingleton(LDCreateAction.end_time(), context)
+        (pattern_matching_result, et) = (None, None)
+        if match_value is not None:
+            if isinstance(value(match_value), datetime):
+                pattern_matching_result = 0
+                et = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return et
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def set_end_time(ca: LDNode, end_time: Any, context: LDContext | None=None) -> Any:
+        return ca.SetProperty(LDCreateAction.end_time(), end_time, context)
+
+    @staticmethod
+    def get_disambiguating_descriptions_as_string(ca: LDNode, context: LDContext | None=None) -> Array[str]:
+        def f(o_1: Any=None) -> Any:
+            return o_1
+
+        def filter(o: Any=None, context_1: LDContext | None=None) -> bool:
+            return str(type(o)) == "<class \'str\'>"
+
+        return ResizeArray_map(f, ca.GetPropertyValues(LDCreateAction.disambiguating_description(), filter, context))
+
+    @staticmethod
+    def set_disambiguating_descriptions_as_string(ca: LDNode, disambiguating_descriptions: Array[str], context: LDContext | None=None) -> Any:
+        return ca.SetProperty(LDCreateAction.disambiguating_description(), disambiguating_descriptions, context)
+
+    @staticmethod
+    def validate(ca: LDNode, context: LDContext | None=None) -> bool:
+        return ca.HasProperty(LDCreateAction.instrument(), context) if ca.HasType(LDCreateAction.schema_type(), context) else False
+
+    @staticmethod
+    def create(name: str, agent: LDNode, instrument: LDNode, objects: Array[LDNode] | None=None, results: Array[LDNode] | None=None, description: str | None=None, id: str | None=None, end_time: Any | None=None, disambiguating_descriptions: Array[str] | None=None, context: LDContext | None=None) -> LDNode:
+        id_2: str = clean(("#ComputationalWorkflow_" + create_missing_identifier()) + "") if (id is None) else id
+        objects_1: Array[LDNode] = default_arg(objects, [])
+        results_1: Array[LDNode] = default_arg(results, [])
+        ca: LDNode = LDNode(id_2, [LDCreateAction.schema_type()], None, context)
+        ca.SetProperty(LDCreateAction.name(), name, context)
+        ca.SetProperty(LDCreateAction.agent(), agent, context)
+        ca.SetProperty(LDCreateAction.object_(), objects_1, context)
+        ca.SetProperty(LDCreateAction.result(), results_1, context)
+        ca.SetProperty(LDCreateAction.instrument(), instrument, context)
+        ca.SetOptionalProperty(LDCreateAction.description(), description, context)
+        ca.SetOptionalProperty(LDCreateAction.end_time(), end_time, context)
+        ca.SetOptionalProperty(LDCreateAction.disambiguating_description(), disambiguating_descriptions, context)
+        return ca
+
+
+LDCreateAction_reflection = _expr2206
+
+__all__ = ["LDCreateAction_reflection"]
+