arctrl 3.0.0__py3-none-any.whl

arctrl/py/Spreadsheet/arc_run.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.list import (FSharpList, empty, of_seq)
+from ..fable_modules.fable_library.seq import (delay, append, singleton, iterate_indexed, map, try_find, choose, try_pick, is_empty)
+from ..fable_modules.fable_library.string_ import (to_fail, printf, to_console)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import (get_enumerator, IEnumerable_1, IEnumerator, to_enumerable)
+from ..fable_modules.fs_spreadsheet.fs_row import FsRow
+from ..fable_modules.fs_spreadsheet.fs_workbook import FsWorkbook
+from ..fable_modules.fs_spreadsheet.fs_worksheet import FsWorksheet
+from ..Core.arc_types import ArcRun
+from ..Core.comment import Remark
+from ..Core.datamap import Datamap
+from ..Core.Helper.identifier import create_missing_identifier
+from ..Core.person import Person
+from ..Core.Table.arc_table import ArcTable
+from .AnnotationTable.arc_table import (try_from_fs_worksheet, to_fs_worksheet)
+from .DatamapTable.datamap_table import try_from_fs_worksheet as try_from_fs_worksheet_1
+from .Metadata.contacts import (from_rows as from_rows_1, to_rows as to_rows_1)
+from .Metadata.run import (from_rows, to_rows)
+from .Metadata.sparse_table import (SparseRowModule_tryGetValueAt, SparseRowModule_fromValues, SparseRowModule_writeToSheet, SparseRowModule_fromFsRow, SparseRowModule_getAllValues, SparseRowModule_fromAllValues)
+
+def ArcRun_fromRows(rows: IEnumerable_1[IEnumerable_1[tuple[int, str]]]) -> ArcRun:
+    en: IEnumerator[IEnumerable_1[tuple[int, str]]] = get_enumerator(rows)
+    def loop(last_row_mut: str | None, run_mut: ArcRun | None, performers_mut: FSharpList[Person], row_number_mut: int, rows: Any=rows) -> ArcRun:
+        while True:
+            (last_row, run, performers, row_number) = (last_row_mut, run_mut, performers_mut, row_number_mut)
+            (pattern_matching_result,) = (None,)
+            if last_row is not None:
+                if last_row == "RUN":
+                    pattern_matching_result = 0
+
+                elif last_row == "RUN PERFORMERS":
+                    pattern_matching_result = 1
+
+                else: 
+                    pattern_matching_result = 2
+
+
+            else: 
+                pattern_matching_result = 2
+
+            if pattern_matching_result == 0:
+                pattern_input: tuple[str | None, int, FSharpList[Remark], ArcRun] = from_rows(row_number + 1, en)
+                last_row_mut = pattern_input[0]
+                run_mut = pattern_input[3]
+                performers_mut = performers
+                row_number_mut = pattern_input[1]
+                continue
+
+            elif pattern_matching_result == 1:
+                pattern_input_1: tuple[str | None, int, FSharpList[Remark], FSharpList[Person]] = from_rows_1("Run Person", row_number + 1, en)
+                last_row_mut = pattern_input_1[0]
+                run_mut = run
+                performers_mut = pattern_input_1[3]
+                row_number_mut = pattern_input_1[1]
+                continue
+
+            elif pattern_matching_result == 2:
+                if run is not None:
+                    run_2: ArcRun = run
+                    run_2.Performers = list(performers)
+                    return run_2
+
+                else: 
+                    return ArcRun.create(create_missing_identifier(), None, None, None, None, None, None, None, None, list(performers))
+
+
+            break
+
+    if en.System_Collections_IEnumerator_MoveNext():
+        return loop(SparseRowModule_tryGetValueAt(0, en.System_Collections_Generic_IEnumerator_1_get_Current()), None, empty(), 1)
+
+    else: 
+        raise Exception("empty run metadata sheet")
+
+
+
+def ArcRun_toRows(run: ArcRun) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    def _arrow2015(__unit: None=None, run: Any=run) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+        def _arrow2014(__unit: None=None) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+            def _arrow2013(__unit: None=None) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+                def _arrow2012(__unit: None=None) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+                    return to_rows_1("Run Person", of_seq(run.Performers))
+
+                return append(singleton(SparseRowModule_fromValues(to_enumerable(["RUN PERFORMERS"]))), delay(_arrow2012))
+
+            return append(to_rows(run), delay(_arrow2013))
+
+        return append(singleton(SparseRowModule_fromValues(to_enumerable(["RUN"]))), delay(_arrow2014))
+
+    return delay(_arrow2015)
+
+
+def ArcRun_toMetadataSheet(run: ArcRun) -> FsWorksheet:
+    sheet: FsWorksheet = FsWorksheet("isa_run")
+    def action(row_i: int, r: IEnumerable_1[tuple[int, str]], run: Any=run) -> None:
+        SparseRowModule_writeToSheet(row_i + 1, r, sheet)
+
+    iterate_indexed(action, ArcRun_toRows(run))
+    return sheet
+
+
+def ArcRun_fromMetadataSheet(sheet: FsWorksheet) -> ArcRun:
+    try: 
+        return ArcRun_fromRows(map(SparseRowModule_fromFsRow, sheet.Rows))
+
+    except Exception as err:
+        arg: str = str(err)
+        return to_fail(printf("Failed while parsing metadatasheet: %s"))(arg)
+
+
+
+def ArcRun_toMetadataCollection(run: ArcRun) -> IEnumerable_1[IEnumerable_1[str | None]]:
+    def mapping(row: IEnumerable_1[tuple[int, str]], run: Any=run) -> IEnumerable_1[str | None]:
+        return SparseRowModule_getAllValues(row)
+
+    return map(mapping, ArcRun_toRows(run))
+
+
+def ArcRun_fromMetadataCollection(collection: IEnumerable_1[IEnumerable_1[str | None]]) -> ArcRun:
+    try: 
+        return ArcRun_fromRows(map(SparseRowModule_fromAllValues, collection))
+
+    except Exception as err:
+        arg: str = str(err)
+        return to_fail(printf("Failed while parsing metadatasheet: %s"))(arg)
+
+
+
+def ArcRun_isMetadataSheetName(name: str) -> bool:
+    return name == "isa_run"
+
+
+def ArcRun_isMetadataSheet(sheet: FsWorksheet) -> bool:
+    return ArcRun_isMetadataSheetName(sheet.Name)
+
+
+def ArcRun_tryGetMetadataSheet(doc: FsWorkbook) -> FsWorksheet | None:
+    def predicate(sheet: FsWorksheet, doc: Any=doc) -> bool:
+        return ArcRun_isMetadataSheet(sheet)
+
+    return try_find(predicate, doc.GetWorksheets())
+
+
+def ARCtrl_ArcRun__ArcRun_fromFsWorkbook_Static_32154C9D(doc: FsWorkbook) -> ArcRun:
+    try: 
+        run_metadata: ArcRun
+        match_value: FsWorksheet | None = ArcRun_tryGetMetadataSheet(doc)
+        if match_value is None:
+            to_console(printf("Cannot retrieve metadata: Run file does not contain \"%s\" sheet."))("isa_run")
+            run_metadata = ArcRun.create(create_missing_identifier())
+
+        else: 
+            run_metadata = ArcRun_fromMetadataSheet(match_value)
+
+        sheets: Array[FsWorksheet] = doc.GetWorksheets()
+        annotation_tables: IEnumerable_1[ArcTable] = choose(try_from_fs_worksheet, sheets)
+        datamap_sheet: Datamap | None = try_pick(try_from_fs_worksheet_1, sheets)
+        run_metadata.Datamap = datamap_sheet
+        if not is_empty(annotation_tables):
+            run_metadata.Tables = list(annotation_tables)
+
+        return run_metadata
+
+    except Exception as err:
+        arg_1: str = str(err)
+        return to_fail(printf("Could not parse assay: \n%s"))(arg_1)
+
+
+
+def ARCtrl_ArcRun__ArcRun_toFsWorkbook_Static_Z3EFAF6F8(run: ArcRun) -> FsWorkbook:
+    doc: FsWorkbook = FsWorkbook()
+    metadata_sheet: FsWorksheet = ArcRun_toMetadataSheet(run)
+    doc.AddWorksheet(metadata_sheet)
+    def action(i: int, arg: ArcTable, run: Any=run) -> None:
+        sheet: FsWorksheet = to_fs_worksheet(i, arg)
+        doc.AddWorksheet(sheet)
+
+    iterate_indexed(action, run.Tables)
+    return doc
+
+
+def ARCtrl_ArcRun__ArcRun_ToFsWorkbook(this: ArcRun) -> FsWorkbook:
+    return ARCtrl_ArcRun__ArcRun_toFsWorkbook_Static_Z3EFAF6F8(this)
+
+
+__all__ = ["ArcRun_fromRows", "ArcRun_toRows", "ArcRun_toMetadataSheet", "ArcRun_fromMetadataSheet", "ArcRun_toMetadataCollection", "ArcRun_fromMetadataCollection", "ArcRun_isMetadataSheetName", "ArcRun_isMetadataSheet", "ArcRun_tryGetMetadataSheet", "ARCtrl_ArcRun__ArcRun_fromFsWorkbook_Static_32154C9D", "ARCtrl_ArcRun__ArcRun_toFsWorkbook_Static_Z3EFAF6F8", "ARCtrl_ArcRun__ArcRun_ToFsWorkbook"]
+

arctrl/py/Spreadsheet/arc_study.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+from typing import Any
+from ..fable_modules.fable_library.list import (FSharpList, empty)
+from ..fable_modules.fable_library.option import (default_arg, to_array)
+from ..fable_modules.fable_library.seq import (iterate_indexed, append, map, try_find, try_pick, iterate)
+from ..fable_modules.fable_library.string_ import (to_fail, printf, to_console)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import (IEnumerable_1, to_enumerable, get_enumerator, IEnumerator, ignore)
+from ..fable_modules.fs_spreadsheet.fs_row import FsRow
+from ..fable_modules.fs_spreadsheet.fs_workbook import FsWorkbook
+from ..fable_modules.fs_spreadsheet.fs_worksheet import FsWorksheet
+from ..Core.arc_types import (ArcStudy, ArcAssay)
+from ..Core.datamap import Datamap
+from ..Core.Helper.collections_ import (ResizeArray_choose, ResizeArray_isEmpty)
+from ..Core.Helper.identifier import create_missing_identifier
+from ..Core.Table.arc_table import ArcTable
+from .AnnotationTable.arc_table import (try_from_fs_worksheet, to_fs_worksheet as to_fs_worksheet_1)
+from .DatamapTable.datamap_table import (try_from_fs_worksheet as try_from_fs_worksheet_1, to_fs_worksheet)
+from .Metadata.sparse_table import (SparseRowModule_writeToSheet, SparseRowModule_fromValues, SparseRowModule_fromFsRow, SparseRowModule_getAllValues, SparseRowModule_fromAllValues)
+from .Metadata.study import (to_rows, from_rows)
+
+def ArcStudy_toMetadataSheet(study: ArcStudy, assays: FSharpList[ArcAssay] | None=None) -> FsWorksheet:
+    sheet: FsWorksheet = FsWorksheet("isa_study")
+    def action(row_i: int, r: IEnumerable_1[tuple[int, str]], study: Any=study, assays: Any=assays) -> None:
+        SparseRowModule_writeToSheet(row_i + 1, r, sheet)
+
+    def _arrow2006(__unit: None=None, study: Any=study, assays: Any=assays) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+        source_1: IEnumerable_1[IEnumerable_1[tuple[int, str]]] = to_rows(study, assays)
+        return append(to_enumerable([SparseRowModule_fromValues(to_enumerable(["STUDY"]))]), source_1)
+
+    iterate_indexed(action, _arrow2006())
+    return sheet
+
+
+def ArcStudy_fromRows(rows: IEnumerable_1[IEnumerable_1[tuple[int, str]]]) -> tuple[ArcStudy, FSharpList[ArcAssay]] | None:
+    en: IEnumerator[IEnumerable_1[tuple[int, str]]] = get_enumerator(rows)
+    ignore(en.System_Collections_IEnumerator_MoveNext())
+    return from_rows(2, en)[3]
+
+
+def ArcStudy_fromMetadataSheet(sheet: FsWorksheet) -> tuple[ArcStudy, FSharpList[ArcAssay]]:
+    try: 
+        return default_arg(ArcStudy_fromRows(map(SparseRowModule_fromFsRow, sheet.Rows)), (ArcStudy.create(create_missing_identifier()), empty()))
+
+    except Exception as err:
+        arg: str = str(err)
+        return to_fail(printf("Failed while parsing metadatasheet: %s"))(arg)
+
+
+
+def ArcStudy_toMetadataCollection(study: ArcStudy, assays: FSharpList[ArcAssay] | None=None) -> IEnumerable_1[IEnumerable_1[str | None]]:
+    def mapping(row: IEnumerable_1[tuple[int, str]], study: Any=study, assays: Any=assays) -> IEnumerable_1[str | None]:
+        return SparseRowModule_getAllValues(row)
+
+    def _arrow2007(__unit: None=None, study: Any=study, assays: Any=assays) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+        source_1: IEnumerable_1[IEnumerable_1[tuple[int, str]]] = to_rows(study, assays)
+        return append(to_enumerable([SparseRowModule_fromValues(to_enumerable(["STUDY"]))]), source_1)
+
+    return map(mapping, _arrow2007())
+
+
+def ArcStudy_fromMetadataCollection(collection: IEnumerable_1[IEnumerable_1[str | None]]) -> tuple[ArcStudy, FSharpList[ArcAssay]]:
+    try: 
+        return default_arg(ArcStudy_fromRows(map(SparseRowModule_fromAllValues, collection)), (ArcStudy.create(create_missing_identifier()), empty()))
+
+    except Exception as err:
+        arg: str = str(err)
+        return to_fail(printf("Failed while parsing metadatasheet: %s"))(arg)
+
+
+
+def ArcStudy_isMetadataSheetName(name: str) -> bool:
+    if name == "isa_study":
+        return True
+
+    else: 
+        return name == "Study"
+
+
+
+def ArcStudy_isMetadataSheet(sheet: FsWorksheet) -> bool:
+    return ArcStudy_isMetadataSheetName(sheet.Name)
+
+
+def ArcStudy_tryGetMetadataSheet(doc: FsWorkbook) -> FsWorksheet | None:
+    def predicate(sheet: FsWorksheet, doc: Any=doc) -> bool:
+        return ArcStudy_isMetadataSheet(sheet)
+
+    return try_find(predicate, doc.GetWorksheets())
+
+
+def ARCtrl_ArcStudy__ArcStudy_fromFsWorkbook_Static_32154C9D(doc: FsWorkbook) -> tuple[ArcStudy, FSharpList[ArcAssay]]:
+    try: 
+        pattern_input: tuple[ArcStudy, FSharpList[ArcAssay]]
+        match_value: FsWorksheet | None = ArcStudy_tryGetMetadataSheet(doc)
+        if match_value is None:
+            to_console(printf("Cannot retrieve metadata: Study file does not contain \"%s\" or \"%s\" sheet."))("isa_study")("Study")
+            pattern_input = (ArcStudy.create(create_missing_identifier()), empty())
+
+        else: 
+            pattern_input = ArcStudy_fromMetadataSheet(match_value)
+
+        study_metadata: ArcStudy = pattern_input[0]
+        sheets: Array[FsWorksheet] = doc.GetWorksheets()
+        annotation_tables: Array[ArcTable] = ResizeArray_choose(try_from_fs_worksheet, sheets)
+        datamap_sheet: Datamap | None = try_pick(try_from_fs_worksheet_1, sheets)
+        if not ResizeArray_isEmpty(annotation_tables):
+            study_metadata.Tables = annotation_tables
+
+        study_metadata.Datamap = datamap_sheet
+        return (study_metadata, pattern_input[1])
+
+    except Exception as err:
+        arg_2: str = str(err)
+        return to_fail(printf("Could not parse study: \n%s"))(arg_2)
+
+
+
+def ARCtrl_ArcStudy__ArcStudy_toFsWorkbook_Static_Z4CEFA522(study: ArcStudy, assays: FSharpList[ArcAssay] | None=None, datamap_sheet: bool | None=None) -> FsWorkbook:
+    datamap_sheet_1: bool = default_arg(datamap_sheet, True)
+    doc: FsWorkbook = FsWorkbook()
+    metadata_sheet: FsWorksheet = ArcStudy_toMetadataSheet(study, assays)
+    doc.AddWorksheet(metadata_sheet)
+    if datamap_sheet_1:
+        def action(arg: Datamap, study: Any=study, assays: Any=assays, datamap_sheet: Any=datamap_sheet) -> None:
+            sheet: FsWorksheet = to_fs_worksheet(arg)
+            doc.AddWorksheet(sheet)
+
+        iterate(action, to_array(study.Datamap))
+
+    def action_1(i: int, arg_1: ArcTable, study: Any=study, assays: Any=assays, datamap_sheet: Any=datamap_sheet) -> None:
+        sheet_1: FsWorksheet = to_fs_worksheet_1(i, arg_1)
+        doc.AddWorksheet(sheet_1)
+
+    iterate_indexed(action_1, study.Tables)
+    return doc
+
+
+def ARCtrl_ArcStudy__ArcStudy_ToFsWorkbook_257FC1F0(this: ArcStudy, assays: FSharpList[ArcAssay] | None=None, datamap_sheet: bool | None=None) -> FsWorkbook:
+    return ARCtrl_ArcStudy__ArcStudy_toFsWorkbook_Static_Z4CEFA522(this, assays, datamap_sheet)
+
+
+__all__ = ["ArcStudy_toMetadataSheet", "ArcStudy_fromRows", "ArcStudy_fromMetadataSheet", "ArcStudy_toMetadataCollection", "ArcStudy_fromMetadataCollection", "ArcStudy_isMetadataSheetName", "ArcStudy_isMetadataSheet", "ArcStudy_tryGetMetadataSheet", "ARCtrl_ArcStudy__ArcStudy_fromFsWorkbook_Static_32154C9D", "ARCtrl_ArcStudy__ArcStudy_toFsWorkbook_Static_Z4CEFA522", "ARCtrl_ArcStudy__ArcStudy_ToFsWorkbook_257FC1F0"]
+

arctrl/py/Spreadsheet/arc_workflow.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_modules.fable_library.list import (FSharpList, empty, of_seq)
+from ..fable_modules.fable_library.seq import (delay, append, singleton, iterate_indexed, map, try_find, try_pick)
+from ..fable_modules.fable_library.string_ import (to_fail, printf, to_console)
+from ..fable_modules.fable_library.util import (get_enumerator, IEnumerable_1, IEnumerator, to_enumerable)
+from ..fable_modules.fs_spreadsheet.fs_row import FsRow
+from ..fable_modules.fs_spreadsheet.fs_workbook import FsWorkbook
+from ..fable_modules.fs_spreadsheet.fs_worksheet import FsWorksheet
+from ..Core.arc_types import ArcWorkflow
+from ..Core.comment import Remark
+from ..Core.datamap import Datamap
+from ..Core.Helper.identifier import create_missing_identifier
+from ..Core.person import Person
+from .DatamapTable.datamap_table import try_from_fs_worksheet
+from .Metadata.contacts import (from_rows as from_rows_1, to_rows as to_rows_1)
+from .Metadata.sparse_table import (SparseRowModule_tryGetValueAt, SparseRowModule_fromValues, SparseRowModule_writeToSheet, SparseRowModule_fromFsRow, SparseRowModule_getAllValues, SparseRowModule_fromAllValues)
+from .Metadata.workflow import (from_rows, to_rows)
+
+def ArcWorkflow_fromRows(rows: IEnumerable_1[IEnumerable_1[tuple[int, str]]]) -> ArcWorkflow:
+    en: IEnumerator[IEnumerable_1[tuple[int, str]]] = get_enumerator(rows)
+    def loop(last_row_mut: str | None, workflow_mut: ArcWorkflow | None, contacts_mut: FSharpList[Person], row_number_mut: int, rows: Any=rows) -> ArcWorkflow:
+        while True:
+            (last_row, workflow, contacts, row_number) = (last_row_mut, workflow_mut, contacts_mut, row_number_mut)
+            (pattern_matching_result,) = (None,)
+            if last_row is not None:
+                if last_row == "WORKFLOW":
+                    pattern_matching_result = 0
+
+                elif last_row == "WORKFLOW CONTACTS":
+                    pattern_matching_result = 1
+
+                else: 
+                    pattern_matching_result = 2
+
+
+            else: 
+                pattern_matching_result = 2
+
+            if pattern_matching_result == 0:
+                pattern_input: tuple[str | None, int, FSharpList[Remark], ArcWorkflow] = from_rows(row_number + 1, en)
+                last_row_mut = pattern_input[0]
+                workflow_mut = pattern_input[3]
+                contacts_mut = contacts
+                row_number_mut = pattern_input[1]
+                continue
+
+            elif pattern_matching_result == 1:
+                pattern_input_1: tuple[str | None, int, FSharpList[Remark], FSharpList[Person]] = from_rows_1("Workflow Person", row_number + 1, en)
+                last_row_mut = pattern_input_1[0]
+                workflow_mut = workflow
+                contacts_mut = pattern_input_1[3]
+                row_number_mut = pattern_input_1[1]
+                continue
+
+            elif pattern_matching_result == 2:
+                if workflow is not None:
+                    workflow_2: ArcWorkflow = workflow
+                    workflow_2.Contacts = list(contacts)
+                    return workflow_2
+
+                else: 
+                    return ArcWorkflow.create(create_missing_identifier(), None, None, None, None, None, None, None, None, None, list(contacts))
+
+
+            break
+
+    if en.System_Collections_IEnumerator_MoveNext():
+        return loop(SparseRowModule_tryGetValueAt(0, en.System_Collections_Generic_IEnumerator_1_get_Current()), None, empty(), 1)
+
+    else: 
+        raise Exception("empty workflow metadata sheet")
+
+
+
+def ArcWorkflow_toRows(workflow: ArcWorkflow) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    def _arrow2011(__unit: None=None, workflow: Any=workflow) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+        def _arrow2010(__unit: None=None) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+            def _arrow2009(__unit: None=None) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+                def _arrow2008(__unit: None=None) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+                    return to_rows_1("Workflow Person", of_seq(workflow.Contacts))
+
+                return append(singleton(SparseRowModule_fromValues(to_enumerable(["WORKFLOW CONTACTS"]))), delay(_arrow2008))
+
+            return append(to_rows(workflow), delay(_arrow2009))
+
+        return append(singleton(SparseRowModule_fromValues(to_enumerable(["WORKFLOW"]))), delay(_arrow2010))
+
+    return delay(_arrow2011)
+
+
+def ArcWorkflow_toMetadataSheet(workflow: ArcWorkflow) -> FsWorksheet:
+    sheet: FsWorksheet = FsWorksheet("isa_workflow")
+    def action(row_i: int, r: IEnumerable_1[tuple[int, str]], workflow: Any=workflow) -> None:
+        SparseRowModule_writeToSheet(row_i + 1, r, sheet)
+
+    iterate_indexed(action, ArcWorkflow_toRows(workflow))
+    return sheet
+
+
+def ArcWorkflow_fromMetadataSheet(sheet: FsWorksheet) -> ArcWorkflow:
+    try: 
+        return ArcWorkflow_fromRows(map(SparseRowModule_fromFsRow, sheet.Rows))
+
+    except Exception as err:
+        arg: str = str(err)
+        return to_fail(printf("Failed while parsing metadatasheet: %s"))(arg)
+
+
+
+def ArcWorkflow_toMetadataCollection(workflow: ArcWorkflow) -> IEnumerable_1[IEnumerable_1[str | None]]:
+    def mapping(row: IEnumerable_1[tuple[int, str]], workflow: Any=workflow) -> IEnumerable_1[str | None]:
+        return SparseRowModule_getAllValues(row)
+
+    return map(mapping, ArcWorkflow_toRows(workflow))
+
+
+def ArcWorkflow_fromMetadataCollection(collection: IEnumerable_1[IEnumerable_1[str | None]]) -> ArcWorkflow:
+    try: 
+        return ArcWorkflow_fromRows(map(SparseRowModule_fromAllValues, collection))
+
+    except Exception as err:
+        arg: str = str(err)
+        return to_fail(printf("Failed while parsing metadatasheet: %s"))(arg)
+
+
+
+def ArcWorkflow_isMetadataSheetName(name: str) -> bool:
+    return name == "isa_workflow"
+
+
+def ArcWorkflow_isMetadataSheet(sheet: FsWorksheet) -> bool:
+    return ArcWorkflow_isMetadataSheetName(sheet.Name)
+
+
+def ArcWorkflow_tryGetMetadataSheet(doc: FsWorkbook) -> FsWorksheet | None:
+    def predicate(sheet: FsWorksheet, doc: Any=doc) -> bool:
+        return ArcWorkflow_isMetadataSheet(sheet)
+
+    return try_find(predicate, doc.GetWorksheets())
+
+
+def ARCtrl_ArcWorkflow__ArcWorkflow_fromFsWorkbook_Static_32154C9D(doc: FsWorkbook) -> ArcWorkflow:
+    try: 
+        workflow_metadata: ArcWorkflow
+        match_value: FsWorksheet | None = ArcWorkflow_tryGetMetadataSheet(doc)
+        if match_value is None:
+            to_console(printf("Cannot retrieve metadata: Workflow file does not contain \"%s\" sheet."))("isa_workflow")
+            workflow_metadata = ArcWorkflow.create(create_missing_identifier())
+
+        else: 
+            workflow_metadata = ArcWorkflow_fromMetadataSheet(match_value)
+
+        datamap_sheet: Datamap | None = try_pick(try_from_fs_worksheet, doc.GetWorksheets())
+        workflow_metadata.Datamap = datamap_sheet
+        return workflow_metadata
+
+    except Exception as err:
+        arg_1: str = str(err)
+        return to_fail(printf("Could not parse assay: \n%s"))(arg_1)
+
+
+
+def ARCtrl_ArcWorkflow__ArcWorkflow_toFsWorkbook_Static_Z1C75CB0E(workflow: ArcWorkflow) -> FsWorkbook:
+    doc: FsWorkbook = FsWorkbook()
+    metadata_sheet: FsWorksheet = ArcWorkflow_toMetadataSheet(workflow)
+    doc.AddWorksheet(metadata_sheet)
+    return doc
+
+
+def ARCtrl_ArcWorkflow__ArcWorkflow_ToFsWorkbook(this: ArcWorkflow) -> FsWorkbook:
+    return ARCtrl_ArcWorkflow__ArcWorkflow_toFsWorkbook_Static_Z1C75CB0E(this)
+
+
+__all__ = ["ArcWorkflow_fromRows", "ArcWorkflow_toRows", "ArcWorkflow_toMetadataSheet", "ArcWorkflow_fromMetadataSheet", "ArcWorkflow_toMetadataCollection", "ArcWorkflow_fromMetadataCollection", "ArcWorkflow_isMetadataSheetName", "ArcWorkflow_isMetadataSheet", "ArcWorkflow_tryGetMetadataSheet", "ARCtrl_ArcWorkflow__ArcWorkflow_fromFsWorkbook_Static_32154C9D", "ARCtrl_ArcWorkflow__ArcWorkflow_toFsWorkbook_Static_Z1C75CB0E", "ARCtrl_ArcWorkflow__ArcWorkflow_ToFsWorkbook"]
+

arctrl/py/Spreadsheet/assembly_info.py

@@ -0,0 +1 @@
+

arctrl/py/Spreadsheet/collection_aux.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ..fable_modules.fable_library.array_ import (initialize, skip as skip_1, try_item)
+from ..fable_modules.fable_library.list import (try_pick, FSharpList, is_empty, reverse, head, cons, tail, empty)
+from ..fable_modules.fable_library.map_util import try_get_value
+from ..fable_modules.fable_library.option import (value, some)
+from ..fable_modules.fable_library.seq import (skip, max_by, try_find)
+from ..fable_modules.fable_library.types import (Array, FSharpRef)
+from ..fable_modules.fable_library.util import (IEnumerable_1, compare_primitives)
+
+__A = TypeVar("__A")
+
+_T = TypeVar("_T")
+
+_A = TypeVar("_A")
+
+_B = TypeVar("_B")
+
+_C = TypeVar("_C")
+
+_D = TypeVar("_D")
+
+_U = TypeVar("_U")
+
+__B = TypeVar("__B")
+
+__C = TypeVar("__C")
+
+__D = TypeVar("__D")
+
+_V = TypeVar("_V")
+
+def Seq_trySkip(i: int, s: IEnumerable_1[Any]) -> IEnumerable_1[Any] | None:
+    try: 
+        return skip(i, s)
+
+    except Exception as match_value:
+        return None
+
+
+
+def Array_ofIndexedSeq(s: IEnumerable_1[tuple[int, str]]) -> Array[str]:
+    def _arrow1456(tuple: tuple[int, str], s: Any=s) -> int:
+        return tuple[0]
+
+    class ObjectExpr1457:
+        @property
+        def Compare(self) -> Callable[[int, int], int]:
+            return compare_primitives
+
+    def _arrow1459(i: int, s: Any=s) -> str:
+        def _arrow1458(arg: tuple[int, str]) -> bool:
+            return i == arg[0]
+
+        match_value: tuple[int, str] | None = try_find(_arrow1458, s)
+        if match_value is None:
+            return ""
+
+        else: 
+            i_1: int = match_value[0] or 0
+            return match_value[1]
+
+
+    return initialize(1 + max_by(_arrow1456, s, ObjectExpr1457())[0], _arrow1459, None)
+
+
+def Array_trySkip(i: int, a: Array[Any]) -> Array[Any] | None:
+    try: 
+        return skip_1(i, a, None)
+
+    except Exception as match_value:
+        return None
+
+
+
+def Array_tryItemDefault(i: int, d: Any, a: Array[Any]) -> Any:
+    match_value: __A | None = try_item(i, a)
+    if match_value is None:
+        return d
+
+    else: 
+        return value(match_value)
+
+
+
+def Array_map4(f: Callable[[_A, _B, _C, _D], _T], aa: Array[Any], ba: Array[Any], ca: Array[Any], da: Array[Any]) -> Array[Any]:
+    if not ((len(ca) == len(da)) if ((len(ba) == len(ca)) if (len(aa) == len(ba)) else False) else False):
+        raise Exception("")
+
+    def _arrow1461(i: int, f: Any=f, aa: Any=aa, ba: Any=ba, ca: Any=ca, da: Any=da) -> _T:
+        return f(aa[i], ba[i], ca[i], da[i])
+
+    return initialize(len(aa), _arrow1461, None)
+
+
+def List_tryPickDefault(chooser: Callable[[_T], _U | None], d: Any, list_1: FSharpList[Any]) -> Any:
+    match_value: _U | None = try_pick(chooser, list_1)
+    if match_value is None:
+        return d
+
+    else: 
+        return value(match_value)
+
+
+
+def List_unzip4(l: FSharpList[tuple[_A, _B, _C, _D]]) -> tuple[FSharpList[_A], FSharpList[_B], FSharpList[_C], FSharpList[_D]]:
+    def loop(la_mut: FSharpList[Any], lb_mut: FSharpList[Any], lc_mut: FSharpList[Any], ld_mut: FSharpList[Any], l_1_mut: FSharpList[tuple[__A, __B, __C, __D]], l: Any=l) -> tuple[FSharpList[__A], FSharpList[__B], FSharpList[__C], FSharpList[__D]]:
+        while True:
+            (la, lb, lc, ld, l_1) = (la_mut, lb_mut, lc_mut, ld_mut, l_1_mut)
+            if is_empty(l_1):
+                return (reverse(la), reverse(lb), reverse(lc), reverse(ld))
+
+            else: 
+                la_mut = cons(head(l_1)[0], la)
+                lb_mut = cons(head(l_1)[1], lb)
+                lc_mut = cons(head(l_1)[2], lc)
+                ld_mut = cons(head(l_1)[3], ld)
+                l_1_mut = tail(l_1)
+                continue
+
+            break
+
+    return loop(empty(), empty(), empty(), empty(), l)
+
+
+def Dictionary_tryGetValue(k: Any, dict_1: Any) -> Any | None:
+    pattern_input: tuple[bool, _V]
+    out_arg: _V = None
+    def _arrow1466(__unit: None=None, k: Any=k, dict_1: Any=dict_1) -> _V:
+        return out_arg
+
+    def _arrow1467(v: _V | None=None, k: Any=k, dict_1: Any=dict_1) -> None:
+        nonlocal out_arg
+        out_arg = v
+
+    pattern_input = (try_get_value(dict_1, k, FSharpRef(_arrow1466, _arrow1467)), out_arg)
+    if pattern_input[0]:
+        return some(pattern_input[1])
+
+    else: 
+        return None
+
+
+
+def Dictionary_tryGetString(k: Any, dict_1: Any) -> str | None:
+    pattern_input: tuple[bool, str]
+    out_arg: str = None
+    def _arrow1468(__unit: None=None, k: Any=k, dict_1: Any=dict_1) -> str:
+        return out_arg
+
+    def _arrow1469(v: str, k: Any=k, dict_1: Any=dict_1) -> None:
+        nonlocal out_arg
+        out_arg = v
+
+    pattern_input = (try_get_value(dict_1, k, FSharpRef(_arrow1468, _arrow1469)), out_arg)
+    v_1: str = pattern_input[1]
+    if (v_1.strip() != "") if pattern_input[0] else False:
+        return v_1.strip()
+
+    else: 
+        return None
+
+
+
+__all__ = ["Seq_trySkip", "Array_ofIndexedSeq", "Array_trySkip", "Array_tryItemDefault", "Array_map4", "List_tryPickDefault", "List_unzip4", "Dictionary_tryGetValue", "Dictionary_tryGetString"]
+