arctrl 3.0.0__py3-none-any.whl

arctrl/py/Spreadsheet/Metadata/design_descriptors.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from ...fable_modules.fable_library.list import (of_array, FSharpList)
+from ...fable_modules.fable_library.util import (IEnumerable_1, IEnumerator)
+from ...Core.comment import Remark
+from ...Core.ontology_annotation import OntologyAnnotation
+from .ontology_annotation import (from_sparse_table as from_sparse_table_1, to_sparse_table as to_sparse_table_1, from_rows as from_rows_1, to_rows as to_rows_1)
+from .sparse_table import SparseTable
+
+design_type_label: str = "Type"
+
+design_type_term_accession_number_label: str = "Type Term Accession Number"
+
+design_type_term_source_reflabel: str = "Type Term Source REF"
+
+labels: FSharpList[str] = of_array([design_type_label, design_type_term_accession_number_label, design_type_term_source_reflabel])
+
+def from_sparse_table(matrix: SparseTable) -> FSharpList[OntologyAnnotation]:
+    return from_sparse_table_1(design_type_label, design_type_term_source_reflabel, design_type_term_accession_number_label, matrix)
+
+
+def to_sparse_table(designs: FSharpList[OntologyAnnotation]) -> SparseTable:
+    return to_sparse_table_1(design_type_label, design_type_term_source_reflabel, design_type_term_accession_number_label, designs)
+
+
+def from_rows(prefix: str | None, line_number: int, rows: IEnumerator[IEnumerable_1[tuple[int, str]]]) -> tuple[str | None, int, FSharpList[Remark], FSharpList[OntologyAnnotation]]:
+    return from_rows_1(prefix, design_type_label, design_type_term_source_reflabel, design_type_term_accession_number_label, line_number, rows)
+
+
+def to_rows(prefix: str | None, designs: FSharpList[OntologyAnnotation]) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    return to_rows_1(prefix, design_type_label, design_type_term_source_reflabel, design_type_term_accession_number_label, designs)
+
+
+__all__ = ["design_type_label", "design_type_term_accession_number_label", "design_type_term_source_reflabel", "labels", "from_sparse_table", "to_sparse_table", "from_rows", "to_rows"]
+

arctrl/py/Spreadsheet/Metadata/factors.py

@@ -0,0 +1,107 @@
+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.Helper.collections_ import (Option_fromValueWithDefault, ResizeArray_iter)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Process.factor import Factor
+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)
+
+name_label: str = "Name"
+
+factor_type_label: str = "Type"
+
+type_term_accession_number_label: str = "Type Term Accession Number"
+
+type_term_source_reflabel: str = "Type Term Source REF"
+
+labels: FSharpList[str] = of_array([name_label, factor_type_label, type_term_accession_number_label, type_term_source_reflabel])
+
+def from_string(name: str | None, design_type: str | None, type_term_source_ref: str | None, type_term_accession_number: str | None, comments: Array[Comment]) -> Factor:
+    factor_type: OntologyAnnotation = OntologyAnnotation.create(design_type, type_term_source_ref, type_term_accession_number)
+    factor_type_1: OntologyAnnotation | None = Option_fromValueWithDefault(OntologyAnnotation(), factor_type)
+    comments_1: Array[Comment] | None = Option_fromValueWithDefault([], comments)
+    return Factor.make(name, factor_type_1, comments_1)
+
+
+def from_sparse_table(matrix: SparseTable) -> FSharpList[Factor]:
+    if (length(matrix.CommentKeys) != 0) if (matrix.ColumnCount == 0) else False:
+        comments: Array[Comment] = SparseTable_GetEmptyComments_3ECCA699(matrix)
+        return singleton(Factor.create(None, None, comments))
+
+    else: 
+        def _arrow1818(i: int, matrix: Any=matrix) -> Factor:
+            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, (name_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (factor_type_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (type_term_source_reflabel, i)), SparseTable__TryGetValue_11FD62A8(matrix, (type_term_accession_number_label, i)), comments_1)
+
+        return initialize(matrix.ColumnCount, _arrow1818)
+
+
+
+def to_sparse_table(factors: FSharpList[Factor]) -> SparseTable:
+    matrix: SparseTable = SparseTable_Create_Z2192E64B(None, labels, None, length(factors) + 1)
+    comment_keys: FSharpList[str] = empty()
+    def action(i: int, f: Factor, factors: Any=factors) -> None:
+        i_1: int = (i + 1) or 0
+        ft: dict[str, Any]
+        f_1: OntologyAnnotation = default_arg(f.FactorType, OntologyAnnotation())
+        ft = OntologyAnnotation.to_string_object(f_1, True)
+        add_to_dict(matrix.Matrix, (name_label, i_1), default_arg(f.Name, ""))
+        add_to_dict(matrix.Matrix, (factor_type_label, i_1), ft["TermName"])
+        add_to_dict(matrix.Matrix, (type_term_accession_number_label, i_1), ft["TermAccessionNumber"])
+        add_to_dict(matrix.Matrix, (type_term_source_reflabel, i_1), ft["TermSourceREF"])
+        match_value: Array[Comment] | None = f.Comments
+        if match_value is not None:
+            def f_2(comment: Comment, i: Any=i, f: Any=f) -> 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_2, match_value)
+
+
+    iterate_indexed(action, factors)
+    class ObjectExpr1820:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1819(x: str, y: str) -> bool:
+                return x == y
+
+            return _arrow1819
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    return SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(comment_keys, ObjectExpr1820())), 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[Factor]]:
+    tupled_arg: tuple[str | None, int, FSharpList[Remark], SparseTable] = SparseTable_FromRows_Z5579EC29(rows, labels, line_number) if (prefix is None) else 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, factors: FSharpList[Factor]) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    m: SparseTable = to_sparse_table(factors)
+    if prefix is None:
+        return SparseTable_ToRows_759CAFC1(m)
+
+    else: 
+        return SparseTable_ToRows_759CAFC1(m, prefix)
+
+
+
+__all__ = ["name_label", "factor_type_label", "type_term_accession_number_label", "type_term_source_reflabel", "labels", "from_string", "from_sparse_table", "to_sparse_table", "from_rows", "to_rows"]
+

arctrl/py/Spreadsheet/Metadata/ontology_annotation.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.fable_library.list import (length, singleton, initialize, map, FSharpList, of_array, empty, iterate_indexed, cons, reverse)
+from ...fable_modules.fable_library.map_util import add_to_dict
+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.Helper.collections_ import ResizeArray_iter
+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)
+
+def from_sparse_table(label: str, label_tsr: str, label_tan: str, matrix: SparseTable) -> FSharpList[OntologyAnnotation]:
+    if (length(matrix.CommentKeys) != 0) if (matrix.ColumnCount == 0) else False:
+        comments: Array[Comment] = SparseTable_GetEmptyComments_3ECCA699(matrix)
+        def _arrow1800(__unit: None=None, label: Any=label, label_tsr: Any=label_tsr, label_tan: Any=label_tan, matrix: Any=matrix) -> OntologyAnnotation:
+            return_val: OntologyAnnotation = OntologyAnnotation.create()
+            return_val.Comments = comments
+            return return_val
+
+        return singleton(_arrow1800())
+
+    else: 
+        def _arrow1801(i: int, label: Any=label, label_tsr: Any=label_tsr, label_tan: Any=label_tan, matrix: Any=matrix) -> OntologyAnnotation:
+            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 OntologyAnnotation(SparseTable__TryGetValue_11FD62A8(matrix, (label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (label_tsr, i)), SparseTable__TryGetValue_11FD62A8(matrix, (label_tan, i)), comments_1)
+
+        return initialize(matrix.ColumnCount, _arrow1801)
+
+
+
+def to_sparse_table(label: str, label_tsr: str, label_tan: str, designs: FSharpList[OntologyAnnotation]) -> SparseTable:
+    matrix: SparseTable = SparseTable_Create_Z2192E64B(None, of_array([label, label_tan, label_tsr]), None, length(designs) + 1)
+    comment_keys: FSharpList[str] = empty()
+    def action(i: int, d: OntologyAnnotation, label: Any=label, label_tsr: Any=label_tsr, label_tan: Any=label_tan, designs: Any=designs) -> None:
+        i_1: int = (i + 1) or 0
+        oa: dict[str, Any] = OntologyAnnotation.to_string_object(d, True)
+        add_to_dict(matrix.Matrix, (label, i_1), oa["TermName"])
+        add_to_dict(matrix.Matrix, (label_tan, i_1), oa["TermAccessionNumber"])
+        add_to_dict(matrix.Matrix, (label_tsr, i_1), oa["TermSourceREF"])
+        def f(comment: Comment, i: Any=i, d: Any=d) -> 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, d.Comments)
+
+    iterate_indexed(action, designs)
+    class ObjectExpr1803:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1802(x: str, y: str) -> bool:
+                return x == y
+
+            return _arrow1802
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    return SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(comment_keys, ObjectExpr1803())), matrix.ColumnCount)
+
+
+def from_rows(prefix: str | None, label: str, label_tsr: str, label_tan: str, line_number: int, rows: IEnumerator[IEnumerable_1[tuple[int, str]]]) -> tuple[str | None, int, FSharpList[Remark], FSharpList[OntologyAnnotation]]:
+    labels: FSharpList[str] = of_array([label, label_tan, label_tsr])
+    tupled_arg: tuple[str | None, int, FSharpList[Remark], SparseTable] = SparseTable_FromRows_Z5579EC29(rows, labels, line_number) if (prefix is None) else SparseTable_FromRows_Z5579EC29(rows, labels, line_number, prefix)
+    return (tupled_arg[0], tupled_arg[1], tupled_arg[2], from_sparse_table(label, label_tsr, label_tan, tupled_arg[3]))
+
+
+def to_rows(prefix: str | None, label: str, label_tsr: str, label_tan: str, designs: FSharpList[OntologyAnnotation]) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    m: SparseTable = to_sparse_table(label, label_tsr, label_tan, designs)
+    if prefix is None:
+        return SparseTable_ToRows_759CAFC1(m)
+
+    else: 
+        return SparseTable_ToRows_759CAFC1(m, prefix)
+
+
+
+__all__ = ["from_sparse_table", "to_sparse_table", "from_rows", "to_rows"]
+

arctrl/py/Spreadsheet/Metadata/ontology_source_reference.py

@@ -0,0 +1,96 @@
+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.Helper.collections_ import ResizeArray_iter
+from ...Core.ontology_source_reference import OntologySourceReference
+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)
+
+name_label: str = "Term Source Name"
+
+file_label: str = "Term Source File"
+
+version_label: str = "Term Source Version"
+
+description_label: str = "Term Source Description"
+
+labels: FSharpList[str] = of_array([name_label, file_label, version_label, description_label])
+
+def from_string(description: str | None, file: str | None, name: str | None, version: str | None, comments: Array[Comment]) -> OntologySourceReference:
+    return OntologySourceReference.make(description, file, name, version, comments)
+
+
+def from_sparse_table(matrix: SparseTable) -> FSharpList[OntologySourceReference]:
+    if (length(matrix.CommentKeys) != 0) if (matrix.ColumnCount == 0) else False:
+        comments: Array[Comment] = SparseTable_GetEmptyComments_3ECCA699(matrix)
+        def _arrow1856(__unit: None=None, matrix: Any=matrix) -> OntologySourceReference:
+            return_val: OntologySourceReference = OntologySourceReference.create()
+            return_val.Comments = comments
+            return return_val
+
+        return singleton(_arrow1856())
+
+    else: 
+        def _arrow1857(i: int, matrix: Any=matrix) -> OntologySourceReference:
+            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, (description_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (file_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (name_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (version_label, i)), comments_1)
+
+        return initialize(matrix.ColumnCount, _arrow1857)
+
+
+
+def to_sparse_table(ontology_sources: FSharpList[OntologySourceReference]) -> SparseTable:
+    matrix: SparseTable = SparseTable_Create_Z2192E64B(None, labels, None, length(ontology_sources) + 1)
+    comment_keys: FSharpList[str] = empty()
+    def action(i: int, o: OntologySourceReference, ontology_sources: Any=ontology_sources) -> None:
+        i_1: int = (i + 1) or 0
+        add_to_dict(matrix.Matrix, (name_label, i_1), default_arg(o.Name, ""))
+        add_to_dict(matrix.Matrix, (file_label, i_1), default_arg(o.File, ""))
+        add_to_dict(matrix.Matrix, (version_label, i_1), default_arg(o.Version, ""))
+        add_to_dict(matrix.Matrix, (description_label, i_1), default_arg(o.Description, ""))
+        def f(comment: Comment, i: Any=i, o: Any=o) -> 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, o.Comments)
+
+    iterate_indexed(action, ontology_sources)
+    class ObjectExpr1859:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1858(x: str, y: str) -> bool:
+                return x == y
+
+            return _arrow1858
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    return SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(comment_keys, ObjectExpr1859())), matrix.ColumnCount)
+
+
+def from_rows(line_number: int, rows: IEnumerator[IEnumerable_1[tuple[int, str]]]) -> tuple[str | None, int, FSharpList[Remark], FSharpList[OntologySourceReference]]:
+    tupled_arg: tuple[str | None, int, FSharpList[Remark], SparseTable] = SparseTable_FromRows_Z5579EC29(rows, labels, line_number)
+    return (tupled_arg[0], tupled_arg[1], tupled_arg[2], from_sparse_table(tupled_arg[3]))
+
+
+def to_rows(term_sources: FSharpList[OntologySourceReference]) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    return SparseTable_ToRows_759CAFC1(to_sparse_table(term_sources))
+
+
+__all__ = ["name_label", "file_label", "version_label", "description_label", "labels", "from_string", "from_sparse_table", "to_sparse_table", "from_rows", "to_rows"]
+

arctrl/py/Spreadsheet/Metadata/protocols.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.fable_library.list import (of_array, FSharpList, of_seq, empty, length, singleton, initialize, map as map_1, iterate_indexed, iterate, 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.util import (string_hash, IEnumerable_1, IEnumerator)
+from ...Core.comment import (Comment, Remark)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.Process.component import Component
+from ...Core.Process.protocol import (Protocol_make, Protocol, Protocol_create_Z414665E7)
+from ...Core.Process.protocol_parameter import ProtocolParameter
+from ...Core.uri import URIModule_fromString
+from .comment import (Comment_fromString, Comment_toString)
+from .conversions import (ProtocolParameter_fromAggregatedStrings, Component_fromAggregatedStrings, Option_fromValueWithDefault, ProtocolParameter_toAggregatedStrings, Component_toAggregatedStrings)
+from .sparse_table import (SparseTable_GetEmptyComments_3ECCA699, SparseTable__TryGetValueDefault_5BAE6133, SparseTable__TryGetValue_11FD62A8, SparseTable, SparseTable_Create_Z2192E64B, SparseTable_FromRows_Z5579EC29, SparseTable_ToRows_759CAFC1)
+
+name_label: str = "Name"
+
+protocol_type_label: str = "Type"
+
+type_term_accession_number_label: str = "Type Term Accession Number"
+
+type_term_source_reflabel: str = "Type Term Source REF"
+
+description_label: str = "Description"
+
+uri_label: str = "URI"
+
+version_label: str = "Version"
+
+parameters_name_label: str = "Parameters Name"
+
+parameters_term_accession_number_label: str = "Parameters Term Accession Number"
+
+parameters_term_source_reflabel: str = "Parameters Term Source REF"
+
+components_name_label: str = "Components Name"
+
+components_type_label: str = "Components Type"
+
+components_type_term_accession_number_label: str = "Components Type Term Accession Number"
+
+components_type_term_source_reflabel: str = "Components Type Term Source REF"
+
+labels: FSharpList[str] = of_array([name_label, protocol_type_label, type_term_accession_number_label, type_term_source_reflabel, description_label, uri_label, version_label, parameters_name_label, parameters_term_accession_number_label, parameters_term_source_reflabel, components_name_label, components_type_label, components_type_term_accession_number_label, components_type_term_source_reflabel])
+
+def from_string(name: str | None, protocol_type: str | None, type_term_accession_number: str | None, type_term_source_ref: str | None, description: str | None, uri: str | None, version: str | None, parameters_name: str, parameters_term_accession_number: str, parameters_term_source_ref: str, components_name: str, components_type: str, components_type_term_accession_number: str, components_type_term_source_ref: str, comments: FSharpList[Comment]) -> Protocol:
+    protocol_type_1: OntologyAnnotation = OntologyAnnotation.create(protocol_type, type_term_source_ref, type_term_accession_number)
+    parameters: FSharpList[ProtocolParameter] = of_seq(ProtocolParameter_fromAggregatedStrings(";", parameters_name, parameters_term_source_ref, parameters_term_accession_number))
+    components: FSharpList[Component] = Component_fromAggregatedStrings(";", components_name, components_type, components_type_term_source_ref, components_type_term_accession_number)
+    def _arrow1821(s: str, name: Any=name, protocol_type: Any=protocol_type, type_term_accession_number: Any=type_term_accession_number, type_term_source_ref: Any=type_term_source_ref, description: Any=description, uri: Any=uri, version: Any=version, parameters_name: Any=parameters_name, parameters_term_accession_number: Any=parameters_term_accession_number, parameters_term_source_ref: Any=parameters_term_source_ref, components_name: Any=components_name, components_type: Any=components_type, components_type_term_accession_number: Any=components_type_term_accession_number, components_type_term_source_ref: Any=components_type_term_source_ref, comments: Any=comments) -> str:
+        return URIModule_fromString(s)
+
+    def _arrow1822(s_1: str, name: Any=name, protocol_type: Any=protocol_type, type_term_accession_number: Any=type_term_accession_number, type_term_source_ref: Any=type_term_source_ref, description: Any=description, uri: Any=uri, version: Any=version, parameters_name: Any=parameters_name, parameters_term_accession_number: Any=parameters_term_accession_number, parameters_term_source_ref: Any=parameters_term_source_ref, components_name: Any=components_name, components_type: Any=components_type, components_type_term_accession_number: Any=components_type_term_accession_number, components_type_term_source_ref: Any=components_type_term_source_ref, comments: Any=comments) -> str:
+        return URIModule_fromString(s_1)
+
+    return Protocol_make(None, map(_arrow1821, name), Option_fromValueWithDefault(OntologyAnnotation(), protocol_type_1), description, map(_arrow1822, uri), version, Option_fromValueWithDefault(empty(), parameters), Option_fromValueWithDefault(empty(), components), Option_fromValueWithDefault(empty(), comments))
+
+
+def from_sparse_table(matrix: SparseTable) -> FSharpList[Protocol]:
+    if (length(matrix.CommentKeys) != 0) if (matrix.ColumnCount == 0) else False:
+        return singleton(Protocol_create_Z414665E7(None, None, None, None, None, None, None, None, of_seq(SparseTable_GetEmptyComments_3ECCA699(matrix))))
+
+    else: 
+        def _arrow1823(i: int, matrix: Any=matrix) -> Protocol:
+            def mapping(k: str) -> Comment:
+                return Comment_fromString(k, SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (k, i)))
+
+            comments_1: FSharpList[Comment] = map_1(mapping, matrix.CommentKeys)
+            return from_string(SparseTable__TryGetValue_11FD62A8(matrix, (name_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (protocol_type_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (type_term_accession_number_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (type_term_source_reflabel, i)), SparseTable__TryGetValue_11FD62A8(matrix, (description_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (uri_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (version_label, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (parameters_name_label, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (parameters_term_accession_number_label, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (parameters_term_source_reflabel, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (components_name_label, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (components_type_label, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (components_type_term_accession_number_label, i)), SparseTable__TryGetValueDefault_5BAE6133(matrix, "", (components_type_term_source_reflabel, i)), comments_1)
+
+        return initialize(matrix.ColumnCount, _arrow1823)
+
+
+
+def to_sparse_table(protocols: FSharpList[Protocol]) -> SparseTable:
+    matrix: SparseTable = SparseTable_Create_Z2192E64B(None, labels, None, length(protocols) + 1)
+    comment_keys: FSharpList[str] = empty()
+    def action_1(i: int, p: Protocol, protocols: Any=protocols) -> None:
+        i_1: int = (i + 1) or 0
+        pt_1: dict[str, Any]
+        pt: OntologyAnnotation = default_arg(p.ProtocolType, OntologyAnnotation())
+        pt_1 = OntologyAnnotation.to_string_object(pt, True)
+        p_agg: dict[str, Any] = ProtocolParameter_toAggregatedStrings(";", default_arg(p.Parameters, empty()))
+        c_agg: dict[str, Any] = Component_toAggregatedStrings(";", default_arg(p.Components, empty()))
+        add_to_dict(matrix.Matrix, (name_label, i_1), default_arg(p.Name, ""))
+        add_to_dict(matrix.Matrix, (protocol_type_label, i_1), pt_1["TermName"])
+        add_to_dict(matrix.Matrix, (type_term_accession_number_label, i_1), pt_1["TermAccessionNumber"])
+        add_to_dict(matrix.Matrix, (type_term_source_reflabel, i_1), pt_1["TermSourceREF"])
+        add_to_dict(matrix.Matrix, (description_label, i_1), default_arg(p.Description, ""))
+        add_to_dict(matrix.Matrix, (uri_label, i_1), default_arg(p.Uri, ""))
+        add_to_dict(matrix.Matrix, (version_label, i_1), default_arg(p.Version, ""))
+        add_to_dict(matrix.Matrix, (parameters_name_label, i_1), p_agg["TermNameAgg"])
+        add_to_dict(matrix.Matrix, (parameters_term_accession_number_label, i_1), p_agg["TermAccessionNumberAgg"])
+        add_to_dict(matrix.Matrix, (parameters_term_source_reflabel, i_1), p_agg["TermSourceREFAgg"])
+        add_to_dict(matrix.Matrix, (components_name_label, i_1), c_agg["NameAgg"])
+        add_to_dict(matrix.Matrix, (components_type_label, i_1), c_agg["TermNameAgg"])
+        add_to_dict(matrix.Matrix, (components_type_term_accession_number_label, i_1), c_agg["TermAccessionNumberAgg"])
+        add_to_dict(matrix.Matrix, (components_type_term_source_reflabel, i_1), c_agg["TermSourceREFAgg"])
+        match_value: FSharpList[Comment] | None = p.Comments
+        if match_value is not None:
+            def action(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])
+
+            iterate(action, match_value)
+
+
+    iterate_indexed(action_1, protocols)
+    class ObjectExpr1825:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1824(x: str, y: str) -> bool:
+                return x == y
+
+            return _arrow1824
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    return SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(comment_keys, ObjectExpr1825())), 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[Protocol]]:
+    tupled_arg: tuple[str | None, int, FSharpList[Remark], SparseTable] = SparseTable_FromRows_Z5579EC29(rows, labels, line_number) if (prefix is None) else 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, protocols: FSharpList[Protocol]) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    m: SparseTable = to_sparse_table(protocols)
+    if prefix is None:
+        return SparseTable_ToRows_759CAFC1(m)
+
+    else: 
+        return SparseTable_ToRows_759CAFC1(m, prefix)
+
+
+
+__all__ = ["name_label", "protocol_type_label", "type_term_accession_number_label", "type_term_source_reflabel", "description_label", "uri_label", "version_label", "parameters_name_label", "parameters_term_accession_number_label", "parameters_term_source_reflabel", "components_name_label", "components_type_label", "components_type_term_accession_number_label", "components_type_term_source_reflabel", "labels", "from_string", "from_sparse_table", "to_sparse_table", "from_rows", "to_rows"]
+

arctrl/py/Spreadsheet/Metadata/publication.py

@@ -0,0 +1,122 @@
+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.types import Array
+from ...fable_modules.fable_library.util import (string_hash, IEnumerable_1, IEnumerator)
+from ...Core.comment import (Comment, Remark)
+from ...Core.Helper.collections_ import (Option_fromValueWithDefault, ResizeArray_iter)
+from ...Core.ontology_annotation import OntologyAnnotation
+from ...Core.publication import Publication
+from ...Core.uri import URIModule_fromString
+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)
+
+pub_med_idlabel: str = "PubMed ID"
+
+doi_label: str = "DOI"
+
+author_list_label: str = "Author List"
+
+title_label: str = "Title"
+
+status_label: str = "Status"
+
+status_term_accession_number_label: str = "Status Term Accession Number"
+
+status_term_source_reflabel: str = "Status Term Source REF"
+
+labels: FSharpList[str] = of_array([pub_med_idlabel, doi_label, author_list_label, title_label, status_label, status_term_accession_number_label, status_term_source_reflabel])
+
+def from_string(pub_med_id: str | None, doi: str | None, author: str | None, title: str | None, status: str | None, status_term_source_ref: str | None, status_term_accession_number: str | None, comments: Array[Comment]) -> Publication:
+    status_1: OntologyAnnotation = OntologyAnnotation(status, status_term_source_ref, status_term_accession_number)
+    def _arrow1826(s: str, pub_med_id: Any=pub_med_id, doi: Any=doi, author: Any=author, title: Any=title, status: Any=status, status_term_source_ref: Any=status_term_source_ref, status_term_accession_number: Any=status_term_accession_number, comments: Any=comments) -> str:
+        return URIModule_fromString(s)
+
+    pub_med_id_1: str | None = map(_arrow1826, pub_med_id)
+    status_2: OntologyAnnotation | None = Option_fromValueWithDefault(OntologyAnnotation(), status_1)
+    return Publication.make(pub_med_id_1, doi, author, title, status_2, comments)
+
+
+def from_sparse_table(matrix: SparseTable) -> FSharpList[Publication]:
+    if (length(matrix.CommentKeys) != 0) if (matrix.ColumnCount == 0) else False:
+        comments: Array[Comment] = SparseTable_GetEmptyComments_3ECCA699(matrix)
+        def _arrow1827(__unit: None=None, matrix: Any=matrix) -> Publication:
+            return_val: Publication = Publication.create()
+            return_val.Comments = comments
+            return return_val
+
+        return singleton(_arrow1827())
+
+    else: 
+        def _arrow1828(i: int, matrix: Any=matrix) -> Publication:
+            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, (pub_med_idlabel, i)), SparseTable__TryGetValue_11FD62A8(matrix, (doi_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (author_list_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (title_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (status_label, i)), SparseTable__TryGetValue_11FD62A8(matrix, (status_term_source_reflabel, i)), SparseTable__TryGetValue_11FD62A8(matrix, (status_term_accession_number_label, i)), comments_1)
+
+        return initialize(matrix.ColumnCount, _arrow1828)
+
+
+
+def to_sparse_table(publications: FSharpList[Publication]) -> SparseTable:
+    matrix: SparseTable = SparseTable_Create_Z2192E64B(None, labels, None, length(publications) + 1)
+    comment_keys: FSharpList[str] = empty()
+    def action(i: int, p: Publication, publications: Any=publications) -> None:
+        i_1: int = (i + 1) or 0
+        s_1: dict[str, Any]
+        s: OntologyAnnotation = default_arg(p.Status, OntologyAnnotation())
+        s_1 = OntologyAnnotation.to_string_object(s, True)
+        add_to_dict(matrix.Matrix, (pub_med_idlabel, i_1), default_arg(p.PubMedID, ""))
+        add_to_dict(matrix.Matrix, (doi_label, i_1), default_arg(p.DOI, ""))
+        add_to_dict(matrix.Matrix, (author_list_label, i_1), default_arg(p.Authors, ""))
+        add_to_dict(matrix.Matrix, (title_label, i_1), default_arg(p.Title, ""))
+        add_to_dict(matrix.Matrix, (status_label, i_1), s_1["TermName"])
+        add_to_dict(matrix.Matrix, (status_term_accession_number_label, i_1), s_1["TermAccessionNumber"])
+        add_to_dict(matrix.Matrix, (status_term_source_reflabel, i_1), s_1["TermSourceREF"])
+        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)
+
+    iterate_indexed(action, publications)
+    class ObjectExpr1830:
+        @property
+        def Equals(self) -> Callable[[str, str], bool]:
+            def _arrow1829(x: str, y: str) -> bool:
+                return x == y
+
+            return _arrow1829
+
+        @property
+        def GetHashCode(self) -> Callable[[str], int]:
+            return string_hash
+
+    return SparseTable(matrix.Matrix, matrix.Keys, reverse(List_distinct(comment_keys, ObjectExpr1830())), 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[Publication]]:
+    tupled_arg: tuple[str | None, int, FSharpList[Remark], SparseTable] = SparseTable_FromRows_Z5579EC29(rows, labels, line_number) if (prefix is None) else 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, publications: FSharpList[Publication]) -> IEnumerable_1[IEnumerable_1[tuple[int, str]]]:
+    m: SparseTable = to_sparse_table(publications)
+    if prefix is None:
+        return SparseTable_ToRows_759CAFC1(m)
+
+    else: 
+        return SparseTable_ToRows_759CAFC1(m, prefix)
+
+
+
+__all__ = ["pub_med_idlabel", "doi_label", "author_list_label", "title_label", "status_label", "status_term_accession_number_label", "status_term_source_reflabel", "labels", "from_string", "from_sparse_table", "to_sparse_table", "from_rows", "to_rows"]
+