arctrl 3.0.0__py3-none-any.whl

arctrl/py/fable_modules/fs_spreadsheet/fs_row.py

@@ -0,0 +1,183 @@
+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 _expr400() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsRow", None, FsRow, FsRangeBase_reflection())
+
+
+class FsRow(FsRangeBase):
+    def __init__(self, range_address: FsRangeAddress, cells: FsCellsCollection) -> None:
+        super().__init__(range_address)
+        self.cells_004021: FsCellsCollection = cells
+
+    @staticmethod
+    def empty(__unit: None=None) -> FsRow:
+        return FsRow(FsRangeAddress(FsAddress(0, 0), FsAddress(0, 0)), FsCellsCollection())
+
+    @staticmethod
+    def create_at(index: int, cells: FsCellsCollection) -> FsRow:
+        def get_index_by(f: Callable[[Callable[[FsCell], int], IEnumerable_1[FsCell]], FsCell]) -> int:
+            if length(cells.GetCellsInRow(index)) == 0:
+                return 1
+
+            else: 
+                def _arrow393(c: FsCell, f: Any=f) -> int:
+                    return c.Address.ColumnNumber
+
+                return f(_arrow393)(cells.GetCellsInRow(index)).Address.ColumnNumber
+
+
+        def _arrow396(projection: Callable[[FsCell], int]) -> Callable[[IEnumerable_1[FsCell]], FsCell]:
+            def _arrow395(source_1: IEnumerable_1[FsCell]) -> FsCell:
+                class ObjectExpr394:
+                    @property
+                    def Compare(self) -> Callable[[int, int], int]:
+                        return compare_primitives
+
+                return min_by(projection, source_1, ObjectExpr394())
+
+            return _arrow395
+
+        min_col_index: int = get_index_by(_arrow396) or 0
+        def _arrow399(projection_1: Callable[[FsCell], int]) -> Callable[[IEnumerable_1[FsCell]], FsCell]:
+            def _arrow398(source_2: IEnumerable_1[FsCell]) -> FsCell:
+                class ObjectExpr397:
+                    @property
+                    def Compare(self) -> Callable[[int, int], int]:
+                        return compare_primitives
+
+                return max_by(projection_1, source_2, ObjectExpr397())
+
+            return _arrow398
+
+        max_col_index: int = get_index_by(_arrow399) or 0
+        return FsRow(FsRangeAddress(FsAddress(index, min_col_index), FsAddress(index, max_col_index)), cells)
+
+    @property
+    def Cells(self, __unit: None=None) -> IEnumerable_1[FsCell]:
+        this: FsRow = self
+        return super().Cells(this.cells_004021)
+
+    @property
+    def Index(self, __unit: None=None) -> int:
+        this: FsRow = self
+        return this.RangeAddress.FirstAddress.RowNumber
+
+    @Index.setter
+    def Index(self, i: int) -> None:
+        this: FsRow = self
+        this.RangeAddress.FirstAddress.RowNumber = i or 0
+        this.RangeAddress.LastAddress.RowNumber = i or 0
+
+    @property
+    def MinColIndex(self, __unit: None=None) -> int:
+        this: FsRow = self
+        return this.RangeAddress.FirstAddress.ColumnNumber
+
+    @property
+    def MaxColIndex(self, __unit: None=None) -> int:
+        this: FsRow = self
+        return this.RangeAddress.LastAddress.ColumnNumber
+
+    def Copy(self, __unit: None=None) -> FsRow:
+        this: FsRow = 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 FsRow(ra, fcc)
+
+    @staticmethod
+    def copy(row: FsRow) -> FsRow:
+        return row.Copy()
+
+    @staticmethod
+    def get_index(row: FsRow) -> int:
+        return row.Index
+
+    def HasCellAt(self, col_index: int) -> bool:
+        this: FsRow = self
+        def predicate(c: FsCell) -> bool:
+            return c.ColumnNumber == col_index
+
+        return exists(predicate, this.Cells)
+
+    @staticmethod
+    def has_cell_at(col_index: int, row: FsRow) -> bool:
+        return row.HasCellAt(col_index)
+
+    def Item(self, column_index: int) -> FsCell:
+        this: FsRow = self
+        return super().Cell(FsAddress(1, column_index), this.cells_004021)
+
+    @staticmethod
+    def item(col_index: int, row: FsRow) -> FsCell:
+        return row.Item(col_index)
+
+    def TryItem(self, col_index: int) -> FsCell | None:
+        this: FsRow = self
+        return this.Item(col_index) if this.HasCellAt(col_index) else None
+
+    @staticmethod
+    def try_item(col_index: int, row: FsRow) -> FsCell | None:
+        return row.TryItem(col_index)
+
+    def InsertValueAt(self, col_index: int, value: Any) -> None:
+        this: FsRow = self
+        cell: FsCell = FsCell(value)
+        this.cells_004021.Add(cell, this.Index, col_index)
+
+    @staticmethod
+    def insert_value_at(col_index: int, value: Any, row: FsRow) -> FsRow:
+        value_1: None = row.InsertValueAt(col_index, value)
+        ignore(None)
+        return row
+
+    def ToDenseRow(self, __unit: None=None) -> None:
+        this: FsRow = self
+        for i in range(this.MinColIndex, this.MaxColIndex + 1, 1):
+            ignore(this.Item(i))
+
+    @staticmethod
+    def to_dense_row(row: FsRow) -> FsRow:
+        row.ToDenseRow()
+        return row
+
+    @staticmethod
+    def create_dense_row_of(row: FsRow) -> FsRow:
+        new_row: FsRow = row.Copy()
+        new_row.ToDenseRow()
+        return new_row
+
+    def GetEnumerator(self, __unit: None=None) -> IEnumerator[FsCell]:
+        this: FsRow = 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: FsRow = self
+        return get_enumerator(this)
+
+
+FsRow_reflection = _expr400
+
+def FsRow__ctor_7678C70A(range_address: FsRangeAddress, cells: FsCellsCollection) -> FsRow:
+    return FsRow(range_address, cells)
+
+
+__all__ = ["FsRow_reflection"]
+

arctrl/py/fable_modules/fs_spreadsheet/fs_workbook.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+from collections.abc import Callable
+from ..fable_library.array_ import (map, remove_in_place, try_find as try_find_1, collect)
+from ..fable_library.option import (value as value_1, default_arg)
+from ..fable_library.reflection import (TypeInfo, class_type)
+from ..fable_library.seq import (exists, iterate, try_item, try_find)
+from ..fable_library.string_ import (to_fail, printf)
+from ..fable_library.types import Array
+from ..fable_library.util import (IEnumerable_1, ignore, equals, safe_hash, IDisposable)
+from .fs_worksheet import FsWorksheet
+from .Tables.fs_table import FsTable
+
+def _expr429() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsWorkbook", None, FsWorkbook)
+
+
+class FsWorkbook(IDisposable):
+    def __init__(self, __unit: None=None) -> None:
+        self._worksheets: Array[FsWorksheet] = []
+
+    def Copy(self, __unit: None=None) -> FsWorkbook:
+        self_1: FsWorkbook = self
+        def mapping(s: FsWorksheet) -> FsWorksheet:
+            return s.Copy()
+
+        shts: Array[FsWorksheet] = map(mapping, self_1.GetWorksheets()[:], None)
+        wb: FsWorkbook = FsWorkbook()
+        wb.AddWorksheets(shts)
+        return wb
+
+    @staticmethod
+    def copy(workbook: FsWorkbook) -> FsWorkbook:
+        return workbook.Copy()
+
+    def InitWorksheet(self, name: str) -> FsWorksheet:
+        self_1: FsWorkbook = self
+        sheet: FsWorksheet = FsWorksheet(name)
+        (self_1._worksheets.append(sheet))
+        return sheet
+
+    @staticmethod
+    def init_worksheet(name: str, workbook: FsWorkbook) -> FsWorksheet:
+        return workbook.InitWorksheet(name)
+
+    def AddWorksheet(self, sheet: FsWorksheet) -> None:
+        self_1: FsWorkbook = self
+        def predicate(ws: FsWorksheet) -> bool:
+            return ws.Name == sheet.Name
+
+        if exists(predicate, self_1._worksheets):
+            arg: str = sheet.Name
+            to_fail(printf("Could not add worksheet with name \"%s\" to workbook as it already contains a worksheet with the same name"))(arg)
+
+        else: 
+            (self_1._worksheets.append(sheet))
+
+
+    @staticmethod
+    def add_worksheet(sheet: FsWorksheet, workbook: FsWorkbook) -> FsWorkbook:
+        workbook.AddWorksheet(sheet)
+        return workbook
+
+    def AddWorksheets(self, sheets: IEnumerable_1[FsWorksheet]) -> None:
+        self_1: FsWorkbook = self
+        def action(sheet: FsWorksheet) -> None:
+            self_1.AddWorksheet(sheet)
+
+        iterate(action, sheets)
+
+    @staticmethod
+    def add_worksheets(sheets: IEnumerable_1[FsWorksheet], workbook: FsWorkbook) -> FsWorkbook:
+        workbook.AddWorksheets(sheets)
+        return workbook
+
+    def GetWorksheets(self, __unit: None=None) -> Array[FsWorksheet]:
+        self_1: FsWorkbook = self
+        return self_1._worksheets
+
+    @staticmethod
+    def get_worksheets(workbook: FsWorkbook) -> Array[FsWorksheet]:
+        return workbook.GetWorksheets()
+
+    def TryGetWorksheetAt(self, index: int) -> FsWorksheet | None:
+        self_1: FsWorkbook = self
+        return try_item(index - 1, self_1._worksheets)
+
+    @staticmethod
+    def try_get_worksheet_at(index: int, workbook: FsWorkbook) -> FsWorksheet | None:
+        return workbook.TryGetWorksheetAt(index)
+
+    def GetWorksheetAt(self, index: int) -> FsWorksheet:
+        self_1: FsWorkbook = self
+        match_value: FsWorksheet | None = self_1.TryGetWorksheetAt(index)
+        if match_value is None:
+            raise Exception(("FsWorksheet at position " + str(index)) + " is not present in the FsWorkbook.")
+
+        else: 
+            return match_value
+
+
+    @staticmethod
+    def get_worksheet_at(index: int, workbook: FsWorkbook) -> FsWorksheet:
+        return workbook.GetWorksheetAt(index)
+
+    def TryGetWorksheetByName(self, sheet_name: str) -> FsWorksheet | None:
+        self_1: FsWorkbook = self
+        def predicate(w: FsWorksheet) -> bool:
+            return w.Name == sheet_name
+
+        return try_find(predicate, self_1._worksheets)
+
+    @staticmethod
+    def try_get_worksheet_by_name(sheet_name: str, workbook: FsWorkbook) -> FsWorksheet | None:
+        return workbook.TryGetWorksheetByName(sheet_name)
+
+    def GetWorksheetByName(self, sheet_name: str) -> FsWorksheet:
+        self_1: FsWorkbook = self
+        try: 
+            return value_1(self_1.TryGetWorksheetByName(sheet_name))
+
+        except Exception as match_value:
+            raise Exception(("FsWorksheet with name " + sheet_name) + " is not present in the FsWorkbook.")
+
+
+    @staticmethod
+    def get_worksheet_by_name(sheet_name: str, workbook: FsWorkbook) -> FsWorksheet:
+        return workbook.GetWorksheetByName(sheet_name)
+
+    def RemoveWorksheet(self, name: str) -> None:
+        self_1: FsWorkbook = self
+        def _arrow427(__unit: None=None) -> FsWorksheet:
+            try: 
+                def _arrow426(ws: FsWorksheet) -> bool:
+                    return ws.Name == name
+
+                return default_arg(try_find_1(_arrow426, self_1._worksheets), None)
+
+            except Exception as match_value:
+                raise Exception(("FsWorksheet with name " + name) + " was not found in FsWorkbook.")
+
+
+        class ObjectExpr428:
+            @property
+            def Equals(self) -> Callable[[FsWorksheet, FsWorksheet], bool]:
+                return equals
+
+            @property
+            def GetHashCode(self) -> Callable[[FsWorksheet], int]:
+                return safe_hash
+
+        ignore(remove_in_place(_arrow427(), self_1._worksheets, ObjectExpr428()))
+
+    @staticmethod
+    def remove_worksheet(name: str, workbook: FsWorkbook) -> FsWorkbook:
+        workbook.RemoveWorksheet(name)
+        return workbook
+
+    def GetTables(self, __unit: None=None) -> Array[FsTable]:
+        self_1: FsWorkbook = self
+        def mapping(s: FsWorksheet) -> Array[FsTable]:
+            return list(s.Tables)
+
+        return collect(mapping, self_1.GetWorksheets()[:], None)
+
+    @staticmethod
+    def get_tables(workbook: FsWorkbook) -> Array[FsTable]:
+        return workbook.GetTables()
+
+    @staticmethod
+    def validate_for_write(workbook: FsWorkbook) -> None:
+        try: 
+            def action(ws: FsWorksheet) -> None:
+                FsWorksheet.validate_for_write(ws)
+
+            iterate(action, workbook.GetWorksheets())
+
+        except Exception as ex:
+            raise Exception(("FsWorkbook could not be validated for write: " + str(ex)) + "")
+
+
+    def Dispose(self, __unit: None=None) -> None:
+        pass
+
+
+FsWorkbook_reflection = _expr429
+
+def FsWorkbook__ctor(__unit: None=None) -> FsWorkbook:
+    return FsWorkbook(__unit)
+
+
+__all__ = ["FsWorkbook_reflection"]
+