arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/fable_modules/fs_spreadsheet/DSL/types.py

@@ -0,0 +1,314 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, Generic, TypeVar)
+from ...fable_library.list import (reduce, map, FSharpList, exists, pick, empty)
+from ...fable_library.reflection import (TypeInfo, string_type, class_type, union_type, list_type, int32_type, obj_type, tuple_type)
+from ...fable_library.string_ import (to_console, printf)
+from ...fable_library.types import (Array, Union)
+from ..Cells.fs_cell import DataType_reflection
+
+_T = TypeVar("_T")
+
+def _expr241() -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.Message", [], Message, lambda: [[("Item", string_type)], [("Item", class_type("System.Exception"))]])
+
+
+class Message(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Text", "Exception"]
+
+
+Message_reflection = _expr241
+
+def Message_message_Z721C83C5(s: str) -> Message:
+    return Message(0, s)
+
+
+def Message_message_2BC701FD(e: Any | None=None) -> Message:
+    return Message(1, e)
+
+
+def Message__MapText_11D407F6(this: Message, m: Callable[[str], str]) -> Message:
+    if this.tag == 1:
+        return this
+
+    else: 
+        return Message(0, m(this.fields[0]))
+
+
+
+def Message__AsString(this: Message) -> str:
+    if this.tag == 1:
+        return str(this.fields[0])
+
+    else: 
+        return this.fields[0]
+
+
+
+def Message__TryText(this: Message) -> str | None:
+    if this.tag == 0:
+        return this.fields[0]
+
+    else: 
+        return None
+
+
+
+def Message__TryException(this: Message) -> Exception | None:
+    if this.tag == 1:
+        return this.fields[0]
+
+    else: 
+        return None
+
+
+
+def Message__get_IsTxt(this: Message) -> bool:
+    if this.tag == 0:
+        return True
+
+    else: 
+        return False
+
+
+
+def Message__get_IsExc(this: Message) -> bool:
+    if this.tag == 0:
+        return True
+
+    else: 
+        return False
+
+
+
+def Messages_format(ms: FSharpList[Message]) -> str:
+    def reduction(a: str, b: str, ms: Any=ms) -> str:
+        return (a + ";") + b
+
+    def mapping(m: Message, ms: Any=ms) -> str:
+        return Message__AsString(m)
+
+    return reduce(reduction, map(mapping, ms))
+
+
+def Messages_fail(ms: FSharpList[Message]) -> Any:
+    s: str = Messages_format(ms)
+    def predicate(m: Message, ms: Any=ms) -> bool:
+        return Message__get_IsExc(m)
+
+    if exists(predicate, ms):
+        to_console(printf("s"))
+        def chooser(m_1: Message, ms: Any=ms) -> Exception | None:
+            return Message__TryException(m_1)
+
+        raise pick(chooser, ms)
+
+    else: 
+        raise Exception(s)
+
+
+
+def _expr242(gen0: TypeInfo) -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.SheetEntity`1", [gen0], SheetEntity_1, lambda: [[("Item1", gen0), ("Item2", list_type(Message_reflection()))], [("Item", list_type(Message_reflection()))], [("Item", list_type(Message_reflection()))]])
+
+
+class SheetEntity_1(Union, Generic[_T]):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Some", "NoneOptional", "NoneRequired"]
+
+
+SheetEntity_1_reflection = _expr242
+
+def SheetEntity_1_some_2B595(v: Any | None=None) -> SheetEntity_1[Any]:
+    return SheetEntity_1(0, v, empty())
+
+
+def SheetEntity_1__get_Messages(this: SheetEntity_1[Any]) -> FSharpList[Message]:
+    if this.tag == 1:
+        return this.fields[0]
+
+    elif this.tag == 2:
+        return this.fields[0]
+
+    else: 
+        return this.fields[1]
+
+
+
+def _expr243() -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.ColumnIndex", [], ColumnIndex, lambda: [[("Item", int32_type)]])
+
+
+class ColumnIndex(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Col"]
+
+
+ColumnIndex_reflection = _expr243
+
+def ColumnIndex__get_Index(self_1: ColumnIndex) -> int:
+    return self_1.fields[0]
+
+
+def _expr244() -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.RowIndex", [], RowIndex, lambda: [[("Item", int32_type)]])
+
+
+class RowIndex(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Row"]
+
+
+RowIndex_reflection = _expr244
+
+def RowIndex__get_Index(self_1: RowIndex) -> int:
+    return self_1.fields[0]
+
+
+def _expr245() -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.ColumnElement", [], ColumnElement, lambda: [[("Item1", RowIndex_reflection()), ("Item2", tuple_type(DataType_reflection(), obj_type))], [("Item", tuple_type(DataType_reflection(), obj_type))]])
+
+
+class ColumnElement(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["IndexedCell", "UnindexedCell"]
+
+
+ColumnElement_reflection = _expr245
+
+def _expr246() -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.RowElement", [], RowElement, lambda: [[("Item1", ColumnIndex_reflection()), ("Item2", tuple_type(DataType_reflection(), obj_type))], [("Item", tuple_type(DataType_reflection(), obj_type))]])
+
+
+class RowElement(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["IndexedCell", "UnindexedCell"]
+
+
+RowElement_reflection = _expr246
+
+def _expr247() -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.TableElement", [], TableElement, lambda: [[("Item", list_type(RowElement_reflection()))], [("Item", list_type(ColumnElement_reflection()))]])
+
+
+class TableElement(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["UnindexedRow", "UnindexedColumn"]
+
+
+TableElement_reflection = _expr247
+
+def TableElement__get_IsRow(this: TableElement) -> bool:
+    if this.tag == 0:
+        return True
+
+    else: 
+        return False
+
+
+
+def TableElement__get_IsColumn(this: TableElement) -> bool:
+    if this.tag == 1:
+        return True
+
+    else: 
+        return False
+
+
+
+def _expr248() -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.SheetElement", [], SheetElement, lambda: [[("Item1", string_type), ("Item2", list_type(TableElement_reflection()))], [("Item1", RowIndex_reflection()), ("Item2", list_type(RowElement_reflection()))], [("Item", list_type(RowElement_reflection()))], [("Item1", ColumnIndex_reflection()), ("Item2", list_type(ColumnElement_reflection()))], [("Item", list_type(ColumnElement_reflection()))], [("Item1", RowIndex_reflection()), ("Item2", ColumnIndex_reflection()), ("Item3", tuple_type(DataType_reflection(), obj_type))], [("Item", tuple_type(DataType_reflection(), obj_type))]])
+
+
+class SheetElement(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Table", "IndexedRow", "UnindexedRow", "IndexedColumn", "UnindexedColumn", "IndexedCell", "UnindexedCell"]
+
+
+SheetElement_reflection = _expr248
+
+def _expr249() -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.WorkbookElement", [], WorkbookElement, lambda: [[("Item", list_type(SheetElement_reflection()))], [("Item1", string_type), ("Item2", list_type(SheetElement_reflection()))]])
+
+
+class WorkbookElement(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["UnnamedSheet", "NamedSheet"]
+
+
+WorkbookElement_reflection = _expr249
+
+def _expr250() -> TypeInfo:
+    return union_type("FsSpreadsheet.DSL.Workbook", [], Workbook, lambda: [[("Item", list_type(WorkbookElement_reflection()))]])
+
+
+class Workbook(Union):
+    def __init__(self, tag: int, *fields: Any) -> None:
+        super().__init__()
+        self.tag: int = tag or 0
+        self.fields: Array[Any] = list(fields)
+
+    @staticmethod
+    def cases() -> list[str]:
+        return ["Workbook"]
+
+
+Workbook_reflection = _expr250
+
+__all__ = ["Message_reflection", "Message_message_Z721C83C5", "Message_message_2BC701FD", "Message__MapText_11D407F6", "Message__AsString", "Message__TryText", "Message__TryException", "Message__get_IsTxt", "Message__get_IsExc", "Messages_format", "Messages_fail", "SheetEntity_1_reflection", "SheetEntity_1_some_2B595", "SheetEntity_1__get_Messages", "ColumnIndex_reflection", "ColumnIndex__get_Index", "RowIndex_reflection", "RowIndex__get_Index", "ColumnElement_reflection", "RowElement_reflection", "TableElement_reflection", "TableElement__get_IsRow", "TableElement__get_IsColumn", "SheetElement_reflection", "WorkbookElement_reflection", "Workbook_reflection"]
+

arctrl/py/fable_modules/fs_spreadsheet/DSL/workbook_builder.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import Any
+from ...fable_library.list import (empty, FSharpList, map, append)
+from ...fable_library.reflection import (TypeInfo, class_type)
+from ...fable_library.string_ import (to_text, printf)
+from .types import (SheetEntity_1_some_2B595, SheetEntity_1, WorkbookElement, Message__MapText_11D407F6, Message, SheetEntity_1__get_Messages)
+
+def _expr272() -> TypeInfo:
+    return class_type("FsSpreadsheet.DSL.WorkbookBuilder", None, WorkbookBuilder)
+
+
+class WorkbookBuilder:
+    def __init__(self, __unit: None=None) -> None:
+        pass
+
+
+WorkbookBuilder_reflection = _expr272
+
+def WorkbookBuilder__ctor(__unit: None=None) -> WorkbookBuilder:
+    return WorkbookBuilder(__unit)
+
+
+def WorkbookBuilder_get_Empty(__unit: None=None) -> SheetEntity_1[FSharpList[WorkbookElement]]:
+    return SheetEntity_1_some_2B595(empty())
+
+
+def WorkbookBuilder__SignMessages_3F89FFFC(this: WorkbookBuilder, messages: FSharpList[Message]) -> FSharpList[Message]:
+    def mapping(m: Message, this: Any=this, messages: Any=messages) -> Message:
+        def _arrow273(__unit: None=None, m: Any=m) -> Callable[[str], str]:
+            clo: Callable[[str], str] = to_text(printf("In Workbook: %s"))
+            return clo
+
+        return Message__MapText_11D407F6(m, _arrow273())
+
+    return map(mapping, messages)
+
+
+def WorkbookBuilder__Combine_49CE2EC0(this: WorkbookBuilder, wx1: SheetEntity_1[FSharpList[WorkbookElement]], wx2: SheetEntity_1[FSharpList[WorkbookElement]]) -> SheetEntity_1[FSharpList[WorkbookElement]]:
+    (pattern_matching_result, l1, l2, messages1, messages2, messages2_1, messages1_1, f1, messages1_2, messages2_2, f2, messages1_3, messages2_3, messages1_4, messages2_4) = (None, None, None, None, None, None, None, None, None, None, None, None, None, None, None)
+    if wx1.tag == 2:
+        if wx2.tag == 2:
+            pattern_matching_result = 1
+            messages2_1 = wx2.fields[0]
+
+        else: 
+            pattern_matching_result = 2
+            messages1_1 = wx1.fields[0]
+
+
+    elif wx1.tag == 1:
+        if wx2.tag == 0:
+            pattern_matching_result = 4
+            f2 = wx2.fields[0]
+            messages1_3 = wx1.fields[0]
+            messages2_3 = wx2.fields[1]
+
+        elif wx2.tag == 1:
+            pattern_matching_result = 5
+            messages1_4 = wx1.fields[0]
+            messages2_4 = wx2.fields[0]
+
+        else: 
+            pattern_matching_result = 1
+            messages2_1 = wx2.fields[0]
+
+
+    elif wx2.tag == 2:
+        pattern_matching_result = 1
+        messages2_1 = wx2.fields[0]
+
+    elif wx2.tag == 1:
+        pattern_matching_result = 3
+        f1 = wx1.fields[0]
+        messages1_2 = wx1.fields[1]
+        messages2_2 = wx2.fields[0]
+
+    else: 
+        pattern_matching_result = 0
+        l1 = wx1.fields[0]
+        l2 = wx2.fields[0]
+        messages1 = wx1.fields[1]
+        messages2 = wx2.fields[1]
+
+    if pattern_matching_result == 0:
+        return SheetEntity_1(0, append(l1, l2), append(messages1, messages2))
+
+    elif pattern_matching_result == 1:
+        return SheetEntity_1(2, append(SheetEntity_1__get_Messages(wx1), messages2_1))
+
+    elif pattern_matching_result == 2:
+        return SheetEntity_1(2, append(messages1_1, SheetEntity_1__get_Messages(wx2)))
+
+    elif pattern_matching_result == 3:
+        return SheetEntity_1(0, f1, append(messages1_2, messages2_2))
+
+    elif pattern_matching_result == 4:
+        return SheetEntity_1(0, f2, append(messages1_3, messages2_3))
+
+    elif pattern_matching_result == 5:
+        return SheetEntity_1(1, append(messages1_4, messages2_4))
+
+
+
+__all__ = ["WorkbookBuilder_reflection", "WorkbookBuilder_get_Empty", "WorkbookBuilder__SignMessages_3F89FFFC", "WorkbookBuilder__Combine_49CE2EC0"]
+

arctrl/py/fable_modules/fs_spreadsheet/Json/cell.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_library.option import default_arg
+from ...fable_library.seq import map
+from ...fable_library.util import (to_enumerable, IEnumerable_1)
+from ...thoth_json_core.decode import (object, IOptionalGetter, int_1, IGetters)
+from ...thoth_json_core.types import (IEncodable, IEncoderHelpers_1, Decoder_1)
+from ..Cells.fs_cell import (FsCell, DataType)
+from ..fs_address import FsAddress__ctor_Z37302880
+from .value import (encode, decode)
+
+__A_ = TypeVar("__A_")
+
+def encode_no_number(cell: FsCell) -> IEncodable:
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("value", encode(cell.Value))])
+    class ObjectExpr281(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], cell: Any=cell) -> Any:
+            def mapping(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, values)
+            return helpers.encode_object(arg)
+
+    return ObjectExpr281()
+
+
+def encode_rows(cell: FsCell) -> IEncodable:
+    def _arrow283(__unit: None=None, cell: Any=cell) -> IEncodable:
+        value_1: int = cell.ColumnNumber or 0
+        class ObjectExpr282(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_signed_integral_number(value_1)
+
+        return ObjectExpr282()
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("column", _arrow283()), ("value", encode(cell.Value))])
+    class ObjectExpr286(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], cell: Any=cell) -> Any:
+            def mapping(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, values)
+            return helpers_1.encode_object(arg)
+
+    return ObjectExpr286()
+
+
+def decode_rows(row_number: int | None=None) -> Decoder_1[FsCell]:
+    def _arrow290(builder: IGetters, row_number: Any=row_number) -> FsCell:
+        def _arrow288(__unit: None=None) -> tuple[Any, DataType] | None:
+            object_arg: IOptionalGetter = builder.Optional
+            return object_arg.Field("value", decode)
+
+        pattern_input: tuple[Any, DataType] = default_arg(_arrow288(), ("", DataType(4)))
+        def _arrow289(__unit: None=None) -> int | None:
+            object_arg_1: IOptionalGetter = builder.Optional
+            return object_arg_1.Field("column", int_1)
+
+        c: int = default_arg(_arrow289(), 0) or 0
+        return FsCell(pattern_input[0], pattern_input[1], FsAddress__ctor_Z37302880(default_arg(row_number, 0), c))
+
+    return object(_arrow290)
+
+
+def encode_cols(cell: FsCell) -> IEncodable:
+    def _arrow293(__unit: None=None, cell: Any=cell) -> IEncodable:
+        value_1: int = cell.RowNumber or 0
+        class ObjectExpr292(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_signed_integral_number(value_1)
+
+        return ObjectExpr292()
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("row", _arrow293()), ("value", encode(cell.Value))])
+    class ObjectExpr296(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], cell: Any=cell) -> Any:
+            def mapping(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, values)
+            return helpers_1.encode_object(arg)
+
+    return ObjectExpr296()
+
+
+def decode_cols(col_number: int | None=None) -> Decoder_1[FsCell]:
+    def _arrow299(builder: IGetters, col_number: Any=col_number) -> FsCell:
+        def _arrow297(__unit: None=None) -> tuple[Any, DataType] | None:
+            object_arg: IOptionalGetter = builder.Optional
+            return object_arg.Field("value", decode)
+
+        pattern_input: tuple[Any, DataType] = default_arg(_arrow297(), ("", DataType(4)))
+        def _arrow298(__unit: None=None) -> int | None:
+            object_arg_1: IOptionalGetter = builder.Optional
+            return object_arg_1.Field("row", int_1)
+
+        return FsCell(pattern_input[0], pattern_input[1], FsAddress__ctor_Z37302880(default_arg(_arrow298(), 0), default_arg(col_number, 0)))
+
+    return object(_arrow299)
+
+
+__all__ = ["encode_no_number", "encode_rows", "decode_rows", "encode_cols", "decode_cols"]
+

arctrl/py/fable_modules/fs_spreadsheet/Json/column.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_library.option import default_arg
+from ...fable_library.seq import (map, empty)
+from ...fable_library.util import (to_enumerable, IEnumerable_1)
+from ...thoth_json_core.decode import (object, IOptionalGetter, int_1, seq as seq_1, 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 .cell import (encode_cols, encode_no_number, decode_cols)
+
+__A_ = TypeVar("__A_")
+
+def encode(col: FsColumn) -> IEncodable:
+    def _arrow301(__unit: None=None, col: Any=col) -> IEncodable:
+        value: int = col.Index or 0
+        class ObjectExpr300(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_signed_integral_number(value)
+
+        return ObjectExpr300()
+
+    def mapping(cell: FsCell, col: Any=col) -> IEncodable:
+        return encode_cols(cell)
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("number", _arrow301()), ("cells", seq(map(mapping, col.Cells)))])
+    class ObjectExpr302(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], col: Any=col) -> Any:
+            def mapping_1(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_1, values)
+            return helpers_1.encode_object(arg)
+
+    return ObjectExpr302()
+
+
+def encode_no_numbers(col: IEnumerable_1[FsCell]) -> IEncodable:
+    def mapping(cell: FsCell, col: Any=col) -> IEncodable:
+        return encode_no_number(cell)
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("cells", seq(map(mapping, col)))])
+    class ObjectExpr303(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], col: Any=col) -> 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 ObjectExpr303()
+
+
+def _arrow305(builder: IGetters) -> tuple[int | None, IEnumerable_1[FsCell]]:
+    n: int | None
+    object_arg: IOptionalGetter = builder.Optional
+    n = object_arg.Field("number", int_1)
+    def _arrow304(__unit: None=None) -> IEnumerable_1[FsCell] | None:
+        arg_3: Decoder_1[IEnumerable_1[FsCell]] = seq_1(decode_cols(n))
+        object_arg_1: IOptionalGetter = builder.Optional
+        return object_arg_1.Field("cells", arg_3)
+
+    return (n, default_arg(_arrow304(), empty()))
+
+
+decode: Decoder_1[tuple[int | None, IEnumerable_1[FsCell]]] = object(_arrow305)
+
+__all__ = ["encode", "encode_no_numbers", "decode"]
+

arctrl/py/fable_modules/fs_spreadsheet/Json/row.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+from typing import (Any, TypeVar)
+from ...fable_library.option import default_arg
+from ...fable_library.seq import (map, empty)
+from ...fable_library.util import (to_enumerable, IEnumerable_1)
+from ...thoth_json_core.decode import (object, IOptionalGetter, int_1, seq as seq_1, 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_row import FsRow
+from .cell import (encode_rows, encode_no_number, decode_rows)
+
+__A_ = TypeVar("__A_")
+
+def encode(row: FsRow) -> IEncodable:
+    def _arrow285(__unit: None=None, row: Any=row) -> IEncodable:
+        value: int = row.Index or 0
+        class ObjectExpr284(IEncodable):
+            def Encode(self, helpers: IEncoderHelpers_1[Any]) -> Any:
+                return helpers.encode_signed_integral_number(value)
+
+        return ObjectExpr284()
+
+    def mapping(cell: FsCell, row: Any=row) -> IEncodable:
+        return encode_rows(cell)
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("number", _arrow285()), ("cells", seq(map(mapping, row.Cells)))])
+    class ObjectExpr287(IEncodable):
+        def Encode(self, helpers_1: IEncoderHelpers_1[Any], row: Any=row) -> Any:
+            def mapping_1(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_1, values)
+            return helpers_1.encode_object(arg)
+
+    return ObjectExpr287()
+
+
+def encode_no_numbers(row: IEnumerable_1[FsCell]) -> IEncodable:
+    def mapping(cell: FsCell, row: Any=row) -> IEncodable:
+        return encode_no_number(cell)
+
+    values: IEnumerable_1[tuple[str, IEncodable]] = to_enumerable([("cells", seq(map(mapping, row)))])
+    class ObjectExpr291(IEncodable):
+        def Encode(self, helpers: IEncoderHelpers_1[Any], row: Any=row) -> 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 ObjectExpr291()
+
+
+def _arrow295(builder: IGetters) -> tuple[int | None, IEnumerable_1[FsCell]]:
+    n: int | None
+    object_arg: IOptionalGetter = builder.Optional
+    n = object_arg.Field("number", int_1)
+    def _arrow294(__unit: None=None) -> IEnumerable_1[FsCell] | None:
+        arg_3: Decoder_1[IEnumerable_1[FsCell]] = seq_1(decode_rows(n))
+        object_arg_1: IOptionalGetter = builder.Optional
+        return object_arg_1.Field("cells", arg_3)
+
+    return (n, default_arg(_arrow294(), empty()))
+
+
+decode: Decoder_1[tuple[int | None, IEnumerable_1[FsCell]]] = object(_arrow295)
+
+__all__ = ["encode", "encode_no_numbers", "decode"]
+