arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/ROCrate/Generic/defined_term.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_modules.fable_library.option import value
+from ...fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..helper import clean
+from ..ldcontext import LDContext
+from ..ldobject import LDNode
+
+def _expr1441() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDDefinedTerm", None, LDDefinedTerm)
+
+
+class LDDefinedTerm:
+    @staticmethod
+    def schema_type() -> str:
+        return "http://schema.org/DefinedTerm"
+
+    @staticmethod
+    def term_code() -> str:
+        return "http://schema.org/termCode"
+
+    @staticmethod
+    def name() -> str:
+        return "http://schema.org/name"
+
+    @staticmethod
+    def try_get_term_code_as_string(dt: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = dt.TryGetPropertyAsSingleton(LDDefinedTerm.term_code(), context)
+        (pattern_matching_result, tc) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                tc = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return tc
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def get_term_code_as_string(dt: LDNode, context: LDContext | None=None) -> str:
+        match_value: Any | None = dt.TryGetPropertyAsSingleton(LDDefinedTerm.term_code(), context)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                tc: str = value(match_value)
+                return tc
+
+            else: 
+                raise Exception(("Property of `termCode` of object with @id `" + dt.Id) + "` was not a string")
+
+
+        else: 
+            raise Exception(("Could not access property `termCode` of object with @id `" + dt.Id) + "`")
+
+
+    @staticmethod
+    def set_term_code_as_string(dt: LDNode, term_code: str, context: LDContext | None=None) -> Any:
+        return dt.SetProperty(LDDefinedTerm.term_code(), term_code, context)
+
+    @staticmethod
+    def try_get_name_as_string(dt: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = dt.TryGetPropertyAsSingleton(LDDefinedTerm.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(dt: LDNode, context: LDContext | None=None) -> str:
+        match_value: Any | None = dt.TryGetPropertyAsSingleton(LDDefinedTerm.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 `" + dt.Id) + "` was not a string")
+
+
+        else: 
+            raise Exception(("Could not access property `name` of object with @id `" + dt.Id) + "`")
+
+
+    @staticmethod
+    def set_name_as_string(dt: LDNode, name: str, context: LDContext | None=None) -> Any:
+        return dt.SetProperty(LDDefinedTerm.name(), name, context)
+
+    @staticmethod
+    def gen_id(name: str, term_code: str | None=None) -> str:
+        return clean(("#OA_" + name) + "") if (term_code is None) else (("" + term_code) + "")
+
+    @staticmethod
+    def validate(dt: LDNode, context: LDContext | None=None) -> bool:
+        return dt.HasProperty(LDDefinedTerm.name(), context) if dt.HasType(LDDefinedTerm.schema_type(), context) else False
+
+    @staticmethod
+    def create(name: str, id: str | None=None, term_code: str | None=None, context: LDContext | None=None) -> LDNode:
+        dt: LDNode = LDNode(LDDefinedTerm.gen_id(name, term_code) if (id is None) else id, [LDDefinedTerm.schema_type()], None, context)
+        dt.SetProperty(LDDefinedTerm.name(), name, context)
+        dt.SetOptionalProperty(LDDefinedTerm.term_code(), term_code, context)
+        return dt
+
+
+LDDefinedTerm_reflection = _expr1441
+
+__all__ = ["LDDefinedTerm_reflection"]
+

arctrl/py/ROCrate/Generic/file.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+from typing import Any
+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 ..ldcontext import LDContext
+from ..ldobject import (LDNode, LDGraph)
+from .comment import LDComment
+from .defined_term import LDDefinedTerm
+
+def _expr1545() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDFile", None, LDFile)
+
+
+class LDFile:
+    @staticmethod
+    def schema_type() -> str:
+        return "http://schema.org/MediaObject"
+
+    @staticmethod
+    def name() -> str:
+        return "http://schema.org/name"
+
+    @staticmethod
+    def comment() -> str:
+        return "http://schema.org/comment"
+
+    @staticmethod
+    def disambiguating_description() -> str:
+        return "http://schema.org/disambiguatingDescription"
+
+    @staticmethod
+    def usage_info() -> str:
+        return "http://schema.org/usageInfo"
+
+    @staticmethod
+    def encoding_format() -> str:
+        return "http://schema.org/encodingFormat"
+
+    @staticmethod
+    def pattern() -> str:
+        return "http://schema.org/pattern"
+
+    @staticmethod
+    def about() -> str:
+        return "http://schema.org/about"
+
+    @staticmethod
+    def try_get_name_as_string(dt: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = dt.TryGetPropertyAsSingleton(LDFile.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(dt: LDNode, context: LDContext | None=None) -> str:
+        match_value: Any | None = dt.TryGetPropertyAsSingleton(LDFile.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 `" + dt.Id) + "` was not a string")
+
+
+        else: 
+            raise Exception(("Could not access property `name` of object with @id `" + dt.Id) + "`")
+
+
+    @staticmethod
+    def set_name_as_string(dt: LDNode, name: str, context: LDContext | None=None) -> Any:
+        return dt.SetProperty(LDFile.name(), name, context)
+
+    @staticmethod
+    def get_comments(dt: 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 dt.GetPropertyNodes(LDFile.comment(), filter, graph, context)
+
+    @staticmethod
+    def set_comments(dt: LDNode, comment: Array[LDNode], context: LDContext | None=None) -> Any:
+        return dt.SetProperty(LDFile.comment(), comment, context)
+
+    @staticmethod
+    def try_get_disambiguating_description_as_string(dt: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = dt.TryGetPropertyAsSingleton(LDFile.disambiguating_description(), context)
+        (pattern_matching_result, dd) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                dd = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return dd
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def set_disambiguating_description_as_string(dt: LDNode, disambiguating_description: str, context: LDContext | None=None) -> Any:
+        return dt.SetProperty(LDFile.disambiguating_description(), disambiguating_description, context)
+
+    @staticmethod
+    def try_get_encoding_format_as_string(dt: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = dt.TryGetPropertyAsSingleton(LDFile.encoding_format(), context)
+        (pattern_matching_result, ef) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                ef = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return ef
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def set_encoding_format_as_string(dt: LDNode, encoding_format: str, context: LDContext | None=None) -> Any:
+        return dt.SetProperty(LDFile.encoding_format(), encoding_format, context)
+
+    @staticmethod
+    def try_get_usage_info_as_string(dt: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = dt.TryGetPropertyAsSingleton(LDFile.usage_info(), context)
+        (pattern_matching_result, ui) = (None, None)
+        if match_value is not None:
+            if str(type(value(match_value))) == "<class \'str\'>":
+                pattern_matching_result = 0
+                ui = value(match_value)
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return ui
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def set_usage_info_as_string(dt: LDNode, usage_info: str, context: LDContext | None=None) -> Any:
+        return dt.SetProperty(LDFile.usage_info(), usage_info, context)
+
+    @staticmethod
+    def try_get_pattern_as_defined_term(dt: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> LDNode | None:
+        match_value: LDNode | None = dt.TryGetPropertyAsSingleNode(LDFile.pattern(), graph, context)
+        if match_value is not None:
+            def _arrow1544(__unit: None=None) -> bool:
+                dt_1: LDNode = match_value
+                return LDDefinedTerm.validate(dt_1, context)
+
+            if _arrow1544():
+                dt_2: LDNode = match_value
+                return dt_2
+
+            else: 
+                raise Exception(("Property of `pattern` of object with @id `" + dt.Id) + "` was not a DefinedTerm")
+
+
+        else: 
+            return None
+
+
+    @staticmethod
+    def set_pattern_as_defined_term(dt: LDNode, pattern: LDNode, context: LDContext | None=None) -> Any:
+        return dt.SetProperty(LDFile.pattern(), pattern, context)
+
+    @staticmethod
+    def try_get_about(dt: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> LDNode | None:
+        return dt.TryGetPropertyAsSingleNode(LDFile.about(), graph, context)
+
+    @staticmethod
+    def set_about(dt: LDNode, about: LDNode, context: LDContext | None=None) -> Any:
+        return dt.SetProperty(LDFile.about(), about, context)
+
+    @staticmethod
+    def gen_id(name: str) -> str:
+        return ("" + name) + ""
+
+    @staticmethod
+    def validate(dt: LDNode, context: LDContext | None=None) -> bool:
+        return dt.HasProperty(LDFile.name(), context) if dt.HasType(LDFile.schema_type(), context) else False
+
+    @staticmethod
+    def create(name: str, id: str | None=None, comments: Array[LDNode] | None=None, disambiguating_description: str | None=None, encoding_format: str | None=None, usage_info: str | None=None, context: LDContext | None=None) -> LDNode:
+        dt: LDNode = LDNode(LDFile.gen_id(name) if (id is None) else id, [LDFile.schema_type()], None, context)
+        dt.SetProperty(LDFile.name(), name, context)
+        dt.SetOptionalProperty(LDFile.comment(), comments, context)
+        dt.SetOptionalProperty(LDFile.disambiguating_description(), disambiguating_description, context)
+        dt.SetOptionalProperty(LDFile.encoding_format(), encoding_format, context)
+        dt.SetOptionalProperty(LDFile.usage_info(), usage_info, context)
+        return dt
+
+
+LDFile_reflection = _expr1545
+
+__all__ = ["LDFile_reflection"]
+

arctrl/py/ROCrate/Generic/lab_process.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+from datetime import datetime
+from typing import (Any, TypeVar)
+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 ..helper import clean
+from ..ldcontext import LDContext
+from ..ldobject import (LDNode, LDGraph)
+from .file import LDFile
+from .lab_protocol import LDLabProtocol
+from .person import LDPerson
+from .property_value import LDPropertyValue
+from .sample import LDSample
+
+__C = TypeVar("__C")
+
+__B = TypeVar("__B")
+
+def _expr1560() -> TypeInfo:
+    return class_type("ARCtrl.ROCrate.LDLabProcess", None, LDLabProcess)
+
+
+class LDLabProcess:
+    @staticmethod
+    def schema_type() -> str:
+        return "https://bioschemas.org/LabProcess"
+
+    @staticmethod
+    def name() -> str:
+        return "http://schema.org/name"
+
+    @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 executes_lab_protocol() -> str:
+        return "https://bioschemas.org/executesLabProtocol"
+
+    @staticmethod
+    def parameter_value() -> str:
+        return "https://bioschemas.org/parameterValue"
+
+    @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(lp: LDNode, context: LDContext | None=None) -> str | None:
+        match_value: Any | None = lp.TryGetPropertyAsSingleton(LDLabProcess.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(lp: LDNode, context: LDContext | None=None) -> str:
+        match_value: Any | None = lp.TryGetPropertyAsSingleton(LDLabProcess.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 `" + lp.Id) + "` was not a string")
+
+
+        else: 
+            raise Exception(("Could not access property `name` of object with @id `" + lp.Id) + "`")
+
+
+    @staticmethod
+    def set_name_as_string(lp: LDNode, name: str, context: LDContext | None=None) -> Any:
+        return lp.SetProperty(LDLabProcess.name(), name, context)
+
+    @staticmethod
+    def try_get_agent(lp: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> LDNode | None:
+        match_value: LDNode | None = lp.TryGetPropertyAsSingleNode(LDLabProcess.agent(), graph, context)
+        (pattern_matching_result, a_1) = (None, None)
+        if match_value is not None:
+            def _arrow1554(__unit: None=None) -> bool:
+                ld_object: LDNode = match_value
+                return LDPerson.validate(ld_object, context)
+
+            if _arrow1554():
+                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(lp: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> LDNode:
+        match_value: LDNode | None = lp.TryGetPropertyAsSingleNode(LDLabProcess.agent(), graph, context)
+        if match_value is not None:
+            def _arrow1555(__unit: None=None) -> bool:
+                ld_object: LDNode = match_value
+                return LDPerson.validate(ld_object, context)
+
+            if _arrow1555():
+                a_1: LDNode = match_value
+                return a_1
+
+            else: 
+                raise Exception(("Property of `agent` of object with @id `" + lp.Id) + "` was not a valid Person")
+
+
+        else: 
+            raise Exception(("Could not access property `agent` of object with @id `" + lp.Id) + "`")
+
+
+    @staticmethod
+    def set_agent(lp: LDNode, agent: LDNode, context: LDContext | None=None) -> Any:
+        return lp.SetProperty(LDLabProcess.agent(), agent, context)
+
+    @staticmethod
+    def get_objects(lp: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        return lp.GetPropertyNodes(LDLabProcess.object_(), None, graph, context)
+
+    @staticmethod
+    def get_objects_as_sample(lp: 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 lp.GetPropertyNodes(LDLabProcess.object_(), filter, graph, context)
+
+    @staticmethod
+    def get_objects_as_data(lp: 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 lp.GetPropertyNodes(LDLabProcess.object_(), filter, graph, context)
+
+    @staticmethod
+    def set_objects(lp: LDNode, objects: Array[LDNode], context: LDContext | None=None) -> Any:
+        return lp.SetProperty(LDLabProcess.object_(), objects, context)
+
+    @staticmethod
+    def get_results(lp: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        return lp.GetPropertyNodes(LDLabProcess.result(), None, graph, context)
+
+    @staticmethod
+    def get_results_as_sample(lp: 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 lp.GetPropertyNodes(LDLabProcess.result(), filter, graph, context)
+
+    @staticmethod
+    def get_results_as_data(lp: 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 lp.GetPropertyNodes(LDLabProcess.result(), filter, graph, context)
+
+    @staticmethod
+    def set_results(lp: LDNode, results: Array[LDNode], context: LDContext | None=None) -> Any:
+        return lp.SetProperty(LDLabProcess.result(), results, context)
+
+    @staticmethod
+    def try_get_executes_lab_protocol(lp: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> LDNode | None:
+        match_value: LDNode | None = lp.TryGetPropertyAsSingleNode(LDLabProcess.executes_lab_protocol(), graph, context)
+        (pattern_matching_result, l_1) = (None, None)
+        if match_value is not None:
+            def _arrow1556(__unit: None=None) -> bool:
+                ld_object: LDNode = match_value
+                return LDLabProtocol.validate(ld_object, context)
+
+            if _arrow1556():
+                pattern_matching_result = 0
+                l_1 = match_value
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return l_1
+
+        elif pattern_matching_result == 1:
+            return None
+
+
+    @staticmethod
+    def set_executes_lab_protocol(lp: LDNode, executes_lab_protocol: LDNode, context: LDContext | None=None) -> Any:
+        return lp.SetProperty(LDLabProcess.executes_lab_protocol(), executes_lab_protocol, context)
+
+    @staticmethod
+    def get_parameter_values(lp: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Array[LDNode]:
+        def filter(ld_object: LDNode, context_1: LDContext | None=None) -> bool:
+            return LDPropertyValue.validate(ld_object, context_1)
+
+        return lp.GetPropertyNodes(LDLabProcess.parameter_value(), filter, graph, context)
+
+    @staticmethod
+    def set_parameter_values(lp: LDNode, parameter_values: Array[LDNode], context: LDContext | None=None) -> Any:
+        return lp.SetProperty(LDLabProcess.parameter_value(), parameter_values, context)
+
+    @staticmethod
+    def try_get_end_time(lp: LDNode, context: LDContext | None=None) -> Any | None:
+        match_value: Any | None = lp.TryGetPropertyAsSingleton(LDLabProcess.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(lp: LDNode, end_time: Any, context: LDContext | None=None) -> Any:
+        return lp.SetProperty(LDLabProcess.end_time(), end_time, context)
+
+    @staticmethod
+    def get_disambiguating_descriptions_as_string(lp: 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, lp.GetPropertyValues(LDLabProcess.disambiguating_description(), filter, context))
+
+    @staticmethod
+    def set_disambiguating_descriptions_as_string(lp: LDNode, disambiguating_descriptions: Array[str], context: LDContext | None=None) -> Any:
+        return lp.SetProperty(LDLabProcess.disambiguating_description(), disambiguating_descriptions, context)
+
+    @staticmethod
+    def validate(lp: LDNode, context: LDContext | None=None) -> bool:
+        return lp.HasProperty(LDLabProcess.name(), context) if lp.HasType(LDLabProcess.schema_type(), context) else False
+
+    @staticmethod
+    def gen_id(name: Any, assay_name: Any | None=None, study_name: Any | None=None) -> str:
+        def _arrow1557(__unit: None=None) -> str:
+            study_1: __C = value(study_name)
+            return ((("#Process_" + str(study_1)) + "_") + str(name)) + ""
+
+        def _arrow1558(__unit: None=None) -> str:
+            assay_1: __B = value(assay_name)
+            return ((("#Process_" + str(assay_1)) + "_") + str(name)) + ""
+
+        def _arrow1559(__unit: None=None) -> str:
+            assay: __B = value(assay_name)
+            study: __C = value(study_name)
+            return ((((("#Process_" + str(study)) + "_") + str(assay)) + "_") + str(name)) + ""
+
+        return clean((_arrow1557() if (study_name is not None) else (("#Process_" + str(name)) + "")) if (assay_name is None) else (_arrow1558() if (study_name is None) else _arrow1559()))
+
+    @staticmethod
+    def create(name: str, objects: Array[LDNode] | None=None, results: Array[LDNode] | None=None, id: str | None=None, agent: LDNode | None=None, executes_lab_protocol: LDNode | None=None, parameter_values: Array[LDNode] | None=None, end_time: Any | None=None, disambiguating_descriptions: Array[str] | None=None, context: LDContext | None=None) -> LDNode:
+        id_1: str = LDLabProcess.gen_id(name) if (id is None) else id
+        objects_1: Array[LDNode] = default_arg(objects, [])
+        results_1: Array[LDNode] = default_arg(results, [])
+        lp: LDNode = LDNode(id_1, [LDLabProcess.schema_type()], None, context)
+        lp.SetProperty(LDLabProcess.name(), name, context)
+        lp.SetOptionalProperty(LDLabProcess.agent(), agent, context)
+        lp.SetProperty(LDLabProcess.object_(), objects_1, context)
+        lp.SetProperty(LDLabProcess.result(), results_1, context)
+        lp.SetOptionalProperty(LDLabProcess.executes_lab_protocol(), executes_lab_protocol, context)
+        lp.SetOptionalProperty(LDLabProcess.parameter_value(), parameter_values, context)
+        lp.SetOptionalProperty(LDLabProcess.end_time(), end_time, context)
+        lp.SetOptionalProperty(LDLabProcess.disambiguating_description(), disambiguating_descriptions, context)
+        return lp
+
+
+LDLabProcess_reflection = _expr1560
+
+__all__ = ["LDLabProcess_reflection"]
+