arctrl 3.0.0__py3-none-any.whl

arctrl/py/Spreadsheet/DatamapTable/datamap_table.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_modules.fable_library.list import (of_array, FSharpList, exists, iterate, length, head, iterate_indexed)
+from ...fable_modules.fable_library.map_util import add_to_dict
+from ...fable_modules.fable_library.range import range_big_int
+from ...fable_modules.fable_library.seq import (try_find, item, to_array, delay, map, to_list)
+from ...fable_modules.fable_library.string_ import (starts_with_exact, to_fail, printf)
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import (IEnumerable_1, ignore)
+from ...fable_modules.fs_spreadsheet.Cells.fs_cell import FsCell
+from ...fable_modules.fs_spreadsheet.Cells.fs_cells_collection import Dictionary_tryGet
+from ...fable_modules.fs_spreadsheet.fs_address import FsAddress
+from ...fable_modules.fs_spreadsheet.fs_column import FsColumn
+from ...fable_modules.fs_spreadsheet.fs_worksheet import FsWorksheet
+from ...fable_modules.fs_spreadsheet.Ranges.fs_range_address import FsRangeAddress
+from ...fable_modules.fs_spreadsheet.Tables.fs_table import FsTable
+from ...Core.data_context import (DataContext__ctor_Z780A8A2A, DataContext)
+from ...Core.datamap import Datamap
+from ..AnnotationTable.arc_table import Aux_List_groupWhen
+from .datamap_column import (set_from_fs_columns, to_fs_columns)
+
+helper_column_strings: FSharpList[str] = of_array(["Term Source REF", "Term Accession Number", "Data Format", "Data Selector Format"])
+
+def group_columns_by_header(columns: FSharpList[FsColumn]) -> FSharpList[FSharpList[FsColumn]]:
+    def f(c: FsColumn, columns: Any=columns) -> bool:
+        v: str = c.Item(1).ValueAsString()
+        def predicate(s: str, c: Any=c) -> bool:
+            return starts_with_exact(v, s)
+
+        return not exists(predicate, helper_column_strings)
+
+    return Aux_List_groupWhen(f, columns)
+
+
+def try_datamap_table(sheet: FsWorksheet) -> FsTable | None:
+    def predicate(t: FsTable, sheet: Any=sheet) -> bool:
+        return starts_with_exact(t.Name, "datamapTable")
+
+    return try_find(predicate, sheet.Tables)
+
+
+def compose_columns(columns: IEnumerable_1[FsColumn]) -> Array[DataContext]:
+    l: int = (item(0, columns).MaxRowIndex - 1) or 0
+    def _arrow2000(__unit: None=None, columns: Any=columns) -> IEnumerable_1[DataContext]:
+        def _arrow1999(i: int) -> DataContext:
+            return DataContext__ctor_Z780A8A2A()
+
+        return map(_arrow1999, range_big_int(0, 1, l - 1))
+
+    dc: Array[DataContext] = list(to_array(delay(_arrow2000)))
+    def action(arg: FSharpList[FsColumn], columns: Any=columns) -> None:
+        ignore(set_from_fs_columns(dc, arg))
+
+    iterate(action, group_columns_by_header(to_list(columns)))
+    return dc
+
+
+def try_from_fs_worksheet(sheet: FsWorksheet) -> Datamap | None:
+    try: 
+        match_value: FsTable | None = try_datamap_table(sheet)
+        if match_value is None:
+            return None
+
+        else: 
+            t: FsTable = match_value
+            return Datamap(compose_columns(t.GetColumns(sheet.CellCollection)))
+
+
+    except Exception as err:
+        arg: str = sheet.Name
+        arg_1: str = str(err)
+        return to_fail(printf("Could not parse datamap table with name \"%s\":\n%s"))(arg)(arg_1)
+
+
+
+def to_fs_worksheet(table: Datamap) -> FsWorksheet:
+    string_count: Any = dict([])
+    ws: FsWorksheet = FsWorksheet("isa_datamap")
+    if len(table.DataContexts) == 0:
+        return ws
+
+    else: 
+        columns: FSharpList[FSharpList[FsCell]] = to_fs_columns(table.DataContexts)
+        max_row: int = length(head(columns)) or 0
+        max_col: int = length(columns) or 0
+        fs_table: FsTable = ws.Table("datamapTable", FsRangeAddress(FsAddress(1, 1), FsAddress(max_row, max_col)))
+        def action_1(col_i: int, col: FSharpList[FsCell], table: Any=table) -> None:
+            def action(row_i: int, cell: FsCell, col_i: Any=col_i, col: Any=col) -> None:
+                value: str
+                v: str = cell.ValueAsString()
+                if row_i == 0:
+                    match_value: str | None = Dictionary_tryGet(v, string_count)
+                    if match_value is None:
+                        add_to_dict(string_count, cell.ValueAsString(), "")
+                        value = v
+
+                    else: 
+                        spaces: str = match_value
+                        string_count[v] = spaces + " "
+                        value = (v + " ") + spaces
+
+
+                else: 
+                    value = v
+
+                address: FsAddress = FsAddress(row_i + 1, col_i + 1)
+                fs_table.Cell(address, ws.CellCollection).SetValueAs(value)
+
+            iterate_indexed(action, col)
+
+        iterate_indexed(action_1, columns)
+        ws.RescanRows()
+        return ws
+
+
+
+__all__ = ["helper_column_strings", "group_columns_by_header", "try_datamap_table", "compose_columns", "try_from_fs_worksheet", "to_fs_worksheet"]
+

arctrl/py/Spreadsheet/Metadata/assays.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.fable_library.list import (of_array, FSharpList, length, singleton, initialize, map as map_1, empty, iterate_indexed, cons, reverse)
+from ...fable_modules.fable_library.map_util import add_to_dict
+from ...fable_modules.fable_library.option import (map, default_arg)
+from ...fable_modules.fable_library.seq2 import List_distinct
+from ...fable_modules.fable_library.string_ import starts_with_exact
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import (string_hash, IEnumerable_1, IEnumerator)
+from ...Core.arc_types import ArcAssay
+from ...Core.comment import (Comment, Remark)
+from ...Core.conversion import (JsonTypes_decomposeTechnologyPlatform, JsonTypes_composeTechnologyPlatform)
+from ...Core.Helper.collections_ import (Option_fromValueWithDefault, ResizeArray_iter)
+from ...Core.Helper.identifier import (create_missing_identifier, Assay_tryIdentifierFromFileName, remove_missing_identifier, Assay_fileNameFromIdentifier)
+from ...Core.ontology_annotation import OntologyAnnotation
+from .comment import (Comment_fromString, Comment_toString)
+from .sparse_table import (SparseTable_GetEmptyComments_3ECCA699, SparseTable__TryGetValueDefault_5BAE6133, SparseTable__TryGetValue_11FD62A8, SparseTable, SparseTable_Create_Z2192E64B, SparseTable_FromRows_Z5579EC29, SparseTable_ToRows_759CAFC1)
+
+labels: FSharpList[str] = of_array(["Identifier", "Title", "Description", "Measurement Type", "Measurement Type Term Accession Number", "Measurement Type Term Source REF", "Technology Type", "Technology Type Term Accession Number", "Technology Type Term Source REF", "Technology Platform", "File Name"])
+
+def from_string(identifier: str | None, title: str | None, description: str | None, measurement_type: str | None, measurement_type_term_source_ref: str | None, measurement_type_term_accession_number: str | None, technology_type: str | None, technology_type_term_source_ref: str | None, technology_type_term_accession_number: str | None, technology_platform: str | None, file_name: str | None, comments: Array[Comment]) -> ArcAssay:
+    measurement_type_1: OntologyAnnotation = OntologyAnnotation.create(measurement_type, measurement_type_term_source_ref, measurement_type_term_accession_number)
+    technology_type_1: OntologyAnnotation = OntologyAnnotation.create(technology_type, technology_type_term_source_ref, technology_type_term_accession_number)
+    identifier_4: str
+    if identifier is None:
+        if file_name is None:
+            identifier_4 = create_missing_identifier()
+
+        else: 
+            match_value: str | None = Assay_tryIdentifierFromFileName(file_name)
+            identifier_4 = match_value if (match_value is not None) else create_missing_identifier()
+
+
+    else: 
+        identifier_4 = identifier
+
+    measurement_type_2: OntologyAnnotation | None = Option_fromValueWithDefault(OntologyAnnotation(), measurement_type_1)
+    technology_type_2: OntologyAnnotation | None = Option_fromValueWithDefault(OntologyAnnotation(), technology_type_1)
+    def _arrow1831(name: str, identifier: Any=identifier, title: Any=title, description: Any=description, measurement_type: Any=measurement_type, measurement_type_term_source_ref: Any=measurement_type_term_source_ref, measurement_type_term_accession_number: Any=measurement_type_term_accession_number, technology_type: Any=technology_type, technology_type_term_source_ref: Any=technology_type_term_source_ref, technology_type_term_accession_number: Any=technology_type_term_accession_number, technology_platform: Any=technology_platform, file_name: Any=file_name, comments: Any=comments) -> OntologyAnnotation:
+        return JsonTypes_decomposeTechnologyPlatform(name)
+
+    technology_platform_1: OntologyAnnotation | None = map(_arrow1831, technology_platform)
+    return ArcAssay.make(identifier_4, title, description, measurement_type_2, technology_type_2, technology_platform_1, [], None, [], comments)
+
+
+def from_sparse_table(matrix: SparseTable) -> FSharpList[ArcAssay]:
+    if (length(matrix.CommentKeys) != 0) if (matrix.ColumnCount == 0) else False:
+        comments: Array[Comment] = SparseTable_GetEmptyComments_3ECCA699(matrix)
+        return singleton(ArcAssay.create(create_missing_identifier(), None, None, None, None, None, None, None, None, comments))
+
+    else: 
+        def _arrow1832(i: int, matrix: Any=matrix) -> ArcAssay:
+            def mapping(k: str) -> Comment:
+                return Comment_fromString(k, SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (k, i)))
+
+            comments_1: Array[Comment] = list(map_1(mapping, matrix.CommentKeys))
+            return from_string(SparseTable__TryGetValue_11FD62A8(matrix, ("Identifier", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("Title", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("Description", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("Measurement Type", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("Measurement Type Term Source REF", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("Measurement Type Term Accession Number", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("Technology Type", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("Technology Type Term Source REF", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("Technology Type Term Accession Number", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("Technology Platform", i)), SparseTable__TryGetValue_11FD62A8(matrix, ("File Name", i)), comments_1)
+
+        return initialize(matrix.ColumnCount, _arrow1832)
+
+
+
+def to_sparse_table(assays: FSharpList[ArcAssay]) -> SparseTable:
+    matrix: SparseTable = SparseTable_Create_Z2192E64B(None, labels, None, length(assays) + 1)
+    comment_keys: FSharpList[str] = empty()
+    def action(i: int, a: ArcAssay, assays: Any=assays) -> None:
+        processed_file_name: str = remove_missing_identifier(a.Identifier) if starts_with_exact(a.Identifier, "MISSING_IDENTIFIER_") else Assay_fileNameFromIdentifier(a.Identifier)
+        i_1: int = (i + 1) or 0
+        mt_1: dict[str, Any]
+        mt: OntologyAnnotation = default_arg(a.MeasurementType, OntologyAnnotation())
+        mt_1 = OntologyAnnotation.to_string_object(mt, True)
+        tt_1: dict[str, Any]
+        tt: OntologyAnnotation = default_arg(a.TechnologyType, OntologyAnnotation())
+        tt_1 = OntologyAnnotation.to_string_object(tt, True)
+        add_to_dict(matrix.Matrix, ("Identifier", i_1), remove_missing_identifier(a.Identifier))
+        add_to_dict(matrix.Matrix, ("Title", i_1), default_arg(a.Title, ""))
+        add_to_dict(matrix.Matrix, ("Description", i_1), default_arg(a.Description, ""))
+        add_to_dict(matrix.Matrix, ("Measurement Type", i_1), mt_1["TermName"])
+        add_to_dict(matrix.Matrix, ("Measurement Type Term Accession Number", i_1), mt_1["TermAccessionNumber"])
+        add_to_dict(matrix.Matrix, ("Measurement Type Term Source REF", i_1), mt_1["TermSourceREF"])
+        add_to_dict(matrix.Matrix, ("Technology Type", i_1), tt_1["TermName"])
+        add_to_dict(matrix.Matrix, ("Technology Type Term Accession Number", i_1), tt_1["TermAccessionNumber"])
+        add_to_dict(matrix.Matrix, ("Technology Type Term Source REF", i_1), tt_1["TermSourceREF"])
+        def mapping(tp: OntologyAnnotation, i: Any=i, a: Any=a) -> str:
+            return JsonTypes_composeTechnologyPlatform(tp)
+
+        add_to_dict(matrix.Matrix, ("Technology Platform", i_1), default_arg(map(mapping, a.TechnologyPlatform), ""))
+        add_to_dict(matrix.Matrix, ("File Name", i_1), processed_file_name)
+        def f(comment: Comment, i: Any=i, a: Any=a) -> None:
+            nonlocal comment_keys
+            pattern_input: tuple[str, str] = Comment_toString(comment)
+            n: str = pattern_input[0]
+            comment_keys = cons(n, comment_keys)
+            add_to_dict(matrix.Matrix, (n, i_1), pattern_input[1])
+
+        ResizeArray_iter(f, a.Comments)
+
+    iterate_indexed(action, assays)
+    class ObjectExpr1834:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1833(x: str, y: str) -> bool:
+                return x == y
+
+            return _arrow1833
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    return SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(comment_keys, ObjectExpr1834())), matrix.ColumnCount)
+
+
+def from_rows(prefix: str | None, line_number: int, rows: IEnumerator[IEnumerable_1[tuple[int, str]]]) -> tuple[str | None, int, FSharpList[Remark], FSharpList[ArcAssay]]:
+    tupled_arg: tuple[str | None, int, FSharpList[Remark], SparseTable] = SparseTable_FromRows_Z5579EC29(rows, labels, line_number, prefix)
+    return (tupled_arg[0], tupled_arg[1], tupled_arg[2], from_sparse_table(tupled_arg[3]))
+
+
+def to_rows(prefix: str | None, assays: FSharpList[ArcAssay]) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    return SparseTable_ToRows_759CAFC1(to_sparse_table(assays), prefix)
+
+
+__all__ = ["labels", "from_string", "from_sparse_table", "to_sparse_table", "from_rows", "to_rows"]
+

arctrl/py/Spreadsheet/Metadata/comment.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_modules.fable_library.option import (default_arg, bind)
+from ...fable_modules.fable_library.reg_exp import (get_item, groups)
+from ...fable_modules.fable_library.string_ import (to_text, printf)
+from ...Core.comment import Comment
+from ...Core.Helper.regex import ActivePatterns__007CRegex_007C__007C
+from .conversions import Option_fromValueWithDefault
+
+Comment_commentValueKey: str = "commentValue"
+
+Comment_commentPattern: str = ("Comment\\s*\\[<(?<" + Comment_commentValueKey) + ">.+)>\\]"
+
+Comment_commentPatternNoAngleBrackets: str = ("Comment\\s*\\[(?<" + Comment_commentValueKey) + ">.+)\\]"
+
+def Comment__007CComment_007C__007C(key: str) -> str | None:
+    active_pattern_result: Any | None = ActivePatterns__007CRegex_007C__007C(Comment_commentPattern, key)
+    if active_pattern_result is not None:
+        r: Any = active_pattern_result
+        return get_item(groups(r), Comment_commentValueKey) or ""
+
+    else: 
+        active_pattern_result_1: Any | None = ActivePatterns__007CRegex_007C__007C(Comment_commentPatternNoAngleBrackets, key)
+        if active_pattern_result_1 is not None:
+            r_1: Any = active_pattern_result_1
+            v: str = get_item(groups(r_1), Comment_commentValueKey) or ""
+            if v == "<>":
+                return None
+
+            else: 
+                return v
+
+
+        else: 
+            return None
+
+
+
+
+def Comment_wrapCommentKey(k: str) -> str:
+    return to_text(printf("Comment[%s]"))(k)
+
+
+def Comment_fromString(k: str, v: str) -> Comment:
+    name: str | None = Option_fromValueWithDefault("", k)
+    value: str | None = Option_fromValueWithDefault("", v)
+    return Comment.make(name, value)
+
+
+def Comment_toString(c: Comment) -> tuple[str, str]:
+    return (default_arg(c.Name, ""), default_arg(c.Value, ""))
+
+
+Remark_remarkValueKey: str = "remarkValue"
+
+Remark_remarkPattern: str = ("#(?<" + Remark_remarkValueKey) + ">.+)"
+
+def Remark__007CRemark_007C__007C(key: str | None=None) -> str | None:
+    def binder(k: str, key: Any=key) -> str | None:
+        active_pattern_result: Any | None = ActivePatterns__007CRegex_007C__007C(Remark_remarkPattern, k)
+        if active_pattern_result is not None:
+            r: Any = active_pattern_result
+            return get_item(groups(r), Remark_remarkValueKey) or ""
+
+        else: 
+            return None
+
+
+    return bind(binder, key)
+
+
+def Remark_wrapRemark(r: str) -> str:
+    return to_text(printf("#%s"))(r)
+
+
+__all__ = ["Comment_commentValueKey", "Comment_commentPattern", "Comment_commentPatternNoAngleBrackets", "Comment__007CComment_007C__007C", "Comment_wrapCommentKey", "Comment_fromString", "Comment_toString", "Remark_remarkValueKey", "Remark_remarkPattern", "Remark__007CRemark_007C__007C", "Remark_wrapRemark"]
+

arctrl/py/Spreadsheet/Metadata/contacts.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.fable_library.list import (of_array, FSharpList, length, singleton, initialize, map, empty, iterate_indexed, cons, reverse)
+from ...fable_modules.fable_library.map_util import add_to_dict
+from ...fable_modules.fable_library.option import default_arg
+from ...fable_modules.fable_library.seq2 import List_distinct
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import (string_hash, IEnumerable_1, IEnumerator)
+from ...Core.comment import (Comment, Remark)
+from ...Core.conversion import (Person_setOrcidFromComments, Person_setCommentFromORCID)
+from ...Core.Helper.collections_ import ResizeArray_iter
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.person import Person
+from .comment import (Comment_fromString, Comment_toString)
+from .conversions import (OntologyAnnotation_fromAggregatedStrings, OntologyAnnotation_toAggregatedStrings)
+from .sparse_table import (SparseTable_GetEmptyComments_3ECCA699, SparseTable__TryGetValueDefault_5BAE6133, SparseTable__TryGetValue_11FD62A8, SparseTable, SparseTable_Create_Z2192E64B, SparseTable_FromRows_Z5579EC29, SparseTable_ToRows_759CAFC1)
+
+last_name_label: str = "Last Name"
+
+first_name_label: str = "First Name"
+
+mid_initials_label: str = "Mid Initials"
+
+email_label: str = "Email"
+
+phone_label: str = "Phone"
+
+fax_label: str = "Fax"
+
+address_label: str = "Address"
+
+affiliation_label: str = "Affiliation"
+
+roles_label: str = "Roles"
+
+roles_term_accession_number_label: str = "Roles Term Accession Number"
+
+roles_term_source_reflabel: str = "Roles Term Source REF"
+
+labels: FSharpList[str] = of_array([last_name_label, first_name_label, mid_initials_label, email_label, phone_label, fax_label, address_label, affiliation_label, roles_label, roles_term_accession_number_label, roles_term_source_reflabel])
+
+def from_string(last_name: str | None, first_name: str | None, mid_initials: str | None, email: str | None, phone: str | None, fax: str | None, address: str | None, affiliation: str | None, role: str, roles_term_accession_number: str, roles_term_source_ref: str, comments: Array[Comment]) -> Person:
+    def _arrow1791(__unit: None=None, last_name: Any=last_name, first_name: Any=first_name, mid_initials: Any=mid_initials, email: Any=email, phone: Any=phone, fax: Any=fax, address: Any=address, affiliation: Any=affiliation, role: Any=role, roles_term_accession_number: Any=roles_term_accession_number, roles_term_source_ref: Any=roles_term_source_ref, comments: Any=comments) -> Person:
+        roles_1: Array[OntologyAnnotation] = OntologyAnnotation_fromAggregatedStrings(";", role, roles_term_source_ref, roles_term_accession_number)
+        return Person.make(None, last_name, first_name, mid_initials, email, phone, fax, address, affiliation, roles_1, comments)
+
+    return Person_setOrcidFromComments(_arrow1791())
+
+
+def from_sparse_table(matrix: SparseTable) -> FSharpList[Person]:
+    if (length(matrix.CommentKeys) != 0) if (matrix.ColumnCount == 0) else False:
+        comments: Array[Comment] = SparseTable_GetEmptyComments_3ECCA699(matrix)
+        def _arrow1792(__unit: None=None, matrix: Any=matrix) -> Person:
+            return_val: Person = Person.create()
+            return_val.Comments = comments
+            return return_val
+
+        return singleton(_arrow1792())
+
+    else: 
+        def _arrow1797(i: int, matrix: Any=matrix) -> Person:
+            def mapping(k: str) -> Comment:
+                return Comment_fromString(k, SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (k, i)))
+
+            comments_1: Array[Comment] = list(map(mapping, matrix.CommentKeys))
+            return from_string(SparseTable__TryGetValue_11FD62A8(matrix, (last_name_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (first_name_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (mid_initials_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (email_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (phone_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (fax_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (address_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (affiliation_label, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (roles_label, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (roles_term_accession_number_label, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (roles_term_source_reflabel, i)), comments_1)
+
+        return initialize(matrix.ColumnCount, _arrow1797)
+
+
+
+def to_sparse_table(persons: FSharpList[Person]) -> SparseTable:
+    matrix: SparseTable = SparseTable_Create_Z2192E64B(None, labels, None, length(persons) + 1)
+    comment_keys: FSharpList[str] = empty()
+    def action(i: int, p: Person, persons: Any=persons) -> None:
+        i_1: int = (i + 1) or 0
+        r_agg: dict[str, Any] = OntologyAnnotation_toAggregatedStrings(";", list(p.Roles))
+        add_to_dict(matrix.Matrix, (last_name_label, i_1), default_arg(p.LastName, ""))
+        add_to_dict(matrix.Matrix, (first_name_label, i_1), default_arg(p.FirstName, ""))
+        add_to_dict(matrix.Matrix, (mid_initials_label, i_1), default_arg(p.MidInitials, ""))
+        add_to_dict(matrix.Matrix, (email_label, i_1), default_arg(p.EMail, ""))
+        add_to_dict(matrix.Matrix, (phone_label, i_1), default_arg(p.Phone, ""))
+        add_to_dict(matrix.Matrix, (fax_label, i_1), default_arg(p.Fax, ""))
+        add_to_dict(matrix.Matrix, (address_label, i_1), default_arg(p.Address, ""))
+        add_to_dict(matrix.Matrix, (affiliation_label, i_1), default_arg(p.Affiliation, ""))
+        add_to_dict(matrix.Matrix, (roles_label, i_1), r_agg["TermNameAgg"])
+        add_to_dict(matrix.Matrix, (roles_term_accession_number_label, i_1), r_agg["TermAccessionNumberAgg"])
+        add_to_dict(matrix.Matrix, (roles_term_source_reflabel, i_1), r_agg["TermSourceREFAgg"])
+        def f(comment: Comment, i: Any=i, p: Any=p) -> None:
+            nonlocal comment_keys
+            pattern_input: tuple[str, str] = Comment_toString(comment)
+            n: str = pattern_input[0]
+            comment_keys = cons(n, comment_keys)
+            add_to_dict(matrix.Matrix, (n, i_1), pattern_input[1])
+
+        ResizeArray_iter(f, p.Comments)
+
+    def mapping(person: Person, persons: Any=persons) -> Person:
+        return Person_setCommentFromORCID(person)
+
+    iterate_indexed(action, map(mapping, persons))
+    class ObjectExpr1799:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1798(x: str, y: str) -> bool:
+                return x == y
+
+            return _arrow1798
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    return SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(comment_keys, ObjectExpr1799())), matrix.ColumnCount)
+
+
+def from_rows(prefix: str | None, line_number: int, rows: IEnumerator[IEnumerable_1[tuple[int, str]]]) -> tuple[str | None, int, FSharpList[Remark], FSharpList[Person]]:
+    tupled_arg: tuple[str | None, int, FSharpList[Remark], SparseTable] = SparseTable_FromRows_Z5579EC29(rows, labels, line_number, prefix)
+    return (tupled_arg[0], tupled_arg[1], tupled_arg[2], from_sparse_table(tupled_arg[3]))
+
+
+def to_rows(prefix: str | None, persons: FSharpList[Person]) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    m: SparseTable = to_sparse_table(persons)
+    if prefix is None:
+        return SparseTable_ToRows_759CAFC1(m)
+
+    else: 
+        return SparseTable_ToRows_759CAFC1(m, prefix)
+
+
+
+__all__ = ["last_name_label", "first_name_label", "mid_initials_label", "email_label", "phone_label", "fax_label", "address_label", "affiliation_label", "roles_label", "roles_term_accession_number_label", "roles_term_source_reflabel", "labels", "from_string", "from_sparse_table", "to_sparse_table", "from_rows", "to_rows"]
+

arctrl/py/Spreadsheet/Metadata/conversions.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.array_ import (fold, map3, fill, equals_with)
+from ...fable_modules.fable_library.list import (empty, of_array, FSharpList, fold as fold_1, map)
+from ...fable_modules.fable_library.option import (some, value, default_arg)
+from ...fable_modules.fable_library.string_ import (to_fail, printf, to_text)
+from ...fable_modules.fable_library.types import Array
+from ...fable_modules.fable_library.util import equals
+from ...Core.Helper.collections_ import ResizeArray_map
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Process.component import (Component_fromISAString_7C9A7CF8, Component, Component_toStringObject_Z685B8F25)
+from ...Core.Process.protocol_parameter import ProtocolParameter
+from ..collection_aux import Array_map4
+
+_T = TypeVar("_T")
+
+def Option_fromValueWithDefault(d: Any, v: Any) -> Any | None:
+    if equals(d, v):
+        return None
+
+    else: 
+        return some(v)
+
+
+
+def Option_mapDefault(d: Any, f: Callable[[_T], _T], o: Any | None=None) -> Any | None:
+    return Option_fromValueWithDefault(d, f(d) if (o is None) else f(value(o)))
+
+
+def OntologyAnnotation_getLengthOfAggregatedStrings(separator: str, strings: Array[str]) -> int:
+    def folder(l: int, s: str, separator: Any=separator, strings: Any=strings) -> int:
+        if s == "":
+            return l
+
+        elif l == 0:
+            return len(s.split(separator))
+
+        elif l == len(s.split(separator)):
+            return l
+
+        else: 
+            return to_fail(printf("The length of the aggregated string %s does not match the length of the others"))(s)
+
+
+    return fold(folder, 0, strings)
+
+
+def OntologyAnnotation_fromAggregatedStrings(separator: str, terms: str, source: str, accessions: str) -> Array[OntologyAnnotation]:
+    l: int = OntologyAnnotation_getLengthOfAggregatedStrings(separator, [terms, source, accessions]) or 0
+    if l == 0:
+        return []
+
+    else: 
+        def _arrow1593(a: str, b: str, c: str, separator: Any=separator, terms: Any=terms, source: Any=source, accessions: Any=accessions) -> OntologyAnnotation:
+            return OntologyAnnotation.create(a, b, c)
+
+        return list(map3(_arrow1593, fill([0] * l, 0, l, "") if (terms == "") else terms.split(separator), fill([0] * l, 0, l, "") if (source == "") else source.split(separator), fill([0] * l, 0, l, "") if (accessions == "") else accessions.split(separator), None))
+
+
+
+def OntologyAnnotation_toAggregatedStrings(separator: str, oas: Array[OntologyAnnotation]) -> dict[str, Any]:
+    first: bool = True
+    def _arrow1594(x: OntologyAnnotation, y: OntologyAnnotation, separator: Any=separator, oas: Any=oas) -> bool:
+        return equals(x, y)
+
+    if equals_with(_arrow1594, oas, []):
+        return {
+            "TermAccessionNumberAgg": "",
+            "TermNameAgg": "",
+            "TermSourceREFAgg": ""
+        }
+
+    else: 
+        def folder(tupled_arg: tuple[str, str, str], term: OntologyAnnotation, separator: Any=separator, oas: Any=oas) -> tuple[str, str, str]:
+            nonlocal first
+            match_value: str = default_arg(term.Name, "")
+            tsr: str = default_arg(term.TermSourceREF, "")
+            tan: str = default_arg(term.TermAccessionNumber, "")
+            name: str = match_value
+            if first:
+                first = False
+                return (name, tsr, tan)
+
+            else: 
+                return (to_text(printf("%s%c%s"))(tupled_arg[0])(separator)(name), to_text(printf("%s%c%s"))(tupled_arg[1])(separator)(tsr), to_text(printf("%s%c%s"))(tupled_arg[2])(separator)(tan))
+
+
+        tupled_arg_1: tuple[str, str, str] = fold(folder, ("", "", ""), oas)
+        return {
+            "TermAccessionNumberAgg": tupled_arg_1[2],
+            "TermNameAgg": tupled_arg_1[0],
+            "TermSourceREFAgg": tupled_arg_1[1]
+        }
+
+
+
+def Component_fromAggregatedStrings(separator: str, names: str, terms: str, source: str, accessions: str) -> FSharpList[Component]:
+    l: int = OntologyAnnotation_getLengthOfAggregatedStrings(separator, [names, terms, source, accessions]) or 0
+    if l == 0:
+        return empty()
+
+    else: 
+        def _arrow1595(a: str, b: str, c: str, d: str, separator: Any=separator, names: Any=names, terms: Any=terms, source: Any=source, accessions: Any=accessions) -> Component:
+            return Component_fromISAString_7C9A7CF8(a, b, c, d)
+
+        return of_array(Array_map4(_arrow1595, fill([0] * l, 0, l, "") if (names == "") else names.split(separator), fill([0] * l, 0, l, "") if (terms == "") else terms.split(separator), fill([0] * l, 0, l, "") if (source == "") else source.split(separator), fill([0] * l, 0, l, "") if (accessions == "") else accessions.split(separator)))
+
+
+
+def Component_toAggregatedStrings(separator: str, cs: FSharpList[Component]) -> dict[str, Any]:
+    first: bool = True
+    if equals(cs, empty()):
+        return {
+            "NameAgg": "",
+            "TermAccessionNumberAgg": "",
+            "TermNameAgg": "",
+            "TermSourceREFAgg": ""
+        }
+
+    else: 
+        def folder(tupled_arg: tuple[str, str, str, str], tupled_arg_1: tuple[str, dict[str, Any]], separator: Any=separator, cs: Any=cs) -> tuple[str, str, str, str]:
+            nonlocal first
+            name: str = tupled_arg_1[0]
+            term: dict[str, Any] = tupled_arg_1[1]
+            if first:
+                first = False
+                return (name, term["TermName"], term["TermSourceREF"], term["TermAccessionNumber"])
+
+            else: 
+                return (to_text(printf("%s%c%s"))(tupled_arg[0])(separator)(name), to_text(printf("%s%c%s"))(tupled_arg[1])(separator)(term["TermName"]), to_text(printf("%s%c%s"))(tupled_arg[2])(separator)(term["TermSourceREF"]), to_text(printf("%s%c%s"))(tupled_arg[3])(separator)(term["TermAccessionNumber"]))
+
+
+        def mapping(c: Component, separator: Any=separator, cs: Any=cs) -> tuple[str, dict[str, Any]]:
+            return Component_toStringObject_Z685B8F25(c)
+
+        tupled_arg_2: tuple[str, str, str, str] = fold_1(folder, ("", "", "", ""), map(mapping, cs))
+        return {
+            "NameAgg": tupled_arg_2[0],
+            "TermAccessionNumberAgg": tupled_arg_2[3],
+            "TermNameAgg": tupled_arg_2[1],
+            "TermSourceREFAgg": tupled_arg_2[2]
+        }
+
+
+
+def ProtocolParameter_fromAggregatedStrings(separator: str, terms: str, source: str, accessions: str) -> Array[ProtocolParameter]:
+    def f(arg: OntologyAnnotation, separator: Any=separator, terms: Any=terms, source: Any=source, accessions: Any=accessions) -> ProtocolParameter:
+        def f2(parameter_name: OntologyAnnotation | None=None, arg: Any=arg) -> ProtocolParameter:
+            return ProtocolParameter.make(None, parameter_name)
+
+        return f2(arg)
+
+    return ResizeArray_map(f, OntologyAnnotation_fromAggregatedStrings(separator, terms, source, accessions))
+
+
+def ProtocolParameter_toAggregatedStrings(separator: str, oas: FSharpList[ProtocolParameter]) -> dict[str, Any]:
+    first: bool = True
+    if equals(oas, empty()):
+        return {
+            "TermAccessionNumberAgg": "",
+            "TermNameAgg": "",
+            "TermSourceREFAgg": ""
+        }
+
+    else: 
+        def folder(tupled_arg: tuple[str, str, str], term: dict[str, Any], separator: Any=separator, oas: Any=oas) -> tuple[str, str, str]:
+            nonlocal first
+            if first:
+                first = False
+                return (term["TermName"], term["TermSourceREF"], term["TermAccessionNumber"])
+
+            else: 
+                return (to_text(printf("%s%c%s"))(tupled_arg[0])(separator)(term["TermName"]), to_text(printf("%s%c%s"))(tupled_arg[1])(separator)(term["TermSourceREF"]), to_text(printf("%s%c%s"))(tupled_arg[2])(separator)(term["TermAccessionNumber"]))
+
+
+        def mapping(pp: ProtocolParameter, separator: Any=separator, oas: Any=oas) -> dict[str, Any]:
+            return ProtocolParameter.to_string_object(pp)
+
+        tupled_arg_1: tuple[str, str, str] = fold_1(folder, ("", "", ""), map(mapping, oas))
+        return {
+            "TermAccessionNumberAgg": tupled_arg_1[2],
+            "TermNameAgg": tupled_arg_1[0],
+            "TermSourceREFAgg": tupled_arg_1[1]
+        }
+
+
+
+__all__ = ["Option_fromValueWithDefault", "Option_mapDefault", "OntologyAnnotation_getLengthOfAggregatedStrings", "OntologyAnnotation_fromAggregatedStrings", "OntologyAnnotation_toAggregatedStrings", "Component_fromAggregatedStrings", "Component_toAggregatedStrings", "ProtocolParameter_fromAggregatedStrings", "ProtocolParameter_toAggregatedStrings"]
+