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

flet/__init__.py

@@ -252,6 +252,7 @@ from flet.controls.material.date_picker import (
     DatePickerEntryModeChangeEvent,
     DatePickerMode,
 )
+from flet.controls.material.date_range_picker import DateRangePicker
 from flet.controls.material.divider import Divider
 from flet.controls.material.dropdown import Dropdown, DropdownOption
 from flet.controls.material.dropdownm2 import DropdownM2
@@ -624,6 +625,7 @@ __all__ = [
     "DatePickerEntryModeChangeEvent",
     "DatePickerMode",
     "DatePickerTheme",
+    "DateRangePicker",
     "DateTimeValue",
     "DecorationImage",
     "DialogControl",

flet/controls/adaptive_control.py

@@ -10,29 +10,32 @@ __all__ = ["AdaptiveControl"]
 class AdaptiveControl(Control):
     """
     Base class for controls that support adaptive behavior, which allows them to adjust
-    their appearance and behavior based on the target platform (ex: Material design on Android/Windows/Linux,
-    Cupertino design on iOS/macOS).
+    their appearance and behavior based on the target platform
+    (ex: Material design on Android/Windows/Linux, Cupertino design on iOS/macOS).
 
     The [`adaptive`][(c).] property is applicable in two common scenarios:
 
     1. **Platform-adaptive controls**:
-       These controls have a corresponding version on both Material and Cupertino platforms.
-       When `adaptive` is set to `True`, the control renders the appropriate platform-specific
-       implementation.
+        These controls have a corresponding version on both Material and Cupertino
+        platforms. When `adaptive` is set to `True`, the control renders the
+        appropriate platform-specific implementation.
 
     2. **Container controls**:
-       Controls that contain children (ex: [`Row`][flet.Row], [`Column`][flet.Column]) can pass
-       the `adaptive` value down to their children that do not explicitly define it themselves.
-       This enables nested adaptive behavior in complex layouts.
+        Controls that contain children (ex: [`Row`][flet.], [`Column`][flet.]) can pass
+        the `adaptive` value down to their children that do not explicitly define it
+        themselves. This enables nested adaptive behavior in complex layouts.
 
-    Extension developers can use this base class to create their own adaptive controls by
-    checking the `adaptive` flag at runtime and rendering accordingly.
+    Extension developers can use this base class to create their own adaptive controls
+    by checking the `adaptive` flag at runtime and rendering accordingly.
 
     Note:
         This class does not implement any platform-specific rendering itself.
-        It is up to the control inheriting from it to interpret the [`adaptive`][(c).] flag and render accordingly.
+        It is up to the control inheriting from it to interpret the [`adaptive`][(c).]
+        flag and render accordingly.
     """
+
     adaptive: Optional[bool] = None
     """
-    Enables platform-specific rendering or inheritance of adaptiveness from parent controls.
-    """
+    Enables platform-specific rendering or inheritance of adaptiveness
+    from parent controls.
+    """

flet/controls/base_page.py

@@ -167,8 +167,8 @@ class BasePage(AdaptiveControl):
         - This property is read-only.
         - To get or set the full window height including window chrome (e.g.,
             title bar and borders) when running a Flet app on desktop,
-            use the [`width`][flet.Window.width] property of
-            [`Page.window`][flet.Page.window] instead.
+            use the [`width`][flet.Window.] property of
+            [`Page.window`][flet.] instead.
     """
 
     height: Optional[Number] = None
@@ -179,8 +179,8 @@ class BasePage(AdaptiveControl):
         - This property is read-only.
         - To get or set the full window height including window chrome (e.g.,
             title bar and borders) when running a Flet app on desktop,
-            use the [`height`][flet.Window.height] property of
-            [`Page.window`][flet.Page.window] instead.
+            use the [`height`][flet.Window.] property of
+            [`Page.window`][flet.] instead.
     """
 
     title: Optional[str] = None
@@ -306,7 +306,7 @@ class BasePage(AdaptiveControl):
         This method adds the specified `dialog` to the active dialog stack
         and renders it on the page. If the dialog is already open, an exception
         is raised.
-        The [`on_dismiss`][flet.DialogControl.on_dismiss] handler of the dialog
+        The [`on_dismiss`][flet.DialogControl.] handler of the dialog
         is temporarily wrapped to ensure the dialog is removed from the stack and
         its dismissal event is triggered appropriately.
 

flet/controls/border.py

@@ -66,8 +66,9 @@ class BorderSide:
     This means that it will render faster than otherwise, but it might
     double-hit pixels, giving it a slightly darker/lighter result.
 
-    To omit the border entirely, set the [`style`][flet.BorderSide.style]
-    to [`BorderStyle.NONE`][flet.BorderStyle.NONE].
+    Tip:
+        To omit the border entirely, set the [`style`][(c).]
+        to [`BorderStyle.NONE`][flet.].
     """
 
     color: ColorValue = Colors.BLACK
@@ -161,7 +162,7 @@ class Border:
     A border comprised of four sides: `top`, `right`, `bottom`, `left`.
 
     Each side of the border is an instance of
-    [`BorderSide`][flet.BorderSide].
+    [`BorderSide`][flet.].
 
     Example:
         ```python

flet/controls/box.py

@@ -300,15 +300,13 @@ class BoxDecoration:
 
     image: Optional[DecorationImage] = None
     """
-    An image to paint above the background [`bgcolor`][flet.BoxDecoration.bgcolor]
-    or [`gradient`][flet.BoxDecoration.gradient].
+    An image to paint above the background [`bgcolor`][(c).] or [`gradient`][(c).].
     """
 
     border: Optional[Border] = None
     """
-    A border to draw above the background
-    [`bgcolor`][flet.BoxDecoration.bgcolor], [`gradient`][flet.BoxDecoration.gradient],
-    and [`image`][flet.BoxDecoration.image].
+    A border to draw above the background [`bgcolor`][(c).], [`gradient`][(c).],
+    and [`image`][(c).].
     """
 
     border_radius: Optional[BorderRadiusValue] = None
@@ -328,16 +326,13 @@ class BoxDecoration:
 
     shape: BoxShape = BoxShape.RECTANGLE
     """
-    The shape to fill the [`bgcolor`][flet.BoxDecoration.bgcolor],
-    [`gradient`][flet.BoxDecoration.gradient], and [`image`][
-    flet.BoxDecoration.image] into and to cast as the
-    [`shadows`][flet.BoxDecoration.shadows].
+    The shape to fill the [`bgcolor`][(c).], [`gradient`][(c).], and [`image`][(c).]
+    into and to cast as the [`shadows`][(c).].
     """
 
     blend_mode: Optional[BlendMode] = None
     """
-    The blend mode to apply to the background [`bgcolor`][flet.BoxDecoration.bgcolor]
-    or [`gradient`][flet.BoxDecoration.gradient].
+    The blend mode to apply to the background [`bgcolor`][(c).] or [`gradient`][(c).].
     """
 
     def __post_init__(self):

flet/controls/buttons.py

@@ -34,7 +34,7 @@ class ShapeBorder:
 
     See subclasses/implementations:
 
-    - [`OutlinedBorder`][flet.OutlinedBorder]
+    - [`OutlinedBorder`][flet.]
     """
 
 
@@ -45,11 +45,11 @@ class OutlinedBorder(ShapeBorder):
 
     See subclasses/implementations:
 
-    - [`BeveledRectangleBorder`][flet.BeveledRectangleBorder]
-    - [`ContinuousRectangleBorder`][flet.ContinuousRectangleBorder]
-    - [`CircleBorder`][flet.CircleBorder]
-    - [`RoundedRectangleBorder`][flet.RoundedRectangleBorder]
-    - [`StadiumBorder`][flet.StadiumBorder]
+    - [`BeveledRectangleBorder`][flet.]
+    - [`ContinuousRectangleBorder`][flet.]
+    - [`CircleBorder`][flet.]
+    - [`RoundedRectangleBorder`][flet.]
+    - [`StadiumBorder`][flet.]
     """
 
     side: Optional[BorderSide] = None
@@ -194,7 +194,7 @@ class ButtonStyle:
     background and shadow colors, content padding, border width and radius.
 
     Most of these style attributes could be configured for all or particular
-    [`ControlState`][flet.ControlState] of a button,
+    [`ControlState`][flet.] of a button,
     such as `HOVERED`, `FOCUSED`, `DISABLED` and others.
     """
 

flet/controls/context.py

@@ -10,13 +10,13 @@ class Context:
     Manages the context for Flet controls, including page reference
     and auto-update behavior.
 
-    Context instance is accessed via [`ft.context`][flet.context].
+    Context instance is accessed via [`flet.context`][flet.context].
     """
 
     @property
     def page(self) -> "Page":
         """
-        Returns the current [`Page`][flet.Page] associated with the context.
+        Returns the current [`Page`][flet.] associated with the context.
 
         For example:
 

flet/controls/control.py

@@ -19,13 +19,16 @@ class Control(BaseControl):
 
     expand: Optional[Union[bool, int]] = None
     """
-    Specifies whether/how this control should expand to fill available space in its parent layout.
+    Specifies whether/how this control should expand to fill available space in its
+    parent layout.
 
-    More information [here](https://docs.flet-docs.pages.dev/cookbook/expanding-controls/#expand).
+    More information
+    [here](https://docs.flet-docs.pages.dev/cookbook/expanding-controls/#expand).
 
     Note:
-        Has effect only if the direct parent of this control is one of the following controls, or their subclasses:
-        [`Column`][flet.Column], [`Row`][flet.Row], [`View`][flet.View], [`Page`][flet.Page].
+        Has effect only if the direct parent of this control is one of the following
+        controls, or their subclasses: [`Column`][flet.], [`Row`][flet.],
+        [`View`][flet.], [`Page`][flet.].
     """
 
     expand_loose: bool = False
@@ -33,25 +36,28 @@ class Control(BaseControl):
     Allows the control to expand along the main axis if space is available,
     but does not require it to fill all available space.
 
-    More information [here](https://docs.flet-docs.pages.dev/cookbook/expanding-controls/#expand_loose).
+    More information
+    [here](https://docs.flet-docs.pages.dev/cookbook/expanding-controls/#expand_loose).
 
     Note:
         If `expand_loose` is `True`, it will have effect only if:
 
         - `expand` is not `None` and
-        - the direct parent of this control is one of the following controls, or their subclasses:
-            [`Column`][flet.Column], [`Row`][flet.Row], [`View`][flet.View], [`Page`][flet.Page].
+        - the direct parent of this control is one of the following controls, or their
+            subclasses: [`Column`][flet.], [`Row`][flet.], [`View`][flet.],
+            [`Page`][flet.].
     """
 
-    col: ResponsiveNumber = 12  # todo: if dict, validate keys with those in parent (ResponsiveRow.breakpoints)
+    # todo: if dict, validate keys with those in parent (ResponsiveRow.breakpoints)
+    col: ResponsiveNumber = 12
     """
-    If a parent of this control is a [`ResponsiveRow`][flet.ResponsiveRow], 
+    If a parent of this control is a [`ResponsiveRow`][flet.],
     this property is used to determine
     how many virtual columns of a screen this control will span.
 
     Can be a number or a dictionary configured to have a different value for specific
     breakpoints, for example `col={"sm": 6}`.
-    
+
     This control spans the 12 virtual columns by default.
 
     /// details | Dimensions
@@ -99,7 +105,8 @@ class Control(BaseControl):
     its children are enabled.
 
     Note:
-        The value of this property will be propagated down to all children controls recursively.
+        The value of this property will be propagated down to all children controls
+        recursively.
 
     /// details | Example
         type: example

flet/controls/core/animated_switcher.py

@@ -27,39 +27,35 @@ class AnimatedSwitcher(LayoutControl):
 
     content: Control
     """
-    The content to display. When the [`content`][flet.AnimatedSwitcher.content] changes,
-    this switcher will animate the transition from the old/previous
-    [`content`][flet.AnimatedSwitcher.content] to the new one.
+    The content to display.
+
+    When it changes, this switcher will animate the transition from the old/previous
+    `content` to the new one.
     """
 
     duration: DurationValue = field(default_factory=lambda: Duration(seconds=1))
     """
-    The duration of the transition from the old
-    [`content`][flet.AnimatedSwitcher.content] to the new one.
+    The duration of the transition from the old [`content`][(c).] to the new one.
     """
 
     reverse_duration: DurationValue = field(default_factory=lambda: Duration(seconds=1))
     """
-    The duration of the transition from the new
-    [`content`][flet.AnimatedSwitcher.content] to the old one.
+    The duration of the transition from the new [`content`][(c).] to the old one.
     """
 
     switch_in_curve: AnimationCurve = AnimationCurve.LINEAR
     """
-    The animation curve to use when transitioning in a
-    new [`content`][flet.AnimatedSwitcher.content].
+    The animation curve to use when transitioning in a new [`content`][(c).].
     """
 
     switch_out_curve: AnimationCurve = AnimationCurve.LINEAR
     """
-    The animation curve to use when transitioning an old
-    [`content`][flet.AnimatedSwitcher.content] out.
+    The animation curve to use when transitioning an old [`content`][(c).] out.
     """
 
     transition: AnimatedSwitcherTransition = AnimatedSwitcherTransition.FADE
     """
-    An animation type to transition between new and old
-    [`content`][flet.AnimatedSwitcher.content].
+    An animation type to transition between new and old [`content`][(c).].
     """
 
     def before_update(self):

flet/controls/core/canvas/canvas.py

@@ -45,7 +45,7 @@ class Canvas(LayoutControl):
     """
     Sampling interval in milliseconds for `on_resize` event.
 
-    Setting to `0` calls [`on_resize`][flet.canvas.Canvas.on_resize] immediately
+    Setting to `0` calls [`on_resize`][(c).] immediately
     on every change.
     """
 

flet/controls/core/canvas/line.py

@@ -14,9 +14,8 @@ class Line(Shape):
     Draws a line between the given points using the given paint.
 
     Note:
-        The line is always rendered as a stroke,
-        regardless of the value of [`paint`][(c).]'s
-        [`style`][flet.Paint.style] property.
+        The line is always rendered as a stroke, regardless of the value
+        of [`paint`][(c).]'s [`style`][flet.Paint.] property.
     """
 
     x1: Number

flet/controls/core/canvas/oval.py

@@ -14,7 +14,7 @@ class Oval(Shape):
     Draws an axis-aligned oval that fills the given
     axis-aligned rectangle with the given [`paint`][(c).].
 
-    The [`style`][flet.Paint.style] property of [`paint`][(c).] indicates
+    The [`style`][flet.Paint.] property of [`paint`][(c).] indicates
     whether this oval is filled, stroked, or both.
     """
 

flet/controls/core/canvas/shape.py

@@ -9,14 +9,14 @@ class Shape(BaseControl):
 
     See subclasses/implementations:
 
-    - [`Arc`][flet.canvas.Arc]
-    - [`Circle`][flet.canvas.Circle]
-    - [`Color`][flet.canvas.Color]
-    - [`Fill`][flet.canvas.Fill]
-    - [`Line`][flet.canvas.Line]
-    - [`Oval`][flet.canvas.Oval]
-    - [`Path`][flet.canvas.Path]
-    - [`Points`][flet.canvas.Points]
-    - [`Rect`][flet.canvas.Rect]
-    - [`Text`][flet.canvas.Text]
+    - [`Arc`][flet.canvas.]
+    - [`Circle`][flet.canvas.]
+    - [`Color`][flet.canvas.]
+    - [`Fill`][flet.canvas.]
+    - [`Line`][flet.canvas.]
+    - [`Oval`][flet.canvas.]
+    - [`Path`][flet.canvas.]
+    - [`Points`][flet.canvas.]
+    - [`Rect`][flet.canvas.]
+    - [`Text`][flet.canvas.]
     """

flet/controls/core/canvas/text.py

@@ -40,7 +40,7 @@ class Text(Shape):
 
     spans: Optional[list[TextSpan]] = None
     """
-    The list of [`TextSpan`][flet.TextSpan]
+    The list of [`TextSpan`][flet.]
     objects to build a rich text paragraph.
     """
 

flet/controls/core/column.py

@@ -29,14 +29,14 @@ class Column(LayoutControl, ScrollableControl, AdaptiveControl):
 
     horizontal_alignment: CrossAxisAlignment = CrossAxisAlignment.START
     """
-    Defines how the [`controls`][flet.Column.controls] should be placed horizontally.
+    Defines how the [`controls`][(c).] should be placed horizontally.
     """
 
     spacing: Number = 10
     """
     Spacing between the `controls`.
 
-    It is applied only when [`alignment`][flet.Column.alignment] is
+    It is applied only when [`alignment`][(c).] is
     `MainAxisAlignment.START`, `MainAxisAlignment.END` or `MainAxisAlignment.CENTER`.
     """
 
@@ -50,18 +50,18 @@ class Column(LayoutControl, ScrollableControl, AdaptiveControl):
 
     wrap: bool = False
     """
-    Whether the [`controls`][flet.Column.controls] should wrap into additional
+    Whether the [`controls`][(c).] should wrap into additional
     columns (runs) when they don't fit in a single vertical column.
     """
 
     run_spacing: Number = 10
     """
-    The spacing between runs when [`wrap`][flet.Column.wrap] is `True`.
+    The spacing between runs when [`wrap`][(c).] is `True`.
     """
 
     run_alignment: MainAxisAlignment = MainAxisAlignment.START
     """
-    How the runs should be placed in the cross-axis when [`wrap`][flet.Column.wrap]
+    How the runs should be placed in the cross-axis when [`wrap`][(c).]
     is `True`.
     """
 

flet/controls/core/dismissible.py

@@ -58,20 +58,20 @@ class Dismissible(LayoutControl, AdaptiveControl):
 
     background: Optional[Control] = None
     """
-    A control that is stacked behind the [`content`][flet.Dismissible.content].
+    A control that is stacked behind the [`content`][(c).].
 
-    If [`secondary_background`][flet.Dismissible.secondary_background] is also
+    If [`secondary_background`][(c).] is also
     specified, then this control only appears when the content has been dragged
     down or to the right.
     """
 
     secondary_background: Optional[Control] = None
     """
-    A control that is stacked behind the [`content`][flet.Dismissible.content] and is
+    A control that is stacked behind the [`content`][(c).] and is
     exposed when it has been dragged up or to the left.
 
     Note:
-        Can only be specified if [`background`][flet.Dismissible.background] is also
+        Can only be specified if [`background`][(c).] is also
         specified/visible.
     """
 
@@ -86,7 +86,7 @@ class Dismissible(LayoutControl, AdaptiveControl):
     """
     The offset threshold the item has to be dragged in order to be considered
     as dismissed. This is specified as a dictionary where the key is of
-    type [`DismissDirection`][flet.DismissDirection] and the value is the threshold
+    type [`DismissDirection`][flet.] and the value is the threshold
     (a fractional/decimal value between `0.0` and `1.0`, inclusive).
 
     Example:
@@ -105,7 +105,7 @@ class Dismissible(LayoutControl, AdaptiveControl):
         default_factory=lambda: Duration(milliseconds=200)
     )
     """
-    The duration for [`content`][flet.Dismissible.content] to dismiss or
+    The duration for [`content`][(c).] to dismiss or
     to come back to original position if not dismissed.
     """
 
@@ -114,13 +114,13 @@ class Dismissible(LayoutControl, AdaptiveControl):
     )
     """
     The amount of time the control will spend contracting
-    before [`on_dismiss`][flet.Dismissible.on_dismiss] is called.
+    before [`on_dismiss`][(c).] is called.
     """
 
     cross_axis_end_offset: Number = 0.0
     """
     Specifies the end offset along the main axis once the
-    [`content`][flet.Dismissible.content] has been dismissed.
+    [`content`][(c).] has been dismissed.
 
     If set to a non-zero value, then this dismissible moves in cross direction
     depending on whether it is positive or negative.

flet/controls/core/drag_target.py

@@ -9,8 +9,8 @@ from flet.controls.transform import Offset
 __all__ = [
     "DragTarget",
     "DragTargetEvent",
-    "DragWillAcceptEvent",
     "DragTargetLeaveEvent",
+    "DragWillAcceptEvent",
 ]
 
 
@@ -39,7 +39,8 @@ class DragTargetLeaveEvent(Event["DragTarget"]):
 @control("DragTarget")
 class DragTarget(Control):
     """
-    A control that completes drag operation when a [`Draggable`][flet.Draggable] control is dropped.
+    A control that completes drag operation when a [`Draggable`][flet.] control
+    is dropped.
 
     When a `Draggable` is dragged on top of a `DragTarget`, the `DragTarget` is asked
     whether it will accept the data the `Draggable` is carrying. The `DragTarget` will
@@ -62,7 +63,7 @@ class DragTarget(Control):
     The group this target belongs to.
 
     Note:
-        For a `DragTarget` to accept an incoming drop from a [`Draggable`][flet.Draggable],
+        For a `DragTarget` to accept an incoming drop from a [`Draggable`][flet.],
         they must both be in the same `group`.
     """
 
@@ -73,7 +74,7 @@ class DragTarget(Control):
 
     on_accept: Optional[EventHandler[DragTargetEvent]] = None
     """
-    Called when the user does drop an acceptable (same [`group`][flet.DragTarget.group]) draggable on
+    Called when the user does drop an acceptable (same [`group`][(c).]) draggable on
     this target.
 
     Use `page.get_control(e.src_id)` to retrieve Control reference by its ID.

flet/controls/core/draggable.py

@@ -11,12 +11,12 @@ __all__ = ["Draggable"]
 @control("Draggable")
 class Draggable(Control):
     """
-    A control that can be dragged from to a [`DragTarget`][flet.DragTarget].
+    A control that can be dragged from to a [`DragTarget`][flet.].
 
     When a draggable control recognizes the start of a drag gesture, it displays the
-    [`content_feedback`][(c).] control that tracks the user's finger across the screen. If the
-    user lifts their finger while on top of a `DragTarget`, this target is given the
-    opportunity to complete drag-and-drop flow.
+    [`content_feedback`][(c).] control that tracks the user's finger across the screen.
+    If the user lifts their finger while on top of a `DragTarget`, this target is
+    given the opportunity to complete drag-and-drop flow.
 
     Raises:
         AssertionError: If [`content`][(c).] is not visible.
@@ -28,7 +28,7 @@ class Draggable(Control):
     The control to display when the draggable is not being dragged.
 
     If the draggable is being dragged, the
-    [`content_when_dragging`][flet.Draggable.content_when_dragging] is displayed instead.
+    [`content_when_dragging`][(c).] is displayed instead.
     """
 
     group: str = "default"
@@ -36,13 +36,14 @@ class Draggable(Control):
     The group this draggable belongs to.
 
     Note:
-        For a [`DragTarget`][flet.DragTarget] to accept an incoming drop from a `Draggable`,
+        For a [`DragTarget`][flet.] to accept an incoming drop from a `Draggable`,
         they must both be in the same `group`.
     """
 
     content_when_dragging: Optional[Control] = None
     """
-    The control to display instead of [`content`][flet.Draggable.content] when this draggable is being dragged.
+    The control to display instead of [`content`][(c).] when this draggable
+    is being dragged.
 
     If set, this control visually replaces `content` during an active drag operation,
     allowing you to show a different appearance or an "empty" placeholder.
@@ -65,11 +66,14 @@ class Draggable(Control):
 
     affinity: Optional[Axis] = None
     """
-    Specifies the axis along which this control competes with other gestures to initiate a drag.
+    Specifies the axis along which this control competes with other gestures to
+    initiate a drag.
 
-    - If `None`, the drag starts as soon as a tap down gesture is recognized, regardless of direction.
-    - If set to `Axis.HORIZONTAL` or `Axis.VERTICAL`, the control will only initiate a drag
-    when the gesture matches the specified axis, allowing it to compete with other gestures in that direction.
+    - If `None`, the drag starts as soon as a tap down gesture is recognized,
+        regardless of direction.
+    - If set to `Axis.HORIZONTAL` or `Axis.VERTICAL`, the control will only initiate a
+        drag when the gesture matches the specified axis, allowing it to compete
+        with other gestures in that direction.
     """
 
     max_simultaneous_drags: Optional[int] = None
@@ -79,7 +83,7 @@ class Draggable(Control):
     - `0` - disables dragging entirely.
     - `1` - allows only one drag at a time.
         For a better user experience, you may want to provide an "empty" widget for
-        [`content_when_dragging`][flet.Draggable.content_when_dragging]
+        [`content_when_dragging`][(c).]
         to visually indicate the item is being moved.
     - Set to any positive integer to allow that many concurrent drags.
     - If `None`, there is no limit on the number of simultaneous drags.
@@ -92,7 +96,7 @@ class Draggable(Control):
 
     on_drag_complete: Optional[ControlEventHandler["Draggable"]] = None
     """
-    Called when this draggable is dropped and accepted by a [`DragTarget`][flet.DragTarget].
+    Called when this draggable is dropped and accepted by a [`DragTarget`][flet.].
     """
 
     def before_update(self):
@@ -101,5 +105,6 @@ class Draggable(Control):
         assert self.max_simultaneous_drags is None or (
             self.max_simultaneous_drags >= 0
         ), (
-            f"max_simultaneous_drags must be greater than or equal to 0, got {self.max_simultaneous_drags}"
+            f"max_simultaneous_drags must be greater than or equal to 0, "
+            f"got {self.max_simultaneous_drags}"
         )

flet/controls/core/grid_view.py

@@ -18,8 +18,8 @@ class GridView(LayoutControl, ScrollableControl, AdaptiveControl):
     A scrollable, 2D array of controls.
 
     It is very effective for large lists (thousands of items).
-    Prefer it over wrapping [`Column`][flet.Column]s or
-    [`Row`][flet.Row]s for smooth scrolling.
+    Prefer it over wrapping [`Column`][flet.]s or
+    [`Row`][flet.]s for smooth scrolling.
     """
 
     controls: list[Control] = field(default_factory=list)

flet/controls/core/image.py

@@ -87,7 +87,7 @@ class Image(LayoutControl):
     color: Optional[ColorValue] = None
     """
     If set, this color is blended with each
-    image pixel using [`color_blend_mode`][flet.Image.color_blend_mode].
+    image pixel using [`color_blend_mode`][(c).].
     """
 
     color_blend_mode: Optional[BlendMode] = None

flet/controls/core/interactive_viewer.py

@@ -62,7 +62,7 @@ class InteractiveViewer(LayoutControl):
     The maximum allowed scale.
 
     Note:
-        Must be greater than or equal to [`min_scale`][flet.InteractiveViewer.min_scale].
+        Must be greater than or equal to [`min_scale`][(c).].
     """  # noqa: E501
 
     min_scale: Number = 0.8
@@ -71,7 +71,7 @@ class InteractiveViewer(LayoutControl):
 
     Note:
         Must be greater than `0` and less than or equal
-        to [`max_scale`][flet.InteractiveViewer.max_scale].
+        to [`max_scale`][(c).].
     """
 
     interaction_end_friction_coefficient: Number = 0.0000135