arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/Spreadsheet/AnnotationTable/arc_table.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.array_ import map as map_1
+from ...fable_modules.fable_library.list import (reverse, map, FSharpList, fold, singleton, cons, is_empty, head, tail, empty, of_array, to_array, exists, collect as collect_1, sort_by, length, 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.reflection import enum_type
+from ...fable_modules.fable_library.seq import (try_find, to_array as to_array_1, delay, map as map_2, collect, singleton as singleton_1, fold as fold_1)
+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, compare_primitives, max)
+from ...fable_modules.fs_spreadsheet.Cells.fs_cell import FsCell
+from ...fable_modules.fs_spreadsheet.Cells.fs_cells_collection import (FsCellsCollection__TryGetCell_Z37302880, Dictionary_tryGet)
+from ...fable_modules.fs_spreadsheet.fs_address import (FsAddress__get_RowNumber, FsAddress__get_ColumnNumber, FsAddress__ctor_Z37302880, FsAddress)
+from ...fable_modules.fs_spreadsheet.fs_worksheet import FsWorksheet
+from ...fable_modules.fs_spreadsheet.Ranges.fs_range_address import (FsRangeAddress__get_LastAddress, FsRangeAddress__ctor_7E77A4A0)
+from ...fable_modules.fs_spreadsheet.Ranges.fs_range_base import (FsRangeBase__get_RangeAddress, FsRangeBase__Cell_Z3407A44B)
+from ...fable_modules.fs_spreadsheet.Tables.fs_table import FsTable
+from ...Core.Table.arc_table import ArcTable
+from ...Core.Table.composite_column import CompositeColumn
+from ...Core.Table.composite_header import CompositeHeader
+from .composite_column import (from_string_cell_columns, fix_deprecated_ioheader, to_string_cell_columns)
+
+__A = TypeVar("__A")
+
+def Aux_List_groupWhen(f: Callable[[__A], bool], list_1: FSharpList[Any]) -> FSharpList[FSharpList[Any]]:
+    def mapping(list_3: FSharpList[__A], f: Any=f, list_1: Any=list_1) -> FSharpList[__A]:
+        return reverse(list_3)
+
+    def folder(acc: FSharpList[FSharpList[__A]], e: __A, f: Any=f, list_1: Any=list_1) -> FSharpList[FSharpList[__A]]:
+        match_value: bool = f(e)
+        if match_value:
+            return cons(singleton(e), acc)
+
+        elif not is_empty(acc):
+            return cons(cons(e, head(acc)), tail(acc))
+
+        else: 
+            return singleton(singleton(e))
+
+
+    return reverse(map(mapping, fold(folder, empty(), list_1)))
+
+
+def classify_header_order(header: CompositeHeader) -> enum_type("ARCtrl.Spreadsheet.ArcTable.ColumnOrder", int, [("InputClass", 1.0), ("ProtocolClass", 2.0), ("ParamsClass", 3.0), ("OutputClass", 4.0)]):
+    if ((((((header.tag == 4) or (header.tag == 5)) or (header.tag == 6)) or (header.tag == 7)) or (header.tag == 8)) or (header.tag == 9)) or (header.tag == 10):
+        return 2
+
+    elif (((((header.tag == 0) or (header.tag == 1)) or (header.tag == 2)) or (header.tag == 3)) or (header.tag == 14)) or (header.tag == 13):
+        return 3
+
+    elif header.tag == 12:
+        return 4
+
+    else: 
+        return 1
+
+
+
+def classify_column_order(column: CompositeColumn) -> enum_type("ARCtrl.Spreadsheet.ArcTable.ColumnOrder", int, [("InputClass", 1.0), ("ProtocolClass", 2.0), ("ParamsClass", 3.0), ("OutputClass", 4.0)]):
+    return classify_header_order(column.Header)
+
+
+helper_column_strings: FSharpList[str] = of_array(["Term Source REF", "Term Accession Number", "Unit", "Data Format", "Data Selector Format"])
+
+def group_columns_by_header(string_cell_columns: Array[Array[str]]) -> Array[Array[Array[str]]]:
+    def mapping(list_4: FSharpList[Array[str]], string_cell_columns: Any=string_cell_columns) -> Array[Array[str]]:
+        return to_array(list_4)
+
+    def f(c: Array[str], string_cell_columns: Any=string_cell_columns) -> bool:
+        v: str = c[0]
+        def predicate(s: str, c: Any=c) -> bool:
+            return starts_with_exact(v, s)
+
+        return not exists(predicate, helper_column_strings)
+
+    return map_1(mapping, to_array(Aux_List_groupWhen(f, of_array(string_cell_columns))), None)
+
+
+def try_annotation_table(sheet: FsWorksheet) -> FsTable | None:
+    def predicate(t: FsTable, sheet: Any=sheet) -> bool:
+        return starts_with_exact(t.Name, "annotationTable")
+
+    return try_find(predicate, sheet.Tables)
+
+
+def compose_columns(string_cell_columns: Array[Array[str]]) -> Array[CompositeColumn]:
+    def _arrow1329(columns: Array[Array[str]], string_cell_columns: Any=string_cell_columns) -> CompositeColumn:
+        return from_string_cell_columns(columns)
+
+    return map_1(_arrow1329, group_columns_by_header(string_cell_columns), None)
+
+
+def try_from_fs_worksheet(sheet: FsWorksheet) -> ArcTable | None:
+    try: 
+        match_value: FsTable | None = try_annotation_table(sheet)
+        if match_value is None:
+            return None
+
+        else: 
+            t: FsTable = match_value
+            def _arrow1333(__unit: None=None) -> IEnumerable_1[Array[str]]:
+                def _arrow1332(c: int) -> Array[str]:
+                    def _arrow1331(__unit: None=None) -> IEnumerable_1[str]:
+                        def _arrow1330(r: int) -> IEnumerable_1[str]:
+                            match_value_1: FsCell | None = FsCellsCollection__TryGetCell_Z37302880(sheet.CellCollection, r, c)
+                            if match_value_1 is None:
+                                return singleton_1("")
+
+                            else: 
+                                cell: FsCell = match_value_1
+                                return singleton_1(cell.ValueAsString())
+
+
+                        return collect(_arrow1330, range_big_int(1, 1, FsAddress__get_RowNumber(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(t)))))
+
+                    return to_array_1(delay(_arrow1331))
+
+                return map_2(_arrow1332, range_big_int(1, 1, FsAddress__get_ColumnNumber(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(t)))))
+
+            composite_columns: Array[CompositeColumn] = compose_columns(map_1(fix_deprecated_ioheader, to_array_1(delay(_arrow1333)), None))
+            return ArcTable.add_columns(composite_columns, None, True)(ArcTable.init(sheet.Name))
+
+
+    except Exception as err:
+        arg: str = sheet.Name
+        arg_1: str = str(err)
+        return to_fail(printf("Could not parse table with name \"%s\":\n%s"))(arg)(arg_1)
+
+
+
+def to_fs_worksheet(index: int | None, table: ArcTable) -> FsWorksheet:
+    string_count: Any = dict([])
+    ws: FsWorksheet = FsWorksheet(table.Name)
+    if table.ColumnCount == 0:
+        return ws
+
+    else: 
+        def _arrow1334(column_1: CompositeColumn, index: Any=index, table: Any=table) -> FSharpList[FSharpList[str]]:
+            return to_string_cell_columns(column_1)
+
+        def _arrow1335(column: CompositeColumn, index: Any=index, table: Any=table) -> enum_type("ARCtrl.Spreadsheet.ArcTable.ColumnOrder", int, [("InputClass", 1.0), ("ProtocolClass", 2.0), ("ParamsClass", 3.0), ("OutputClass", 4.0)]):
+            return classify_column_order(column)
+
+        class ObjectExpr1336:
+            @property
+            def Compare(self) -> Callable[[enum_type("ARCtrl.Spreadsheet.ArcTable.ColumnOrder", int, [("InputClass", 1.0), ("ProtocolClass", 2.0), ("ParamsClass", 3.0), ("OutputClass", 4.0)]), enum_type("ARCtrl.Spreadsheet.ArcTable.ColumnOrder", int, [("InputClass", 1.0), ("ProtocolClass", 2.0), ("ParamsClass", 3.0), ("OutputClass", 4.0)])], int]:
+                return compare_primitives
+
+        columns: FSharpList[FSharpList[str]] = collect_1(_arrow1334, sort_by(_arrow1335, of_array(table.Columns), ObjectExpr1336()))
+        table_row_count: int
+        def folder(acc: int, c: FSharpList[str], index: Any=index, table: Any=table) -> int:
+            def _arrow1337(x_1: int, y_1: int, acc: Any=acc, c: Any=c) -> int:
+                return compare_primitives(x_1, y_1)
+
+            return max(_arrow1337, acc, length(c))
+
+        max_row: int = fold_1(folder, 0, columns) or 0
+        table_row_count = 2 if (max_row == 1) else max_row
+        table_column_count: int = length(columns) or 0
+        name: str = "annotationTable" if (index is None) else (((("" + "annotationTable") + "") + str(index)) + "")
+        fs_table: FsTable = ws.Table(name, FsRangeAddress__ctor_7E77A4A0(FsAddress__ctor_Z37302880(1, 1), FsAddress__ctor_Z37302880(table_row_count, table_column_count)))
+        def action_1(col_i: int, col: FSharpList[str], index: Any=index, table: Any=table) -> None:
+            def action(row_i: int, string_cell: str, col_i: Any=col_i, col: Any=col) -> None:
+                value: str
+                if row_i == 0:
+                    match_value: str | None = Dictionary_tryGet(string_cell, string_count)
+                    if match_value is None:
+                        add_to_dict(string_count, string_cell, "")
+                        value = string_cell
+
+                    else: 
+                        spaces: str = match_value
+                        string_count[string_cell] = spaces + " "
+                        value = (string_cell + " ") + spaces
+
+
+                else: 
+                    value = string_cell
+
+                address: FsAddress = FsAddress__ctor_Z37302880(row_i + 1, col_i + 1)
+                FsRangeBase__Cell_Z3407A44B(fs_table, address, ws.CellCollection).SetValueAs(value)
+
+            iterate_indexed(action, col)
+
+        iterate_indexed(action_1, columns)
+        return ws
+
+
+
+__all__ = ["Aux_List_groupWhen", "classify_header_order", "classify_column_order", "helper_column_strings", "group_columns_by_header", "try_annotation_table", "compose_columns", "try_from_fs_worksheet", "to_fs_worksheet"]
+

arctrl/py/Spreadsheet/AnnotationTable/composite_cell.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_modules.fable_library.option import (map, bind, default_arg)
+from ...fable_modules.fable_library.types import Array
+from ...Core.Helper.collections_ import Option_fromValueWithDefault
+from ...Core.Table.composite_cell import CompositeCell
+
+def term_from_string_cells(tsr_col: int | None, tan_col: int | None, cell_values: Array[str]) -> CompositeCell:
+    def _arrow1242(i: int, tsr_col: Any=tsr_col, tan_col: Any=tan_col, cell_values: Any=cell_values) -> str:
+        return cell_values[i]
+
+    tan: str | None = map(_arrow1242, tan_col)
+    def _arrow1243(i_1: int, tsr_col: Any=tsr_col, tan_col: Any=tan_col, cell_values: Any=cell_values) -> str:
+        return cell_values[i_1]
+
+    tsr: str | None = map(_arrow1243, tsr_col)
+    return CompositeCell.create_term_from_string(cell_values[0], tsr, tan)
+
+
+def unitized_from_string_cells(unit_col: int, tsr_col: int | None, tan_col: int | None, cell_values: Array[str]) -> CompositeCell:
+    unit: str = cell_values[unit_col]
+    def _arrow1244(i: int, unit_col: Any=unit_col, tsr_col: Any=tsr_col, tan_col: Any=tan_col, cell_values: Any=cell_values) -> str:
+        return cell_values[i]
+
+    tan: str | None = map(_arrow1244, tan_col)
+    def _arrow1245(i_1: int, unit_col: Any=unit_col, tsr_col: Any=tsr_col, tan_col: Any=tan_col, cell_values: Any=cell_values) -> str:
+        return cell_values[i_1]
+
+    tsr: str | None = map(_arrow1245, tsr_col)
+    return CompositeCell.create_unitized_from_string(cell_values[0], unit, tsr, tan)
+
+
+def free_text_from_string_cells(cell_values: Array[str]) -> CompositeCell:
+    return CompositeCell.create_free_text(cell_values[0])
+
+
+def data_from_string_cells(format: int | None, selector_format: int | None, cell_values: Array[str]) -> CompositeCell:
+    def _arrow1246(i: int, format: Any=format, selector_format: Any=selector_format, cell_values: Any=cell_values) -> str | None:
+        return Option_fromValueWithDefault("", cell_values[i])
+
+    format_1: str | None = bind(_arrow1246, format)
+    def _arrow1247(i_1: int, format: Any=format, selector_format: Any=selector_format, cell_values: Any=cell_values) -> str | None:
+        return Option_fromValueWithDefault("", cell_values[i_1])
+
+    selector_format_1: str | None = bind(_arrow1247, selector_format)
+    return CompositeCell.create_data_from_string(cell_values[0], format_1, selector_format_1)
+
+
+def to_string_cells(is_term: bool, has_unit: bool, cell: CompositeCell) -> Array[str]:
+    if cell.tag == 0:
+        if has_unit:
+            return [cell.fields[0].NameText, "", default_arg(cell.fields[0].TermSourceREF, ""), cell.fields[0].TermAccessionOntobeeUrl]
+
+        else: 
+            return [cell.fields[0].NameText, default_arg(cell.fields[0].TermSourceREF, ""), cell.fields[0].TermAccessionOntobeeUrl]
+
+
+    elif cell.tag == 2:
+        return [cell.fields[0], cell.fields[1].NameText, default_arg(cell.fields[1].TermSourceREF, ""), cell.fields[1].TermAccessionOntobeeUrl]
+
+    elif cell.tag == 3:
+        format: str = default_arg(cell.fields[0].Format, "")
+        selector_format: str = default_arg(cell.fields[0].SelectorFormat, "")
+        return [default_arg(cell.fields[0].Name, ""), format, selector_format]
+
+    elif has_unit:
+        return [cell.fields[0], "", "", ""]
+
+    elif is_term:
+        return [cell.fields[0], "", ""]
+
+    else: 
+        return [cell.fields[0]]
+
+
+
+__all__ = ["term_from_string_cells", "unitized_from_string_cells", "free_text_from_string_cells", "data_from_string_cells", "to_string_cells"]
+

arctrl/py/Spreadsheet/AnnotationTable/composite_column.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_modules.fable_library.array_ import (skip, map, try_item)
+from ...fable_modules.fable_library.list import (of_array, singleton as singleton_1, FSharpList, map as map_2)
+from ...fable_modules.fable_library.option import default_arg
+from ...fable_modules.fable_library.range import range_big_int
+from ...fable_modules.fable_library.seq import (to_array, delay, map as map_1, exists, to_list, append, singleton)
+from ...fable_modules.fable_library.types import (Array, to_string)
+from ...fable_modules.fable_library.util import IEnumerable_1
+from ...fable_modules.fs_spreadsheet.Cells.fs_cell import FsCell
+from ...fable_modules.fs_spreadsheet.fs_column import FsColumn
+from ...Core.Table.composite_cell import CompositeCell
+from ...Core.Table.composite_column import CompositeColumn
+from ...Core.Table.composite_header import (IOType, CompositeHeader)
+from .composite_cell import to_string_cells as to_string_cells_1
+from .composite_header import (from_string_cells, to_string_cells)
+
+def fix_deprecated_ioheader(string_cell_col: Array[str]) -> Array[str]:
+    if len(string_cell_col) == 0:
+        raise Exception("Can\'t fix IOHeader Invalid column, neither header nor values given")
+
+    values: Array[str] = skip(1, string_cell_col, None)
+    match_value: IOType = IOType.of_string(string_cell_col[0])
+    if match_value.tag == 4:
+        return string_cell_col
+
+    elif match_value.tag == 0:
+        string_cell_col[0] = to_string(CompositeHeader(11, IOType(0)))
+        return string_cell_col
+
+    else: 
+        string_cell_col[0] = to_string(CompositeHeader(12, match_value))
+        return string_cell_col
+
+
+
+def from_string_cell_columns(columns: Array[Array[str]]) -> CompositeColumn:
+    def mapping(c: Array[str], columns: Any=columns) -> str:
+        return c[0]
+
+    pattern_input: tuple[CompositeHeader, Callable[[Array[str]], CompositeCell]] = from_string_cells(map(mapping, columns, None))
+    l: int = len(columns[0]) or 0
+    def _arrow1286(__unit: None=None, columns: Any=columns) -> IEnumerable_1[CompositeCell]:
+        def _arrow1285(i: int) -> CompositeCell:
+            def mapping_1(c_1: Array[str]) -> str:
+                return c_1[i]
+
+            return pattern_input[1](map(mapping_1, columns, None))
+
+        return map_1(_arrow1285, range_big_int(1, 1, l - 1))
+
+    cells: Array[CompositeCell] = to_array(delay(_arrow1286))
+    return CompositeColumn.create(pattern_input[0], cells)
+
+
+def from_fs_columns(columns: Array[FsColumn]) -> CompositeColumn:
+    def mapping_1(c: FsColumn, columns: Any=columns) -> Array[str]:
+        c.ToDenseColumn()
+        def mapping(c_1: FsCell, c: Any=c) -> str:
+            return c_1.ValueAsString()
+
+        return map(mapping, to_array(c.Cells), None)
+
+    return from_string_cell_columns(map(mapping_1, columns, None))
+
+
+def to_string_cell_columns(column: CompositeColumn) -> FSharpList[FSharpList[str]]:
+    def predicate(c: CompositeCell, column: Any=column) -> bool:
+        return c.is_unitized
+
+    has_unit: bool = exists(predicate, column.Cells)
+    is_term: bool = column.Header.IsTermColumn
+    def predicate_1(c_1: CompositeCell, column: Any=column) -> bool:
+        return c_1.is_data
+
+    is_data: bool = exists(predicate_1, column.Cells) if column.Header.IsDataColumn else False
+    header: Array[str] = to_string_cells(has_unit, column.Header)
+    def mapping(cell: CompositeCell, column: Any=column) -> Array[str]:
+        return to_string_cells_1(is_term, has_unit, cell)
+
+    cells: Array[Array[str]] = map(mapping, column.Cells, None)
+    def get_cell_or_default(ri: int, ci: int, cells_1: Array[Array[str]], column: Any=column) -> str:
+        return default_arg(try_item(ci, cells_1[ri]), "")
+
+    if has_unit:
+        def _arrow1292(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1291(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1290(i: int) -> str:
+                    return get_cell_or_default(i, 0, cells)
+
+                return map_1(_arrow1290, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[0]), delay(_arrow1291))
+
+        def _arrow1295(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1294(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1293(i_1: int) -> str:
+                    return get_cell_or_default(i_1, 1, cells)
+
+                return map_1(_arrow1293, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[1]), delay(_arrow1294))
+
+        def _arrow1298(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1297(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1296(i_2: int) -> str:
+                    return get_cell_or_default(i_2, 2, cells)
+
+                return map_1(_arrow1296, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[2]), delay(_arrow1297))
+
+        def _arrow1301(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1300(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1299(i_3: int) -> str:
+                    return get_cell_or_default(i_3, 3, cells)
+
+                return map_1(_arrow1299, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[3]), delay(_arrow1300))
+
+        return of_array([to_list(delay(_arrow1292)), to_list(delay(_arrow1295)), to_list(delay(_arrow1298)), to_list(delay(_arrow1301))])
+
+    elif is_term:
+        def _arrow1307(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1306(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1305(i_4: int) -> str:
+                    return get_cell_or_default(i_4, 0, cells)
+
+                return map_1(_arrow1305, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[0]), delay(_arrow1306))
+
+        def _arrow1310(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1309(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1308(i_5: int) -> str:
+                    return get_cell_or_default(i_5, 1, cells)
+
+                return map_1(_arrow1308, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[1]), delay(_arrow1309))
+
+        def _arrow1313(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1312(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1311(i_6: int) -> str:
+                    return get_cell_or_default(i_6, 2, cells)
+
+                return map_1(_arrow1311, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[2]), delay(_arrow1312))
+
+        return of_array([to_list(delay(_arrow1307)), to_list(delay(_arrow1310)), to_list(delay(_arrow1313))])
+
+    elif is_data:
+        def _arrow1319(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1318(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1317(i_7: int) -> str:
+                    return get_cell_or_default(i_7, 0, cells)
+
+                return map_1(_arrow1317, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[0]), delay(_arrow1318))
+
+        def _arrow1322(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1321(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1320(i_8: int) -> str:
+                    return get_cell_or_default(i_8, 1, cells)
+
+                return map_1(_arrow1320, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[1]), delay(_arrow1321))
+
+        def _arrow1325(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1324(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1323(i_9: int) -> str:
+                    return get_cell_or_default(i_9, 2, cells)
+
+                return map_1(_arrow1323, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[2]), delay(_arrow1324))
+
+        return of_array([to_list(delay(_arrow1319)), to_list(delay(_arrow1322)), to_list(delay(_arrow1325))])
+
+    else: 
+        def _arrow1328(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1327(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1326(i_10: int) -> str:
+                    return cells[i_10][0]
+
+                return map_1(_arrow1326, range_big_int(0, 1, len(column.Cells) - 1))
+
+            return append(singleton(header[0]), delay(_arrow1327))
+
+        return singleton_1(to_list(delay(_arrow1328)))
+
+
+
+def to_fs_columns(column: CompositeColumn) -> FSharpList[FSharpList[FsCell]]:
+    def mapping_1(c: FSharpList[str], column: Any=column) -> FSharpList[FsCell]:
+        def mapping(s: str, c: Any=c) -> FsCell:
+            return FsCell(s)
+
+        return map_2(mapping, c)
+
+    return map_2(mapping_1, to_string_cell_columns(column))
+
+
+__all__ = ["fix_deprecated_ioheader", "from_string_cell_columns", "from_fs_columns", "to_string_cell_columns", "to_fs_columns"]
+