arctrl 3.0.0__py3-none-any.whl

arctrl/py/rocrate_io.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+from typing import Any
+from .Core.arc_types import (ArcInvestigation, ArcRun, ArcWorkflow)
+from .Core.Helper.collections_ import ResizeArray_choose
+from .FileSystem.file_system import FileSystem
+from .Json.ROCrate.ldgraph import (encoder, decoder)
+from .Json.ROCrate.ldnode import decoder as decoder_1
+from .ROCrate.ldcontext import LDContext
+from .ROCrate.ldobject import (LDNode, LDRef, LDGraph, DynamicObj_DynamicObj__DynamicObj_HasProperty_Z721C83C5)
+from .ROCrate.LDTypes.computational_workflow import LDComputationalWorkflow
+from .ROCrate.LDTypes.create_action import LDCreateAction
+from .ROCrate.LDTypes.creative_work import LDCreativeWork
+from .ROCrate.LDTypes.dataset import LDDataset
+from .ROCrate.LDTypes.file import LDFile
+from .ROCrate.rocrate_context import (init_v1_2, init_bioschemas_context, init_v1_1)
+from .conversion import (ARCtrl_ArcInvestigation__ArcInvestigation_ToROCrateInvestigation_Z7960E96B, ARCtrl_ArcInvestigation__ArcInvestigation_fromROCrateInvestigation_Static_Z6839B9E8, ARCtrl_ArcRun__ArcRun_ToROCrateRun_1695DD5C, ARCtrl_ArcWorkflow__ArcWorkflow_ToROCrateWorkflow_1695DD5C)
+from .JsonIO.ldobject import ARCtrl_ROCrate_LDGraph__LDGraph_toROCrateJsonString_Static_71136F3F
+from .license import License
+from .fable_modules.fable_library.date import now
+from .fable_modules.fable_library.list import (of_array, filter, FSharpList, is_empty, map as map_1)
+from .fable_modules.fable_library.option import (bind, default_arg, value as value_2)
+from .fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from .fable_modules.fable_library.seq import (iterate, try_head, exactly_one)
+from .fable_modules.fable_library.string_ import (join, replace, to_fail, printf)
+from .fable_modules.fable_library.types import Array
+from .fable_modules.thoth_json_core.decode import map
+from .fable_modules.thoth_json_core.types import (IEncodable, Decoder_1)
+
+def _expr4425() -> TypeInfo:
+    return class_type("ARCtrl.Json.ARC.ROCrate", None, ROCrate)
+
+
+class ROCrate:
+    ...
+
+ROCrate_reflection = _expr4425
+
+def ROCrate_get_metadataFileDescriptor(__unit: None=None) -> LDNode:
+    node: LDNode = LDNode("ro-crate-metadata.json", ["http://schema.org/CreativeWork"])
+    node.SetProperty("http://purl.org/dc/terms/conformsTo", LDRef("https://w3id.org/ro/crate/1.2"))
+    node.SetProperty("http://schema.org/about", LDRef("./"))
+    return node
+
+
+def ROCrate_get_metadataFileDescriptorWfRun(__unit: None=None) -> LDNode:
+    node: LDNode = LDNode("ro-crate-metadata.json", ["http://schema.org/CreativeWork"])
+    node.SetProperty("http://purl.org/dc/terms/conformsTo", of_array([LDRef("https://w3id.org/ro/crate/1.1"), LDRef("https://w3id.org/workflowhub/workflow-ro-crate/1.0")]))
+    node.SetProperty("http://schema.org/about", LDRef("./"))
+    return node
+
+
+def ROCrate_createLicenseNode_29619109(license: License | None=None) -> LDNode:
+    if license is None:
+        return LDCreativeWork.create("#LICENSE", None, None, None, None, None, None, None, None, "ALL RIGHTS RESERVED BY THE AUTHORS")
+
+    else: 
+        license_1: License = license
+        text: str
+        match_value: str = license_1.Type
+        text = license_1.Content
+        return LDCreativeWork.create(license_1.Path, None, None, None, None, None, None, None, None, text)
+
+
+
+def ROCrate_getLicense_Z2F770004(license: LDNode, context: LDContext | None=None) -> License | None:
+    text: str | None = LDCreativeWork.try_get_text_as_string(license, context)
+    match_value: str = license.Id
+    (pattern_matching_result, text_1, path, text_2, path_1) = (None, None, None, None, None)
+    if match_value == "#LICENSE":
+        if text is not None:
+            if text == "ALL RIGHTS RESERVED BY THE AUTHORS":
+                pattern_matching_result = 0
+
+            else: 
+                pattern_matching_result = 1
+                text_1 = text
+
+
+        else: 
+            pattern_matching_result = 0
+
+
+    elif text is None:
+        pattern_matching_result = 3
+        path_1 = match_value
+
+    else: 
+        pattern_matching_result = 2
+        path = match_value
+        text_2 = text
+
+    if pattern_matching_result == 0:
+        return None
+
+    elif pattern_matching_result == 1:
+        return License("fulltext", text_1)
+
+    elif pattern_matching_result == 2:
+        return License("fulltext", text_2, path)
+
+    elif pattern_matching_result == 3:
+        return License("fulltext", "", path_1)
+
+
+
+def ROCrate_encoder_Z7FE34C43(isa: ArcInvestigation, license: License | None=None, fs: FileSystem | None=None, ignore_broken_wr: bool | None=None) -> IEncodable:
+    license_1: LDNode = ROCrate_createLicenseNode_29619109(license)
+    isa_1: LDNode = ARCtrl_ArcInvestigation__ArcInvestigation_ToROCrateInvestigation_Z7960E96B(isa, fs, ignore_broken_wr)
+    LDDataset.set_sddate_published_as_date_time(isa_1, now())
+    LDDataset.set_license_as_creative_work(isa_1, license_1)
+    graph: LDGraph = isa_1.Flatten()
+    context: LDContext = LDContext(None, [init_v1_2(), init_bioschemas_context()])
+    graph.SetContext(context)
+    graph.AddNode(ROCrate_get_metadataFileDescriptor())
+    graph.Compact_InPlace()
+    return encoder(graph)
+
+
+def ROCrate_get_decoder(__unit: None=None) -> Decoder_1[tuple[ArcInvestigation, Array[str], License | None]]:
+    def ctor(graph: LDGraph) -> tuple[ArcInvestigation, Array[str], License | None]:
+        match_value: LDNode | None = graph.TryGetNode("./")
+        if match_value is None:
+            raise Exception("RO-Crate graph did not contain root data Entity")
+
+        else: 
+            node: LDNode = match_value
+            def f(n: LDNode, graph: Any=graph) -> str | None:
+                if (not n.HasType(LDDataset.schema_type(), graph.TryGetContext())) if ((not (n.Id.find("#") >= 0)) if LDFile.validate(n, graph.TryGetContext()) else False) else False:
+                    return n.Id
+
+                else: 
+                    return None
+
+
+            files: Array[str] = ResizeArray_choose(f, graph.Nodes)
+            def binder(n_1: LDNode, graph: Any=graph) -> License | None:
+                return ROCrate_getLicense_Z2F770004(n_1, graph.TryGetContext())
+
+            license: License | None = bind(binder, LDDataset.try_get_license_as_creative_work(node, graph, graph.TryGetContext()))
+            return (ARCtrl_ArcInvestigation__ArcInvestigation_fromROCrateInvestigation_Static_Z6839B9E8(node, graph, graph.TryGetContext()), files, license)
+
+
+    return map(ctor, decoder)
+
+
+def ROCrate_packDatasetAsCrate_Z2DB026F7(dataset: LDNode, dataset_name: str, dataset_description: str, metadata_file_descriptor: LDNode | None, license: License) -> LDGraph:
+    metadata_file_descriptor_1: LDNode = default_arg(metadata_file_descriptor, ROCrate_get_metadataFileDescriptor())
+    license_1: LDNode = ROCrate_createLicenseNode_29619109(license)
+    main_entity: LDNode = LDDataset.create("./", None, None, None, None, None, dataset_description, None, dataset_name)
+    def action(kv: Any, dataset: Any=dataset, dataset_name: Any=dataset_name, dataset_description: Any=dataset_description, metadata_file_descriptor: Any=metadata_file_descriptor, license: Any=license) -> None:
+        main_entity.SetProperty(kv[0], kv[1])
+
+    iterate(action, dataset.GetProperties(False))
+    LDDataset.set_date_created_as_date_time(main_entity, now())
+    LDDataset.set_license_as_creative_work(main_entity, license_1)
+    graph: LDGraph = main_entity.Flatten()
+    context: LDContext = LDContext(None, [init_v1_2(), init_bioschemas_context()])
+    graph.SetContext(context)
+    graph.AddNode(metadata_file_descriptor_1)
+    graph.Compact_InPlace()
+    return graph
+
+
+def ROCrate_writeRunAsCrate_5E53831D(arc_run: ArcRun, file_system: FileSystem, license: License) -> str:
+    run_dataset: LDNode = ARCtrl_ArcRun__ArcRun_ToROCrateRun_1695DD5C(arc_run, file_system)
+    def predicate(prop: str, arc_run: Any=arc_run, file_system: Any=file_system, license: Any=license) -> bool:
+        return not DynamicObj_DynamicObj__DynamicObj_HasProperty_Z721C83C5(run_dataset, prop)
+
+    missing_dataset_props: FSharpList[str] = filter(predicate, of_array([LDDataset.identifier(), LDDataset.name(), LDDataset.description(), LDDataset.about(), LDDataset.mentions(), LDDataset.creator(), LDDataset.has_part()]))
+    if not is_empty(missing_dataset_props):
+        def mapping(p: str, arc_run: Any=arc_run, file_system: Any=file_system, license: Any=license) -> str:
+            return replace(p, "http://schema.org/", "")
+
+        missing_props_str: str = join(", ", map_1(mapping, missing_dataset_props))
+        to_fail(printf("Run dataset is missing required properties: %s"))(missing_props_str)
+
+    workflow_invocation: LDNode
+    match_value: LDNode | None = try_head(LDDataset.get_abouts_as_workflow_invocation(run_dataset))
+    if match_value is None:
+        raise Exception("Run dataset \'about\' property must contain a workflowInvocation")
+
+    else: 
+        workflow_invocation = match_value
+
+    def predicate_1(prop_1: str, arc_run: Any=arc_run, file_system: Any=file_system, license: Any=license) -> bool:
+        return not DynamicObj_DynamicObj__DynamicObj_HasProperty_Z721C83C5(workflow_invocation, prop_1)
+
+    missing_wf_invocation_props: FSharpList[str] = filter(predicate_1, of_array([LDCreateAction.name(), LDCreateAction.instrument(), LDCreateAction.result(), LDCreateAction.object_()]))
+    if not is_empty(missing_wf_invocation_props):
+        def mapping_1(p_1: str, arc_run: Any=arc_run, file_system: Any=file_system, license: Any=license) -> str:
+            return replace(p_1, "http://schema.org/", "")
+
+        missing_props_str_1: str = join(", ", map_1(mapping_1, missing_wf_invocation_props))
+        to_fail(printf("WorkflowInvocation is missing required properties: %s"))(missing_props_str_1)
+
+    return ARCtrl_ROCrate_LDGraph__LDGraph_toROCrateJsonString_Static_71136F3F(2)(ROCrate_packDatasetAsCrate_Z2DB026F7(run_dataset, value_2(arc_run.Title), value_2(arc_run.Description), ROCrate_get_metadataFileDescriptorWfRun(), license))
+
+
+def ROCrate_writeWorkflowAsCrate_Z4A0538D9(arc_workflow: ArcWorkflow, file_system: FileSystem, license: License) -> str:
+    workflow_dataset: LDNode = ARCtrl_ArcWorkflow__ArcWorkflow_ToROCrateWorkflow_1695DD5C(arc_workflow, file_system)
+    def predicate(prop: str, arc_workflow: Any=arc_workflow, file_system: Any=file_system, license: Any=license) -> bool:
+        return not DynamicObj_DynamicObj__DynamicObj_HasProperty_Z721C83C5(workflow_dataset, prop)
+
+    missing_dataset_props: FSharpList[str] = filter(predicate, of_array([LDDataset.identifier(), LDDataset.name(), LDDataset.description(), LDDataset.main_entity(), LDDataset.has_part(), LDDataset.creator()]))
+    if not is_empty(missing_dataset_props):
+        def mapping(p: str, arc_workflow: Any=arc_workflow, file_system: Any=file_system, license: Any=license) -> str:
+            return replace(p, "http://schema.org/", "")
+
+        missing_props_str: str = join(", ", map_1(mapping, missing_dataset_props))
+        to_fail(printf("Workflow dataset is missing required properties: %s"))(missing_props_str)
+
+    workflow_protocol: LDNode
+    match_value: LDNode | None = LDDataset.try_get_main_entity_as_workflow_protocol(workflow_dataset)
+    if match_value is None:
+        raise Exception("Workflow dataset \'mainEntity\' property must contain a workflow protocol")
+
+    else: 
+        workflow_protocol = match_value
+
+    def predicate_1(prop_1: str, arc_workflow: Any=arc_workflow, file_system: Any=file_system, license: Any=license) -> bool:
+        return not DynamicObj_DynamicObj__DynamicObj_HasProperty_Z721C83C5(workflow_protocol, prop_1)
+
+    missing_protocol_props: FSharpList[str] = filter(predicate_1, of_array([LDComputationalWorkflow.creator(), LDComputationalWorkflow.name(), LDComputationalWorkflow.input(), LDComputationalWorkflow.output(), LDComputationalWorkflow.programming_language(), LDComputationalWorkflow.url(), LDComputationalWorkflow.version(), LDComputationalWorkflow.date_created()]))
+    if not is_empty(missing_protocol_props):
+        def mapping_1(p_1: str, arc_workflow: Any=arc_workflow, file_system: Any=file_system, license: Any=license) -> str:
+            return replace(p_1, "http://schema.org/", "")
+
+        missing_props_str_1: str = join(", ", map_1(mapping_1, missing_protocol_props))
+        to_fail(printf("Workflow protocol is missing required properties: %s"))(missing_props_str_1)
+
+    return ARCtrl_ROCrate_LDGraph__LDGraph_toROCrateJsonString_Static_71136F3F(2)(ROCrate_packDatasetAsCrate_Z2DB026F7(workflow_dataset, value_2(arc_workflow.Title), value_2(arc_workflow.Description), ROCrate_get_metadataFileDescriptorWfRun(), license))
+
+
+def ROCrate_get_decoderDeprecated(__unit: None=None) -> Decoder_1[ArcInvestigation]:
+    def ctor(ldnode: LDNode) -> ArcInvestigation:
+        return ARCtrl_ArcInvestigation__ArcInvestigation_fromROCrateInvestigation_Static_Z6839B9E8(exactly_one(LDDataset.get_abouts(ldnode)), None, init_v1_1())
+
+    return map(ctor, decoder_1)
+
+
+__all__ = ["ROCrate_reflection", "ROCrate_get_metadataFileDescriptor", "ROCrate_get_metadataFileDescriptorWfRun", "ROCrate_createLicenseNode_29619109", "ROCrate_getLicense_Z2F770004", "ROCrate_encoder_Z7FE34C43", "ROCrate_get_decoder", "ROCrate_packDatasetAsCrate_Z2DB026F7", "ROCrate_writeRunAsCrate_5E53831D", "ROCrate_writeWorkflowAsCrate_Z4A0538D9", "ROCrate_get_decoderDeprecated"]
+

arctrl/py/template_web.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from typing import Any
+from .Core.template import Template
+from .JsonIO.Table.templates import Templates_fromJsonString
+from .fable_modules.fable_library.async_builder import (singleton, Async)
+from .fable_modules.fable_library.option import default_arg
+from .fable_modules.fable_library.types import Array
+from .WebRequest.web_request import download_file
+
+def get_templates(url: str | None=None) -> Async[Array[Template]]:
+    url_1: str = default_arg(url, "https://github.com/nfdi4plants/Swate-templates/releases/download/latest/templates_v2.0.0.json")
+    def _arrow4466(__unit: None=None, url: Any=url) -> Async[Array[Template]]:
+        def _arrow4465(_arg: str) -> Async[Array[Template]]:
+            map_result: Array[Template] = Templates_fromJsonString(_arg)
+            return singleton.Return(map_result)
+
+        return singleton.Bind(download_file(url_1), _arrow4465)
+
+    return singleton.Delay(_arrow4466)
+
+
+__all__ = ["get_templates"]
+

arctrl/py/xlsx.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+from .Core.arc_types import (ArcAssay, ArcStudy, ArcWorkflow, ArcRun, ArcInvestigation)
+from .Core.datamap import Datamap
+from .Spreadsheet.arc_assay import (ARCtrl_ArcAssay__ArcAssay_fromFsWorkbook_Static_32154C9D, ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F)
+from .Spreadsheet.arc_investigation import (ARCtrl_ArcInvestigation__ArcInvestigation_fromFsWorkbook_Static_32154C9D, ARCtrl_ArcInvestigation__ArcInvestigation_toFsWorkbook_Static_Z720BD3FF)
+from .Spreadsheet.arc_run import (ARCtrl_ArcRun__ArcRun_fromFsWorkbook_Static_32154C9D, ARCtrl_ArcRun__ArcRun_toFsWorkbook_Static_Z3EFAF6F8)
+from .Spreadsheet.arc_study import (ARCtrl_ArcStudy__ArcStudy_fromFsWorkbook_Static_32154C9D, ARCtrl_ArcStudy__ArcStudy_toFsWorkbook_Static_Z4CEFA522)
+from .Spreadsheet.arc_workflow import (ARCtrl_ArcWorkflow__ArcWorkflow_fromFsWorkbook_Static_32154C9D, ARCtrl_ArcWorkflow__ArcWorkflow_toFsWorkbook_Static_Z1C75CB0E)
+from .Spreadsheet.datamap import (from_fs_workbook, to_fs_workbook)
+from .fable_modules.fable_library.list import (FSharpList, of_seq)
+from .fable_modules.fable_library.option import map
+from .fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from .fable_modules.fable_library.types import Array
+from .fable_modules.fs_spreadsheet.fs_workbook import FsWorkbook
+from .fable_modules.fs_spreadsheet_py.fs_extension import (FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5, FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static)
+
+def _expr4529() -> TypeInfo:
+    return class_type("ARCtrl.XlsxHelper.DatamapXlsx", None, XlsxHelper_DatamapXlsx)
+
+
+class XlsxHelper_DatamapXlsx:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+    def from_fs_workbook(self, fswb: FsWorkbook) -> Datamap:
+        return from_fs_workbook(fswb)
+
+    def to_fs_workbook(self, datamap: Datamap) -> FsWorkbook:
+        return to_fs_workbook(datamap)
+
+    def from_xlsx_file(self, path: str) -> Datamap:
+        return from_fs_workbook(FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path))
+
+    def to_xlsx_file(self, path: str, datamap: Datamap) -> None:
+        FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, to_fs_workbook(datamap))
+
+
+XlsxHelper_DatamapXlsx_reflection = _expr4529
+
+def XlsxHelper_DatamapXlsx__ctor(__unit: None=None) -> XlsxHelper_DatamapXlsx:
+    return XlsxHelper_DatamapXlsx(__unit)
+
+
+def _expr4530() -> TypeInfo:
+    return class_type("ARCtrl.XlsxHelper.AssayXlsx", None, XlsxHelper_AssayXlsx)
+
+
+class XlsxHelper_AssayXlsx:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+    def from_fs_workbook(self, fswb: FsWorkbook) -> ArcAssay:
+        return ARCtrl_ArcAssay__ArcAssay_fromFsWorkbook_Static_32154C9D(fswb)
+
+    def to_fs_workbook(self, assay: ArcAssay) -> FsWorkbook:
+        return ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F(assay)
+
+    def from_xlsx_file(self, path: str) -> ArcAssay:
+        return ARCtrl_ArcAssay__ArcAssay_fromFsWorkbook_Static_32154C9D(FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path))
+
+    def to_xlsx_file(self, path: str, assay: ArcAssay) -> None:
+        FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, ARCtrl_ArcAssay__ArcAssay_toFsWorkbook_Static_Z2508BE4F(assay))
+
+
+XlsxHelper_AssayXlsx_reflection = _expr4530
+
+def XlsxHelper_AssayXlsx__ctor(__unit: None=None) -> XlsxHelper_AssayXlsx:
+    return XlsxHelper_AssayXlsx(__unit)
+
+
+def _expr4531() -> TypeInfo:
+    return class_type("ARCtrl.XlsxHelper.StudyXlsx", None, XlsxHelper_StudyXlsx)
+
+
+class XlsxHelper_StudyXlsx:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+    def from_fs_workbook(self, fswb: FsWorkbook) -> tuple[ArcStudy, FSharpList[ArcAssay]]:
+        return ARCtrl_ArcStudy__ArcStudy_fromFsWorkbook_Static_32154C9D(fswb)
+
+    def to_fs_workbook(self, study: ArcStudy, assays: Array[ArcAssay] | None=None) -> FsWorkbook:
+        return ARCtrl_ArcStudy__ArcStudy_toFsWorkbook_Static_Z4CEFA522(study, map(of_seq, assays))
+
+    def from_xlsx_file(self, path: str) -> tuple[ArcStudy, FSharpList[ArcAssay]]:
+        return ARCtrl_ArcStudy__ArcStudy_fromFsWorkbook_Static_32154C9D(FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path))
+
+    def to_xlsx_file(self, path: str, study: ArcStudy, assays: Array[ArcAssay] | None=None) -> None:
+        FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, ARCtrl_ArcStudy__ArcStudy_toFsWorkbook_Static_Z4CEFA522(study, map(of_seq, assays)))
+
+
+XlsxHelper_StudyXlsx_reflection = _expr4531
+
+def XlsxHelper_StudyXlsx__ctor(__unit: None=None) -> XlsxHelper_StudyXlsx:
+    return XlsxHelper_StudyXlsx(__unit)
+
+
+def _expr4532() -> TypeInfo:
+    return class_type("ARCtrl.XlsxHelper.WorkflowXlsx", None, XlsxHelper_WorkflowXlsx)
+
+
+class XlsxHelper_WorkflowXlsx:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+    def from_fs_workbook(self, fswb: FsWorkbook) -> ArcWorkflow:
+        return ARCtrl_ArcWorkflow__ArcWorkflow_fromFsWorkbook_Static_32154C9D(fswb)
+
+    def to_fs_workbook(self, workflow: ArcWorkflow) -> FsWorkbook:
+        return ARCtrl_ArcWorkflow__ArcWorkflow_toFsWorkbook_Static_Z1C75CB0E(workflow)
+
+    def from_xlsx_file(self, path: str) -> ArcWorkflow:
+        return ARCtrl_ArcWorkflow__ArcWorkflow_fromFsWorkbook_Static_32154C9D(FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path))
+
+    def to_xlsx_file(self, path: str, workflow: ArcWorkflow) -> None:
+        FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, ARCtrl_ArcWorkflow__ArcWorkflow_toFsWorkbook_Static_Z1C75CB0E(workflow))
+
+
+XlsxHelper_WorkflowXlsx_reflection = _expr4532
+
+def XlsxHelper_WorkflowXlsx__ctor(__unit: None=None) -> XlsxHelper_WorkflowXlsx:
+    return XlsxHelper_WorkflowXlsx(__unit)
+
+
+def _expr4533() -> TypeInfo:
+    return class_type("ARCtrl.XlsxHelper.RunXlsx", None, XlsxHelper_RunXlsx)
+
+
+class XlsxHelper_RunXlsx:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+    def from_fs_workbook(self, fswb: FsWorkbook) -> ArcRun:
+        return ARCtrl_ArcRun__ArcRun_fromFsWorkbook_Static_32154C9D(fswb)
+
+    def to_fs_workbook(self, run: ArcRun) -> FsWorkbook:
+        return ARCtrl_ArcRun__ArcRun_toFsWorkbook_Static_Z3EFAF6F8(run)
+
+    def from_xlsx_file(self, path: str) -> ArcRun:
+        return ARCtrl_ArcRun__ArcRun_fromFsWorkbook_Static_32154C9D(FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path))
+
+    def to_xlsx_file(self, path: str, run: ArcRun) -> None:
+        FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, ARCtrl_ArcRun__ArcRun_toFsWorkbook_Static_Z3EFAF6F8(run))
+
+
+XlsxHelper_RunXlsx_reflection = _expr4533
+
+def XlsxHelper_RunXlsx__ctor(__unit: None=None) -> XlsxHelper_RunXlsx:
+    return XlsxHelper_RunXlsx(__unit)
+
+
+def _expr4534() -> TypeInfo:
+    return class_type("ARCtrl.XlsxHelper.InvestigationXlsx", None, XlsxHelper_InvestigationXlsx)
+
+
+class XlsxHelper_InvestigationXlsx:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+    def from_fs_workbook(self, fswb: FsWorkbook) -> ArcInvestigation:
+        return ARCtrl_ArcInvestigation__ArcInvestigation_fromFsWorkbook_Static_32154C9D(fswb)
+
+    def to_fs_workbook(self, investigation: ArcInvestigation) -> FsWorkbook:
+        return ARCtrl_ArcInvestigation__ArcInvestigation_toFsWorkbook_Static_Z720BD3FF(investigation)
+
+    def from_xlsx_file(self, path: str) -> ArcInvestigation:
+        return ARCtrl_ArcInvestigation__ArcInvestigation_fromFsWorkbook_Static_32154C9D(FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path))
+
+    def to_xlsx_file(self, path: str, investigation: ArcInvestigation) -> None:
+        FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, ARCtrl_ArcInvestigation__ArcInvestigation_toFsWorkbook_Static_Z720BD3FF(investigation))
+
+
+XlsxHelper_InvestigationXlsx_reflection = _expr4534
+
+def XlsxHelper_InvestigationXlsx__ctor(__unit: None=None) -> XlsxHelper_InvestigationXlsx:
+    return XlsxHelper_InvestigationXlsx(__unit)
+
+
+def _expr4535() -> TypeInfo:
+    return class_type("ARCtrl.XlsxController", None, XlsxController)
+
+
+class XlsxController:
+    @staticmethod
+    def Datamap() -> XlsxHelper_DatamapXlsx:
+        return XlsxHelper_DatamapXlsx()
+
+    @staticmethod
+    def Assay() -> XlsxHelper_AssayXlsx:
+        return XlsxHelper_AssayXlsx()
+
+    @staticmethod
+    def Study() -> XlsxHelper_StudyXlsx:
+        return XlsxHelper_StudyXlsx()
+
+    @staticmethod
+    def Workflow() -> XlsxHelper_WorkflowXlsx:
+        return XlsxHelper_WorkflowXlsx()
+
+    @staticmethod
+    def Run() -> XlsxHelper_RunXlsx:
+        return XlsxHelper_RunXlsx()
+
+    @staticmethod
+    def Investigation() -> XlsxHelper_InvestigationXlsx:
+        return XlsxHelper_InvestigationXlsx()
+
+
+XlsxController_reflection = _expr4535
+
+__all__ = ["XlsxHelper_DatamapXlsx_reflection", "XlsxHelper_AssayXlsx_reflection", "XlsxHelper_StudyXlsx_reflection", "XlsxHelper_WorkflowXlsx_reflection", "XlsxHelper_RunXlsx_reflection", "XlsxHelper_InvestigationXlsx_reflection", "XlsxController_reflection"]
+

arctrl/py/yaml.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+from typing import Any
+from .CWL.cwlprocessing_unit import CWLProcessingUnit
+from .CWL.decode import (Decode_decodeCWLProcessingUnit, DecodeParameters_decodeYAMLParameterFile)
+from .CWL.encode import (encode_processing_unit, write_yaml, y_map)
+from .CWL.parameter_reference import CWLParameterReference
+from .fable_modules.fable_library.reflection import (TypeInfo, class_type)
+from .fable_modules.fable_library.seq import (to_list, map)
+from .fable_modules.fable_library.types import Array
+from .fable_modules.yamlicious.encode import (string, seq)
+from .fable_modules.yamlicious.yamlicious_types import YAMLElement
+
+def _expr4516() -> TypeInfo:
+    return class_type("ARCtrl.YamlHelper.ProcessingUnitYAML", None, YamlHelper_ProcessingUnitYAML)
+
+
+class YamlHelper_ProcessingUnitYAML:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+    def from_yamlstring(self, s: str) -> CWLProcessingUnit:
+        return Decode_decodeCWLProcessingUnit(s)
+
+    def to_yamlstring(self, pu: CWLProcessingUnit) -> str:
+        return encode_processing_unit(pu)
+
+
+YamlHelper_ProcessingUnitYAML_reflection = _expr4516
+
+def YamlHelper_ProcessingUnitYAML__ctor(__unit: None=None) -> YamlHelper_ProcessingUnitYAML:
+    return YamlHelper_ProcessingUnitYAML(__unit)
+
+
+def _expr4518() -> TypeInfo:
+    return class_type("ARCtrl.YamlHelper.ParameterReferenceYAML", None, YamlHelper_ParameterReferenceYAML)
+
+
+class YamlHelper_ParameterReferenceYAML:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+    def from_yamlstring(self, s: str) -> Array[CWLParameterReference]:
+        return DecodeParameters_decodeYAMLParameterFile(s)
+
+    def to_yamlstring(self, pr: Array[CWLParameterReference]) -> str:
+        def mapping(p: CWLParameterReference) -> tuple[str, YAMLElement]:
+            def _arrow4517(value: str, p: Any=p) -> YAMLElement:
+                return string(value)
+
+            values: YAMLElement = string(p.Values[0]) if (len(p.Values) == 1) else seq(_arrow4517, p.Values)
+            return (p.Key, values)
+
+        return write_yaml(y_map(to_list(map(mapping, pr))))
+
+
+YamlHelper_ParameterReferenceYAML_reflection = _expr4518
+
+def YamlHelper_ParameterReferenceYAML__ctor(__unit: None=None) -> YamlHelper_ParameterReferenceYAML:
+    return YamlHelper_ParameterReferenceYAML(__unit)
+
+
+def _expr4520() -> TypeInfo:
+    return class_type("ARCtrl.YamlController", None, YamlController)
+
+
+class YamlController:
+    @staticmethod
+    def ProcessingUnit() -> YamlHelper_ProcessingUnitYAML:
+        return YamlHelper_ProcessingUnitYAML()
+
+    @staticmethod
+    def ParameterReference() -> YamlHelper_ParameterReferenceYAML:
+        return YamlHelper_ParameterReferenceYAML()
+
+
+YamlController_reflection = _expr4520
+
+__all__ = ["YamlHelper_ProcessingUnitYAML_reflection", "YamlHelper_ParameterReferenceYAML_reflection", "YamlController_reflection"]
+

arctrl/rocrate.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from .py.ROCrate.ldobject import LDGraph, LDNode, LDValue, LDRef
+from .py.ROCrate.ldcontext import LDContext
+from .py.ROCrate.rocrate_context import init_v1_1, init_v1_2, init_bioschemas_context
+from .py.ROCrate.LDTypes.comment import LDComment
+from .py.ROCrate.LDTypes.defined_term import LDDefinedTerm
+from .py.ROCrate.LDTypes.file import LDFile
+from .py.ROCrate.LDTypes.lab_process import LDLabProcess
+from .py.ROCrate.LDTypes.lab_protocol import LDLabProtocol
+from .py.ROCrate.LDTypes.organization import LDOrganization
+from .py.ROCrate.LDTypes.person import LDPerson
+from .py.ROCrate.LDTypes.postal_address import LDPostalAddress
+from .py.ROCrate.LDTypes.property_value import LDPropertyValue
+from .py.ROCrate.LDTypes.sample import LDSample
+from .py.ROCrate.LDTypes.scholarly_article import LDScholarlyArticle
+from .py.ROCrate.LDTypes.dataset import LDDataset
+from .py.JsonIO.ldobject import LDGraphExtensions_PyJsInterop as LDGraphIO
+from .py.JsonIO.ldobject import LDNodeExtensions_PyJsInterop as LDNodeIO
+from .py.conversion import Conversion as Conversion