flet-datatable2 0.1.0.dev1__tar.gz

flet_datatable2-0.1.0.dev1/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.2
+Name: flet-datatable2
+Version: 0.1.0.dev1
+Summary: DataTable2 control for Flet
+Author-email: Flet contributors <you@example.com>
+Project-URL: Homepage, https://mydomain.dev
+Project-URL: Documentation, https://github.com/MyGithubAccount/flet-datatable2
+Project-URL: Repository, https://github.com/MyGithubAccount/flet-datatable2
+Project-URL: Issues, https://github.com/MyGithubAccount/flet-datatable2/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: flet>=0.27.3
+
+# Flet DataTable2
+
+DataTable2 Control for Flet based on [DataTable2 package](https://pub.dev/packages/data_table_2) for Flutter. 
+
+DataTable2 features fixed/sticky header/top rows and left columns and many other useful features additionally to all the properties of built-in Flet [DataTable](https://flet.dev/docs/controls/datatable).
+
+## Installation
+
+Add dependency to `pyproject.toml` of your Flet app:
+
+```
+dependencies = [
+  "flet-datatable2 @ git+https://github.com/flet-dev/flet_datatable2.git",
+  "flet>=0.27.4",
+]
+```
+
+Build your app:
+```
+flet build macos -v
+```
+
+## Documentation
+
+https://flet-dev.github.io/flet-datatable2/

flet_datatable2-0.1.0.dev1/README.md

@@ -0,0 +1,25 @@
+# Flet DataTable2
+
+DataTable2 Control for Flet based on [DataTable2 package](https://pub.dev/packages/data_table_2) for Flutter. 
+
+DataTable2 features fixed/sticky header/top rows and left columns and many other useful features additionally to all the properties of built-in Flet [DataTable](https://flet.dev/docs/controls/datatable).
+
+## Installation
+
+Add dependency to `pyproject.toml` of your Flet app:
+
+```
+dependencies = [
+  "flet-datatable2 @ git+https://github.com/flet-dev/flet_datatable2.git",
+  "flet>=0.27.4",
+]
+```
+
+Build your app:
+```
+flet build macos -v
+```
+
+## Documentation
+
+https://flet-dev.github.io/flet-datatable2/

flet_datatable2-0.1.0.dev1/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "flet-datatable2"
+version = "0.1.0.dev1"
+description = "DataTable2 control for Flet"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+    { name = "Flet contributors", email = "you@example.com" }
+]
+dependencies = [
+    "flet>=0.27.3",
+]
+
+[project.urls]
+Homepage = "https://mydomain.dev"
+Documentation = "https://github.com/MyGithubAccount/flet-datatable2"
+Repository = "https://github.com/MyGithubAccount/flet-datatable2"
+Issues = "https://github.com/MyGithubAccount/flet-datatable2/issues"
+
+[tool.setuptools.package-data]
+"flutter.flet_datatable2" = ["**/*"]
+
+[tool.uv]
+dev-dependencies = [
+    "flet[all]==0.27.3",
+    "mkdocs", 
+    "mkdocs-material",
+    "mkdocstrings[python]"
+]
+
+[tool.poetry.group.dev.dependencies]
+flet = {extras = ["all"], version = "0.27.3"}
+mkdocs = "^1.0"
+mkdocstrings = { extras = ["python"], version = "^0.10" }
+mkdocs-material = "^8.0"
+
+[tool.setuptools]
+license-files = []
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

flet_datatable2-0.1.0.dev1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flet_datatable2-0.1.0.dev1/src/flet_datatable2/__init__.py

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

flet_datatable2-0.1.0.dev1/src/flet_datatable2/datacolumn2.py

@@ -0,0 +1,173 @@
+import json
+from enum import Enum
+from typing import Any, 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
+
+
+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.
+    """
+
+    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.
+
+    """
+
+    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
+
+    @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)

flet_datatable2-0.1.0.dev1/src/flet_datatable2/datarow2.py

@@ -0,0 +1,220 @@
+from typing import Any, List, 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
+
+
+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.
+    """
+
+    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**
+
+        Row right click handler. Won't be called if tapped cell has `tap` event.
+        """
+        return self._get_event_handler("secondary_tap")
+
+    @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)
+
+    # on_secondary_tap_down
+    @property
+    def on_secondary_tap_down(self) -> OptionalControlEventCallable:
+        """
+        **NEW**
+
+        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_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_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_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)