flet 0.70.0.dev5771__py3-none-any.whl → 0.70.0.dev5776__py3-none-any.whl

flet/controls/material/datatable.py

@@ -36,7 +36,7 @@ class DataColumn(Control):
     Column configuration for a [`DataTable`][flet.].
 
     Raises:
-        AssertionError: If the [`label`][(c).] is neither a string nor
+        ValueError: If the [`label`][(c).] is neither a string nor
             a visible control.
     """
 
@@ -82,9 +82,11 @@ class DataColumn(Control):
 
     def before_update(self):
         super().before_update()
-        assert isinstance(self.label, str) or (
-            isinstance(self.label, Control) and self.label.visible
-        ), "label must a string or a visible control"
+        if not (
+            isinstance(self.label, str)
+            or (isinstance(self.label, Control) and self.label.visible)
+        ):
+            raise ValueError("label must a string or a visible control")
 
 
 @control("DataCell")
@@ -93,7 +95,7 @@ class DataCell(Control):
     The data for a cell of a [`DataTable`][flet.].
 
     Raises:
-        AssertionError: If the [`content`][(c).] is neither a string nor a visible
+        ValueError: If the [`content`][(c).] is neither a string nor a visible
             control.
     """
 
@@ -185,8 +187,8 @@ class DataCell(Control):
 
     def before_update(self):
         super().before_update()
-        if isinstance(self.content, Control):
-            assert self.content.visible, "content must be visible"
+        if isinstance(self.content, Control) and not self.content.visible:
+            raise ValueError("content must be visible")
 
 
 @control("DataRow")
@@ -197,6 +199,9 @@ class DataRow(Control):
     One row configuration must be provided for each row to display in the table.
 
     The data for this row of the table is provided in the [`cells`][(c).] property.
+
+    Raises:
+        ValueError: If [`cells`][(c).] does not contain at least one visible DataCell.
     """
 
     cells: list[DataCell] = field(default_factory=list)
@@ -267,9 +272,8 @@ class DataRow(Control):
 
     def before_update(self):
         super().before_update()
-        assert any(cell.visible for cell in self.cells), (
-            "cells must contain at minimum one visible DataCell"
-        )
+        if not any(cell.visible for cell in self.cells):
+            raise ValueError("cells must contain at minimum one visible DataCell")
 
 
 @control("DataTable")
@@ -278,13 +282,13 @@ class DataTable(LayoutControl):
     A Material Design data table.
 
     Raises:
-        AssertionError: If there are no visible [`columns`][(c).].
-        AssertionError: If any visible row does not contain exactly as many visible
+        ValueError: If there are no visible [`columns`][(c).].
+        ValueError: If any visible row does not contain exactly as many visible
             [`DataRow.cells`][flet.] as there are visible [`columns`][(c).].
-        AssertionError: If [`data_row_min_height`][(c).] is greater than
+        ValueError: If [`data_row_min_height`][(c).] is greater than
             [`data_row_max_height`][(c).].
-        AssertionError: If [`divider_thickness`][(c).] is negative.
-        AssertionError: If [`sort_column_index`][(c).] is out of range.
+        ValueError: If [`divider_thickness`][(c).] is negative.
+        ValueError: If [`sort_column_index`][(c).] is out of range.
     """
 
     columns: list[DataColumn]
@@ -488,34 +492,37 @@ class DataTable(LayoutControl):
             list(filter(lambda column: column.visible, self.columns))
         )
         visible_rows = list(filter(lambda row: row.visible, self.rows))
-        assert visible_columns_count > 0, (
-            "columns must contain at minimum one visible DataColumn"
-        )
-        assert all(
+        if visible_columns_count == 0:
+            raise ValueError("columns must contain at minimum one visible DataColumn")
+        if not all(
             [
                 len([c for c in row.cells if c.visible]) == visible_columns_count
                 for row in visible_rows
             ]
-        ), (
-            f"each visible DataRow must contain exactly as many visible DataCells as "
-            f"there are visible DataColumns ({visible_columns_count})"
-        )
-        assert (
-            self.data_row_min_height is None
-            or self.data_row_max_height is None
-            or (self.data_row_min_height <= self.data_row_max_height)
-        ), (
-            f"data_row_min_height ({self.data_row_min_height}) must be less than or "
-            f"equal to data_row_max_height ({self.data_row_max_height})"
-        )
-        assert self.divider_thickness is None or self.divider_thickness >= 0, (
-            f"divider_thickness must be greater than or equal to 0, "
-            f"got {self.divider_thickness}"
-        )
-        assert self.sort_column_index is None or (
+        ):
+            raise ValueError(
+                f"each visible DataRow must contain exactly as many visible DataCells "
+                f"as there are visible DataColumns ({visible_columns_count})"
+            )
+        if (
+            self.data_row_min_height is not None
+            and self.data_row_max_height is not None
+            and self.data_row_min_height > self.data_row_max_height
+        ):
+            raise ValueError(
+                f"data_row_min_height ({self.data_row_min_height}) must be less than "
+                f"or equal to data_row_max_height ({self.data_row_max_height})"
+            )
+        if self.divider_thickness is not None and self.divider_thickness < 0:
+            raise ValueError(
+                f"divider_thickness must be greater than or equal to 0, "
+                f"got {self.divider_thickness}"
+            )
+        if self.sort_column_index is not None and not (
             0 <= self.sort_column_index < visible_columns_count
-        ), (
-            f"sort_column_index ({self.sort_column_index}) must be greater than or "
-            f"equal to 0 and less than the "
-            f"number of visible columns ({visible_columns_count})"
-        )
+        ):
+            raise ValueError(
+                f"sort_column_index ({self.sort_column_index}) must be greater than or "
+                f"equal to 0 and less than the "
+                f"number of visible columns ({visible_columns_count})"
+            )

flet/controls/material/divider.py

@@ -11,6 +11,12 @@ __all__ = ["Divider"]
 class Divider(Control):
     """
     A thin horizontal line (divider), with padding on either side.
+
+    Raises:
+        ValueError: If [`height`][(c).] is negative.
+        ValueError: If [`thickness`][(c).] is negative.
+        ValueError: If [`leading_indent`][(c).] is negative.
+        ValueError: If [`trailing_indent`][(c).] is negative.
     """
 
     color: Optional[ColorValue] = None
@@ -58,17 +64,21 @@ class Divider(Control):
 
     def before_update(self):
         super().before_update()
-        assert self.height is None or self.height >= 0, (
-            f"height must be greater than or equal to 0, got {self.height}"
-        )
-        assert self.thickness is None or self.thickness >= 0, (
-            f"thickness must be greater than or equal to 0, got {self.thickness}"
-        )
-        assert self.leading_indent is None or self.leading_indent >= 0, (
-            "leading_indent must be greater than or equal to 0, "
-            f"got {self.leading_indent}"
-        )
-        assert self.trailing_indent is None or self.trailing_indent >= 0, (
-            "trailing_indent must be greater than or equal to 0, "
-            f"got {self.trailing_indent}"
-        )
+        if self.height is not None and self.height < 0:
+            raise ValueError(
+                f"height must be greater than or equal to 0, got {self.height}"
+            )
+        if self.thickness is not None and self.thickness < 0:
+            raise ValueError(
+                f"thickness must be greater than or equal to 0, got {self.thickness}"
+            )
+        if self.leading_indent is not None and self.leading_indent < 0:
+            raise ValueError(
+                f"leading_indent must be greater than or equal to 0, "
+                f"got {self.leading_indent}"
+            )
+        if self.trailing_indent is not None and self.trailing_indent < 0:
+            raise ValueError(
+                f"trailing_indent must be greater than or equal to 0, "
+                f"got {self.trailing_indent}"
+            )

flet/controls/material/dropdown.py

@@ -30,6 +30,9 @@ class DropdownOption(Control):
     """
     Represents an item in a dropdown. Either `key` or `text` must be specified, else an
     `AssertionError` will be raised.
+
+    Raises:
+        ValueError: If neither [`key`][(c).] nor [`text`][(c).] are provided.
     """
 
     key: Optional[str] = None
@@ -66,9 +69,8 @@ class DropdownOption(Control):
 
     def before_update(self):
         super().before_update()
-        assert self.key is not None or self.text is not None, (
-            "key or text must be specified"
-        )
+        if self.key is None and self.text is None:
+            raise ValueError("key or text must be specified")
 
 
 Option = DropdownOption

flet/controls/material/expansion_tile.py

@@ -33,6 +33,9 @@ class ExpansionTile(LayoutControl, AdaptiveControl):
     """
     A single-line ListTile with an expansion arrow icon that expands or collapses the
     tile to reveal or hide its controls.
+
+    Raises:
+        ValueError: If [`title`][(c).] is neither a string nor a visible Control.
     """
 
     title: StrOrControl
@@ -108,28 +111,22 @@ class ExpansionTile(LayoutControl, AdaptiveControl):
     initially_expanded: bool = False
     """
     A boolean value which defines whether the tile is initially expanded or collapsed.
-
-    Defaults to `False`.
     """
 
     maintain_state: bool = False
     """
     A boolean value which defines whether the state of the `controls` is maintained
     when the tile expands and collapses.
-
-    Defaults to `False`.
     """
 
     text_color: Optional[ColorValue] = None
     """
-    The color of the tile's titles when the
-    sublist is expanded.
+    The color of the tile's titles when the sublist is expanded.
     """
 
     icon_color: Optional[ColorValue] = None
     """
-    The icon color of tile's expansion arrow
-    icon when the sublist is expanded.
+    The icon color of tile's expansion arrow icon when the sublist is expanded.
     """
 
     shape: Optional[OutlinedBorder] = None
@@ -139,26 +136,22 @@ class ExpansionTile(LayoutControl, AdaptiveControl):
 
     bgcolor: Optional[ColorValue] = None
     """
-    The  color to display behind the sublist
-    when expanded.
+    The  color to display behind the sublist when expanded.
     """
 
     collapsed_bgcolor: Optional[ColorValue] = None
     """
-    Defines the background color of tile when
-    the sublist is collapsed.
+    Defines the background color of tile when the sublist is collapsed.
     """
 
     collapsed_icon_color: Optional[ColorValue] = None
     """
-    The icon color of tile's expansion arrow
-    icon when the sublist is collapsed.
+    The icon color of tile's expansion arrow icon when the sublist is collapsed.
     """
 
     collapsed_text_color: Optional[ColorValue] = None
     """
-    The color of the tile's titles when the
-    sublist is collapsed.
+    The color of the tile's titles when the sublist is collapsed.
     """
 
     collapsed_shape: Optional[OutlinedBorder] = None
@@ -179,16 +172,12 @@ class ExpansionTile(LayoutControl, AdaptiveControl):
     Whether detected gestures should provide acoustic and/or haptic feedback. For
     example, on Android a tap will produce a clicking sound and a long-press will
     produce a short vibration, when feedback is enabled.
-
-    Defaults to `True`.
     """
 
     show_trailing_icon: bool = True
     """
     Whether to show the trailing icon (be it the default icon or the custom `trailing`,
     if specified and visible).
-
-    Defaults to `True`.
     """
 
     min_tile_height: Optional[Number] = None
@@ -208,5 +197,5 @@ class ExpansionTile(LayoutControl, AdaptiveControl):
 
     def before_update(self):
         super().before_update()
-        if isinstance(self.title, Control):
-            assert self.title.visible, "title must be visible"
+        if isinstance(self.title, Control) and not self.title.visible:
+            raise ValueError("title must be visible")

flet/controls/material/floating_action_button.py

@@ -27,9 +27,9 @@ class FloatingActionButton(LayoutControl):
     place on a page.
 
     Raises:
-        AssertionError: If neither [`icon`][(c).] nor a valid [`content`][(c).]
+        ValueError: If neither [`icon`][(c).] nor a valid [`content`][(c).]
             (string or visible Control) is provided.
-        AssertionError: If [`elevation`][(c).],
+        ValueError: If [`elevation`][(c).],
             [`disabled_elevation`][(c).], [`focus_elevation`][(c).],
             [`highlight_elevation`][(c).], or [`hover_elevation`][(c).]
             is negative.
@@ -161,27 +161,36 @@ class FloatingActionButton(LayoutControl):
 
     def before_update(self):
         super().before_update()
-        assert (
+        if not (
             self.icon
             or isinstance(self.content, str)
             or (isinstance(self.content, Control) and self.content.visible)
-        ), "at minimum, icon or a content (string or visible Control) must be provided"
-        assert self.elevation is None or self.elevation >= 0, (
-            f"elevation must be greater than or equal to 0, got {self.elevation}"
-        )
-        assert self.disabled_elevation is None or self.disabled_elevation >= 0, (
-            "disabled_elevation must be greater than or equal to 0, "
-            f"got {self.disabled_elevation}"
-        )
-        assert self.focus_elevation is None or self.focus_elevation >= 0, (
-            "focus_elevation must be greater than or equal to 0, "
-            f"got {self.focus_elevation}"
-        )
-        assert self.highlight_elevation is None or self.highlight_elevation >= 0, (
-            "highlight_elevation must be greater than or equal to 0, "
-            f"got {self.highlight_elevation}"
-        )
-        assert self.hover_elevation is None or self.hover_elevation >= 0, (
-            "hover_elevation must be greater than or equal to 0, "
-            f"got {self.hover_elevation}"
-        )
+        ):
+            raise ValueError(
+                "at minimum, icon or a content (string or visible Control) "
+                "must be provided"
+            )
+        if self.elevation is not None and self.elevation < 0:
+            raise ValueError(
+                f"elevation must be greater than or equal to 0, got {self.elevation}"
+            )
+        if self.disabled_elevation is not None and self.disabled_elevation < 0:
+            raise ValueError(
+                "disabled_elevation must be greater than or equal to 0, "
+                f"got {self.disabled_elevation}"
+            )
+        if self.focus_elevation is not None and self.focus_elevation < 0:
+            raise ValueError(
+                "focus_elevation must be greater than or equal to 0, "
+                f"got {self.focus_elevation}"
+            )
+        if self.highlight_elevation is not None and self.highlight_elevation < 0:
+            raise ValueError(
+                "highlight_elevation must be greater than or equal to 0, "
+                f"got {self.highlight_elevation}"
+            )
+        if self.hover_elevation is not None and self.hover_elevation < 0:
+            raise ValueError(
+                "hover_elevation must be greater than or equal to 0, "
+                f"got {self.hover_elevation}"
+            )

flet/controls/material/icon_button.py

@@ -34,6 +34,9 @@ class IconButton(LayoutControl, AdaptiveControl):
 
     Icon buttons are commonly used in the toolbars, but they can be used in many other
     places as well.
+
+    Raises:
+        ValueError: If [`splash_radius`][(c).] is not greater than `0`.
     """
 
     icon: Optional[IconDataOrControl] = None
@@ -200,9 +203,10 @@ class IconButton(LayoutControl, AdaptiveControl):
 
     def before_update(self):
         super().before_update()
-        assert self.splash_radius is None or self.splash_radius > 0, (
-            f"splash_radius must be greater than 0, got {self.splash_radius}"
-        )
+        if self.splash_radius is not None and self.splash_radius <= 0:
+            raise ValueError(
+                f"splash_radius must be greater than 0, got {self.splash_radius}"
+            )
         if (
             self.style is not None
             or self.bgcolor is not None

flet/controls/material/navigation_rail.py

@@ -28,7 +28,7 @@ class NavigationRailLabelType(Enum):
 @control("NavigationRailDestination")
 class NavigationRailDestination(Control):
     """
-    TBD
+    Represents a destination in a `NavigationRail`.
     """
 
     icon: Optional[IconDataOrControl] = None
@@ -81,6 +81,11 @@ class NavigationRail(LayoutControl):
     """
     A material widget that is meant to be displayed at the left or right of an app to
     navigate between a small number of views, typically between three and five.
+
+    Raises:
+        ValueError: If [`elevation`][(c).] is negative.
+        ValueError: If [`min_width`][(c).] is negative.
+        ValueError: If [`min_extended_width`][(c).] is negative.
     """
 
     destinations: list[NavigationRailDestination] = field(default_factory=list)
@@ -130,14 +135,12 @@ class NavigationRail(LayoutControl):
 
     bgcolor: Optional[ColorValue] = None
     """
-    Sets the color of the Container that holds
-    all of the NavigationRail's contents.
+    Sets the color of the Container that holds all of the NavigationRail's contents.
     """
 
     indicator_color: Optional[ColorValue] = None
     """
-    The color of the navigation rail's
-    indicator.
+    The color of the navigation rail's indicator.
     """
 
     indicator_shape: Optional[OutlinedBorder] = None
@@ -241,9 +244,9 @@ class NavigationRail(LayoutControl):
 
     def before_update(self):
         super().before_update()
-        if self.elevation is not None:
-            assert self.elevation >= 0, "elevation cannot be negative"
-        if self.min_width is not None:
-            assert self.min_width >= 0, "min_width cannot be negative"
-        if self.min_extended_width is not None:
-            assert self.min_extended_width >= 0, "min_extended_width cannot be negative"
+        if self.elevation is not None and self.elevation < 0:
+            raise ValueError("elevation cannot be negative")
+        if self.min_width is not None and self.min_width < 0:
+            raise ValueError("min_width cannot be negative")
+        if self.min_extended_width is not None and self.min_extended_width < 0:
+            raise ValueError("min_extended_width cannot be negative")

flet/controls/material/outlined_button.py

@@ -21,8 +21,11 @@ __all__ = ["OutlinedButton"]
 class OutlinedButton(LayoutControl, AdaptiveControl):
     """
     Outlined buttons are medium-emphasis buttons. They contain actions that are
-    important, but aren’t the primary action in an app. Outlined buttons pair well with
+    important, but aren't the primary action in an app. Outlined buttons pair well with
     filled buttons to indicate an alternative, secondary action.
+
+    Raises:
+        ValueError: If neither [`icon`][(c).] nor [`content`][(c).] is provided.
     """
 
     content: Optional[StrOrControl] = None
@@ -95,11 +98,12 @@ class OutlinedButton(LayoutControl, AdaptiveControl):
 
     def before_update(self):
         super().before_update()
-        assert (
+        if not (
             self.icon
             or isinstance(self.content, str)
             or (isinstance(self.content, Control) and self.content.visible)
-        ), "at minimum, icon or a visible content must be provided"
+        ):
+            raise ValueError("at minimum, icon or a visible content must be provided")
 
     async def focus(self):
         await self._invoke_method("focus")

flet/controls/material/progress_bar.py

@@ -14,6 +14,11 @@ class ProgressBar(LayoutControl):
     A material design linear progress indicator, also known as a progress bar.
 
     A control that shows progress along a line.
+
+    Raises:
+        ValueError: If [`value`][(c).] is negative.
+        ValueError: If [`bar_height`][(c).] is negative.
+        ValueError: If [`semantics_value`][(c).] is negative.
     """
 
     value: Optional[Number] = None
@@ -114,13 +119,16 @@ class ProgressBar(LayoutControl):
 
     def before_update(self):
         super().before_update()
-        assert self.value is None or self.value >= 0, (
-            f"value must be greater than or equal to 0, got {self.value}"
-        )
-        assert self.bar_height is None or self.bar_height >= 0, (
-            f"bar_height must be greater than or equal to 0, got {self.bar_height}"
-        )
-        assert self.semantics_value is None or self.semantics_value >= 0, (
-            f"semantics_value must be greater than or equal to 0, "
-            f"got {self.semantics_value}"
-        )
+        if self.value is not None and self.value < 0:
+            raise ValueError(
+                f"value must be greater than or equal to 0, got {self.value}"
+            )
+        if self.bar_height is not None and self.bar_height < 0:
+            raise ValueError(
+                f"bar_height must be greater than or equal to 0, got {self.bar_height}"
+            )
+        if self.semantics_value is not None and self.semantics_value < 0:
+            raise ValueError(
+                f"semantics_value must be greater than or equal to 0, "
+                f"got {self.semantics_value}"
+            )

flet/controls/material/radio_group.py

@@ -11,6 +11,9 @@ __all__ = ["RadioGroup"]
 class RadioGroup(Control):
     """
     Radio buttons let people select a single option from two or more choices.
+
+    Raises:
+        ValueError: If [`content`][(c).] is not visible.
     """
 
     content: Control
@@ -33,4 +36,5 @@ class RadioGroup(Control):
 
     def before_update(self):
         super().before_update()
-        assert self.content.visible, "content must be visible"
+        if not self.content.visible:
+            raise ValueError("content must be visible")

flet/controls/material/range_slider.py

@@ -20,6 +20,11 @@ class RangeSlider(LayoutControl):
     A range slider can be used to select from either a continuous or a discrete
     set of values.
     The default is to use a continuous range of values from min to max.
+
+    Raises:
+        ValueError: If [`end_value`][(c).] is greater than [`max`][(c).].
+        ValueError: If [`start_value`][(c).] is less than [`min`][(c).].
+        ValueError: If [`start_value`][(c).] is greater than [`end_value`][(c).].
     """
 
     start_value: Number
@@ -124,17 +129,12 @@ class RangeSlider(LayoutControl):
     """
 
     def before_update(self):
-        if self.max is not None:
-            assert self.end_value <= self.max, (
-                "end_value must be less than or equal to max"
-            )
-
-        if self.min is not None:
-            assert self.start_value >= self.min, (
-                "start_value must be greater than or equal to min"
-            )
-
-        assert self.start_value <= self.end_value, (
-            "start_value must be less than or equal to end_value"
-        )
+        if self.max is not None and self.end_value > self.max:
+            raise ValueError("end_value must be less than or equal to max")
+
+        if self.min is not None and self.start_value < self.min:
+            raise ValueError("start_value must be greater than or equal to min")
+
+        if self.start_value > self.end_value:
+            raise ValueError("start_value must be less than or equal to end_value")
         pass