arctrl 3.0.0__py3-none-any.whl

arctrl/py/Spreadsheet/AnnotationTable/arc_table.py

@@ -0,0 +1,203 @@
+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, unzip)
+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, of_seq, 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 Dictionary_tryGet
+from ...fable_modules.fs_spreadsheet.fs_address import FsAddress
+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.Table.arc_table import ArcTable
+from ...Core.Table.arc_table_aux import (ColumnValueRefs, ArcTableValues)
+from ...Core.Table.composite_column import CompositeColumn
+from ...Core.Table.composite_header import CompositeHeader
+from .composite_column import (from_string_cell_columns, ColumnValueRefs_fromStringCellColumns, 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 _arrow1951(columns: Array[Array[str]], string_cell_columns: Any=string_cell_columns) -> CompositeColumn:
+        return from_string_cell_columns(columns)
+
+    return map_1(_arrow1951, group_columns_by_header(string_cell_columns), None)
+
+
+def compose_arc_table_values(string_cell_columns: Array[Array[str]]) -> tuple[Array[CompositeHeader], ArcTableValues]:
+    value_map: Any = dict([])
+    row_count: int = (len(string_cell_columns[0]) - 1) or 0
+    def mapping(columns: Array[Array[str]], string_cell_columns: Any=string_cell_columns) -> tuple[CompositeHeader, ColumnValueRefs]:
+        return ColumnValueRefs_fromStringCellColumns(value_map, columns)
+
+    pattern_input: tuple[Array[CompositeHeader], Array[ColumnValueRefs]] = unzip(map_1(mapping, group_columns_by_header(string_cell_columns), None))
+    return (pattern_input[0], ArcTableValues.from_ref_columns(pattern_input[1], value_map, row_count))
+
+
+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 _arrow1955(__unit: None=None) -> IEnumerable_1[Array[str]]:
+                def _arrow1954(c: int) -> Array[str]:
+                    def _arrow1953(__unit: None=None) -> IEnumerable_1[str]:
+                        def _arrow1952(r: int) -> IEnumerable_1[str]:
+                            match_value_1: FsCell | None = sheet.CellCollection.TryGetCell(r, c)
+                            if match_value_1 is None:
+                                return singleton_1("")
+
+                            else: 
+                                cell: FsCell = match_value_1
+                                return singleton_1(cell.ValueAsString())
+
+
+                        return collect(_arrow1952, range_big_int(1, 1, t.RangeAddress.LastAddress.RowNumber))
+
+                    return to_array_1(delay(_arrow1953))
+
+                return map_2(_arrow1954, range_big_int(1, 1, t.RangeAddress.LastAddress.ColumnNumber))
+
+            pattern_input: tuple[Array[CompositeHeader], ArcTableValues] = compose_arc_table_values(map_1(fix_deprecated_ioheader, to_array_1(delay(_arrow1955)), None))
+            return ArcTable.from_arc_table_values(sheet.Name, list(pattern_input[0]), pattern_input[1])
+
+
+    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 _arrow1956(column_1: CompositeColumn, index: Any=index, table: Any=table) -> FSharpList[FSharpList[str]]:
+            return to_string_cell_columns(column_1)
+
+        def _arrow1957(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 ObjectExpr1958:
+            @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(_arrow1956, sort_by(_arrow1957, of_seq(table.Columns), ObjectExpr1958()))
+        table_row_count: int
+        def folder(acc: int, c: FSharpList[str], index: Any=index, table: Any=table) -> int:
+            def _arrow1959(x_1: int, y_1: int, acc: Any=acc, c: Any=c) -> int:
+                return compare_primitives(x_1, y_1)
+
+            return max(_arrow1959, 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(FsAddress(1, 1), FsAddress(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(row_i + 1, col_i + 1)
+                fs_table.Cell(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", "compose_arc_table_values", "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 _arrow1860(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(_arrow1860, tan_col)
+    def _arrow1861(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(_arrow1861, 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 _arrow1862(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(_arrow1862, tan_col)
+    def _arrow1863(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(_arrow1863, 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 _arrow1864(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(_arrow1864, format)
+    def _arrow1865(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(_arrow1865, 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,305 @@
+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.map_util import (try_get_value, get_item_from_dict)
+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, reduce)
+from ...fable_modules.fable_library.types import (Array, to_string)
+from ...fable_modules.fable_library.util import (IEnumerable_1, string_hash)
+from ...fable_modules.fs_spreadsheet.Cells.fs_cell import FsCell
+from ...fable_modules.fs_spreadsheet.fs_column import FsColumn
+from ...fable_modules.fs_spreadsheet.hash_codes import merge_hashes
+from ...fable_modules.fable_library.types import FSharpRef
+from ...Core.Table.arc_table_aux import (ColumnValueRefs, ensure_cell_hash_in_value_map)
+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 _arrow1904(__unit: None=None, columns: Any=columns) -> IEnumerable_1[CompositeCell]:
+        def _arrow1903(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(_arrow1903, range_big_int(1, 1, l - 1))
+
+    cells: Array[CompositeCell] = list(to_array(delay(_arrow1904)))
+    return CompositeColumn.create(pattern_input[0], cells)
+
+
+def string_cell_columns_of_fs_columns(columns: Array[FsColumn]) -> Array[Array[str]]:
+    def mapping_1(c: FsColumn, columns: Any=columns) -> Array[str]:
+        c.ToDenseColumn()
+        def mapping(cell: FsCell, c: Any=c) -> str:
+            return cell.ValueAsString()
+
+        return map(mapping, to_array(c.Cells), None)
+
+    return map(mapping_1, columns, None)
+
+
+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)
+    composite_cells: Array[CompositeCell] = to_array(column.Cells)
+    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, to_array(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 _arrow1910(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1909(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1908(i: int) -> str:
+                    return get_cell_or_default(i, 0, cells)
+
+                return map_1(_arrow1908, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[0]), delay(_arrow1909))
+
+        def _arrow1913(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1912(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1911(i_1: int) -> str:
+                    return get_cell_or_default(i_1, 1, cells)
+
+                return map_1(_arrow1911, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[1]), delay(_arrow1912))
+
+        def _arrow1916(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1915(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1914(i_2: int) -> str:
+                    return get_cell_or_default(i_2, 2, cells)
+
+                return map_1(_arrow1914, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[2]), delay(_arrow1915))
+
+        def _arrow1919(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1918(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1917(i_3: int) -> str:
+                    return get_cell_or_default(i_3, 3, cells)
+
+                return map_1(_arrow1917, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[3]), delay(_arrow1918))
+
+        return of_array([to_list(delay(_arrow1910)), to_list(delay(_arrow1913)), to_list(delay(_arrow1916)), to_list(delay(_arrow1919))])
+
+    elif is_term:
+        def _arrow1925(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1924(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1923(i_4: int) -> str:
+                    return get_cell_or_default(i_4, 0, cells)
+
+                return map_1(_arrow1923, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[0]), delay(_arrow1924))
+
+        def _arrow1928(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1927(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1926(i_5: int) -> str:
+                    return get_cell_or_default(i_5, 1, cells)
+
+                return map_1(_arrow1926, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[1]), delay(_arrow1927))
+
+        def _arrow1931(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1930(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1929(i_6: int) -> str:
+                    return get_cell_or_default(i_6, 2, cells)
+
+                return map_1(_arrow1929, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[2]), delay(_arrow1930))
+
+        return of_array([to_list(delay(_arrow1925)), to_list(delay(_arrow1928)), to_list(delay(_arrow1931))])
+
+    elif is_data:
+        def _arrow1937(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1936(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1935(i_7: int) -> str:
+                    return get_cell_or_default(i_7, 0, cells)
+
+                return map_1(_arrow1935, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[0]), delay(_arrow1936))
+
+        def _arrow1940(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1939(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1938(i_8: int) -> str:
+                    return get_cell_or_default(i_8, 1, cells)
+
+                return map_1(_arrow1938, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[1]), delay(_arrow1939))
+
+        def _arrow1943(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1942(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1941(i_9: int) -> str:
+                    return get_cell_or_default(i_9, 2, cells)
+
+                return map_1(_arrow1941, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[2]), delay(_arrow1942))
+
+        return of_array([to_list(delay(_arrow1937)), to_list(delay(_arrow1940)), to_list(delay(_arrow1943))])
+
+    else: 
+        def _arrow1946(__unit: None=None, column: Any=column) -> IEnumerable_1[str]:
+            def _arrow1945(__unit: None=None) -> IEnumerable_1[str]:
+                def _arrow1944(i_10: int) -> str:
+                    return cells[i_10][0]
+
+                return map_1(_arrow1944, range_big_int(0, 1, len(composite_cells) - 1))
+
+            return append(singleton(header[0]), delay(_arrow1945))
+
+        return singleton_1(to_list(delay(_arrow1946)))
+
+
+
+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))
+
+
+def ColumnValueRefs_fromStringCellColumns(value_map: Any, columns: Array[Array[str]]) -> tuple[CompositeHeader, ColumnValueRefs]:
+    hash_map: Any = dict([])
+    cells: Any = dict([])
+    constant: bool = True
+    def mapping(c: Array[str], value_map: Any=value_map, columns: Any=columns) -> str:
+        return c[0]
+
+    pattern_input: tuple[CompositeHeader, Callable[[Array[str]], CompositeCell]] = from_string_cells(map(mapping, columns, None))
+    header: CompositeHeader = pattern_input[0]
+    cell_parser: Callable[[Array[str]], CompositeCell] = pattern_input[1]
+    l: int = len(columns[0]) or 0
+    if l == 1:
+        return (header, ColumnValueRefs(1, cells))
+
+    else: 
+        for i in range(1, (l - 1) + 1, 1):
+            def mapping_1(c_1: Array[str], value_map: Any=value_map, columns: Any=columns) -> str:
+                return c_1[i]
+
+            strings: Array[str] = map(mapping_1, columns, None)
+            def _arrow1947(hash_1: int, hash_2: int, value_map: Any=value_map, columns: Any=columns) -> int:
+                return merge_hashes(hash_1, hash_2)
+
+            def mapping_2(s: str, value_map: Any=value_map, columns: Any=columns) -> int:
+                return string_hash(s)
+
+            hash_3: int = reduce(_arrow1947, map_1(mapping_2, strings)) or 0
+            match_value: int | None
+            pattern_input_1: tuple[bool, int]
+            out_arg: int = None or 0
+            def _arrow1948(__unit: None=None, value_map: Any=value_map, columns: Any=columns) -> int:
+                return out_arg
+
+            def _arrow1949(v: int, value_map: Any=value_map, columns: Any=columns) -> None:
+                nonlocal out_arg
+                out_arg = v or 0
+
+            pattern_input_1 = (try_get_value(hash_map, hash_3, FSharpRef(_arrow1948, _arrow1949)), out_arg)
+            match_value = pattern_input_1[1] if pattern_input_1[0] else None
+            if match_value is None:
+                if i == 1:
+                    cell_hash_3: int = ensure_cell_hash_in_value_map(cell_parser(strings), value_map) or 0
+                    hash_map[hash_3] = cell_hash_3
+                    cells[i - 1] = cell_hash_3
+
+                else: 
+                    if constant:
+                        constant = False
+                        for j in range(0, (i - 1) + 1, 1):
+                            cell_hash_4: int = get_item_from_dict(cells, 0) or 0
+                            cells[j] = cell_hash_4
+
+                    cell_hash_5: int = ensure_cell_hash_in_value_map(cell_parser(strings), value_map) or 0
+                    hash_map[hash_3] = cell_hash_5
+                    cells[i - 1] = cell_hash_5
+
+
+            else: 
+                def _arrow1950(__unit: None=None, value_map: Any=value_map, columns: Any=columns) -> bool:
+                    cell_hash: int = match_value or 0
+                    return constant
+
+                if _arrow1950():
+                    cell_hash_1: int = match_value or 0
+
+                else: 
+                    cell_hash_2: int = match_value or 0
+                    cells[i - 1] = cell_hash_2
+
+
+        if constant:
+            return (header, ColumnValueRefs(0, get_item_from_dict(cells, 0)))
+
+        else: 
+            return (header, ColumnValueRefs(1, cells))
+
+
+
+
+__all__ = ["fix_deprecated_ioheader", "from_string_cell_columns", "string_cell_columns_of_fs_columns", "from_fs_columns", "to_string_cell_columns", "to_fs_columns", "ColumnValueRefs_fromStringCellColumns"]
+