flet-datatable2 0.1.0__py3-none-any.whl → 0.2.0.dev40__py3-none-any.whl

flet_datatable2/__init__.py

@@ -1,5 +1,4 @@
-"""DataTable2 control"""
-
-from flet_datatable2.datacolumn2 import DataColumn2, Size
-from flet_datatable2.datarow2 import DataRow2
-from flet_datatable2.datatable2 import DataTable2
+from .datacolumn2 import DataColumn2
+from .datarow2 import DataRow2
+from .datatable2 import DataTable2
+from .types import DataColumnSize

flet_datatable2/datacolumn2.py

@@ -1,173 +1,27 @@
-import json
-from enum import Enum
-from typing import Any, Optional
+from typing import Optional
 
-from flet.core.control import Control, OptionalNumber
-from flet.core.control_event import ControlEvent
-from flet.core.event_handler import EventHandler
-from flet.core.types import MainAxisAlignment, OptionalEventCallable
+import flet as ft
+from .types import DataColumnSize
 
+__all__ = ["DataColumn2"]
 
-class Size(Enum):
-    """Relative size of a column determines the share of total table width allocated to each individual column.
 
-    When determining column widths, ratios between `S`, `M` and `L` columns are kept (i.e. Large columns are set to 1.2x width of Medium ones).
-    See `DataTable2.smRatio`, `DataTable2.lmRatio`. Default S/M ratio is 0.67, L/M ratio is 1.2.
+@ft.control("DataColumn2")
+class DataColumn2(ft.DataColumn):
     """
+    Extends Flet [`DataColumn`](https://flet.dev/docs/controls/datatable/#datacolumn),
+    adding the ability to set relative column size and fixed column width.
 
-    S = "s"
-    M = "m"
-    L = "l"
-
-
-class DataColumnSortEvent(ControlEvent):
-    def __init__(self, e: ControlEvent):
-        super().__init__(e.target, e.name, e.data, e.control, e.page)
-        d = json.loads(e.data)
-        self.column_index: int = d.get("i")
-        self.ascending: bool = d.get("a")
-
-
-class DataColumn2(Control):
-    """Column configuration for a [DataTable2](datatable2.md).
-
-    One column configuration must be provided for each column to display in the table.
-
-    Additional to Flet [DataColumn](https://flet.dev/docs/controls/datatable/#datacolumn), adds the capability to set relative column size via size property.
-
+    Meant to be used as an item of [`DataTable2.columns`][(p).].
     """
 
-    def __init__(
-        self,
-        label: Control,
-        size: Optional[Size] = None,
-        numeric: Optional[bool] = None,
-        tooltip: Optional[str] = None,
-        fixed_width: OptionalNumber = None,
-        heading_row_alignment: Optional[MainAxisAlignment] = None,
-        on_sort: OptionalEventCallable[DataColumnSortEvent] = None,
-        #
-        # Control
-        #
-        ref=None,
-        visible: Optional[bool] = None,
-        disabled: Optional[bool] = None,
-        data: Any = None,
-    ):
-        Control.__init__(self, ref=ref, visible=visible, disabled=disabled, data=data)
-
-        self.__on_sort = EventHandler(lambda e: DataColumnSortEvent(e))
-        self._add_event_handler("sort", self.__on_sort.get_handler())
-
-        self.label = label
-        self.size = size
-        self.fixed_width = fixed_width
-        self.numeric = numeric
-        self.tooltip = tooltip
-        self.heading_row_alignment = heading_row_alignment
-        self.on_sort = on_sort
-
-    def _get_control_name(self):
-        return "datacolumn2"
-
-    def _get_children(self):
-        self.__label._set_attr_internal("n", "label")
-        return [self.__label]
-
-    def before_update(self):
-        super().before_update()
-        assert self.__label.visible, "label must be visible"
-
-    # label
-    @property
-    def label(self) -> Control:
-        """
-        See DataColumn [label](https://flet.dev/docs/controls/datatable#label).
-        """
-        return self.__label
-
-    @label.setter
-    def label(self, value: Control):
-        self.__label = value
-
-    # size
-    @property
-    def size(self) -> Optional[Size]:
-        """
-        **NEW**
-
-        Column sizes are determined based on available width by distributing it to individual columns accounting for their relative sizes.
-
-        Value is of type `Size` and defaults to `Size.S`.
-        """
-        return self.__size
-
-    @size.setter
-    def size(self, value: Optional[Size]):
-        self.__size = value
-        self._set_enum_attr("size", value, Size)
-
-    # numeric
-    @property
-    def numeric(self) -> bool:
-        """
-        See DataColumn [numeric](https://flet.dev/docs/controls/datatable#numeric).
-        """
-
-        return self._get_attr("numeric", data_type="bool", def_value=False)
-
-    @numeric.setter
-    def numeric(self, value: Optional[bool]):
-        self._set_attr("numeric", value)
-
-    # fixed_width
-    @property
-    def fixed_width(self) -> OptionalNumber:
-        """
-        **NEW**
-
-        Defines absolute width of the column in pixel (as opposed to relative `size` used by default).
-        """
-        return self._get_attr("fixedWidth")
-
-    @fixed_width.setter
-    def fixed_width(self, value: OptionalNumber):
-        self._set_attr("fixedWidth", value)
-
-    # tooltip
-    @property
-    def tooltip(self) -> Optional[str]:
-        """
-        See DataColumn [tooltip](https://flet.dev/docs/controls/datatable#tooltip).
-        """
-        return self._get_attr("tooltip")
-
-    @tooltip.setter
-    def tooltip(self, value: Optional[str]):
-        self._set_attr("tooltip", value)
-
-    # heading_row_alignment
-    @property
-    def heading_row_alignment(self) -> Optional[MainAxisAlignment]:
-        """
-        See DataColumn [heading_row_alignment](https://flet.dev/docs/controls/datatable#heading_row_alignment).
-        """
-        return self.__heading_row_alignment
-
-    @heading_row_alignment.setter
-    def heading_row_alignment(self, value: Optional[MainAxisAlignment]):
-        self.__heading_row_alignment = value
-        self._set_enum_attr("headingRowAlignment", value, MainAxisAlignment)
-
-    # on_sort
-    @property
-    def on_sort(self) -> OptionalEventCallable["DataColumnSortEvent"]:
-        """
-        See DataColumn [on_sort](https://flet.dev/docs/controls/datatable#on_sort).
-        """
-        return self.__on_sort.handler
+    fixed_width: Optional[ft.Number] = None
+    """
+    Defines absolute width of the column in pixels (as opposed to relative [`size`][..] used by default).
+    """
 
-    @on_sort.setter
-    def on_sort(self, handler: OptionalEventCallable["DataColumnSortEvent"]):
-        self.__on_sort.handler = handler
-        self._set_attr("onSort", True if handler is not None else None)
+    size: Optional[DataColumnSize] = DataColumnSize.S
+    """
+    Column sizes are determined based on available width by distributing 
+    it to individual columns accounting for their relative sizes. 
+    """

flet_datatable2/datarow2.py

@@ -1,220 +1,58 @@
-from typing import Any, List, Optional
+from typing import Optional
 
-from flet.core.box import BoxDecoration
-from flet.core.control import Control, OptionalNumber
-from flet.core.datatable import DataCell
-from flet.core.types import ColorValue, ControlStateValue, OptionalControlEventCallable
+import flet as ft
 
+__all__ = ["DataRow2"]
 
-class DataRow2(Control):
-    """
-    Extension of [DataRow](https://flet.dev/docs/controls/datatable#datarow).
 
-    Adds row level `tap` events. There are also `onSecondaryTap` and `onSecondaryTapDown` which are not available in DataCells and which can be useful in Desktop settings when a reaction to the right click is required.
+@ft.control("DataRow2")
+class DataRow2(ft.DataRow):
     """
+    Extends [`DataRow`](https://flet.dev/docs/controls/datatable#datarow).
 
-    def __init__(
-        self,
-        cells: List[DataCell],
-        color: ControlStateValue[ColorValue] = None,
-        decoration: Optional[BoxDecoration] = None,
-        specific_row_height: OptionalNumber = None,
-        selected: Optional[bool] = None,
-        on_long_press: OptionalControlEventCallable = None,
-        on_select_changed: OptionalControlEventCallable = None,
-        on_double_tap: OptionalControlEventCallable = None,
-        on_secondary_tap: OptionalControlEventCallable = None,
-        on_secondary_tap_down: OptionalControlEventCallable = None,
-        on_tap: OptionalControlEventCallable = None,
-        #
-        # Control
-        #
-        ref=None,
-        visible: Optional[bool] = None,
-        disabled: Optional[bool] = None,
-        data: Any = None,
-    ):
-        Control.__init__(self, ref=ref, visible=visible, disabled=disabled, data=data)
-
-        self.cells = cells
-        self.color = color
-        self.decoration = decoration
-        self.specific_row_height = specific_row_height
-        self.selected = selected
-        self.on_long_press = on_long_press
-        self.on_select_changed = on_select_changed
-        self.on_double_tap = on_double_tap
-        self.on_secondary_tap = on_secondary_tap
-        self.on_secondary_tap_down = on_secondary_tap_down
-        self.on_tap = on_tap
-
-    def _get_control_name(self):
-        return "datarow2"
-
-    def __contains__(self, item):
-        return item in self.__cells
-
-    def before_update(self):
-        super().before_update()
-        assert any(
-            cell.visible for cell in self.__cells
-        ), "cells must contain at minimum one visible DataCell"
-        self._set_attr_json("color", self.__color, wrap_attr_dict=True)
-        self._set_attr_json("decoration", self.__decoration)
-
-    def _get_children(self):
-        return self.__cells
-
-    # cells
-    @property
-    def cells(self) -> List[DataCell]:
-        """
-        See DataRow [cells](https://flet.dev/docs/controls/datatable#cells).
-        """
-        return self.__cells
-
-    @cells.setter
-    def cells(self, value: List[DataCell]):
-        # assert all(
-        #     isinstance(cell, DataCell) for cell in value
-        # ), "cells must contain only DataCell instances"
-        self.__cells = value
-
-    # color
-    @property
-    def color(self) -> ControlStateValue[str]:
-        """
-        See DataRow [color](https://flet.dev/docs/controls/datatable#color).
-        """
-        return self.__color
-
-    @color.setter
-    def color(self, value: ControlStateValue[str]):
-        self.__color = value
-
-    # decoration
-    @property
-    def decoration(self) -> Optional[BoxDecoration]:
-        """
-        **NEW**
-
-        Decoration to be applied to the given row. Value is an instance of [BoxDecoration](https://flet.dev/docs/reference/types/boxdecoration).
-        When applied, it `divider_thickness` won't take effect.
-        """
-        return self.__decoration
-
-    @decoration.setter
-    def decoration(self, value: Optional[BoxDecoration]):
-        self.__decoration = value
-
-    # specific_row_height
-    @property
-    def specific_row_height(self) -> OptionalNumber:
-        """
-        **NEW**
-
-        Specific row height. If not provided, `data_row_height` will be applied.
-        """
-        return self._get_attr("specificRowHeight")
-
-    @specific_row_height.setter
-    def specific_row_height(self, value: OptionalNumber):
-        self._set_attr("specificRowHeight", value)
-
-    # selected
-    @property
-    def selected(self) -> bool:
-        """
-        See DataRow [selected](https://flet.dev/docs/controls/datatable#selected).
-        """
-        return self._get_attr("selected", data_type="bool", def_value=False)
-
-    @selected.setter
-    def selected(self, value: Optional[bool]):
-        self._set_attr("selected", value)
-
-    # on_long_press
-    @property
-    def on_long_press(self) -> OptionalControlEventCallable:
-        """
-        See DataRow [on_long_press](https://flet.dev/docs/controls/datatable#on_long_press).
-        """
-        return self._get_event_handler("long_press")
-
-    @on_long_press.setter
-    def on_long_press(self, handler: OptionalControlEventCallable):
-        self._add_event_handler("long_press", handler)
-        self._set_attr("onLongPress", True if handler is not None else None)
-
-    # on_tap
-    @property
-    def on_tap(self) -> OptionalControlEventCallable:
-        """
-        **NEW**
-
-        Row tap handler. Won't be called if tapped cell has `tap` event handler.
-        """
-        return self._get_event_handler("tap")
-
-    @on_tap.setter
-    def on_tap(self, handler: OptionalControlEventCallable):
-        self._add_event_handler("tap", handler)
-        self._set_attr("onTap", True if handler is not None else None)
-
-    # on_double_tap
-    @property
-    def on_double_tap(self) -> OptionalControlEventCallable:
-        """
-        **NEW**
-
-        Row double tap handler. Won't be called if tapped cell has `tap` event handler.
-        """
-        return self._get_event_handler("double_tap")
-
-    @on_double_tap.setter
-    def on_double_tap(self, handler: OptionalControlEventCallable):
-        self._add_event_handler("double_tap", handler)
-        self._set_attr("onDoubleTap", True if handler is not None else None)
-
-    # on_secondary_tap
-    @property
-    def on_secondary_tap(self) -> OptionalControlEventCallable:
-        """
-        **NEW**
+    Adds row-level `tap` events. There are also [`on_secondary_tap`][(c).] and [`on_secondary_tap_down`][(c).],
+    which are not available in `DataCell`s and can be useful in desktop settings to handle right-click actions.
+    """
 
-        Row right click handler. Won't be called if tapped cell has `tap` event.
-        """
-        return self._get_event_handler("secondary_tap")
+    decoration: Optional[ft.BoxDecoration] = None
+    """
+    Decoration to be applied to the row. 
+    
+    Overrides `divider_thickness`.
+    """
 
-    @on_secondary_tap.setter
-    def on_secondary_tap(self, handler: OptionalControlEventCallable):
-        self._add_event_handler("secondary_tap", handler)
-        self._set_attr("onSecondaryTap", True if handler is not None else None)
+    specific_row_height: Optional[ft.Number] = None
+    """
+    Specific row height. 
+    
+    Falls back to `data_row_height` if not set.
+    """
 
-    # on_secondary_tap_down
-    @property
-    def on_secondary_tap_down(self) -> OptionalControlEventCallable:
-        """
-        **NEW**
+    on_double_tap: ft.OptionalControlEventHandler["DataRow2"] = None
+    """
+    Fires when the row is double-tapped.
+    
+    Ignored if the tapped cell has a `tap` handler.
+    """
 
-        Row right mouse down handler. Won't be called if tapped cell has `tap` event handler.
-        """
-        return self._get_event_handler("secondary_tap_down")
+    on_secondary_tap: ft.OptionalControlEventHandler["DataRow2"] = None
+    """
+    Fires when the row is right-clicked (secondary tap).
+    
+    Ignored if the tapped cell has a `tap` handler.
+    """
 
-    @on_secondary_tap_down.setter
-    def on_secondary_tap_down(self, handler: OptionalControlEventCallable):
-        self._add_event_handler("secondary_tap_down", handler)
-        self._set_attr("onSecondaryTapDown", True if handler is not None else None)
+    on_secondary_tap_down: ft.OptionalControlEventHandler["DataRow2"] = None
+    """
+    Fires when the row is right-clicked (secondary tap down).
+    
+    Ignored if the tapped cell has a `tap` handler.
+    """
 
-    # on_select_changed
-    @property
-    def on_select_changed(self) -> OptionalControlEventCallable:
-        """
-        See DataRow [on_select_changed](https://flet.dev/docs/controls/datatable#on_select_changed).
-        """
-        return self._get_event_handler("select_changed")
+    on_tap: ft.OptionalEventHandler[ft.TapEvent["DataRow2"]] = None
+    """
+    Fires when the row is tapped.
+    
+    Ignored if the tapped cell has a `tap` handler.
+    """
 
-    @on_select_changed.setter
-    def on_select_changed(self, handler: OptionalControlEventCallable):
-        self._add_event_handler("select_changed", handler)
-        self._set_attr("onSelectChanged", True if handler is not None else None)