arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/fable_modules/fs_spreadsheet/Tables/fs_table_field.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_library.reflection import (TypeInfo, class_type)
+from ...fable_library.seq import skip
+from ...fable_library.string_ import (to_fail, printf)
+from ...fable_library.util import (equals, IEnumerable_1)
+from ..Cells.fs_cell import FsCell
+from ..Cells.fs_cells_collection import FsCellsCollection
+from ..fs_address import (FsAddress__ctor_Z37302880, FsAddress__get_RowNumber)
+from ..Ranges.fs_range_address import (FsRangeAddress__ctor_7E77A4A0, FsRangeAddress__get_FirstAddress, FsRangeAddress__get_LastAddress)
+from ..Ranges.fs_range_base import FsRangeBase__get_RangeAddress
+from ..Ranges.fs_range_column import (FsRangeColumn, FsRangeColumn__ctor_6A2513BC, FsRangeColumn__FirstCell_Z2740B3CA, FsRangeColumn__Copy, FsRangeColumn__Cells_Z2740B3CA)
+
+def _expr193() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsTableField", None, FsTableField)
+
+
+class FsTableField:
+    def __init__(self, name: str, index: int, column: FsRangeColumn, totals_row_label: Any=None, totals_row_function: Any=None) -> None:
+        self._totalsRowsFunction: Any = totals_row_function
+        self._totalsRowLabel: Any = totals_row_label
+        self._column: FsRangeColumn = column
+        self._index: int = index or 0
+        self._name: str = name
+        self._Column: FsRangeColumn = self._column
+
+
+FsTableField_reflection = _expr193
+
+def FsTableField__ctor_726EFFB(name: str, index: int, column: FsRangeColumn, totals_row_label: Any=None, totals_row_function: Any=None) -> FsTableField:
+    return FsTableField(name, index, column, totals_row_label, totals_row_function)
+
+
+def FsTableField__ctor(__unit: None=None) -> FsTableField:
+    return FsTableField__ctor_726EFFB("", 0, None, None, None)
+
+
+def FsTableField__ctor_Z721C83C5(name: str) -> FsTableField:
+    return FsTableField__ctor_726EFFB(name, 0, None, None, None)
+
+
+def FsTableField__ctor_Z18115A39(name: str, index: int) -> FsTableField:
+    return FsTableField__ctor_726EFFB(name, index, None, None, None)
+
+
+def FsTableField__ctor_6547009B(name: str, index: int, column: FsRangeColumn) -> FsTableField:
+    return FsTableField__ctor_726EFFB(name, index, column, None, None)
+
+
+def FsTableField__get_Column(__: FsTableField) -> FsRangeColumn:
+    return __._Column
+
+
+def FsTableField__set_Column_Z7F7BA1C4(__: FsTableField, v: FsRangeColumn) -> None:
+    __._Column = v
+
+
+def FsTableField__get_Index(this: FsTableField) -> int:
+    return this._index
+
+
+def FsTableField__set_Index_Z524259A4(this: FsTableField, index: int) -> None:
+    if index == this._index:
+        pass
+
+    else: 
+        this._index = index or 0
+        if equals(this._column, None):
+            pass
+
+        else: 
+            ind_diff: int = (index - this._index) or 0
+            FsTableField__set_Column_Z7F7BA1C4(this, FsRangeColumn__ctor_6A2513BC(FsRangeAddress__ctor_7E77A4A0(FsAddress__ctor_Z37302880(FsAddress__get_RowNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(FsTableField__get_Column(this)))), this._index + ind_diff), FsAddress__ctor_Z37302880(FsAddress__get_RowNumber(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(FsTableField__get_Column(this)))), this._index + ind_diff))))
+
+
+
+
+def FsTableField__get_Name(this: FsTableField) -> str:
+    return this._name
+
+
+def FsTableField__SetName_103577A7(this: FsTableField, name: str, cells_collection: FsCellsCollection, show_header_row: bool) -> None:
+    this._name = name
+    if show_header_row:
+        FsRangeColumn__FirstCell_Z2740B3CA(FsTableField__get_Column(this), cells_collection).SetValueAs(name)
+
+
+
+def FsTableField_setName(name: str, cells_collection: FsCellsCollection, show_header_row: bool, table_field: FsTableField) -> FsTableField:
+    FsTableField__SetName_103577A7(table_field, name, cells_collection, show_header_row)
+    return table_field
+
+
+def FsTableField__Copy(this: FsTableField) -> FsTableField:
+    col: FsRangeColumn = FsRangeColumn__Copy(FsTableField__get_Column(this))
+    ind: int = FsTableField__get_Index(this) or 0
+    return FsTableField__ctor_726EFFB(FsTableField__get_Name(this), ind, col, None, None)
+
+
+def FsTableField_copy_Z5343F797(table_field: FsTableField) -> FsTableField:
+    return FsTableField__Copy(table_field)
+
+
+def FsTableField__HeaderCell_10EBE01C(this: FsTableField, cells_collection: FsCellsCollection, show_header_row: bool) -> FsCell:
+    if not show_header_row:
+        arg: str = this._name
+        return to_fail(printf("tried to get header cell of table field \"%s\" even though showHeaderRow is set to zero"))(arg)
+
+    else: 
+        return FsRangeColumn__FirstCell_Z2740B3CA(FsTableField__get_Column(this), cells_collection)
+
+
+
+def FsTableField_getHeaderCell(cells_collection: FsCellsCollection, show_header_row: bool, table_field: FsTableField) -> FsCell:
+    return FsTableField__HeaderCell_10EBE01C(table_field, cells_collection, show_header_row)
+
+
+def FsTableField__DataCells_Z2740B3CA(this: FsTableField, cells_collection: FsCellsCollection) -> IEnumerable_1[FsCell]:
+    return skip(1, FsRangeColumn__Cells_Z2740B3CA(FsTableField__get_Column(this), cells_collection))
+
+
+def FsTableField_getDataCells(cells_collection: FsCellsCollection, table_field: FsTableField) -> IEnumerable_1[FsCell]:
+    return FsTableField__DataCells_Z2740B3CA(table_field, cells_collection)
+
+
+__all__ = ["FsTableField_reflection", "FsTableField__ctor", "FsTableField__ctor_Z721C83C5", "FsTableField__ctor_Z18115A39", "FsTableField__ctor_6547009B", "FsTableField__get_Column", "FsTableField__set_Column_Z7F7BA1C4", "FsTableField__get_Index", "FsTableField__set_Index_Z524259A4", "FsTableField__get_Name", "FsTableField__SetName_103577A7", "FsTableField_setName", "FsTableField__Copy", "FsTableField_copy_Z5343F797", "FsTableField__HeaderCell_10EBE01C", "FsTableField_getHeaderCell", "FsTableField__DataCells_Z2740B3CA", "FsTableField_getDataCells"]
+

arctrl/py/fable_modules/fs_spreadsheet/Tables/fs_table_row.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from ...fable_library.reflection import (TypeInfo, class_type)
+from ..Ranges.fs_range_address import FsRangeAddress
+from ..Ranges.fs_range_row import (FsRangeRow, FsRangeRow_reflection)
+
+def _expr192() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsTableRow", None, FsTableRow, FsRangeRow_reflection())
+
+
+class FsTableRow(FsRangeRow):
+    def __init__(self, range_address: FsRangeAddress) -> None:
+        super().__init__(range_address)
+        pass
+
+
+FsTableRow_reflection = _expr192
+
+def FsTableRow__ctor_6A2513BC(range_address: FsRangeAddress) -> FsTableRow:
+    return FsTableRow(range_address)
+
+
+__all__ = ["FsTableRow_reflection"]
+

arctrl/py/fable_modules/fs_spreadsheet/fs_address.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+from collections.abc import Callable
+from math import pow
+from typing import Any
+from ..fable_library.char import (char_code_at, is_letter, is_digit)
+from ..fable_library.int32 import parse
+from ..fable_library.long import (op_addition, from_integer, to_int)
+from ..fable_library.reflection import (TypeInfo, class_type)
+from ..fable_library.reg_exp import create
+from ..fable_library.seq import iterate
+from ..fable_library.string_ import (to_text, printf, to_fail)
+from ..fable_library.system_text import (StringBuilder__ctor, StringBuilder__Append_244C7CD6)
+from ..fable_library.types import (uint32, to_string, int64)
+from ..fable_library.util import ignore
+
+CellReference_indexRegex: Any = create("([A-Z]*)(\\d*)")
+
+def CellReference_colAdressToIndex(column_adress: str) -> uint32:
+    length: int = len(column_adress) or 0
+    sum: uint32 = uint32(0)
+    for i in range(0, (length - 1) + 1, 1):
+        c_1: str
+        c: str = column_adress[(length - 1) - i]
+        c_1 = c.upper()
+        factor: uint32
+        value: float = pow(26.0, i)
+        factor = int(value+0x100000000 if value < 0 else value)
+        sum = sum + (((int(char_code_at(c_1, 0)+0x100000000 if char_code_at(c_1, 0) < 0 else char_code_at(c_1, 0))) - uint32(64)) * factor)
+    return sum
+
+
+def CellReference_indexToColAdress(i: uint32) -> str:
+    def loop(index_mut: uint32, acc_mut: str, i: Any=i) -> str:
+        while True:
+            (index, acc) = (index_mut, acc_mut)
+            if index == uint32(0):
+                return acc
+
+            else: 
+                mod26: uint32 = (index - uint32(1)) % uint32(26)
+                index_mut = (index - uint32(1)) // uint32(26)
+                acc_mut = chr((int(char_code_at("A", 0)+0x100000000 if char_code_at("A", 0) < 0 else char_code_at("A", 0))) + mod26) + acc
+                continue
+
+            break
+
+    return loop(i, "")
+
+
+def CellReference_ofIndices(column: uint32, row: uint32) -> str:
+    arg: str = CellReference_indexToColAdress(column)
+    return to_text(printf("%s%i"))(arg)(row)
+
+
+def CellReference_toIndices(reference: str) -> tuple[uint32, uint32]:
+    char_part: Any = StringBuilder__ctor()
+    num_part: Any = StringBuilder__ctor()
+    def action(c: str, reference: Any=reference) -> None:
+        if is_letter(c):
+            ignore(StringBuilder__Append_244C7CD6(char_part, c))
+
+        elif is_digit(c):
+            ignore(StringBuilder__Append_244C7CD6(num_part, c))
+
+        else: 
+            to_fail(printf("Reference %s does not match Excel A1-style"))(reference)
+
+
+    iterate(action, reference)
+    return (CellReference_colAdressToIndex(to_string(char_part)), parse(to_string(num_part), 511, True, 32))
+
+
+def CellReference_toColIndex(reference: str) -> uint32:
+    return CellReference_toIndices(reference)[0]
+
+
+def CellReference_toRowIndex(reference: str) -> uint32:
+    return CellReference_toIndices(reference)[1]
+
+
+def CellReference_setColIndex(col_i: uint32, reference: str) -> str:
+    return CellReference_ofIndices(col_i, CellReference_toIndices(reference)[1])
+
+
+def CellReference_setRowIndex(row_i: uint32, reference: str) -> str:
+    return CellReference_ofIndices(CellReference_toIndices(reference)[0], row_i)
+
+
+def CellReference_moveHorizontal(amount: int, reference: str) -> str:
+    tupled_arg_1: tuple[uint32, uint32]
+    tupled_arg: tuple[uint32, uint32] = CellReference_toIndices(reference)
+    def _arrow62(__unit: None=None, amount: Any=amount, reference: Any=reference) -> uint32:
+        value: int64 = op_addition(from_integer(tupled_arg[0], False, 6), from_integer(amount, False, 2))
+        return int(to_int(value)+0x100000000 if to_int(value) < 0 else to_int(value))
+
+    tupled_arg_1 = (_arrow62(), tupled_arg[1])
+    return CellReference_ofIndices(tupled_arg_1[0], tupled_arg_1[1])
+
+
+def CellReference_moveVertical(amount: int, reference: str) -> str:
+    tupled_arg_1: tuple[uint32, uint32]
+    tupled_arg: tuple[uint32, uint32] = CellReference_toIndices(reference)
+    def _arrow63(__unit: None=None, amount: Any=amount, reference: Any=reference) -> uint32:
+        value: int64 = op_addition(from_integer(tupled_arg[1], False, 6), from_integer(amount, False, 2))
+        return int(to_int(value)+0x100000000 if to_int(value) < 0 else to_int(value))
+
+    tupled_arg_1 = (tupled_arg[0], _arrow63())
+    return CellReference_ofIndices(tupled_arg_1[0], tupled_arg_1[1])
+
+
+def _expr64() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsAddress", None, FsAddress)
+
+
+class FsAddress:
+    def __init__(self, row_number: int, column_number: int, fixed_row: bool, fixed_column: bool) -> None:
+        self._fixedRow: bool = fixed_row
+        self._fixedColumn: bool = fixed_column
+        self._rowNumber: int = row_number or 0
+        self._columnNumber: int = column_number or 0
+        self._trimmedAddress: str = ""
+
+
+FsAddress_reflection = _expr64
+
+def FsAddress__ctor_Z4C746FC0(row_number: int, column_number: int, fixed_row: bool, fixed_column: bool) -> FsAddress:
+    return FsAddress(row_number, column_number, fixed_row, fixed_column)
+
+
+def FsAddress__ctor_Z668C30D9(row_number: int, column_letter: str, fixed_row: bool, fixed_column: bool) -> FsAddress:
+    return FsAddress__ctor_Z4C746FC0(row_number, int(CellReference_colAdressToIndex(column_letter)), fixed_row, fixed_column)
+
+
+def FsAddress__ctor_Z37302880(row_number: int, column_number: int) -> FsAddress:
+    return FsAddress__ctor_Z4C746FC0(row_number, column_number, False, False)
+
+
+def FsAddress__ctor_Z721C83C5(cell_address_string: str) -> FsAddress:
+    pattern_input: tuple[uint32, uint32] = CellReference_toIndices(cell_address_string)
+    return FsAddress__ctor_Z37302880(int(pattern_input[1]), int(pattern_input[0]))
+
+
+def FsAddress__get_ColumnNumber(self_1: FsAddress) -> int:
+    return self_1._columnNumber
+
+
+def FsAddress__set_ColumnNumber_Z524259A4(self_1: FsAddress, col_i: int) -> None:
+    self_1._columnNumber = col_i or 0
+
+
+def FsAddress__get_RowNumber(self_1: FsAddress) -> int:
+    return self_1._rowNumber
+
+
+def FsAddress__set_RowNumber_Z524259A4(self_1: FsAddress, row_i: int) -> None:
+    self_1._rowNumber = row_i or 0
+
+
+def FsAddress__get_Address(self_1: FsAddress) -> str:
+    return CellReference_ofIndices(int(self_1._columnNumber+0x100000000 if self_1._columnNumber < 0 else self_1._columnNumber), int(self_1._rowNumber+0x100000000 if self_1._rowNumber < 0 else self_1._rowNumber))
+
+
+def FsAddress__set_Address_Z721C83C5(self_1: FsAddress, address: str) -> None:
+    pattern_input: tuple[uint32, uint32] = CellReference_toIndices(address)
+    self_1._rowNumber = int(pattern_input[1]) or 0
+    self_1._columnNumber = int(pattern_input[0]) or 0
+
+
+def FsAddress__get_FixedRow(self_1: FsAddress) -> bool:
+    return False
+
+
+def FsAddress__get_FixedColumn(self_1: FsAddress) -> bool:
+    return False
+
+
+def FsAddress__Copy(this: FsAddress) -> FsAddress:
+    col_no: int = FsAddress__get_ColumnNumber(this) or 0
+    return FsAddress__ctor_Z4C746FC0(FsAddress__get_RowNumber(this), col_no, FsAddress__get_FixedRow(this), FsAddress__get_FixedColumn(this))
+
+
+def FsAddress_copy_6D30B323(address: FsAddress) -> FsAddress:
+    return FsAddress__Copy(address)
+
+
+def FsAddress__UpdateIndices_Z37302880(self_1: FsAddress, row_index: int, col_index: int) -> None:
+    self_1._columnNumber = col_index or 0
+    self_1._rowNumber = row_index or 0
+
+
+def FsAddress_updateIndices(row_index: int, col_index: int, address: FsAddress) -> FsAddress:
+    FsAddress__UpdateIndices_Z37302880(address, row_index, col_index)
+    return address
+
+
+def FsAddress__ToIndices(self_1: FsAddress) -> tuple[int, int]:
+    return (self_1._rowNumber, self_1._columnNumber)
+
+
+def FsAddress_toIndices_6D30B323(address: FsAddress) -> tuple[int, int]:
+    return FsAddress__ToIndices(address)
+
+
+def FsAddress__Compare_6D30B323(self_1: FsAddress, address: FsAddress) -> bool:
+    if (FsAddress__get_FixedColumn(self_1) == FsAddress__get_FixedColumn(address)) if ((FsAddress__get_RowNumber(self_1) == FsAddress__get_RowNumber(address)) if ((FsAddress__get_ColumnNumber(self_1) == FsAddress__get_ColumnNumber(address)) if (FsAddress__get_Address(self_1) == FsAddress__get_Address(address)) else False) else False) else False:
+        return FsAddress__get_FixedRow(self_1) == FsAddress__get_FixedRow(address)
+
+    else: 
+        return False
+
+
+
+def FsAddress_compare(address1: FsAddress, address2: FsAddress) -> bool:
+    return FsAddress__Compare_6D30B323(address1, address2)
+
+
+__all__ = ["CellReference_indexRegex", "CellReference_colAdressToIndex", "CellReference_indexToColAdress", "CellReference_ofIndices", "CellReference_toIndices", "CellReference_toColIndex", "CellReference_toRowIndex", "CellReference_setColIndex", "CellReference_setRowIndex", "CellReference_moveHorizontal", "CellReference_moveVertical", "FsAddress_reflection", "FsAddress__ctor_Z668C30D9", "FsAddress__ctor_Z37302880", "FsAddress__ctor_Z721C83C5", "FsAddress__get_ColumnNumber", "FsAddress__set_ColumnNumber_Z524259A4", "FsAddress__get_RowNumber", "FsAddress__set_RowNumber_Z524259A4", "FsAddress__get_Address", "FsAddress__set_Address_Z721C83C5", "FsAddress__get_FixedRow", "FsAddress__get_FixedColumn", "FsAddress__Copy", "FsAddress_copy_6D30B323", "FsAddress__UpdateIndices_Z37302880", "FsAddress_updateIndices", "FsAddress__ToIndices", "FsAddress_toIndices_6D30B323", "FsAddress__Compare_6D30B323", "FsAddress_compare"]
+

arctrl/py/fable_modules/fs_spreadsheet/fs_column.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ..fable_library.reflection import (TypeInfo, class_type)
+from ..fable_library.seq import (length, min_by, max_by, map, exists)
+from ..fable_library.util import (IEnumerable_1, compare_primitives, ignore, get_enumerator, IEnumerator, to_iterator)
+from .Cells.fs_cell import FsCell
+from .Cells.fs_cells_collection import (FsCellsCollection__ctor, FsCellsCollection__GetCellsInColumn_Z524259A4, FsCellsCollection, FsCellsCollection__Add_Z21F271A4)
+from .fs_address import (FsAddress__ctor_Z37302880, FsAddress__get_RowNumber, FsAddress__get_ColumnNumber, FsAddress__set_ColumnNumber_Z524259A4)
+from .Ranges.fs_range_address import (FsRangeAddress__ctor_7E77A4A0, FsRangeAddress__get_FirstAddress, FsRangeAddress__get_LastAddress, FsRangeAddress__Copy, FsRangeAddress)
+from .Ranges.fs_range_base import (FsRangeBase__Cells_Z2740B3CA, FsRangeBase__get_RangeAddress, FsRangeBase__Cell_Z3407A44B, FsRangeBase, FsRangeBase_reflection)
+
+def _expr191() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsColumn", None, FsColumn, FsRangeBase_reflection())
+
+
+class FsColumn(FsRangeBase):
+    def __init__(self, range_address: FsRangeAddress, cells: FsCellsCollection) -> None:
+        super().__init__(range_address)
+        self.cells_004018: FsCellsCollection = cells
+
+    @staticmethod
+    def empty(__unit: None=None) -> FsColumn:
+        return FsColumn(FsRangeAddress__ctor_7E77A4A0(FsAddress__ctor_Z37302880(0, 0), FsAddress__ctor_Z37302880(0, 0)), FsCellsCollection__ctor())
+
+    @staticmethod
+    def create_at(index: int, cells: FsCellsCollection) -> FsColumn:
+        def get_index_by(f: Callable[[Callable[[FsCell], int], IEnumerable_1[FsCell]], FsCell]) -> int:
+            if length(FsCellsCollection__GetCellsInColumn_Z524259A4(cells, index)) == 0:
+                return 1
+
+            else: 
+                def _arrow184(c: FsCell, f: Any=f) -> int:
+                    return FsAddress__get_RowNumber(c.Address)
+
+                return FsAddress__get_RowNumber(f(_arrow184)(FsCellsCollection__GetCellsInColumn_Z524259A4(cells, index)).Address)
+
+
+        def _arrow187(projection: Callable[[FsCell], int]) -> Callable[[IEnumerable_1[FsCell]], FsCell]:
+            def _arrow186(source_1: IEnumerable_1[FsCell]) -> FsCell:
+                class ObjectExpr185:
+                    @property
+                    def Compare(self) -> Callable[[int, int], int]:
+                        return compare_primitives
+
+                return min_by(projection, source_1, ObjectExpr185())
+
+            return _arrow186
+
+        min_row_index: int = get_index_by(_arrow187) or 0
+        def _arrow190(projection_1: Callable[[FsCell], int]) -> Callable[[IEnumerable_1[FsCell]], FsCell]:
+            def _arrow189(source_2: IEnumerable_1[FsCell]) -> FsCell:
+                class ObjectExpr188:
+                    @property
+                    def Compare(self) -> Callable[[int, int], int]:
+                        return compare_primitives
+
+                return max_by(projection_1, source_2, ObjectExpr188())
+
+            return _arrow189
+
+        max_row_index: int = get_index_by(_arrow190) or 0
+        return FsColumn(FsRangeAddress__ctor_7E77A4A0(FsAddress__ctor_Z37302880(min_row_index, index), FsAddress__ctor_Z37302880(max_row_index, index)), cells)
+
+    @property
+    def Cells(self, __unit: None=None) -> IEnumerable_1[FsCell]:
+        this: FsColumn = self
+        return FsRangeBase__Cells_Z2740B3CA(this, this.cells_004018)
+
+    @property
+    def Index(self, __unit: None=None) -> int:
+        this: FsColumn = self
+        return FsAddress__get_ColumnNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(this)))
+
+    @Index.setter
+    def Index(self, i: int) -> None:
+        this: FsColumn = self
+        FsAddress__set_ColumnNumber_Z524259A4(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(this)), i)
+        FsAddress__set_ColumnNumber_Z524259A4(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(this)), i)
+
+    @property
+    def MinRowIndex(self, __unit: None=None) -> int:
+        this: FsColumn = self
+        return FsAddress__get_RowNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(this)))
+
+    @property
+    def MaxRowIndex(self, __unit: None=None) -> int:
+        this: FsColumn = self
+        return FsAddress__get_RowNumber(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(this)))
+
+    def Copy(self, __unit: None=None) -> FsColumn:
+        this: FsColumn = self
+        ra: FsRangeAddress = FsRangeAddress__Copy(FsRangeBase__get_RangeAddress(this))
+        def mapping(c: FsCell) -> FsCell:
+            return c.Copy()
+
+        cells: IEnumerable_1[FsCell] = map(mapping, this.Cells)
+        fcc: FsCellsCollection = FsCellsCollection__ctor()
+        FsCellsCollection__Add_Z21F271A4(fcc, cells)
+        return FsColumn(ra, fcc)
+
+    @staticmethod
+    def copy(column: FsColumn) -> FsColumn:
+        return column.Copy()
+
+    @staticmethod
+    def get_index(column: FsColumn) -> int:
+        return column.Index
+
+    def HasCellAt(self, row_index: int) -> bool:
+        this: FsColumn = self
+        def predicate(c: FsCell) -> bool:
+            return c.RowNumber == row_index
+
+        return exists(predicate, this.Cells)
+
+    @staticmethod
+    def has_cell_at(row_index: int, column: FsColumn) -> bool:
+        return column.HasCellAt(row_index)
+
+    def Item(self, row_index: int) -> FsCell:
+        this: FsColumn = self
+        return FsRangeBase__Cell_Z3407A44B(this, FsAddress__ctor_Z37302880(row_index, 1), this.cells_004018)
+
+    @staticmethod
+    def item(row_index: int, column: FsColumn) -> FsCell:
+        return column.Item(row_index)
+
+    def TryItem(self, row_index: int) -> FsCell | None:
+        this: FsColumn = self
+        return this.Item(row_index) if this.HasCellAt(row_index) else None
+
+    @staticmethod
+    def try_item(row_index: int, column: FsColumn) -> FsCell | None:
+        return column.TryItem(row_index)
+
+    def ToDenseColumn(self, __unit: None=None) -> None:
+        this: FsColumn = self
+        for i in range(this.MinRowIndex, this.MaxRowIndex + 1, 1):
+            ignore(this.Item(i))
+
+    @staticmethod
+    def to_dense_column(column: FsColumn) -> FsColumn:
+        column.ToDenseColumn()
+        return column
+
+    @staticmethod
+    def create_dense_column_of(column: FsColumn) -> FsColumn:
+        new_column: FsColumn = column.Copy()
+        new_column.ToDenseColumn()
+        return new_column
+
+    def GetEnumerator(self, __unit: None=None) -> IEnumerator[FsCell]:
+        this: FsColumn = self
+        return get_enumerator(this.Cells)
+
+    def __iter__(self) -> IEnumerator[FsCell]:
+        return to_iterator(self.GetEnumerator())
+
+    def System_Collections_IEnumerable_GetEnumerator(self, __unit: None=None) -> IEnumerator[Any]:
+        this: FsColumn = self
+        return get_enumerator(this)
+
+
+FsColumn_reflection = _expr191
+
+def FsColumn__ctor_7678C70A(range_address: FsRangeAddress, cells: FsCellsCollection) -> FsColumn:
+    return FsColumn(range_address, cells)
+
+
+__all__ = ["FsColumn_reflection"]
+