arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/fable_modules/fs_spreadsheet/Json/table.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_library.seq import map
+from ...fable_library.util import (to_enumerable, IEnumerable_1)
+from ...thoth_json_core.decode import (object, IRequiredGetter, string, IGetters)
+from ...thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ..Ranges.fs_range_address import (FsRangeAddress__get_Range, FsRangeAddress__ctor_Z721C83C5)
+from ..Ranges.fs_range_base import FsRangeBase__get_RangeAddress
+from ..Tables.fs_table import FsTable
+
+__A_ = TypeVar("__A_")
+
+def encode(sheet: FsTable) -> IEncodable:
+    def _arrow307(__unit: None=None, sheet: Any=sheet) -> IEncodable:
+        value: str = sheet.Name
+        class ObjectExpr306(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr306()
+
+    def _arrow309(__unit: None=None, sheet: Any=sheet) -> IEncodable:
+        value_1: str = FsRangeAddress__get_Range(FsRangeBase__get_RangeAddress(sheet))
+        class ObjectExpr308(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_1)
+
+        return ObjectExpr308()
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("name", _arrow307()), ("range", _arrow309())])
+    class ObjectExpr310(IEncodable):
+        def Encode(self, helpers_2: IEncoderHelpers_1[Any], sheet: Any=sheet) -> Any:
+            def mapping(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_2))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping, values)
+            return helpers_2.encode_object(arg)
+
+    return ObjectExpr310()
+
+
+def _arrow313(builder: IGetters) -> FsTable:
+    def _arrow311(__unit: None=None) -> str:
+        object_arg: IRequiredGetter = builder.Required
+        return object_arg.Field("name", string)
+
+    def _arrow312(__unit: None=None) -> str:
+        object_arg_1: IRequiredGetter = builder.Required
+        return object_arg_1.Field("range", string)
+
+    return FsTable(_arrow311(), FsRangeAddress__ctor_Z721C83C5(_arrow312()))
+
+
+decode: Decoder_1[FsTable] = object(_arrow313)
+
+__all__ = ["encode", "decode"]
+

arctrl/py/fable_modules/fs_spreadsheet/Json/value.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+from abc import abstractmethod
+from datetime import datetime
+from typing import (Any, Protocol)
+from ...fable_library.date import (to_universal_time, to_string)
+from ...fable_library.list import of_array
+from ...thoth_json_core.decode import (map, datetime_local, one_of, bool_1, int_1, float_1, string)
+from ...thoth_json_core.types import (Decoder_1, IEncodable, IEncoderHelpers_1)
+from ..Cells.fs_cell import DataType
+
+class DateTimeStatic(Protocol):
+    @abstractmethod
+    def from_time_stamp(self, timestamp: float) -> Any:
+        ...
+
+
+def PyTime_toUniversalTimePy(dt: Any) -> Any:
+    timestamp: float = to_universal_time(dt).timestamp()
+    return datetime.fromtimestamp(timestamp=timestamp)
+
+
+Decode_datetime: Decoder_1[Any] = map(PyTime_toUniversalTimePy, datetime_local)
+
+def encode(value: Any=None) -> IEncodable:
+    if str(type(value)) == "<class \'str\'>":
+        class ObjectExpr275(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr275()
+
+    elif str(type(value)) == "<class \'float\'>":
+        class ObjectExpr276(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_1.encode_decimal_number(value)
+
+        return ObjectExpr276()
+
+    elif str(type(value)) == "<class \'int\'>":
+        class ObjectExpr277(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_2.encode_signed_integral_number(value)
+
+        return ObjectExpr277()
+
+    elif str(type(value)) == "<class \'bool\'>":
+        class ObjectExpr278(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_3.encode_bool(value)
+
+        return ObjectExpr278()
+
+    elif isinstance(value, datetime):
+        value_5: str = to_string(value, "O", {}).split("+")[0]
+        class ObjectExpr279(IEncodable):
+            def Encode(self, helpers_4: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_4.encode_string(value_5)
+
+        return ObjectExpr279()
+
+    else: 
+        class ObjectExpr280(IEncodable):
+            def Encode(self, helpers_5: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_5.encode_null()
+
+        return ObjectExpr280()
+
+
+
+def ctor(b: bool) -> tuple[Any, DataType]:
+    return (b, DataType(1))
+
+
+def ctor_1(i: int) -> tuple[Any, DataType]:
+    return (i, DataType(2))
+
+
+def ctor_2(f: float) -> tuple[Any, DataType]:
+    return (f, DataType(2))
+
+
+def ctor_3(d_3: Any) -> tuple[Any, DataType]:
+    return (d_3, DataType(3))
+
+
+def ctor_4(s: str) -> tuple[Any, DataType]:
+    return (s, DataType(0))
+
+
+decode: Decoder_1[tuple[Any, DataType]] = one_of(of_array([map(ctor, bool_1), map(ctor_1, int_1), map(ctor_2, float_1), map(ctor_3, Decode_datetime), map(ctor_4, string)]))
+
+__all__ = ["PyTime_toUniversalTimePy", "Decode_datetime", "encode", "decode"]
+

arctrl/py/fable_modules/fs_spreadsheet/Json/workbook.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_library.seq import map
+from ...fable_library.util import (to_enumerable, IEnumerable_1)
+from ...thoth_json_core.decode import (object, seq as seq_1, IRequiredGetter, IGetters)
+from ...thoth_json_core.encode import seq
+from ...thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ..fs_workbook import FsWorkbook
+from ..fs_worksheet import FsWorksheet
+from .worksheet import (encode_rows as encode_rows_1, decode_rows as decode_rows_1, encode_columns as encode_columns_1, decode_columns as decode_columns_1)
+
+__A_ = TypeVar("__A_")
+
+def encode_rows(no_numbering: bool, wb: FsWorkbook) -> IEncodable:
+    def mapping(sheet: FsWorksheet, no_numbering: Any=no_numbering, wb: Any=wb) -> IEncodable:
+        return encode_rows_1(no_numbering, sheet)
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("sheets", seq(map(mapping, wb.GetWorksheets())))])
+    class ObjectExpr314(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], no_numbering: Any=no_numbering, wb: Any=wb) -> Any:
+            def mapping_1(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping_1, values)
+            return helpers.encode_object(arg)
+
+    return ObjectExpr314()
+
+
+def _arrow315(builder: IGetters) -> FsWorkbook:
+    wb: FsWorkbook = FsWorkbook()
+    ws: IEnumerable_1[FsWorksheet]
+    arg_1: Decoder_1[IEnumerable_1[FsWorksheet]] = seq_1(decode_rows_1)
+    object_arg: IRequiredGetter = builder.Required
+    ws = object_arg.Field("sheets", arg_1)
+    wb.AddWorksheets(ws)
+    return wb
+
+
+decode_rows: Decoder_1[FsWorkbook] = object(_arrow315)
+
+def encode_columns(no_numbering: bool, wb: FsWorkbook) -> IEncodable:
+    def mapping(sheet: FsWorksheet, no_numbering: Any=no_numbering, wb: Any=wb) -> IEncodable:
+        return encode_columns_1(no_numbering, sheet)
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("sheets", seq(map(mapping, wb.GetWorksheets())))])
+    class ObjectExpr316(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], no_numbering: Any=no_numbering, wb: Any=wb) -> Any:
+            def mapping_1(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping_1, values)
+            return helpers.encode_object(arg)
+
+    return ObjectExpr316()
+
+
+def _arrow317(builder: IGetters) -> FsWorkbook:
+    wb: FsWorkbook = FsWorkbook()
+    ws: IEnumerable_1[FsWorksheet]
+    arg_1: Decoder_1[IEnumerable_1[FsWorksheet]] = seq_1(decode_columns_1)
+    object_arg: IRequiredGetter = builder.Required
+    ws = object_arg.Field("sheets", arg_1)
+    wb.AddWorksheets(ws)
+    return wb
+
+
+decode_columns: Decoder_1[FsWorkbook] = object(_arrow317)
+
+__all__ = ["encode_rows", "decode_rows", "encode_columns", "decode_columns"]
+

arctrl/py/fable_modules/fs_spreadsheet/Json/worksheet.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_library.option import default_arg
+from ...fable_library.range import range_big_int
+from ...fable_library.seq import (to_list, delay, map, collect, singleton, append, is_empty, empty, iterate)
+from ...fable_library.util import (IEnumerable_1, ignore)
+from ...thoth_json_core.decode import (object, IRequiredGetter, string, seq as seq_1, IOptionalGetter, IGetters)
+from ...thoth_json_core.encode import seq
+from ...thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ..Cells.fs_cell import FsCell
+from ..Cells.fs_cells_collection import FsCellsCollection__TryGetCell_Z37302880
+from ..fs_column import FsColumn
+from ..fs_row import FsRow
+from ..fs_worksheet import FsWorksheet
+from ..Tables.fs_table import FsTable
+from .column import (encode_no_numbers as encode_no_numbers_1, encode as encode_2, decode as decode_2)
+from .row import (encode_no_numbers, encode, decode as decode_1)
+from .table import (encode as encode_1, decode)
+
+__A_ = TypeVar("__A_")
+
+def encode_rows(no_numbering: bool, sheet: FsWorksheet) -> IEncodable:
+    sheet.RescanRows()
+    def _arrow321(__unit: None=None, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEnumerable_1[IEncodable]:
+        def _arrow320(r: int) -> IEncodable:
+            def _arrow319(__unit: None=None) -> IEnumerable_1[FsCell]:
+                def _arrow318(c: int) -> IEnumerable_1[FsCell]:
+                    match_value: FsCell | None = FsCellsCollection__TryGetCell_Z37302880(sheet.CellCollection, r, c)
+                    return singleton(FsCell("")) if (match_value is None) else singleton(match_value)
+
+                return collect(_arrow318, range_big_int(1, 1, sheet.MaxColumnIndex))
+
+            return encode_no_numbers(to_list(delay(_arrow319)))
+
+        return map(_arrow320, range_big_int(1, 1, sheet.MaxRowIndex))
+
+    def mapping(row_1: FsRow, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEncodable:
+        return encode(row_1)
+
+    j_rows: IEncodable = seq(to_list(delay(_arrow321))) if no_numbering else seq(map(mapping, sheet.Rows))
+    def _arrow326(__unit: None=None, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEnumerable_1[tuple[str, IEncodable]]:
+        def _arrow323(__unit: None=None) -> IEncodable:
+            value: str = sheet.Name
+            class ObjectExpr322(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr322()
+
+        def _arrow325(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+            def _arrow324(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+                return singleton(("rows", j_rows))
+
+            return append(singleton(("tables", seq(map(encode_1, sheet.Tables)))) if (not is_empty(sheet.Tables)) else empty(), delay(_arrow324))
+
+        return append(singleton(("name", _arrow323())), delay(_arrow325))
+
+    values_1: IEnumerable_1[tuple[str, IEncodable]] = to_list(delay(_arrow326))
+    class ObjectExpr327(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], no_numbering: Any=no_numbering, sheet: Any=sheet) -> Any:
+            def mapping_2(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_1))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping_2, values_1)
+            return helpers_1.encode_object(arg)
+
+    return ObjectExpr327()
+
+
+def _arrow329(builder: IGetters) -> FsWorksheet:
+    row_index: int = 0
+    n: str
+    object_arg: IRequiredGetter = builder.Required
+    n = object_arg.Field("name", string)
+    ts: IEnumerable_1[FsTable] | None
+    arg_3: Decoder_1[IEnumerable_1[FsTable]] = seq_1(decode)
+    object_arg_1: IOptionalGetter = builder.Optional
+    ts = object_arg_1.Field("tables", arg_3)
+    def _arrow328(__unit: None=None) -> IEnumerable_1[tuple[int | None, IEnumerable_1[FsCell]]] | None:
+        arg_5: Decoder_1[IEnumerable_1[tuple[int | None, IEnumerable_1[FsCell]]]] = seq_1(decode_1)
+        object_arg_2: IOptionalGetter = builder.Optional
+        return object_arg_2.Field("rows", arg_5)
+
+    rs: IEnumerable_1[tuple[int | None, IEnumerable_1[FsCell]]] = default_arg(_arrow328(), empty())
+    sheet: FsWorksheet = FsWorksheet(n)
+    def action_1(tupled_arg: tuple[int | None, IEnumerable_1[FsCell]]) -> None:
+        nonlocal row_index
+        row_i: int | None = tupled_arg[0]
+        col_index: int = 0
+        row_i_1: int = ((row_index + 1) if (row_i is None) else row_i) or 0
+        row_index = row_i_1 or 0
+        r: FsRow = sheet.Row(row_i_1)
+        def action(cell: FsCell, tupled_arg: Any=tupled_arg) -> None:
+            nonlocal col_index
+            col_i: int
+            match_value: int = cell.ColumnNumber or 0
+            col_i = (col_index + 1) if (match_value == 0) else match_value
+            col_index = col_i or 0
+            c: FsCell = r.Item(col_i)
+            c.Value = cell.Value
+            c.DataType = cell.DataType
+
+        iterate(action, tupled_arg[1])
+
+    iterate(action_1, rs)
+    if ts is None:
+        pass
+
+    else: 
+        def action_2(t: FsTable) -> None:
+            ignore(sheet.AddTable(t))
+
+        iterate(action_2, ts)
+
+    return sheet
+
+
+decode_rows: Decoder_1[FsWorksheet] = object(_arrow329)
+
+def encode_columns(no_numbering: bool, sheet: FsWorksheet) -> IEncodable:
+    sheet.RescanRows()
+    def _arrow333(__unit: None=None, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEnumerable_1[IEncodable]:
+        def _arrow332(c: int) -> IEncodable:
+            def _arrow331(__unit: None=None) -> IEnumerable_1[FsCell]:
+                def _arrow330(r: int) -> IEnumerable_1[FsCell]:
+                    match_value: FsCell | None = FsCellsCollection__TryGetCell_Z37302880(sheet.CellCollection, r, c)
+                    return singleton(FsCell("")) if (match_value is None) else singleton(match_value)
+
+                return collect(_arrow330, range_big_int(1, 1, sheet.MaxRowIndex))
+
+            return encode_no_numbers_1(to_list(delay(_arrow331)))
+
+        return map(_arrow332, range_big_int(1, 1, sheet.MaxColumnIndex))
+
+    def mapping(col_1: FsColumn, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEncodable:
+        return encode_2(col_1)
+
+    j_columns: IEncodable = seq(to_list(delay(_arrow333))) if no_numbering else seq(map(mapping, sheet.Columns))
+    def _arrow338(__unit: None=None, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEnumerable_1[tuple[str, IEncodable]]:
+        def _arrow335(__unit: None=None) -> IEncodable:
+            value: str = sheet.Name
+            class ObjectExpr334(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr334()
+
+        def _arrow337(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+            def _arrow336(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+                return singleton(("columns", j_columns))
+
+            return append(singleton(("tables", seq(map(encode_1, sheet.Tables)))) if (not is_empty(sheet.Tables)) else empty(), delay(_arrow336))
+
+        return append(singleton(("name", _arrow335())), delay(_arrow337))
+
+    values_1: IEnumerable_1[tuple[str, IEncodable]] = to_list(delay(_arrow338))
+    class ObjectExpr339(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], no_numbering: Any=no_numbering, sheet: Any=sheet) -> Any:
+            def mapping_2(tupled_arg: tuple[str, IEncodable]) -> tuple[str, __A_]:
+                return (tupled_arg[0], tupled_arg[1].Encode(helpers_1))
+
+            arg: IEnumerable_1[tuple[str, __A_]] = map(mapping_2, values_1)
+            return helpers_1.encode_object(arg)
+
+    return ObjectExpr339()
+
+
+def _arrow340(builder: IGetters) -> FsWorksheet:
+    col_index: int = 0
+    n: str
+    object_arg: IRequiredGetter = builder.Required
+    n = object_arg.Field("name", string)
+    ts: IEnumerable_1[FsTable] | None
+    arg_3: Decoder_1[IEnumerable_1[FsTable]] = seq_1(decode)
+    object_arg_1: IOptionalGetter = builder.Optional
+    ts = object_arg_1.Field("tables", arg_3)
+    cs: IEnumerable_1[tuple[int | None, IEnumerable_1[FsCell]]]
+    arg_5: Decoder_1[IEnumerable_1[tuple[int | None, IEnumerable_1[FsCell]]]] = seq_1(decode_2)
+    object_arg_2: IRequiredGetter = builder.Required
+    cs = object_arg_2.Field("columns", arg_5)
+    sheet: FsWorksheet = FsWorksheet(n)
+    def action_1(tupled_arg: tuple[int | None, IEnumerable_1[FsCell]]) -> None:
+        nonlocal col_index
+        col_i: int | None = tupled_arg[0]
+        row_index: int = 0
+        col_i_1: int = ((col_index + 1) if (col_i is None) else col_i) or 0
+        col_index = col_i_1 or 0
+        col: FsColumn = sheet.Column(col_i_1)
+        def action(cell: FsCell, tupled_arg: Any=tupled_arg) -> None:
+            nonlocal row_index
+            row_i: int
+            match_value: int = cell.RowNumber or 0
+            row_i = (row_index + 1) if (match_value == 0) else match_value
+            row_index = row_i or 0
+            c: FsCell = col.Item(row_index)
+            c.Value = cell.Value
+            c.DataType = cell.DataType
+
+        iterate(action, tupled_arg[1])
+
+    iterate(action_1, cs)
+    if ts is None:
+        pass
+
+    else: 
+        def action_2(t: FsTable) -> None:
+            ignore(sheet.AddTable(t))
+
+        iterate(action_2, ts)
+
+    return sheet
+
+
+decode_columns: Decoder_1[FsWorksheet] = object(_arrow340)
+
+__all__ = ["encode_rows", "decode_rows", "encode_columns", "decode_columns"]
+

arctrl/py/fable_modules/fs_spreadsheet/Ranges/fs_range.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_library.reflection import (TypeInfo, class_type)
+from ...fable_library.string_ import (to_text, printf)
+from ...fable_library.util import int32_to_string
+from ..fs_address import (FsAddress__get_RowNumber, FsAddress__ctor_Z37302880, FsAddress__get_ColumnNumber)
+from .fs_range_address import (FsRangeAddress, FsRangeAddress__get_FirstAddress, FsRangeAddress__ctor_7E77A4A0, FsRangeAddress__get_LastAddress)
+from .fs_range_base import (FsRangeBase, FsRangeBase_reflection, FsRangeBase__get_RangeAddress)
+from .fs_range_row import (FsRangeRow__ctor_6A2513BC, FsRangeRow)
+
+def _expr175() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsRange", None, FsRange, FsRangeBase_reflection())
+
+
+class FsRange(FsRangeBase):
+    def __init__(self, range_address: FsRangeAddress, style_value: Any=None) -> None:
+        super().__init__(range_address)
+        pass
+
+
+FsRange_reflection = _expr175
+
+def FsRange__ctor_Z1F5897D9(range_address: FsRangeAddress, style_value: Any=None) -> FsRange:
+    return FsRange(range_address, style_value)
+
+
+def FsRange__ctor_6A2513BC(range_address: FsRangeAddress) -> FsRange:
+    return FsRange__ctor_Z1F5897D9(range_address, None)
+
+
+def FsRange__ctor_65705F1F(range_base: FsRangeBase) -> FsRange:
+    return FsRange__ctor_Z1F5897D9(FsRangeBase__get_RangeAddress(range_base), None)
+
+
+def FsRange__Row_Z524259A4(self_1: FsRange, row: int) -> FsRangeRow:
+    if True if (row <= 0) else (((row + FsAddress__get_RowNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(self_1)))) - 1) > 1048576):
+        raise Exception(int32_to_string(row), to_text(printf("Row number must be between 1 and %i"))(1048576))
+
+    return FsRangeRow__ctor_6A2513BC(FsRangeAddress__ctor_7E77A4A0(FsAddress__ctor_Z37302880((FsAddress__get_RowNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(self_1))) + row) - 1, FsAddress__get_ColumnNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(self_1)))), FsAddress__ctor_Z37302880((FsAddress__get_RowNumber(FsRangeAddress__get_FirstAddress(FsRangeBase__get_RangeAddress(self_1))) + row) - 1, FsAddress__get_ColumnNumber(FsRangeAddress__get_LastAddress(FsRangeBase__get_RangeAddress(self_1))))))
+
+
+def FsRange__FirstRow(self_1: FsRange) -> FsRangeRow:
+    return FsRange__Row_Z524259A4(self_1, 1)
+
+
+__all__ = ["FsRange_reflection", "FsRange__ctor_6A2513BC", "FsRange__ctor_65705F1F", "FsRange__Row_Z524259A4", "FsRange__FirstRow"]
+

arctrl/py/fable_modules/fs_spreadsheet/Ranges/fs_range_address.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+from ...fable_library.reflection import (TypeInfo, class_type)
+from ...fable_library.string_ import (to_text, printf, to_console)
+from ...fable_library.types import (Array, uint32)
+from ..fs_address import (FsAddress, CellReference_toIndices, CellReference_moveHorizontal, FsAddress__ctor_Z721C83C5, FsAddress__get_RowNumber, FsAddress__set_RowNumber_Z524259A4, FsAddress__get_ColumnNumber, FsAddress__set_ColumnNumber_Z524259A4, FsAddress__ctor_Z37302880, FsAddress__get_Address)
+
+def _expr161() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsRangeAddress", None, FsRangeAddress)
+
+
+class FsRangeAddress:
+    def __init__(self, first_address: FsAddress, last_address: FsAddress) -> None:
+        self.first_address: FsAddress = first_address
+        self.last_address: FsAddress = last_address
+        self._firstAddress: FsAddress = self.first_address
+        self._lastAddress: FsAddress = self.last_address
+
+    def __str__(self, __unit: None=None) -> str:
+        self_1: FsRangeAddress = self
+        return FsRangeAddress__get_Range(self_1)
+
+
+FsRangeAddress_reflection = _expr161
+
+def FsRangeAddress__ctor_7E77A4A0(first_address: FsAddress, last_address: FsAddress) -> FsRangeAddress:
+    return FsRangeAddress(first_address, last_address)
+
+
+def Range_ofBoundaries(from_cell_reference: str, to_cell_reference: str) -> str:
+    return to_text(printf("%s:%s"))(from_cell_reference)(to_cell_reference)
+
+
+def Range_toBoundaries(area: str) -> tuple[str, str]:
+    a: Array[str] = area.split(":")
+    return (a[0], a[1])
+
+
+def Range_rightBoundary(area: str) -> uint32:
+    return CellReference_toIndices(Range_toBoundaries(area)[1])[0]
+
+
+def Range_leftBoundary(area: str) -> uint32:
+    return CellReference_toIndices(Range_toBoundaries(area)[0])[0]
+
+
+def Range_upperBoundary(area: str) -> uint32:
+    return CellReference_toIndices(Range_toBoundaries(area)[0])[1]
+
+
+def Range_lowerBoundary(area: str) -> uint32:
+    return CellReference_toIndices(Range_toBoundaries(area)[1])[1]
+
+
+def Range_moveHorizontal(amount: int, area: str) -> str:
+    tupled_arg_1: tuple[str, str]
+    tupled_arg: tuple[str, str] = Range_toBoundaries(area)
+    tupled_arg_1 = (CellReference_moveHorizontal(amount, tupled_arg[0]), CellReference_moveHorizontal(amount, tupled_arg[1]))
+    return Range_ofBoundaries(tupled_arg_1[0], tupled_arg_1[1])
+
+
+def Range_moveVertical(amount: int, area: str) -> str:
+    tupled_arg_1: tuple[str, str]
+    tupled_arg: tuple[str, str] = Range_toBoundaries(area)
+    tupled_arg_1 = (CellReference_moveHorizontal(amount, tupled_arg[0]), CellReference_moveHorizontal(amount, tupled_arg[1]))
+    return Range_ofBoundaries(tupled_arg_1[0], tupled_arg_1[1])
+
+
+def Range_extendRight(amount: int, area: str) -> str:
+    tupled_arg_1: tuple[str, str]
+    tupled_arg: tuple[str, str] = Range_toBoundaries(area)
+    tupled_arg_1 = (tupled_arg[0], CellReference_moveHorizontal(amount, tupled_arg[1]))
+    return Range_ofBoundaries(tupled_arg_1[0], tupled_arg_1[1])
+
+
+def Range_extendLeft(amount: int, area: str) -> str:
+    tupled_arg_1: tuple[str, str]
+    tupled_arg: tuple[str, str] = Range_toBoundaries(area)
+    tupled_arg_1 = (CellReference_moveHorizontal(amount, tupled_arg[0]), tupled_arg[1])
+    return Range_ofBoundaries(tupled_arg_1[0], tupled_arg_1[1])
+
+
+def Range_referenceExceedsAreaRight(reference: str, area: str) -> bool:
+    return CellReference_toIndices(reference)[0] > Range_rightBoundary(area)
+
+
+def Range_referenceExceedsAreaLeft(reference: str, area: str) -> bool:
+    return CellReference_toIndices(reference)[0] < Range_leftBoundary(area)
+
+
+def Range_referenceExceedsAreaAbove(reference: str, area: str) -> bool:
+    return CellReference_toIndices(reference)[1] > Range_upperBoundary(area)
+
+
+def Range_referenceExceedsAreaBelow(reference: str, area: str) -> bool:
+    return CellReference_toIndices(reference)[1] < Range_lowerBoundary(area)
+
+
+def Range_referenceExceedsArea(reference: str, area: str) -> bool:
+    if True if (True if Range_referenceExceedsAreaRight(reference, area) else Range_referenceExceedsAreaLeft(reference, area)) else Range_referenceExceedsAreaAbove(reference, area):
+        return True
+
+    else: 
+        return Range_referenceExceedsAreaBelow(reference, area)
+
+
+
+def Range_isCorrect(area: str) -> bool:
+    try: 
+        hor: bool = Range_leftBoundary(area) <= Range_rightBoundary(area)
+        ver: bool = Range_upperBoundary(area) <= Range_lowerBoundary(area)
+        if not hor:
+            to_console(printf("Right area boundary must be higher or equal to left area boundary."))
+
+        if not ver:
+            to_console(printf("Lower area boundary must be higher or equal to upper area boundary."))
+
+        return ver if hor else False
+
+    except Exception as err:
+        arg_1: str = str(err)
+        to_console(printf("Area \"%s\" could not be parsed: %s"))(area)(arg_1)
+        return False
+
+
+
+def FsRangeAddress__ctor_Z721C83C5(range_address: str) -> FsRangeAddress:
+    pattern_input: tuple[str, str] = Range_toBoundaries(range_address)
+    return FsRangeAddress__ctor_7E77A4A0(FsAddress__ctor_Z721C83C5(pattern_input[0]), FsAddress__ctor_Z721C83C5(pattern_input[1]))
+
+
+def FsRangeAddress__Copy(self_1: FsRangeAddress) -> FsRangeAddress:
+    return FsRangeAddress__ctor_Z721C83C5(FsRangeAddress__get_Range(self_1))
+
+
+def FsRangeAddress_copy_6A2513BC(range_address: FsRangeAddress) -> FsRangeAddress:
+    return FsRangeAddress__Copy(range_address)
+
+
+def FsRangeAddress__Extend_6D30B323(self_1: FsRangeAddress, address: FsAddress) -> None:
+    if FsAddress__get_RowNumber(address) < FsAddress__get_RowNumber(self_1._firstAddress):
+        FsAddress__set_RowNumber_Z524259A4(self_1._firstAddress, FsAddress__get_RowNumber(address))
+
+    if FsAddress__get_RowNumber(address) > FsAddress__get_RowNumber(self_1._lastAddress):
+        FsAddress__set_RowNumber_Z524259A4(self_1._lastAddress, FsAddress__get_RowNumber(address))
+
+    if FsAddress__get_ColumnNumber(address) < FsAddress__get_ColumnNumber(self_1._firstAddress):
+        FsAddress__set_ColumnNumber_Z524259A4(self_1._firstAddress, FsAddress__get_ColumnNumber(address))
+
+    if FsAddress__get_ColumnNumber(address) > FsAddress__get_ColumnNumber(self_1._lastAddress):
+        FsAddress__set_ColumnNumber_Z524259A4(self_1._lastAddress, FsAddress__get_ColumnNumber(address))
+
+
+
+def FsRangeAddress__Normalize(self_1: FsRangeAddress) -> None:
+    pattern_input: tuple[int, int] = ((FsAddress__get_RowNumber(self_1.first_address), FsAddress__get_RowNumber(self_1.last_address))) if (FsAddress__get_RowNumber(self_1.first_address) < FsAddress__get_RowNumber(self_1.last_address)) else ((FsAddress__get_RowNumber(self_1.last_address), FsAddress__get_RowNumber(self_1.first_address)))
+    pattern_input_1: tuple[int, int] = ((FsAddress__get_RowNumber(self_1.first_address), FsAddress__get_RowNumber(self_1.last_address))) if (FsAddress__get_RowNumber(self_1.first_address) < FsAddress__get_RowNumber(self_1.last_address)) else ((FsAddress__get_RowNumber(self_1.last_address), FsAddress__get_RowNumber(self_1.first_address)))
+    self_1._firstAddress = FsAddress__ctor_Z37302880(pattern_input[0], pattern_input_1[0])
+    self_1._lastAddress = FsAddress__ctor_Z37302880(pattern_input[1], pattern_input_1[1])
+
+
+def FsRangeAddress__get_Range(self_1: FsRangeAddress) -> str:
+    return Range_ofBoundaries(FsAddress__get_Address(self_1._firstAddress), FsAddress__get_Address(self_1._lastAddress))
+
+
+def FsRangeAddress__set_Range_Z721C83C5(self_1: FsRangeAddress, address: str) -> None:
+    pattern_input: tuple[str, str] = Range_toBoundaries(address)
+    self_1._firstAddress = FsAddress__ctor_Z721C83C5(pattern_input[0])
+    self_1._lastAddress = FsAddress__ctor_Z721C83C5(pattern_input[1])
+
+
+def FsRangeAddress__get_FirstAddress(self_1: FsRangeAddress) -> FsAddress:
+    return self_1._firstAddress
+
+
+def FsRangeAddress__get_LastAddress(self_1: FsRangeAddress) -> FsAddress:
+    return self_1._lastAddress
+
+
+def FsRangeAddress__Union_6A2513BC(self_1: FsRangeAddress, range_address: FsRangeAddress) -> FsRangeAddress:
+    FsRangeAddress__Extend_6D30B323(self_1, FsRangeAddress__get_FirstAddress(range_address))
+    FsRangeAddress__Extend_6D30B323(self_1, FsRangeAddress__get_LastAddress(range_address))
+    return self_1
+
+
+__all__ = ["FsRangeAddress_reflection", "Range_ofBoundaries", "Range_toBoundaries", "Range_rightBoundary", "Range_leftBoundary", "Range_upperBoundary", "Range_lowerBoundary", "Range_moveHorizontal", "Range_moveVertical", "Range_extendRight", "Range_extendLeft", "Range_referenceExceedsAreaRight", "Range_referenceExceedsAreaLeft", "Range_referenceExceedsAreaAbove", "Range_referenceExceedsAreaBelow", "Range_referenceExceedsArea", "Range_isCorrect", "FsRangeAddress__ctor_Z721C83C5", "FsRangeAddress__Copy", "FsRangeAddress_copy_6A2513BC", "FsRangeAddress__Extend_6D30B323", "FsRangeAddress__Normalize", "FsRangeAddress__get_Range", "FsRangeAddress__set_Range_Z721C83C5", "FsRangeAddress__get_FirstAddress", "FsRangeAddress__get_LastAddress", "FsRangeAddress__Union_6A2513BC"]
+