arctrl 3.0.0__py3-none-any.whl

arctrl/py/ROCrate/LDTypes/software_source_code.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_modules.fable_library.list import FSharpList
+from ...fable_modules.fable_library.option import value
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import Array
+from ...Core.Helper.identifier import create_missing_identifier
+from ..helper import clean
+from ..ldcontext import LDContext
+from ..ldobject import (LDNode, LDGraph)
+from .comment import LDComment
+from .organization import LDOrganization
+from .person import LDPerson
+
+def _expr2208() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDSoftwareSourceCode", None, LDSoftwareSourceCode)
+
+
+class LDSoftwareSourceCode:
+    @staticmethod
+    def schema_type() -> str:
+        return "http://schema.org/SoftwareSourceCode"
+
+    @staticmethod
+    def creator() -> str:
+        return "http://schema.org/creator"
+
+    @staticmethod
+    def date_created() -> str:
+        return "http://schema.org/dateCreated"
+
+    @staticmethod
+    def license() -> str:
+        return "http://schema.org/license"
+
+    @staticmethod
+    def name() -> str:
+        return "http://schema.org/name"
+
+    @staticmethod
+    def programming_language() -> str:
+        return "http://schema.org/programmingLanguage"
+
+    @staticmethod
+    def sd_publisher() -> str:
+        return "http://schema.org/sdPublisher"
+
+    @staticmethod
+    def url() -> str:
+        return "http://schema.org/url"
+
+    @staticmethod
+    def version() -> str:
+        return "http://schema.org/version"
+
+    @staticmethod
+    def description() -> str:
+        return "http://schema.org/description"
+
+    @staticmethod
+    def has_part() -> str:
+        return "http://schema.org/hasPart"
+
+    @staticmethod
+    def comment() -> str:
+        return "http://schema.org/comment"
+
+    @staticmethod
+    def get_creator(ssc: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            if LDPerson.validate(ld_object, context_1):
+                return True
+
+            else: 
+                return LDOrganization.validate(ld_object, context_1)
+
+
+        return ssc.GetPropertyNodes(LDSoftwareSourceCode.creator(), filter, graph, context)
+
+    @staticmethod
+    def set_creator(ssc: LDNode, creator: LDNode, context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.creator(), creator, context)
+
+    @staticmethod
+    def try_get_date_created(ssc: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.date_created(), 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_date_created(ssc: LDNode, date: str, context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.date_created(), date, context)
+
+    @staticmethod
+    def get_licenses(ssc: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        return ssc.GetPropertyNodes(LDSoftwareSourceCode.license(), None, graph, context)
+
+    @staticmethod
+    def set_licenses(ssc: LDNode, licenses: Array[LDNode], context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.license(), licenses, context)
+
+    @staticmethod
+    def try_get_name_as_string(ssc: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.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 set_name_as_string(ssc: LDNode, name: str, context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.name(), name, context)
+
+    @staticmethod
+    def get_programming_languages(ssc: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        return ssc.GetPropertyNodes(LDSoftwareSourceCode.programming_language(), None, graph, context)
+
+    @staticmethod
+    def set_programming_languages(ssc: LDNode, programming_languages: Array[LDNode], context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.programming_language(), programming_languages, context)
+
+    @staticmethod
+    def try_get_sd_publisher(ssc: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> LDNode | None:
+        match_value: LDNode | None = ssc.TryGetPropertyAsSingleNode(LDSoftwareSourceCode.sd_publisher(), graph, context)
+        (pattern_matching_result, a_1) = (None, None)
+        if match_value is not None:
+            def _arrow2207(__unit: None=None) -> bool:
+                ld_object: LDNode = match_value
+                context_1: LDContext | None = context
+                return True if LDPerson.validate(ld_object, context_1) else LDOrganization.validate(ld_object, context_1)
+
+            if _arrow2207():
+                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 set_sd_publisher(ssc: LDNode, sd_publisher: LDNode, context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.sd_publisher(), sd_publisher, context)
+
+    @staticmethod
+    def try_get_url(ssc: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.url(), context)
+        (pattern_matching_result, u) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                u = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return u
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def set_url(ssc: LDNode, url: str, context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.url(), url, context)
+
+    @staticmethod
+    def try_get_version(ssc: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.version(), context)
+        (pattern_matching_result, v) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                v = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return v
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def set_version(ssc: LDNode, version: str, context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.version(), version, context)
+
+    @staticmethod
+    def try_get_description(ssc: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = ssc.TryGetPropertyAsSingleton(LDSoftwareSourceCode.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(ssc: LDNode, description: str, context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.description(), description, context)
+
+    @staticmethod
+    def get_has_part(ssc: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        return ssc.GetPropertyNodes(LDSoftwareSourceCode.has_part(), None, graph, context)
+
+    @staticmethod
+    def set_has_part(ssc: LDNode, has_parts: FSharpList[str], context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.has_part(), list(has_parts), context)
+
+    @staticmethod
+    def get_comments(ssc: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDComment.validate(ld_object, context_1)
+
+        return ssc.GetPropertyNodes(LDSoftwareSourceCode.comment(), filter, graph, context)
+
+    @staticmethod
+    def set_comments(ssc: LDNode, comments: Array[LDNode], context: LDContext | None=None) -> Any:
+        return ssc.SetProperty(LDSoftwareSourceCode.comment(), comments, context)
+
+    @staticmethod
+    def validate(lp: LDNode, context: LDContext | None=None) -> bool:
+        return lp.HasType(LDSoftwareSourceCode.schema_type(), context)
+
+    @staticmethod
+    def create(id: str | None=None, creator: LDNode | None=None, date_created: str | None=None, licenses: Array[LDNode] | None=None, name: str | None=None, programming_languages: Array[LDNode] | None=None, sd_publisher: LDNode | None=None, url: str | None=None, version: str | None=None, description: str | None=None, has_parts: Array[LDNode] | None=None, comments: Array[LDNode] | None=None, context: LDContext | None=None) -> LDNode:
+        ssc: LDNode = LDNode(clean(("#ComputationalWorkflow_" + create_missing_identifier()) + "") if (id is None) else id, [LDSoftwareSourceCode.schema_type()], None, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.creator(), creator, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.date_created(), date_created, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.license(), licenses, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.name(), name, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.programming_language(), programming_languages, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.sd_publisher(), sd_publisher, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.url(), url, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.version(), version, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.description(), description, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.has_part(), has_parts, context)
+        ssc.SetOptionalProperty(LDSoftwareSourceCode.comment(), comments, context)
+        return ssc
+
+
+LDSoftwareSourceCode_reflection = _expr2208
+
+__all__ = ["LDSoftwareSourceCode_reflection"]
+

arctrl/py/ROCrate/LDTypes/workflow_invocation.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import Array
+from ..helper import clean
+from ..ldcontext import LDContext
+from ..ldobject import LDNode
+from .create_action import LDCreateAction
+from .lab_process import LDLabProcess
+
+def _expr2210() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDWorkflowInvocation", None, LDWorkflowInvocation)
+
+
+class LDWorkflowInvocation:
+    @staticmethod
+    def schema_type() -> Array[str]:
+        return [LDCreateAction.schema_type(), LDLabProcess.schema_type()]
+
+    @staticmethod
+    def gen_id(name: str, run_name: str | None=None) -> str:
+        return clean(("#WorkflowInvocation_" + name) + "") if (run_name is None) else clean(((("#WorkflowInvocation_R_" + run_name) + "_") + name) + "")
+
+    @staticmethod
+    def validate(wp: LDNode, context: LDContext | None=None) -> bool:
+        return LDLabProcess.validate(wp, context) if LDCreateAction.validate(wp, context) else False
+
+    @staticmethod
+    def create(name: str, instrument: LDNode, objects: Array[LDNode] | None=None, results: Array[LDNode] | None=None, description: str | None=None, agents: Array[LDNode] | None=None, id: str | None=None, end_time: Any | None=None, disambiguating_descriptions: Array[str] | None=None, executes_lab_protocol: LDNode | None=None, parameter_values: Array[LDNode] | None=None, context: LDContext | None=None) -> LDNode:
+        at: Array[str] = ["WorkflowInvocation"]
+        ca: LDNode = LDNode(LDWorkflowInvocation.gen_id(name) if (id is None) else id, LDWorkflowInvocation.schema_type(), at, context)
+        ca.SetProperty(LDCreateAction.name(), name, context)
+        ca.SetOptionalProperty(LDCreateAction.object_(), objects, context)
+        ca.SetOptionalProperty(LDCreateAction.result(), results, context)
+        ca.SetProperty(LDCreateAction.instrument(), instrument, context)
+        ca.SetOptionalProperty(LDCreateAction.agent(), agents, context)
+        ca.SetOptionalProperty(LDCreateAction.description(), description, context)
+        ca.SetOptionalProperty(LDCreateAction.end_time(), end_time, context)
+        ca.SetOptionalProperty(LDCreateAction.disambiguating_description(), disambiguating_descriptions, context)
+        ca.SetOptionalProperty(LDLabProcess.executes_lab_protocol(), executes_lab_protocol, context)
+        ca.SetOptionalProperty(LDLabProcess.parameter_value(), parameter_values, context)
+        return ca
+
+
+LDWorkflowInvocation_reflection = _expr2210
+
+__all__ = ["LDWorkflowInvocation_reflection"]
+

arctrl/py/ROCrate/LDTypes/workflow_protocol.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ...fable_modules.fable_library.types import Array
+from ...Core.Helper.identifier import create_missing_identifier
+from ..helper import clean
+from ..ldcontext import LDContext
+from ..ldobject import LDNode
+from .computational_workflow import LDComputationalWorkflow
+from .file import LDFile
+from .lab_protocol import LDLabProtocol
+from .software_source_code import LDSoftwareSourceCode
+
+def _expr2209() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDWorkflowProtocol", None, LDWorkflowProtocol)
+
+
+class LDWorkflowProtocol:
+    @staticmethod
+    def schema_type() -> Array[str]:
+        return [LDFile.schema_type(), LDComputationalWorkflow.schema_type(), LDSoftwareSourceCode.schema_type(), LDLabProtocol.schema_type()]
+
+    @staticmethod
+    def validate(wp: LDNode, context: LDContext | None=None) -> bool:
+        return LDLabProtocol.validate(wp, context) if (LDSoftwareSourceCode.validate(wp, context) if LDComputationalWorkflow.validate(wp, context) else False) else False
+
+    @staticmethod
+    def create(id: str | None=None, inputs: Array[LDNode] | None=None, outputs: Array[LDNode] | None=None, creator: LDNode | None=None, date_created: str | None=None, licenses: Array[LDNode] | None=None, name: str | None=None, programming_languages: Array[LDNode] | None=None, sd_publisher: LDNode | None=None, url: str | None=None, version: str | None=None, description: str | None=None, has_parts: Array[LDNode] | None=None, intended_use: LDNode | None=None, comments: Array[LDNode] | None=None, computational_tools: Array[LDNode] | None=None, additional_type: Array[str] | None=None, context: LDContext | None=None) -> LDNode:
+        at: Array[str] = ["WorkflowProtocol"]
+        wp: LDNode = LDNode(clean(("#ComputationalWorkflow_" + create_missing_identifier()) + "") if (id is None) else id, LDWorkflowProtocol.schema_type(), at, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.input(), inputs, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.output(), outputs, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.creator(), creator, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.date_created(), date_created, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.license(), licenses, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.name(), name, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.programming_language(), programming_languages, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.sd_publisher(), sd_publisher, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.url(), url, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.version(), version, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.description(), description, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.has_part(), has_parts, context)
+        wp.SetOptionalProperty(LDLabProtocol.intended_use(), intended_use, context)
+        wp.SetOptionalProperty(LDLabProtocol.computational_tool(), computational_tools, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.additional_type(), additional_type, context)
+        wp.SetOptionalProperty(LDComputationalWorkflow.comment(), comments, context)
+        return wp
+
+
+LDWorkflowProtocol_reflection = _expr2209
+
+__all__ = ["LDWorkflowProtocol_reflection"]
+

arctrl/py/ROCrate/arc_rocrate_metadata.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from ..fable_modules.dynamic_obj.dynamic_obj import DynamicObj
+from ..fable_modules.dynamic_obj.dyn_obj import set_optional_property
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.types import FSharpRef
+from .ldcontext import LDContext
+from .ldobject import (LDNode, LDNode_reflection)
+
+def _expr2252() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.ArcROCrateMetadata", None, ArcROCrateMetadata, LDNode_reflection())
+
+
+class ArcROCrateMetadata(LDNode):
+    def __init__(self, about: LDNode | None=None) -> None:
+        super().__init__("ro-crate-metadata", ["CreativeWork"])
+        this: FSharpRef[ArcROCrateMetadata] = FSharpRef(None)
+        this.contents = self
+        self.init_00405: int = 1
+        set_optional_property("about", about, this.contents)
+        conforms_to: DynamicObj = DynamicObj()
+        conforms_to.SetProperty("@id", "https://w3id.org/ro/crate/1.1")
+        this.contents.SetProperty("conformsTo", conforms_to)
+        context: LDContext = LDContext()
+        context.AddMapping("sdo", "http://schema.org/")
+        context.AddMapping("arc", "http://purl.org/nfdi4plants/ontology/")
+        context.AddMapping("CreativeWork", "sdo:CreativeWork")
+        context.AddMapping("about", "sdo:about")
+        context.AddMapping("conformsTo", "sdo:conformsTo")
+        this.contents.SetProperty("@context", context)
+
+
+ArcROCrateMetadata_reflection = _expr2252
+
+def ArcROCrateMetadata__ctor_Z7020538(about: LDNode | None=None) -> ArcROCrateMetadata:
+    return ArcROCrateMetadata(about)
+
+
+__all__ = ["ArcROCrateMetadata_reflection"]
+

arctrl/py/ROCrate/dyn_obj_extensions.py

@@ -0,0 +1 @@
+

arctrl/py/ROCrate/helper.py

@@ -0,0 +1,8 @@
+from ..fable_modules.fable_library.string_ import replace
+
+def clean(id: str) -> str:
+    return replace(id, " ", "_")
+
+
+__all__ = ["clean"]
+