arctrl 3.0.0__py3-none-any.whl

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

@@ -0,0 +1,54 @@
+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
+from ..Tables.fs_table import FsTable
+
+__A_ = TypeVar("__A_")
+
+def encode(sheet: FsTable) -> IEncodable:
+    def _arrow530(__unit: None=None, sheet: Any=sheet) -> IEncodable:
+        value: str = sheet.Name
+        class ObjectExpr529(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr529()
+
+    def _arrow532(__unit: None=None, sheet: Any=sheet) -> IEncodable:
+        value_1: str = sheet.RangeAddress.Range
+        class ObjectExpr531(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any]) -> Any:
+                return helpers_1.encode_string(value_1)
+
+        return ObjectExpr531()
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("name", _arrow530()), ("range", _arrow532())])
+    class ObjectExpr533(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 ObjectExpr533()
+
+
+def _arrow534(builder: IGetters) -> FsTable:
+    n: str
+    object_arg: IRequiredGetter = builder.Required
+    n = object_arg.Field("name", string)
+    r: str
+    object_arg_1: IRequiredGetter = builder.Required
+    r = object_arg_1.Field("range", string)
+    return FsTable(n, FsRangeAddress.from_string(r))
+
+
+decode: Decoder_1[FsTable] = object(_arrow534)
+
+__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 ObjectExpr498(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers.encode_string(value)
+
+        return ObjectExpr498()
+
+    elif str(type(value)) == "<class \'float\'>":
+        class ObjectExpr499(IEncodable):
+            def Encode(self, helpers_1: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_1.encode_decimal_number(value)
+
+        return ObjectExpr499()
+
+    elif str(type(value)) == "<class \'int\'>":
+        class ObjectExpr500(IEncodable):
+            def Encode(self, helpers_2: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_2.encode_signed_integral_number(value)
+
+        return ObjectExpr500()
+
+    elif str(type(value)) == "<class \'bool\'>":
+        class ObjectExpr501(IEncodable):
+            def Encode(self, helpers_3: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_3.encode_bool(value)
+
+        return ObjectExpr501()
+
+    elif isinstance(value, datetime):
+        value_5: str = to_string(value, "O", {}).split("+")[0]
+        class ObjectExpr502(IEncodable):
+            def Encode(self, helpers_4: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_4.encode_string(value_5)
+
+        return ObjectExpr502()
+
+    else: 
+        class ObjectExpr503(IEncodable):
+            def Encode(self, helpers_5: IEncoderHelpers_1[Any], value: Any=value) -> Any:
+                return helpers_5.encode_null()
+
+        return ObjectExpr503()
+
+
+
+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 ObjectExpr535(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 ObjectExpr535()
+
+
+def _arrow536(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(_arrow536)
+
+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 ObjectExpr537(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 ObjectExpr537()
+
+
+def _arrow538(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(_arrow538)
+
+__all__ = ["encode_rows", "decode_rows", "encode_columns", "decode_columns"]
+

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

@@ -0,0 +1,216 @@
+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 ..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 _arrow542(__unit: None=None, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEnumerable_1[IEncodable]:
+        def _arrow541(r: int) -> IEncodable:
+            def _arrow540(__unit: None=None) -> IEnumerable_1[FsCell]:
+                def _arrow539(c: int) -> IEnumerable_1[FsCell]:
+                    match_value: FsCell | None = sheet.CellCollection.TryGetCell(r, c)
+                    return singleton(FsCell("")) if (match_value is None) else singleton(match_value)
+
+                return collect(_arrow539, range_big_int(1, 1, sheet.MaxColumnIndex))
+
+            return encode_no_numbers(to_list(delay(_arrow540)))
+
+        return map(_arrow541, 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(_arrow542))) if no_numbering else seq(map(mapping, sheet.Rows))
+    def _arrow547(__unit: None=None, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEnumerable_1[tuple[str, IEncodable]]:
+        def _arrow544(__unit: None=None) -> IEncodable:
+            value: str = sheet.Name
+            class ObjectExpr543(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr543()
+
+        def _arrow546(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+            def _arrow545(__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(_arrow545))
+
+        return append(singleton(("name", _arrow544())), delay(_arrow546))
+
+    values_1: IEnumerable_1[tuple[str, IEncodable]] = to_list(delay(_arrow547))
+    class ObjectExpr548(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 ObjectExpr548()
+
+
+def _arrow550(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 _arrow549(__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(_arrow549(), 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(_arrow550)
+
+def encode_columns(no_numbering: bool, sheet: FsWorksheet) -> IEncodable:
+    sheet.RescanRows()
+    def _arrow554(__unit: None=None, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEnumerable_1[IEncodable]:
+        def _arrow553(c: int) -> IEncodable:
+            def _arrow552(__unit: None=None) -> IEnumerable_1[FsCell]:
+                def _arrow551(r: int) -> IEnumerable_1[FsCell]:
+                    match_value: FsCell | None = sheet.CellCollection.TryGetCell(r, c)
+                    return singleton(FsCell("")) if (match_value is None) else singleton(match_value)
+
+                return collect(_arrow551, range_big_int(1, 1, sheet.MaxRowIndex))
+
+            return encode_no_numbers_1(to_list(delay(_arrow552)))
+
+        return map(_arrow553, 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(_arrow554))) if no_numbering else seq(map(mapping, sheet.Columns))
+    def _arrow559(__unit: None=None, no_numbering: Any=no_numbering, sheet: Any=sheet) -> IEnumerable_1[tuple[str, IEncodable]]:
+        def _arrow556(__unit: None=None) -> IEncodable:
+            value: str = sheet.Name
+            class ObjectExpr555(IEncodable):
+                def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                    return helpers.encode_string(value)
+
+            return ObjectExpr555()
+
+        def _arrow558(__unit: None=None) -> IEnumerable_1[tuple[str, IEncodable]]:
+            def _arrow557(__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(_arrow557))
+
+        return append(singleton(("name", _arrow556())), delay(_arrow558))
+
+    values_1: IEnumerable_1[tuple[str, IEncodable]] = to_list(delay(_arrow559))
+    class ObjectExpr560(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 ObjectExpr560()
+
+
+def _arrow563(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(_arrow563)
+
+__all__ = ["encode_rows", "decode_rows", "encode_columns", "decode_columns"]
+

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

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from typing import Any
+from ...fable_library.option import some
+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
+from .fs_range_address import FsRangeAddress
+from .fs_range_base import (FsRangeBase, FsRangeBase_reflection)
+from .fs_range_row import FsRangeRow
+
+def _expr392() -> TypeInfo:
+    return class_type("FsSpreadsheet.FsRange", None, FsRange, FsRangeBase_reflection())
+
+
+class FsRange(FsRangeBase):
+    def __init__(self, range_address: FsRangeAddress, style_value: Any | None=None) -> None:
+        super().__init__(range_address)
+        pass
+
+    @staticmethod
+    def from_range_base(range_base: FsRangeBase) -> FsRange:
+        return FsRange(range_base.RangeAddress, some(None))
+
+    def Row(self, row: int) -> FsRangeRow:
+        if True if (row <= 0) else (((row + super().RangeAddress.FirstAddress.RowNumber) - 1) > 1048576):
+            raise Exception(int32_to_string(row), to_text(printf("Row number must be between 1 and %i"))(1048576))
+
+        return FsRangeRow(FsRangeAddress(FsAddress((super().RangeAddress.FirstAddress.RowNumber + row) - 1, super().RangeAddress.FirstAddress.ColumnNumber), FsAddress((super().RangeAddress.FirstAddress.RowNumber + row) - 1, super().RangeAddress.LastAddress.ColumnNumber)))
+
+    def FirstRow(self, __unit: None=None) -> FsRangeRow:
+        self_1: FsRange = self
+        return self_1.Row(1)
+
+
+FsRange_reflection = _expr392
+
+def FsRange__ctor_Z15E90CDC(range_address: FsRangeAddress, style_value: Any | None=None) -> FsRange:
+    return FsRange(range_address, style_value)
+
+
+__all__ = ["FsRange_reflection"]
+

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

@@ -0,0 +1,190 @@
+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)
+
+def _expr375() -> 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
+
+    @staticmethod
+    def from_string(range_address: str) -> FsRangeAddress:
+        pattern_input: tuple[str, str] = Range_toBoundaries(range_address)
+        return FsRangeAddress(FsAddress.from_string(pattern_input[0]), FsAddress.from_string(pattern_input[1]))
+
+    def Copy(self, __unit: None=None) -> FsRangeAddress:
+        self_1: FsRangeAddress = self
+        return FsRangeAddress.from_string(self_1.Range)
+
+    @staticmethod
+    def copy(range_address: FsRangeAddress) -> FsRangeAddress:
+        return range_address.Copy()
+
+    def Extend(self, address: FsAddress) -> None:
+        self_1: FsRangeAddress = self
+        if address.RowNumber < self_1._firstAddress.RowNumber:
+            self_1._firstAddress.RowNumber = address.RowNumber or 0
+
+        if address.RowNumber > self_1._lastAddress.RowNumber:
+            self_1._lastAddress.RowNumber = address.RowNumber or 0
+
+        if address.ColumnNumber < self_1._firstAddress.ColumnNumber:
+            self_1._firstAddress.ColumnNumber = address.ColumnNumber or 0
+
+        if address.ColumnNumber > self_1._lastAddress.ColumnNumber:
+            self_1._lastAddress.ColumnNumber = address.ColumnNumber or 0
+
+
+    def Normalize(self, __unit: None=None) -> None:
+        self_1: FsRangeAddress = self
+        pattern_input: tuple[int, int] = ((self_1.first_address.RowNumber, self_1.last_address.RowNumber)) if (self_1.first_address.RowNumber < self_1.last_address.RowNumber) else ((self_1.last_address.RowNumber, self_1.first_address.RowNumber))
+        pattern_input_1: tuple[int, int] = ((self_1.first_address.RowNumber, self_1.last_address.RowNumber)) if (self_1.first_address.RowNumber < self_1.last_address.RowNumber) else ((self_1.last_address.RowNumber, self_1.first_address.RowNumber))
+        self_1._firstAddress = FsAddress(pattern_input[0], pattern_input_1[0])
+        self_1._lastAddress = FsAddress(pattern_input[1], pattern_input_1[1])
+
+    @property
+    def Range(self, __unit: None=None) -> str:
+        self_1: FsRangeAddress = self
+        return Range_ofBoundaries(self_1._firstAddress.Address, self_1._lastAddress.Address)
+
+    @Range.setter
+    def Range(self, address: str) -> None:
+        self_1: FsRangeAddress = self
+        pattern_input: tuple[str, str] = Range_toBoundaries(address)
+        self_1._firstAddress = FsAddress.from_string(pattern_input[0])
+        self_1._lastAddress = FsAddress.from_string(pattern_input[1])
+
+    def __str__(self, __unit: None=None) -> str:
+        self_1: FsRangeAddress = self
+        return self_1.Range
+
+    @property
+    def FirstAddress(self, __unit: None=None) -> FsAddress:
+        self_1: FsRangeAddress = self
+        return self_1._firstAddress
+
+    @property
+    def LastAddress(self, __unit: None=None) -> FsAddress:
+        self_1: FsRangeAddress = self
+        return self_1._lastAddress
+
+    def Union(self, range_address: FsRangeAddress) -> FsRangeAddress:
+        self_1: FsRangeAddress = self
+        self_1.Extend(range_address.FirstAddress)
+        self_1.Extend(range_address.LastAddress)
+        return self_1
+
+
+FsRangeAddress_reflection = _expr375
+
+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
+
+
+
+__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"]
+