arctrl 3.0.0__py3-none-any.whl

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

@@ -0,0 +1,117 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_library.option import (some, default_arg)
+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
+from ..Ranges.fs_range_address import FsRangeAddress
+from ..Ranges.fs_range_column import FsRangeColumn
+
+def _expr410() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsTableField", None, FsTableField)
+
+
+class FsTableField:
+    def __init__(self, name: str, index: int | None=None, column: FsRangeColumn | None=None, totals_row_label: Any | None=None, totals_row_function: Any | None=None) -> None:
+        self._totalsRowsFunction: Any = default_arg(totals_row_function, None)
+        self._totalsRowLabel: Any = default_arg(totals_row_label, None)
+        self._column: FsRangeColumn = default_arg(column, None)
+        self._index: int = default_arg(index, 0) or 0
+        self._name: str = name
+        self._Column: FsRangeColumn = self._column
+
+    @property
+    def Column(self, __unit: None=None) -> FsRangeColumn:
+        __: FsTableField = self
+        return __._Column
+
+    @Column.setter
+    def Column(self, v: FsRangeColumn) -> None:
+        __: FsTableField = self
+        __._Column = v
+
+    @property
+    def Index(self, __unit: None=None) -> int:
+        this: FsTableField = self
+        return this._index
+
+    @Index.setter
+    def Index(self, index: int) -> None:
+        this: FsTableField = self
+        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
+                new_col: FsRangeColumn = FsRangeColumn(FsRangeAddress(FsAddress(this.Column.RangeAddress.FirstAddress.RowNumber, this._index + ind_diff), FsAddress(this.Column.RangeAddress.LastAddress.RowNumber, this._index + ind_diff)))
+                this.Column = new_col
+
+
+
+    @property
+    def Name(self, __unit: None=None) -> str:
+        this: FsTableField = self
+        return this._name
+
+    def SetName(self, name: str, cells_collection: FsCellsCollection, show_header_row: bool) -> None:
+        this: FsTableField = self
+        this._name = name
+        if show_header_row:
+            this.Column.FirstCell(cells_collection).SetValueAs(name)
+
+
+    @staticmethod
+    def set_name(name: str, cells_collection: FsCellsCollection, show_header_row: bool, table_field: FsTableField) -> FsTableField:
+        table_field.SetName(name, cells_collection, show_header_row)
+        return table_field
+
+    def Copy(self, __unit: None=None) -> FsTableField:
+        this: FsTableField = self
+        col: FsRangeColumn = this.Column.Copy()
+        ind: int = this.Index or 0
+        return FsTableField(this.Name, ind, col, some(None), some(None))
+
+    @staticmethod
+    def copy(table_field: FsTableField) -> FsTableField:
+        return table_field.Copy()
+
+    def HeaderCell(self, cells_collection: FsCellsCollection, show_header_row: bool) -> FsCell:
+        this: FsTableField = self
+        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 this.Column.FirstCell(cells_collection)
+
+
+    @staticmethod
+    def get_header_cell(cells_collection: FsCellsCollection, show_header_row: bool, table_field: FsTableField) -> FsCell:
+        return table_field.HeaderCell(cells_collection, show_header_row)
+
+    def DataCells(self, cells_collection: FsCellsCollection) -> IEnumerable_1[FsCell]:
+        this: FsTableField = self
+        return skip(1, this.Column.Cells(cells_collection))
+
+    @staticmethod
+    def get_data_cells(cells_collection: FsCellsCollection, table_field: FsTableField) -> IEnumerable_1[FsCell]:
+        return table_field.DataCells(cells_collection)
+
+
+FsTableField_reflection = _expr410
+
+def FsTableField__ctor_E675DBB(name: str, index: int | None=None, column: FsRangeColumn | None=None, totals_row_label: Any | None=None, totals_row_function: Any | None=None) -> FsTableField:
+    return FsTableField(name, index, column, totals_row_label, totals_row_function)
+
+
+__all__ = ["FsTableField_reflection"]
+

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 _expr408() -> 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 = _expr408
+
+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,236 @@
+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.option import value as value_2
+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, string_hash, identity_hash)
+from .hash_codes import merge_hashes
+
+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 _arrow277(__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 = (_arrow277(), 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 _arrow278(__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], _arrow278())
+    return CellReference_ofIndices(tupled_arg_1[0], tupled_arg_1[1])
+
+
+def _expr281() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsAddress", None, FsAddress)
+
+
+class FsAddress:
+    def __init__(self, row_number: int, column_number: int, fixed_row: bool | None=None, fixed_column: bool | None=None) -> None:
+        self._fixedRow: bool = value_2(fixed_row) if (fixed_row is not None) else False
+        self._fixedColumn: bool = value_2(fixed_column) if (fixed_column is not None) else False
+        self._rowNumber: int = row_number or 0
+        self._columnNumber: int = column_number or 0
+        self._trimmedAddress: str = ""
+
+    @staticmethod
+    def from_string(cell_address_string: str, fixed_row: bool | None=None, fixed_column: bool | None=None) -> FsAddress:
+        pattern_input: tuple[uint32, uint32] = CellReference_toIndices(cell_address_string)
+        return FsAddress(int(pattern_input[1]), int(pattern_input[0]), fixed_row, fixed_column)
+
+    @property
+    def ColumnNumber(self, __unit: None=None) -> int:
+        self_1: FsAddress = self
+        return self_1._columnNumber
+
+    @ColumnNumber.setter
+    def ColumnNumber(self, col_i: int) -> None:
+        self_1: FsAddress = self
+        self_1._columnNumber = col_i or 0
+
+    @property
+    def RowNumber(self, __unit: None=None) -> int:
+        self_1: FsAddress = self
+        return self_1._rowNumber
+
+    @RowNumber.setter
+    def RowNumber(self, row_i: int) -> None:
+        self_1: FsAddress = self
+        self_1._rowNumber = row_i or 0
+
+    @property
+    def Address(self, __unit: None=None) -> str:
+        self_1: FsAddress = self
+        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))
+
+    @Address.setter
+    def Address(self, address: str) -> None:
+        self_1: FsAddress = self
+        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
+
+    @property
+    def FixedRow(self, __unit: None=None) -> bool:
+        return False
+
+    @property
+    def FixedColumn(self, __unit: None=None) -> bool:
+        return False
+
+    def Copy(self, __unit: None=None) -> FsAddress:
+        this: FsAddress = self
+        col_no: int = this.ColumnNumber or 0
+        return FsAddress(this.RowNumber, col_no, this.FixedRow, this.FixedColumn)
+
+    @staticmethod
+    def copy(address: FsAddress) -> FsAddress:
+        return address.Copy()
+
+    def UpdateIndices(self, row_index: int, col_index: int) -> None:
+        self_1: FsAddress = self
+        self_1._columnNumber = col_index or 0
+        self_1._rowNumber = row_index or 0
+
+    @staticmethod
+    def update_indices(row_index: int, col_index: int, address: FsAddress) -> FsAddress:
+        address.UpdateIndices(row_index, col_index)
+        return address
+
+    def ToIndices(self, __unit: None=None) -> tuple[int, int]:
+        self_1: FsAddress = self
+        return (self_1._rowNumber, self_1._columnNumber)
+
+    @staticmethod
+    def to_indices(address: FsAddress) -> tuple[int, int]:
+        return address.ToIndices()
+
+    def Compare(self, address: FsAddress) -> bool:
+        self_1: FsAddress = self
+        return (self_1.FixedRow == address.FixedRow) if ((self_1.FixedColumn == address.FixedColumn) if ((self_1.RowNumber == address.RowNumber) if ((self_1.ColumnNumber == address.ColumnNumber) if (self_1.Address == address.Address) else False) else False) else False) else False
+
+    @staticmethod
+    def compare(address1: FsAddress, address2: FsAddress) -> bool:
+        return address1.Compare(address2)
+
+    def __hash__(self, __unit: None=None) -> int:
+        this: FsAddress = self
+        hash_8: int
+        hash_6: int
+        hash_4: int
+        hash_2: int = string_hash(this.Address) or 0
+        hash_4 = merge_hashes(this.ColumnNumber, hash_2)
+        hash_6 = merge_hashes(this.RowNumber, hash_4)
+        def _arrow279(__unit: None=None) -> int:
+            copy_of_struct: bool = this.FixedColumn
+            return identity_hash(copy_of_struct)
+
+        hash_8 = merge_hashes(_arrow279(), hash_6)
+        def _arrow280(__unit: None=None) -> int:
+            copy_of_struct_1: bool = this.FixedRow
+            return identity_hash(copy_of_struct_1)
+
+        return merge_hashes(_arrow280(), hash_8)
+
+    def __eq__(self, other: Any=None) -> bool:
+        this: FsAddress = self
+        return this.Compare(other) if isinstance(other, FsAddress) else False
+
+
+FsAddress_reflection = _expr281
+
+def FsAddress__ctor_42410CA0(row_number: int, column_number: int, fixed_row: bool | None=None, fixed_column: bool | None=None) -> FsAddress:
+    return FsAddress(row_number, column_number, fixed_row, fixed_column)
+
+
+__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"]
+

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
+from .fs_address import FsAddress
+from .Ranges.fs_range_address import FsRangeAddress
+from .Ranges.fs_range_base import (FsRangeBase, FsRangeBase_reflection)
+
+def _expr409() -> 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(FsAddress(0, 0), FsAddress(0, 0)), FsCellsCollection())
+
+    @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(cells.GetCellsInColumn(index)) == 0:
+                return 1
+
+            else: 
+                def _arrow401(c: FsCell, f: Any=f) -> int:
+                    return c.Address.RowNumber
+
+                return f(_arrow401)(cells.GetCellsInColumn(index)).Address.RowNumber
+
+
+        def _arrow404(projection: Callable[[FsCell], int]) -> Callable[[IEnumerable_1[FsCell]], FsCell]:
+            def _arrow403(source_1: IEnumerable_1[FsCell]) -> FsCell:
+                class ObjectExpr402:
+                    @property
+                    def Compare(self) -> Callable[[int, int], int]:
+                        return compare_primitives
+
+                return min_by(projection, source_1, ObjectExpr402())
+
+            return _arrow403
+
+        min_row_index: int = get_index_by(_arrow404) or 0
+        def _arrow407(projection_1: Callable[[FsCell], int]) -> Callable[[IEnumerable_1[FsCell]], FsCell]:
+            def _arrow406(source_2: IEnumerable_1[FsCell]) -> FsCell:
+                class ObjectExpr405:
+                    @property
+                    def Compare(self) -> Callable[[int, int], int]:
+                        return compare_primitives
+
+                return max_by(projection_1, source_2, ObjectExpr405())
+
+            return _arrow406
+
+        max_row_index: int = get_index_by(_arrow407) or 0
+        return FsColumn(FsRangeAddress(FsAddress(min_row_index, index), FsAddress(max_row_index, index)), cells)
+
+    @property
+    def Cells(self, __unit: None=None) -> IEnumerable_1[FsCell]:
+        this: FsColumn = self
+        return super().Cells(this.cells_004018)
+
+    @property
+    def Index(self, __unit: None=None) -> int:
+        this: FsColumn = self
+        return this.RangeAddress.FirstAddress.ColumnNumber
+
+    @Index.setter
+    def Index(self, i: int) -> None:
+        this: FsColumn = self
+        this.RangeAddress.FirstAddress.ColumnNumber = i or 0
+        this.RangeAddress.LastAddress.ColumnNumber = i or 0
+
+    @property
+    def MinRowIndex(self, __unit: None=None) -> int:
+        this: FsColumn = self
+        return this.RangeAddress.FirstAddress.RowNumber
+
+    @property
+    def MaxRowIndex(self, __unit: None=None) -> int:
+        this: FsColumn = self
+        return this.RangeAddress.LastAddress.RowNumber
+
+    def Copy(self, __unit: None=None) -> FsColumn:
+        this: FsColumn = self
+        ra: FsRangeAddress = this.RangeAddress.Copy()
+        def mapping(c: FsCell) -> FsCell:
+            return c.Copy()
+
+        cells: IEnumerable_1[FsCell] = map(mapping, this.Cells)
+        fcc: FsCellsCollection = FsCellsCollection()
+        fcc.AddMany(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 super().Cell(FsAddress(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 = _expr409
+
+def FsColumn__ctor_7678C70A(range_address: FsRangeAddress, cells: FsCellsCollection) -> FsColumn:
+    return FsColumn(range_address, cells)
+
+
+__all__ = ["FsColumn_reflection"]
+