arctrl 3.0.0__py3-none-any.whl

arctrl/py/Conversion/run.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+from typing import Any
+from ..Core.arc_types import ArcRun
+from ..Core.comment import Comment
+from ..Core.datamap import Datamap
+from ..Core.Helper.collections_ import (ResizeArray_singleton, ResizeArray_map, ResizeArray_zip, ResizeArray_appendSingleton, Option_fromSeq, Option_fromValueWithDefault, ResizeArray_filter)
+from ..Core.Helper.identifier import Run_cwlFileNameFromIdentifier
+from ..Core.ontology_annotation import OntologyAnnotation
+from ..Core.person import Person
+from ..Core.Table.arc_tables import ArcTables
+from ..CWL.cwlprocessing_unit import CWLProcessingUnit
+from ..CWL.cwltypes import (CWLType, CWLType_file)
+from ..CWL.encode import (write_yaml, encode_cwltype)
+from ..CWL.inputs import (InputBinding, CWLInput)
+from ..CWL.parameter_reference import CWLParameterReference
+from ..FileSystem.file_system import FileSystem
+from ..FileSystem.path import (combine_many, combine)
+from ..ROCrate.ldcontext import LDContext
+from ..ROCrate.ldobject import (LDNode, LDGraph)
+from ..ROCrate.LDTypes.computational_workflow import LDComputationalWorkflow
+from ..ROCrate.LDTypes.dataset import LDDataset
+from ..ROCrate.LDTypes.file import LDFile
+from ..ROCrate.LDTypes.formal_parameter import LDFormalParameter
+from ..ROCrate.LDTypes.lab_process import LDLabProcess
+from ..ROCrate.LDTypes.organization import LDOrganization
+from ..ROCrate.LDTypes.property_value import LDPropertyValue
+from ..ROCrate.LDTypes.workflow_invocation import LDWorkflowInvocation
+from ..ROCrate.LDTypes.workflow_protocol import LDWorkflowProtocol
+from ..fable_modules.fable_library.date import utc_now
+from ..fable_modules.fable_library.list import of_seq
+from ..fable_modules.fable_library.option import (value as value_1, default_arg, bind, map)
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.seq import (exists, try_pick, find)
+from ..fable_modules.fable_library.string_ import (starts_with_exact, replace, trim_start, join, to_fail, printf)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import equals
+from .assay import AssayConversion_getDataFilesFromProcesses_6BABD1B0
+from .basic import (BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_composePropertyValueFromOA_ZDED3A0F, BaseTypes_composeComment_Z13201A7E, BaseTypes_decomposeDefinedTerm_Z2F770004, BaseTypes_decomposePropertyValueToOA_Z2F770004, BaseTypes_decomposeComment_Z2F770004)
+from .datamap import (DatamapConversion_composeFragmentDescriptors_Z892BFC3, DatamapConversion_decomposeFragmentDescriptors_Z6E59645F)
+from .person import (PersonConversion_composePerson_Z64D846DC, PersonConversion_decomposePerson_Z6839B9E8)
+from .table import (ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C, ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586)
+from .workflow import (WorkflowConversion_composeWorkflowProtocolFromProcessingUnit_Z3099C0F7, WorkflowConversion_getInputParametersFromProcessingUnit_30922B92, WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F)
+
+def _expr4408() -> TypeInfo:
+    return class_type("ARCtrl.Conversion.RunConversion", None, RunConversion)
+
+
+class RunConversion:
+    ...
+
+RunConversion_reflection = _expr4408
+
+def RunConversion_formatCWLType_Z5C31A0F9(type_: CWLType) -> str:
+    s: str = write_yaml(encode_cwltype(type_))
+    return s.strip()
+
+
+def RunConversion_isArrayType_Z5C31A0F9(type_: CWLType) -> bool:
+    if type_.tag == 11:
+        return True
+
+    elif type_.tag == 14:
+        def predicate(_arg: CWLType, type_: Any=type_) -> bool:
+            if _arg.tag == 11:
+                return True
+
+            else: 
+                return False
+
+
+        return exists(predicate, type_.fields[0])
+
+    else: 
+        return False
+
+
+
+def RunConversion_composeCWLInputFilePath_Z384F8060(path: str, run_name: str) -> str:
+    if starts_with_exact(path, "../.."):
+        return replace(replace(path, "../../", ""), "../..", "")
+
+    else: 
+        return combine_many(["runs", run_name, path])
+
+
+
+def RunConversion_decomposeCWLInputFilePath_Z384F8060(path: str, run_name: str) -> str:
+    prefix: str = combine_many(["runs", run_name])
+    if starts_with_exact(path, prefix):
+        return trim_start(replace(path, prefix, ""), "/")
+
+    else: 
+        return combine("../..", path)
+
+
+
+def RunConversion_composeCWLInputValue_70DD9184(input_value: CWLParameterReference, example_of_work: LDNode, input_param: CWLInput, run_name: str) -> LDNode:
+    if input_param.Type_ is None:
+        raise Exception(((("Cannot convert param values \"" + str(input_value.Values)) + "\" as Input parameter \"") + input_param.Name) + "\" has no type.")
+
+    type_: CWLType = value_1(input_param.Type_)
+    if input_value.Type is not None:
+        if not equals(value_1(input_value.Type), type_):
+            raise Exception(((((("Type (" + RunConversion_formatCWLType_Z5C31A0F9(value_1(input_value.Type))) + ") of yml input value \"") + input_value.Key) + "\" does not match type of workflow input parameter (") + RunConversion_formatCWLType_Z5C31A0F9(type_)) + ").")
+
+
+    (pattern_matching_result,) = (None,)
+    if type_.tag == 0:
+        if len(input_value.Values) == 1:
+            pattern_matching_result = 0
+
+        elif RunConversion_isArrayType_Z5C31A0F9(type_):
+            pattern_matching_result = 1
+
+        else: 
+            pattern_matching_result = 2
+
+
+    elif RunConversion_isArrayType_Z5C31A0F9(type_):
+        pattern_matching_result = 1
+
+    else: 
+        pattern_matching_result = 2
+
+    if pattern_matching_result == 0:
+        path: str = RunConversion_composeCWLInputFilePath_Z384F8060(input_value.Values[0], run_name)
+        return LDFile.create_cwlparameter(path, example_of_work)
+
+    elif pattern_matching_result == 1:
+        def binder(ib: InputBinding, input_value: Any=input_value, example_of_work: Any=example_of_work, input_param: Any=input_param, run_name: Any=run_name) -> str | None:
+            return ib.ItemSeparator
+
+        values: str = join(default_arg(bind(binder, input_param.InputBinding), ","), input_value.Values)
+        return LDPropertyValue.create_cwlparameter(example_of_work, input_value.Key, ResizeArray_singleton(values))
+
+    elif pattern_matching_result == 2:
+        return LDPropertyValue.create_cwlparameter(example_of_work, input_value.Key, input_value.Values)
+
+
+
+def RunConversion_decomposeCWLInputValue_Z1346FE9D(input_value: LDNode, run_name: str, context: LDContext | None=None, graph: LDGraph | None=None) -> CWLParameterReference:
+    example_of_work: LDNode
+    match_value: LDNode | None = LDFile.try_get_example_of_work_as_formal_parameter(input_value, graph, context)
+    if match_value is None:
+        arg: str = input_value.Id
+        example_of_work = to_fail(printf("Input value %s of run %s must have an exampleOfWork property pointing to a CWL formal parameter."))(arg)(run_name)
+
+    else: 
+        example_of_work = match_value
+
+    key: str = LDFormalParameter.get_name_as_string(example_of_work, context)
+    if LDFile.validate_cwlparameter(input_value, context):
+        return CWLParameterReference(key, [RunConversion_decomposeCWLInputFilePath_Z384F8060(input_value.Id, run_name)], CWLType_file())
+
+    elif LDPropertyValue.validate_cwlparameter(input_value, context):
+        return CWLParameterReference(key, LDPropertyValue.get_values_as_string(input_value, context))
+
+    else: 
+        arg_2: str = input_value.Id
+        return to_fail(printf("Input value %s of run %s is neither a CWL File nor a CWL Parameter."))(arg_2)(run_name)
+
+
+
+def RunConversion_composeWorkflowInvocationFromArcRun_Z8CC08AC(run: ArcRun, fs: FileSystem | None=None) -> Array[LDNode]:
+    workflow_protocol: LDNode
+    workflow_file_path: str = Run_cwlFileNameFromIdentifier(run.Identifier)
+    match_value: CWLProcessingUnit | None = run.CWLDescription
+    if match_value is None:
+        arg: str = run.Identifier
+        workflow_protocol = to_fail(printf("Run %s must have a CWL description"))(arg)
+
+    else: 
+        workflow_protocol = WorkflowConversion_composeWorkflowProtocolFromProcessingUnit_Z3099C0F7(workflow_file_path, match_value, None, run.Identifier)
+
+    def f(tupled_arg: tuple[CWLInput, LDNode], run: Any=run, fs: Any=fs) -> LDNode:
+        ld_i: LDNode = tupled_arg[1]
+        name: str = LDFormalParameter.get_name_as_string(ld_i, workflow_protocol.TryGetContext())
+        def chooser(i_1: CWLParameterReference, tupled_arg: Any=tupled_arg) -> CWLParameterReference | None:
+            if i_1.Key == name:
+                return i_1
+
+            else: 
+                return None
+
+
+        param_ref: CWLParameterReference | None = try_pick(chooser, run.CWLInput)
+        if param_ref is None:
+            raise Exception(((("Could not create workflow invocation for run \"" + run.Identifier) + "\": Workflow parameter \"") + name) + "\" had no assigned value.")
+
+        else: 
+            return RunConversion_composeCWLInputValue_70DD9184(param_ref, ld_i, tupled_arg[0], run.Identifier)
+
+
+    def _arrow4409(__unit: None=None, run: Any=run, fs: Any=fs) -> Array[tuple[CWLInput, LDNode]]:
+        b: Array[LDNode] = LDComputationalWorkflow.get_inputs_as_formal_parameters(workflow_protocol, None, workflow_protocol.TryGetContext())
+        return ResizeArray_zip(WorkflowConversion_getInputParametersFromProcessingUnit_30922B92(value_1(run.CWLDescription)), b)
+
+    input_params: Array[LDNode] = ResizeArray_map(f, _arrow4409())
+    process_sequence: Array[LDNode] = list(ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C(ArcTables(run.Tables), None, None, fs))
+    main_invocation: LDNode = LDWorkflowInvocation.create(run.Identifier, workflow_protocol, input_params, None, None, None, None, None, None, workflow_protocol)
+    if len(process_sequence) == 0:
+        return ResizeArray_singleton(main_invocation)
+
+    else: 
+        def f_1(p: LDNode, run: Any=run, fs: Any=fs) -> LDNode:
+            id: str = replace(p.Id, "Process", ("WorkflowInvocation_" + run.Identifier) + "")
+            name_1: str = LDLabProcess.get_name_as_string(p, p.TryGetContext())
+            inputs: Array[LDNode] = LDLabProcess.get_objects(p)
+            results: Array[LDNode] | None = Option_fromSeq(LDLabProcess.get_results(p))
+            protocol: LDNode | None = LDLabProcess.try_get_executes_lab_protocol(p)
+            parameter_values: Array[LDNode] | None = Option_fromSeq(LDLabProcess.get_parameter_values(p))
+            def mapping(a_3: LDNode, p: Any=p) -> Array[LDNode]:
+                return ResizeArray_singleton(a_3)
+
+            agents: Array[LDNode] | None = map(mapping, LDLabProcess.try_get_agent(p))
+            disambiguating_descriptions: Array[str] | None = Option_fromSeq(LDLabProcess.get_disambiguating_descriptions_as_string(p))
+            return LDWorkflowInvocation.create(name_1, workflow_protocol, inputs, results, None, agents, id, None, disambiguating_descriptions, protocol, parameter_values)
+
+        return ResizeArray_appendSingleton(main_invocation, ResizeArray_map(f_1, process_sequence))
+
+
+
+def RunConversion_decomposeMainWorkflowInvocation_Z1346FE9D(workflow_invocation: LDNode, run_name: str, context: LDContext | None=None, graph: LDGraph | None=None) -> tuple[CWLProcessingUnit, Array[CWLParameterReference]]:
+    def _arrow4410(__unit: None=None, workflow_invocation: Any=workflow_invocation, run_name: Any=run_name, context: Any=context, graph: Any=graph) -> CWLProcessingUnit:
+        match_value: LDNode | None = LDLabProcess.try_get_executes_lab_protocol(workflow_invocation, graph, context)
+        if match_value is None:
+            raise Exception(("Could not decompose workflow invocation for run \"" + run_name) + "\": Workflow parameter \"name\" had no assigned value.")
+
+        else: 
+            return WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F(match_value, None, context, graph)
+
+
+    def f(iv: LDNode, workflow_invocation: Any=workflow_invocation, run_name: Any=run_name, context: Any=context, graph: Any=graph) -> CWLParameterReference:
+        return RunConversion_decomposeCWLInputValue_Z1346FE9D(iv, run_name, context, graph)
+
+    return (_arrow4410(), ResizeArray_map(f, LDLabProcess.get_objects(workflow_invocation, graph, context)))
+
+
+def RunConversion_composeRun_Z8CC08AC(run: ArcRun, fs: FileSystem | None=None) -> LDNode:
+    workflow_protocol: LDNode
+    workflow_file_path: str = Run_cwlFileNameFromIdentifier(run.Identifier)
+    match_value: CWLProcessingUnit | None = run.CWLDescription
+    if match_value is None:
+        arg: str = run.Identifier
+        workflow_protocol = to_fail(printf("Run %s must have a CWL description"))(arg)
+
+    else: 
+        workflow_protocol = WorkflowConversion_composeWorkflowProtocolFromProcessingUnit_Z3099C0F7(workflow_file_path, match_value, None, run.Identifier)
+
+    workflow_invocations: Array[LDNode] | None = Option_fromSeq(RunConversion_composeWorkflowInvocationFromArcRun_Z8CC08AC(run, fs))
+    def mapping(term: OntologyAnnotation, run: Any=run, fs: Any=fs) -> LDNode:
+        return BaseTypes_composeDefinedTerm_ZDED3A0F(term)
+
+    measurement_method: LDNode | None = map(mapping, run.TechnologyType)
+    def mapping_1(term_1: OntologyAnnotation, run: Any=run, fs: Any=fs) -> LDNode:
+        return BaseTypes_composeDefinedTerm_ZDED3A0F(term_1)
+
+    measurement_technique: LDNode | None = map(mapping_1, run.TechnologyPlatform)
+    def mapping_2(term_2: OntologyAnnotation, run: Any=run, fs: Any=fs) -> LDNode:
+        return BaseTypes_composePropertyValueFromOA_ZDED3A0F(term_2)
+
+    variable_measured: LDNode | None = map(mapping_2, run.MeasurementType)
+    def f(c: Person, run: Any=run, fs: Any=fs) -> LDNode:
+        return PersonConversion_composePerson_Z64D846DC(c)
+
+    creators: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f, run.Performers))
+    publisher: LDNode = LDOrganization.create("DataPLANT")
+    date_created: Any = utc_now()
+    if creators is not None:
+        LDComputationalWorkflow.set_creators(workflow_protocol, value_1(creators))
+
+    LDComputationalWorkflow.set_sd_publisher(workflow_protocol, publisher)
+    LDComputationalWorkflow.set_date_created_as_date_time(workflow_protocol, date_created)
+    def mapping_3(datamap: Datamap, run: Any=run, fs: Any=fs) -> Array[LDNode]:
+        return DatamapConversion_composeFragmentDescriptors_Z892BFC3(datamap)
+
+    fragment_descriptors: Array[LDNode] | None = map(mapping_3, run.Datamap)
+    def mapping_4(ps: Array[LDNode], run: Any=run, fs: Any=fs) -> Array[LDNode]:
+        return AssayConversion_getDataFilesFromProcesses_6BABD1B0(ps, fragment_descriptors)
+
+    data_files: Array[LDNode] | None = map(mapping_4, workflow_invocations)
+    has_parts: Array[LDNode] | None = ResizeArray_singleton(workflow_protocol) if (data_files is None) else ResizeArray_appendSingleton(workflow_protocol, data_files)
+    def _arrow4411(__unit: None=None, run: Any=run, fs: Any=fs) -> Array[LDNode] | None:
+        fds_1: Array[LDNode] = fragment_descriptors
+        return fds_1
+
+    def _arrow4412(__unit: None=None, run: Any=run, fs: Any=fs) -> Array[LDNode] | None:
+        vm_1: LDNode = variable_measured
+        return ResizeArray_singleton(vm_1)
+
+    def _arrow4413(__unit: None=None, run: Any=run, fs: Any=fs) -> Array[LDNode] | None:
+        fds: Array[LDNode] = fragment_descriptors
+        vm: LDNode = variable_measured
+        return ResizeArray_appendSingleton(vm, fds)
+
+    variable_measureds: Array[LDNode] | None = (None if (fragment_descriptors is None) else _arrow4411()) if (variable_measured is None) else (_arrow4412() if (fragment_descriptors is None) else _arrow4413())
+    def f_1(c_1: Comment, run: Any=run, fs: Any=fs) -> LDNode:
+        return BaseTypes_composeComment_Z13201A7E(c_1)
+
+    comments: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f_1, run.Comments))
+    return LDDataset.create_arcrun(run.Identifier, ResizeArray_singleton(workflow_protocol), None, run.Title, run.Description, creators, has_parts, measurement_method, measurement_technique, variable_measureds, workflow_invocations, workflow_invocations, comments)
+
+
+def RunConversion_decomposeRun_Z6839B9E8(run: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> ArcRun:
+    workflow_protocol: LDNode | None = LDDataset.try_get_main_entity_as_workflow_protocol(run, graph, context)
+    def predicate(wi: LDNode, run: Any=run, graph: Any=graph, context: Any=context) -> bool:
+        match_value: LDNode | None = LDLabProcess.try_get_executes_lab_protocol(wi, graph, context)
+        (pattern_matching_result,) = (None,)
+        if match_value is not None:
+            def _arrow4415(__unit: None=None, wi: Any=wi) -> bool:
+                lp: LDNode = match_value
+                return LDWorkflowProtocol.validate(lp, context)
+
+            if _arrow4415():
+                pattern_matching_result = 0
+
+            else: 
+                pattern_matching_result = 1
+
+
+        else: 
+            pattern_matching_result = 1
+
+        if pattern_matching_result == 0:
+            return True
+
+        elif pattern_matching_result == 1:
+            return False
+
+
+    main_workflow_invocation: LDNode = find(predicate, LDDataset.get_abouts_as_workflow_invocation(run, graph, context))
+    def f(iv: LDNode, run: Any=run, graph: Any=graph, context: Any=context) -> CWLParameterReference:
+        return RunConversion_decomposeCWLInputValue_Z1346FE9D(iv, LDDataset.get_identifier_as_string(run, context), context, graph)
+
+    pattern_input: tuple[CWLProcessingUnit, Array[CWLParameterReference]] = RunConversion_decomposeMainWorkflowInvocation_Z1346FE9D(main_workflow_invocation, LDDataset.get_identifier_as_string(run, context), context, graph) if (workflow_protocol is None) else ((WorkflowConversion_decomposeWorkflowProtocolToProcessingUnit_ZB11202F(workflow_protocol, None, context, graph), ResizeArray_map(f, LDLabProcess.get_objects(main_workflow_invocation, graph, context))))
+    def mapping(m: LDNode, run: Any=run, graph: Any=graph, context: Any=context) -> OntologyAnnotation:
+        return BaseTypes_decomposeDefinedTerm_Z2F770004(m, context)
+
+    measurement_method: OntologyAnnotation | None = map(mapping, LDDataset.try_get_measurement_method_as_defined_term(run, graph, context))
+    def mapping_1(m_1: LDNode, run: Any=run, graph: Any=graph, context: Any=context) -> OntologyAnnotation:
+        return BaseTypes_decomposeDefinedTerm_Z2F770004(m_1, context)
+
+    measurement_technique: OntologyAnnotation | None = map(mapping_1, LDDataset.try_get_measurement_technique_as_defined_term(run, graph, context))
+    def mapping_2(v: LDNode, run: Any=run, graph: Any=graph, context: Any=context) -> OntologyAnnotation:
+        return BaseTypes_decomposePropertyValueToOA_Z2F770004(v, context)
+
+    variable_measured: OntologyAnnotation | None = map(mapping_2, LDDataset.try_get_variable_measured_as_measurement_type(run, graph, context))
+    def f_1(c: LDNode, run: Any=run, graph: Any=graph, context: Any=context) -> Person:
+        return PersonConversion_decomposePerson_Z6839B9E8(c, graph, context)
+
+    contacts: Array[Person] = ResizeArray_map(f_1, LDDataset.get_creators(run, graph, context))
+    def f_2(c_1: LDNode, run: Any=run, graph: Any=graph, context: Any=context) -> Comment:
+        return BaseTypes_decomposeComment_Z2F770004(c_1, context)
+
+    comments: Array[Comment] = ResizeArray_map(f_2, LDDataset.get_comments(run, graph, context))
+    datamap: Datamap | None
+    v_1: Datamap = DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(LDDataset.get_variable_measured_as_fragment_descriptors(run, graph, context), graph, context)
+    datamap = Option_fromValueWithDefault(Datamap.init(), v_1)
+    def f_3(wi_1: LDNode, run: Any=run, graph: Any=graph, context: Any=context) -> bool:
+        return wi_1.Id != main_workflow_invocation.Id
+
+    tables: ArcTables = ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(of_seq(ResizeArray_filter(f_3, LDDataset.get_abouts_as_lab_process(run, graph, context))), graph, context)
+    return ArcRun.create(LDDataset.get_identifier_as_string(run, context), LDDataset.try_get_name_as_string(run, context), LDDataset.try_get_description_as_string(run, context), variable_measured, measurement_method, measurement_technique, None, tables.Tables, datamap, contacts, pattern_input[0], pattern_input[1], comments)
+
+
+__all__ = ["RunConversion_reflection", "RunConversion_formatCWLType_Z5C31A0F9", "RunConversion_isArrayType_Z5C31A0F9", "RunConversion_composeCWLInputFilePath_Z384F8060", "RunConversion_decomposeCWLInputFilePath_Z384F8060", "RunConversion_composeCWLInputValue_70DD9184", "RunConversion_decomposeCWLInputValue_Z1346FE9D", "RunConversion_composeWorkflowInvocationFromArcRun_Z8CC08AC", "RunConversion_decomposeMainWorkflowInvocation_Z1346FE9D", "RunConversion_composeRun_Z8CC08AC", "RunConversion_decomposeRun_Z6839B9E8"]
+

arctrl/py/Conversion/scholarly_article.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+from typing import Any
+from ..Core.comment import Comment
+from ..Core.Helper.collections_ import (ResizeArray_map, Option_fromSeq, ResizeArray_tryPick)
+from ..Core.ontology_annotation import OntologyAnnotation
+from ..Core.publication import Publication
+from ..Json.ROCrate.ldnode import (decoder as decoder_1, encoder)
+from ..ROCrate.ldcontext import LDContext
+from ..ROCrate.ldobject import (LDNode, LDGraph)
+from ..ROCrate.LDTypes.person import LDPerson
+from ..ROCrate.LDTypes.property_value import LDPropertyValue
+from ..ROCrate.LDTypes.scholarly_article import LDScholarlyArticle
+from ..fable_modules.thoth_json_python.decode import Decode_fromString
+from ..fable_modules.thoth_json_python.encode import to_string as to_string_1
+from ..fable_modules.fable_library.option import (map as map_1, value as value_4)
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.result import FSharpResult_2
+from ..fable_modules.fable_library.seq import (map, is_empty, filter, to_list, delay, append, singleton, empty)
+from ..fable_modules.fable_library.string_ import (to_text, printf, join)
+from ..fable_modules.fable_library.system_text import (StringBuilder__ctor, StringBuilder__Append_244C7CD6, StringBuilder__Clear)
+from ..fable_modules.fable_library.types import (Array, to_string)
+from ..fable_modules.fable_library.util import (ignore, get_enumerator, IEnumerable_1)
+from .basic import (BaseTypes_composeComment_Z13201A7E, BaseTypes_composeDefinedTerm_ZDED3A0F, BaseTypes_decomposeComment_Z2F770004, BaseTypes_decomposeDefinedTerm_Z2F770004)
+
+def _expr4379() -> TypeInfo:
+    return class_type("ARCtrl.Conversion.ScholarlyArticleConversion", None, ScholarlyArticleConversion)
+
+
+class ScholarlyArticleConversion:
+    ...
+
+ScholarlyArticleConversion_reflection = _expr4379
+
+def ScholarlyArticleConversion_composeAuthor_Z721C83C5(author: str) -> LDNode:
+    try: 
+        match_value: FSharpResult_2[LDNode, str] = Decode_fromString(decoder_1, author)
+        if match_value.tag == 1:
+            raise Exception(to_text(printf("Error decoding string: %O"))(match_value.fields[0]))
+
+        else: 
+            return match_value.fields[0]
+
+
+    except Exception as match_value_1:
+        return LDPerson.create(author)
+
+
+
+def ScholarlyArticleConversion_splitAuthors_Z721C83C5(a: str) -> Array[str]:
+    bracket_count: int = 0
+    authors: Array[str] = []
+    sb: Any = StringBuilder__ctor()
+    with get_enumerator(list(a)) as enumerator:
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            c: str = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            if c == "{":
+                bracket_count = (bracket_count + 1) or 0
+                ignore(StringBuilder__Append_244C7CD6(sb, c))
+
+            elif c == "}":
+                bracket_count = (bracket_count - 1) or 0
+                ignore(StringBuilder__Append_244C7CD6(sb, c))
+
+            elif (bracket_count == 0) if (c == ",") else False:
+                (authors.append(to_string(sb)))
+                ignore(StringBuilder__Clear(sb))
+
+            else: 
+                ignore(StringBuilder__Append_244C7CD6(sb, c))
+
+    (authors.append(to_string(sb)))
+    return authors
+
+
+def ScholarlyArticleConversion_composeAuthors_Z721C83C5(authors: str) -> Array[LDNode]:
+    def mapping(author: str, authors: Any=authors) -> LDNode:
+        return ScholarlyArticleConversion_composeAuthor_Z721C83C5(author)
+
+    return list(map(mapping, ScholarlyArticleConversion_splitAuthors_Z721C83C5(authors)))
+
+
+def ScholarlyArticleConversion_decomposeAuthor_Z2F770004(author: LDNode, context: LDContext | None=None) -> str:
+    def predicate(n: str, author: Any=author, context: Any=context) -> bool:
+        return n != LDPerson.given_name()
+
+    if is_empty(filter(predicate, author.GetPropertyNames(context))):
+        return LDPerson.get_given_name_as_string(author, context)
+
+    else: 
+        return to_string_1(0, encoder(author))
+
+
+
+def ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5(authors: Array[LDNode], context: LDContext | None=None) -> str:
+    def f(a: LDNode, authors: Any=authors, context: Any=context) -> str:
+        return ScholarlyArticleConversion_decomposeAuthor_Z2F770004(a, context)
+
+    return join(",", ResizeArray_map(f, authors))
+
+
+def ScholarlyArticleConversion_composeScholarlyArticle_D324A6D(publication: Publication) -> LDNode:
+    title: str
+    match_value: str | None = publication.Title
+    if match_value is None:
+        raise Exception("Publication must have a title")
+
+    else: 
+        title = match_value
+
+    def mapping(authors: str, publication: Any=publication) -> Array[LDNode]:
+        return ScholarlyArticleConversion_composeAuthors_Z721C83C5(authors)
+
+    authors_1: Array[LDNode] | None = map_1(mapping, publication.Authors)
+    def f(comment: Comment, publication: Any=publication) -> LDNode:
+        return BaseTypes_composeComment_Z13201A7E(comment)
+
+    comments: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f, publication.Comments))
+    def _arrow4381(__unit: None=None, publication: Any=publication) -> IEnumerable_1[LDNode]:
+        def _arrow4380(__unit: None=None) -> IEnumerable_1[LDNode]:
+            return singleton(LDPropertyValue.create_pub_med_id(value_4(publication.PubMedID))) if ((value_4(publication.PubMedID) != "") if (publication.PubMedID is not None) else False) else empty()
+
+        return append(singleton(LDPropertyValue.create_doi(value_4(publication.DOI))) if ((value_4(publication.DOI) != "") if (publication.DOI is not None) else False) else empty(), delay(_arrow4380))
+
+    identifiers: Array[LDNode] = list(to_list(delay(_arrow4381)))
+    def mapping_1(term: OntologyAnnotation, publication: Any=publication) -> LDNode:
+        return BaseTypes_composeDefinedTerm_ZDED3A0F(term)
+
+    status: LDNode | None = map_1(mapping_1, publication.Status)
+    return LDScholarlyArticle.create(title, identifiers, None, authors_1, None, status, comments)
+
+
+def ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8(sa: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> Publication:
+    title: str = LDScholarlyArticle.get_headline_as_string(sa, context)
+    def mapping(a: Array[LDNode], sa: Any=sa, graph: Any=graph, context: Any=context) -> str:
+        return ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5(a, context)
+
+    authors: str | None = map_1(mapping, Option_fromSeq(LDScholarlyArticle.get_authors(sa, graph, context)))
+    def f(c: LDNode, sa: Any=sa, graph: Any=graph, context: Any=context) -> Comment:
+        return BaseTypes_decomposeComment_Z2F770004(c, context)
+
+    comments: Array[Comment] = ResizeArray_map(f, LDScholarlyArticle.get_comments(sa, graph, context))
+    def mapping_1(s: LDNode, sa: Any=sa, graph: Any=graph, context: Any=context) -> OntologyAnnotation:
+        return BaseTypes_decomposeDefinedTerm_Z2F770004(s, context)
+
+    status: OntologyAnnotation | None = map_1(mapping_1, LDScholarlyArticle.try_get_creative_work_status(sa, graph, context))
+    identifiers: Array[LDNode] = LDScholarlyArticle.get_identifiers_as_property_value(sa, graph, context)
+    doi: str | None
+    def f_1(i: LDNode, sa: Any=sa, graph: Any=graph, context: Any=context) -> str | None:
+        return LDPropertyValue.try_get_as_doi(i, context)
+
+    _arg: str | None = ResizeArray_tryPick(f_1, identifiers)
+    doi = LDScholarlyArticle.try_get_same_as_as_string(sa, context) if (_arg is None) else _arg
+    pub_med_id: str | None
+    def f_2(i_1: LDNode, sa: Any=sa, graph: Any=graph, context: Any=context) -> str | None:
+        return LDPropertyValue.try_get_as_pub_med_id(i_1, context)
+
+    _arg_1: str | None = ResizeArray_tryPick(f_2, identifiers)
+    pub_med_id = LDScholarlyArticle.try_get_url_as_string(sa, context) if (_arg_1 is None) else _arg_1
+    return Publication.create(pub_med_id, doi, authors, title, status, comments)
+
+
+__all__ = ["ScholarlyArticleConversion_reflection", "ScholarlyArticleConversion_composeAuthor_Z721C83C5", "ScholarlyArticleConversion_splitAuthors_Z721C83C5", "ScholarlyArticleConversion_composeAuthors_Z721C83C5", "ScholarlyArticleConversion_decomposeAuthor_Z2F770004", "ScholarlyArticleConversion_decomposeAuthors_1AAAE9A5", "ScholarlyArticleConversion_composeScholarlyArticle_D324A6D", "ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8"]
+

arctrl/py/Conversion/study.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+from typing import Any
+from ..Core.arc_types import ArcStudy
+from ..Core.comment import Comment
+from ..Core.datamap import Datamap
+from ..Core.Helper.collections_ import (Option_fromSeq, ResizeArray_map, Option_fromValueWithDefault)
+from ..Core.person import Person
+from ..Core.publication import Publication
+from ..Core.Table.arc_tables import ArcTables
+from ..FileSystem.file_system import FileSystem
+from ..ROCrate.ldcontext import LDContext
+from ..ROCrate.ldobject import (LDNode, LDGraph)
+from ..ROCrate.LDTypes.dataset import LDDataset
+from ..fable_modules.fable_library.date import now
+from ..fable_modules.fable_library.list import of_seq
+from ..fable_modules.fable_library.option import (bind, map)
+from ..fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from ..fable_modules.fable_library.types import Array
+from .assay import AssayConversion_getDataFilesFromProcesses_6BABD1B0
+from .basic import (BaseTypes_composeComment_Z13201A7E, BaseTypes_decomposeComment_Z2F770004)
+from .datamap import (DatamapConversion_composeFragmentDescriptors_Z892BFC3, DatamapConversion_decomposeFragmentDescriptors_Z6E59645F)
+from .date_time import (try_from_string, to_string)
+from .person import (PersonConversion_composePerson_Z64D846DC, PersonConversion_decomposePerson_Z6839B9E8)
+from .scholarly_article import (ScholarlyArticleConversion_composeScholarlyArticle_D324A6D, ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8)
+from .table import (ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C, ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586)
+
+def _expr4403() -> TypeInfo:
+    return class_type("ARCtrl.Conversion.StudyConversion", None, StudyConversion)
+
+
+class StudyConversion:
+    ...
+
+StudyConversion_reflection = _expr4403
+
+def StudyConversion_composeStudy_ZFE0E38E(study: ArcStudy, fs: FileSystem | None=None) -> LDNode:
+    def _arrow4404(s: str, study: Any=study, fs: Any=fs) -> Any | None:
+        return try_from_string(s)
+
+    date_created: Any | None = bind(_arrow4404, study.SubmissionDate)
+    def _arrow4405(s_1: str, study: Any=study, fs: Any=fs) -> Any | None:
+        return try_from_string(s_1)
+
+    date_published: Any | None = bind(_arrow4405, study.PublicReleaseDate)
+    date_modified: Any = now()
+    def f(p: Publication, study: Any=study, fs: Any=fs) -> LDNode:
+        return ScholarlyArticleConversion_composeScholarlyArticle_D324A6D(p)
+
+    publications: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f, study.Publications))
+    def f_1(c: Person, study: Any=study, fs: Any=fs) -> LDNode:
+        return PersonConversion_composePerson_Z64D846DC(c)
+
+    creators: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f_1, study.Contacts))
+    process_sequence: Array[LDNode] | None = Option_fromSeq(list(ARCtrl_ArcTables__ArcTables_GetProcesses_5E660E5C(ArcTables(study.Tables), None, study.Identifier, fs)))
+    def mapping(datamap: Datamap, study: Any=study, fs: Any=fs) -> Array[LDNode]:
+        return DatamapConversion_composeFragmentDescriptors_Z892BFC3(datamap)
+
+    fragment_descriptors: Array[LDNode] | None = map(mapping, study.Datamap)
+    def mapping_1(ps: Array[LDNode], study: Any=study, fs: Any=fs) -> Array[LDNode]:
+        return AssayConversion_getDataFilesFromProcesses_6BABD1B0(ps, fragment_descriptors)
+
+    data_files: Array[LDNode] | None = map(mapping_1, process_sequence)
+    def f_2(c_1: Comment, study: Any=study, fs: Any=fs) -> LDNode:
+        return BaseTypes_composeComment_Z13201A7E(c_1)
+
+    comments: Array[LDNode] | None = Option_fromSeq(ResizeArray_map(f_2, study.Comments))
+    return LDDataset.create_study(study.Identifier, None, creators, date_created, date_published, date_modified, study.Description, data_files, study.Title, publications, fragment_descriptors, comments, None, process_sequence)
+
+
+def StudyConversion_decomposeStudy_Z6839B9E8(study: LDNode, graph: LDGraph | None=None, context: LDContext | None=None) -> ArcStudy:
+    def _arrow4406(d: Any, study: Any=study, graph: Any=graph, context: Any=context) -> str:
+        return to_string(d)
+
+    date_created: str | None = map(_arrow4406, LDDataset.try_get_date_created_as_date_time(study, context))
+    def _arrow4407(d_1: Any, study: Any=study, graph: Any=graph, context: Any=context) -> str:
+        return to_string(d_1)
+
+    date_published: str | None = map(_arrow4407, LDDataset.try_get_date_published_as_date_time(study, context))
+    def f(p: LDNode, study: Any=study, graph: Any=graph, context: Any=context) -> Publication:
+        return ScholarlyArticleConversion_decomposeScholarlyArticle_Z6839B9E8(p, graph, context)
+
+    publications: Array[Publication] = ResizeArray_map(f, LDDataset.get_citations(study, graph, context))
+    def f_1(c: LDNode, study: Any=study, graph: Any=graph, context: Any=context) -> Person:
+        return PersonConversion_decomposePerson_Z6839B9E8(c, graph, context)
+
+    creators: Array[Person] = ResizeArray_map(f_1, LDDataset.get_creators(study, graph, context))
+    datamap: Datamap | None
+    v: Datamap = DatamapConversion_decomposeFragmentDescriptors_Z6E59645F(LDDataset.get_variable_measured_as_fragment_descriptors(study, graph, context), graph, context)
+    datamap = Option_fromValueWithDefault(Datamap.init(), v)
+    tables: ArcTables = ARCtrl_ArcTables__ArcTables_fromProcesses_Static_Z27F0B586(of_seq(LDDataset.get_abouts_as_lab_process(study, graph, context)), graph, context)
+    def f_2(c_1: LDNode, study: Any=study, graph: Any=graph, context: Any=context) -> Comment:
+        return BaseTypes_decomposeComment_Z2F770004(c_1, context)
+
+    comments: Array[Comment] = ResizeArray_map(f_2, LDDataset.get_comments(study, graph, context))
+    return ArcStudy.create(LDDataset.get_identifier_as_string(study, context), LDDataset.try_get_name_as_string(study, context), LDDataset.try_get_description_as_string(study, context), date_created, date_published, publications, creators, None, tables.Tables, datamap, None, comments)
+
+
+__all__ = ["StudyConversion_reflection", "StudyConversion_composeStudy_ZFE0E38E", "StudyConversion_decomposeStudy_Z6839B9E8"]
+