flet-charts 0.2.0.dev35__py3-none-any.whl → 0.70.0.dev6551__py3-none-any.whl

flet_charts/matplotlib_chart.py

@@ -1,27 +1,78 @@
-import io
-import re
-import xml.etree.ElementTree as ET
-from dataclasses import field
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from io import BytesIO
+from typing import Any, Optional
 
 import flet as ft
+import flet.canvas as fc
+
+_MATPLOTLIB_IMPORT_ERROR: Optional[ImportError] = None
 
 try:
-    from matplotlib.figure import Figure
-except ImportError as e:
-    raise Exception(
-        'Install "matplotlib" Python package to use MatplotlibChart control.'
-    ) from e
+    import matplotlib  # type: ignore[import]
+    from matplotlib.figure import Figure  # type: ignore[import]
+except ImportError as e:  # pragma: no cover - depends on optional dependency
+    matplotlib = None  # type: ignore[assignment]
+    Figure = Any  # type: ignore[assignment]
+    _MATPLOTLIB_IMPORT_ERROR = e
+else:
+    matplotlib.use("module://flet_charts.matplotlib_backends.backend_flet_agg")
+
+__all__ = [
+    "MatplotlibChart",
+    "MatplotlibChartMessageEvent",
+    "MatplotlibChartToolbarButtonsUpdateEvent",
+]
+
+logger = logging.getLogger("flet-charts.matplotlib")
+
+figure_cursors = {
+    "default": None,
+    "pointer": ft.MouseCursor.CLICK,
+    "crosshair": ft.MouseCursor.PRECISE,
+    "move": ft.MouseCursor.MOVE,
+    "wait": ft.MouseCursor.WAIT,
+    "ew-resize": ft.MouseCursor.RESIZE_LEFT_RIGHT,
+    "ns-resize": ft.MouseCursor.RESIZE_UP_DOWN,
+}
+
+
+def _require_matplotlib() -> None:
+    if matplotlib is None:
+        raise ModuleNotFoundError(
+            'Install "matplotlib" Python package to use MatplotlibChart control.'
+        ) from _MATPLOTLIB_IMPORT_ERROR
+
+
+@dataclass
+class MatplotlibChartMessageEvent(ft.Event["MatplotlibChart"]):
+    message: str
+    """
+    Message text.
+    """
+
 
-__all__ = ["MatplotlibChart"]
+@dataclass
+class MatplotlibChartToolbarButtonsUpdateEvent(ft.Event["MatplotlibChart"]):
+    back_enabled: bool
+    """
+    Whether Back button is enabled or not.
+    """
+    forward_enabled: bool
+    """
+    Whether Forward button is enabled or not.
+    """
 
 
-@ft.control(kw_only=True)
-class MatplotlibChart(ft.Container):
+@ft.control(kw_only=True, isolated=True)
+class MatplotlibChart(ft.GestureDetector):
     """
     Displays a [Matplotlib](https://matplotlib.org/) chart.
 
     Warning:
-        This control requires the [`matplotlib`](https://matplotlib.org/) Python package to be installed.
+        This control requires the [`matplotlib`](https://matplotlib.org/)
+        Python package to be installed.
 
         See this [installation guide](index.md#installation) for more information.
     """
@@ -32,33 +83,342 @@ class MatplotlibChart(ft.Container):
     [`matplotlib.figure.Figure`](https://matplotlib.org/stable/api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure).
     """
 
-    original_size: bool = False
+    on_message: Optional[ft.EventHandler[MatplotlibChartMessageEvent]] = None
     """
-    Whether to display chart in original size.
-
-    Set to `False` to display a chart that fits configured bounds.
+    The event is triggered on figure message update.
     """
 
-    transparent: bool = False
+    on_toolbar_buttons_update: Optional[
+        ft.EventHandler[MatplotlibChartToolbarButtonsUpdateEvent]
+    ] = None
     """
-    Whether to remove the background from the chart.
+    Triggers when toolbar buttons status is updated.
     """
 
     def init(self):
-        self.alignment = ft.Alignment.CENTER
-        self.__img = ft.Image(fit=ft.BoxFit.FILL)
-        self.content = self.__img
-
-    def before_update(self):
-        super().before_update()
-        if self.figure is not None:
-            s = io.StringIO()
-            self.figure.savefig(s, format="svg", transparent=self.transparent)
-            svg = s.getvalue()
-
-            if not self.original_size:
-                root = ET.fromstring(svg)
-                w = float(re.findall(r"\d+", root.attrib["width"])[0])
-                h = float(re.findall(r"\d+", root.attrib["height"])[0])
-                self.__img.aspect_ratio = w / h
-            self.__img.src = svg
+        _require_matplotlib()
+        super().init()
+
+    def build(self):
+        self.mouse_cursor = ft.MouseCursor.WAIT
+        self.__started = False
+        self.__dpr = self.page.media.device_pixel_ratio
+        logger.debug(f"DPR: {self.__dpr}")
+        self.__image_mode = "full"
+
+        self.canvas = fc.Canvas(
+            # resize_interval=10,
+            on_resize=self._on_canvas_resize,
+            expand=True,
+        )
+        self.keyboard_listener = ft.KeyboardListener(
+            self.canvas,
+            autofocus=True,
+            on_key_down=self._on_key_down,
+            on_key_up=self._on_key_up,
+        )
+        self.content = self.keyboard_listener
+        self.on_enter = self._on_enter
+        self.on_hover = self._on_hover
+        self.on_exit = self._on_exit
+        self.on_pan_start = self._pan_start
+        self.on_pan_update = self._pan_update
+        self.on_pan_end = self._pan_end
+        self.on_right_pan_start = self._right_pan_start
+        self.on_right_pan_update = self._right_pan_update
+        self.on_right_pan_end = self._right_pan_end
+        self.img_count = 1
+        self._receive_queue = asyncio.Queue()
+        self._main_loop = asyncio.get_event_loop()
+        self._width = 0
+        self._height = 0
+        self._waiting = False
+
+    def _on_key_down(self, e):
+        logger.debug(f"ON KEY DOWN: {e}")
+
+    def _on_key_up(self, e):
+        logger.debug(f"ON KEY UP: {e}")
+
+    def _on_enter(self, e: ft.HoverEvent):
+        logger.debug(f"_on_enter: {e.local_position.x}, {e.local_position.y}")
+        self.send_message(
+            {
+                "type": "figure_enter",
+                "x": e.local_position.x * self.__dpr,
+                "y": e.local_position.y * self.__dpr,
+                "button": 0,
+                "buttons": 0,
+                "modifiers": [],
+            }
+        )
+
+    def _on_hover(self, e: ft.HoverEvent):
+        logger.debug(f"_on_hover: {e.local_position.x}, {e.local_position.y}")
+        self.send_message(
+            {
+                "type": "motion_notify",
+                "x": e.local_position.x * self.__dpr,
+                "y": e.local_position.y * self.__dpr,
+                "button": 0,
+                "buttons": 0,
+                "modifiers": [],
+            }
+        )
+
+    def _on_exit(self, e: ft.HoverEvent):
+        logger.debug(f"_on_exit: {e.local_position.x}, {e.local_position.y}")
+        self.send_message(
+            {
+                "type": "figure_leave",
+                "x": e.local_position.x * self.__dpr,
+                "y": e.local_position.y * self.__dpr,
+                "button": 0,
+                "buttons": 0,
+                "modifiers": [],
+            }
+        )
+
+    def _pan_start(self, e: ft.DragStartEvent):
+        logger.debug(f"_pan_start: {e.local_position.x}, {e.local_position.y}")
+        asyncio.create_task(self.keyboard_listener.focus())
+        self.send_message(
+            {
+                "type": "button_press",
+                "x": e.local_position.x * self.__dpr,
+                "y": e.local_position.y * self.__dpr,
+                "button": 0,
+                "buttons": 1,
+                "modifiers": [],
+            }
+        )
+
+    def _pan_update(self, e: ft.DragUpdateEvent):
+        logger.debug(f"_pan_update: {e.local_position.x}, {e.local_position.y}")
+        self.send_message(
+            {
+                "type": "motion_notify",
+                "x": e.local_position.x * self.__dpr,
+                "y": e.local_position.y * self.__dpr,
+                "button": 0,
+                "buttons": 1,
+                "modifiers": [],
+            }
+        )
+
+    def _pan_end(self, e: ft.DragEndEvent):
+        logger.debug(f"_pan_end: {e.local_position.x}, {e.local_position.y}")
+        self.send_message(
+            {
+                "type": "button_release",
+                "x": e.local_position.x * self.__dpr,
+                "y": e.local_position.y * self.__dpr,
+                "button": 0,
+                "buttons": 0,
+                "modifiers": [],
+            }
+        )
+
+    def _right_pan_start(self, e: ft.PointerEvent):
+        logger.debug(f"_pan_start: {e.local_position.x}, {e.local_position.y}")
+        self.send_message(
+            {
+                "type": "button_press",
+                "x": e.local_position.x * self.__dpr,
+                "y": e.local_position.y * self.__dpr,
+                "button": 2,
+                "buttons": 2,
+                "modifiers": [],
+            }
+        )
+
+    def _right_pan_update(self, e: ft.PointerEvent):
+        logger.debug(f"_pan_update: {e.local_position.x}, {e.local_position.y}")
+        self.send_message(
+            {
+                "type": "motion_notify",
+                "x": e.local_position.x * self.__dpr,
+                "y": e.local_position.y * self.__dpr,
+                "button": 0,
+                "buttons": 2,
+                "modifiers": [],
+            }
+        )
+
+    def _right_pan_end(self, e: ft.PointerEvent):
+        logger.debug(f"_pan_end: {e.local_position.x}, {e.local_position.y}")
+        self.send_message(
+            {
+                "type": "button_release",
+                "x": e.local_position.x * self.__dpr,
+                "y": e.local_position.y * self.__dpr,
+                "button": 2,
+                "buttons": 0,
+                "modifiers": [],
+            }
+        )
+
+    def will_unmount(self):
+        """
+        Called when the control is about to be removed from the page.
+        """
+        self.figure.canvas.manager.remove_web_socket(self)
+
+    def home(self):
+        """
+        Resets the view to the original state.
+        """
+        logger.debug("home)")
+        self.send_message({"type": "toolbar_button", "name": "home"})
+
+    def back(self):
+        """
+        Goes back to the previous view.
+        """
+        logger.debug("back()")
+        self.send_message({"type": "toolbar_button", "name": "back"})
+
+    def forward(self):
+        """
+        Goes forward to the next view.
+        """
+        logger.debug("forward)")
+        self.send_message({"type": "toolbar_button", "name": "forward"})
+
+    def pan(self):
+        """
+        Activates the pan tool.
+        """
+        logger.debug("pan()")
+        self.send_message({"type": "toolbar_button", "name": "pan"})
+
+    def zoom(self):
+        """
+        Activates the zoom tool.
+        """
+        logger.debug("zoom()")
+        self.send_message({"type": "toolbar_button", "name": "zoom"})
+
+    def download(self, format) -> bytes:
+        """
+        Downloads the current figure in the specified format.
+        Args:
+            format (str): The format to download the figure in (e.g., 'png',
+                'jpg', 'svg', etc.).
+        Returns:
+            bytes: The figure image in the specified format as a byte array.
+        """
+        logger.debug(f"Download in format: {format}")
+        buff = BytesIO()
+        self.figure.savefig(buff, format=format, dpi=self.figure.dpi * self.__dpr)
+        return buff.getvalue()
+
+    async def _receive_loop(self):
+        while True:
+            is_binary, content = await self._receive_queue.get()
+            if is_binary:
+                logger.debug(f"receive_binary({len(content)})")
+                if self.__image_mode == "full":
+                    await self.canvas.clear_capture()
+
+                self.canvas.shapes = [
+                    fc.Image(
+                        src_bytes=content,
+                        x=0,
+                        y=0,
+                        width=self.figure.bbox.size[0] / self.__dpr,
+                        height=self.figure.bbox.size[1] / self.__dpr,
+                    )
+                ]
+                ft.context.disable_auto_update()
+                self.canvas.update()
+                await self.canvas.capture()
+                self.img_count += 1
+                self._waiting = False
+            else:
+                logger.debug(f"receive_json({content})")
+                if content["type"] == "image_mode":
+                    self.__image_mode = content["mode"]
+                elif content["type"] == "cursor":
+                    self.mouse_cursor = figure_cursors[content["cursor"]]
+                    self.update()
+                elif content["type"] == "draw" and not self._waiting:
+                    self._waiting = True
+                    self.send_message({"type": "draw"})
+                elif content["type"] == "rubberband":
+                    if len(self.canvas.shapes) == 2:
+                        self.canvas.shapes.pop()
+                    if (
+                        content["x0"] != -1
+                        and content["y0"] != -1
+                        and content["x1"] != -1
+                        and content["y1"] != -1
+                    ):
+                        x0 = content["x0"] / self.__dpr
+                        y0 = self._height - content["y0"] / self.__dpr
+                        x1 = content["x1"] / self.__dpr
+                        y1 = self._height - content["y1"] / self.__dpr
+                        self.canvas.shapes.append(
+                            fc.Rect(
+                                x=x0,
+                                y=y0,
+                                width=x1 - x0,
+                                height=y1 - y0,
+                                paint=ft.Paint(
+                                    stroke_width=1, style=ft.PaintingStyle.STROKE
+                                ),
+                            )
+                        )
+                    self.canvas.update()
+                elif content["type"] == "resize":
+                    self.send_message({"type": "refresh"})
+                elif content["type"] == "message":
+                    await self._trigger_event(
+                        "message", {"message": content["message"]}
+                    )
+                elif content["type"] == "history_buttons":
+                    await self._trigger_event(
+                        "toolbar_buttons_update",
+                        {
+                            "back_enabled": content["Back"],
+                            "forward_enabled": content["Forward"],
+                        },
+                    )
+
+    def send_message(self, message):
+        """Sends a message to the figure's canvas manager."""
+        logger.debug(f"send_message({message})")
+        manager = self.figure.canvas.manager
+        if manager is not None:
+            manager.handle_json(message)
+
+    def send_json(self, content):
+        """Sends a JSON message to the front end."""
+        logger.debug(f"send_json: {content}")
+        self._main_loop.call_soon_threadsafe(
+            lambda: self._receive_queue.put_nowait((False, content))
+        )
+
+    def send_binary(self, blob):
+        """Sends a binary message to the front end."""
+        self._main_loop.call_soon_threadsafe(
+            lambda: self._receive_queue.put_nowait((True, blob))
+        )
+
+    async def _on_canvas_resize(self, e: fc.CanvasResizeEvent):
+        logger.debug(f"on_canvas_resize: {e.width}, {e.height}")
+
+        if not self.__started:
+            self.__started = True
+            asyncio.create_task(self._receive_loop())
+            self.figure.canvas.manager.add_web_socket(self)
+            self.send_message({"type": "send_image_mode"})
+            self.send_message(
+                {"type": "set_device_pixel_ratio", "device_pixel_ratio": self.__dpr}
+            )
+            self.send_message({"type": "refresh"})
+        self._width = e.width
+        self._height = e.height
+        self.send_message(
+            {"type": "resize", "width": self._width, "height": self._height}
+        )

flet_charts/matplotlib_chart_with_toolbar.py

@@ -0,0 +1,125 @@
+from dataclasses import field
+from typing import Any, Optional
+
+import flet as ft
+import flet_charts
+
+_MATPLOTLIB_IMPORT_ERROR: Optional[ImportError] = None
+
+try:
+    from matplotlib.figure import Figure  # type: ignore
+except ImportError as e:  # pragma: no cover - depends on optional dependency
+    Figure = Any  # type: ignore[assignment]
+    _MATPLOTLIB_IMPORT_ERROR = e
+
+_download_formats = [
+    "eps",
+    "jpeg",
+    "pgf",
+    "pdf",
+    "png",
+    "ps",
+    "raw",
+    "svg",
+    "tif",
+    "webp",
+]
+
+
+def _require_matplotlib() -> None:
+    if _MATPLOTLIB_IMPORT_ERROR is not None:
+        raise ModuleNotFoundError(
+            'Install "matplotlib" Python package to use MatplotlibChart control.'
+        ) from _MATPLOTLIB_IMPORT_ERROR
+
+
+@ft.control(kw_only=True, isolated=True)
+class MatplotlibChartWithToolbar(ft.Column):
+    figure: Figure = field(metadata={"skip": True})
+    """
+    Matplotlib figure to draw - an instance of
+    [`matplotlib.figure.Figure`](https://matplotlib.org/stable/api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure).
+    """
+
+    def build(self):
+        _require_matplotlib()
+        self.mpl = flet_charts.MatplotlibChart(
+            figure=self.figure,
+            expand=True,
+            on_message=self.on_message,
+            on_toolbar_buttons_update=self.on_toolbar_update,
+        )
+        self.home_btn = ft.IconButton(ft.Icons.HOME, on_click=lambda: self.mpl.home())
+        self.back_btn = ft.IconButton(
+            ft.Icons.ARROW_BACK_ROUNDED, on_click=lambda: self.mpl.back()
+        )
+        self.fwd_btn = ft.IconButton(
+            ft.Icons.ARROW_FORWARD_ROUNDED, on_click=lambda: self.mpl.forward()
+        )
+        self.pan_btn = ft.IconButton(
+            ft.Icons.OPEN_WITH,
+            selected_icon=ft.Icons.OPEN_WITH,
+            selected_icon_color=ft.Colors.AMBER_800,
+            on_click=self.pan_click,
+        )
+        self.zoom_btn = ft.IconButton(
+            ft.Icons.ZOOM_IN,
+            selected_icon=ft.Icons.ZOOM_IN,
+            selected_icon_color=ft.Colors.AMBER_800,
+            on_click=self.zoom_click,
+        )
+        self.download_btn = ft.IconButton(
+            ft.Icons.DOWNLOAD, on_click=self.download_click
+        )
+        self.download_fmt = ft.Dropdown(
+            value="png",
+            options=[ft.DropdownOption(fmt) for fmt in _download_formats],
+        )
+        self.msg = ft.Text()
+        self.controls = [
+            ft.Row(
+                controls=[
+                    self.home_btn,
+                    self.back_btn,
+                    self.fwd_btn,
+                    self.pan_btn,
+                    self.zoom_btn,
+                    self.download_btn,
+                    self.download_fmt,
+                    self.msg,
+                ]
+            ),
+            self.mpl,
+        ]
+        if not self.expand:
+            if not self.height:
+                self.height = self.figure.bbox.height
+            if not self.width:
+                self.width = self.figure.bbox.width
+
+    def on_message(self, e: flet_charts.MatplotlibChartMessageEvent):
+        self.msg.value = e.message
+        self.msg.update()
+
+    def on_toolbar_update(
+        self, e: flet_charts.MatplotlibChartToolbarButtonsUpdateEvent
+    ):
+        self.back_btn.disabled = not e.back_enabled
+        self.fwd_btn.disabled = not e.forward_enabled
+        self.update()
+
+    def pan_click(self):
+        self.mpl.pan()
+        self.pan_btn.selected = not self.pan_btn.selected
+        self.zoom_btn.selected = False
+
+    def zoom_click(self):
+        self.mpl.zoom()
+        self.pan_btn.selected = False
+        self.zoom_btn.selected = not self.zoom_btn.selected
+
+    async def download_click(self):
+        fmt = self.download_fmt.value
+        buffer = self.mpl.download(fmt)
+        title = self.figure.canvas.manager.get_window_title()
+        await ft.FilePicker().save_file(file_name=f"{title}.{fmt}", src_bytes=buffer)

flet_charts/pie_chart.py

@@ -2,9 +2,8 @@ from dataclasses import dataclass, field
 from typing import Optional
 
 import flet as ft
-
-from .pie_chart_section import PieChartSection
-from .types import ChartEventType
+from flet_charts.pie_chart_section import PieChartSection
+from flet_charts.types import ChartEventType
 
 __all__ = ["PieChart", "PieChartEvent"]
 
@@ -33,11 +32,9 @@ class PieChartEvent(ft.Event["PieChart"]):
 
 
 @ft.control("PieChart")
-class PieChart(ft.ConstrainedControl):
+class PieChart(ft.LayoutControl):
     """
     A pie chart control displaying multiple sections as slices of a circle.
-
-    ![Overview](assets/pie-chart/diagram.svg)
     """
 
     sections: list[PieChartSection] = field(default_factory=list)

flet_charts/pie_chart_section.py

@@ -10,10 +10,6 @@ __all__ = ["PieChartSection"]
 class PieChartSection(ft.BaseControl):
     """
     Configures a [PieChart][(p).] section.
-
-    Raises:
-        AssertionError: If [`title_position`][(c).] or
-            [`badge_position`][(c).] is not between `0.0` and `1.0` inclusive.
     """
 
     value: ft.Number
@@ -51,11 +47,13 @@ class PieChartSection(ft.BaseControl):
     """
     The position/offset of the title relative to the section's center.
 
+    - `0.0`: near the center
+    - `1.0`: near the outside of the chart
+
     By default the title is drawn in the middle of the section.
 
-    Note:
-        Must be between `0.0` (near the center)
-        and `1.0`(near the outside of the chart) inclusive.
+    Raises:
+        ValueError: If it is not between `0.0` and `1.0` inclusive.
     """
 
     badge: Optional[ft.Control] = None
@@ -67,20 +65,29 @@ class PieChartSection(ft.BaseControl):
     """
     The position/offset of the badge relative to the section's center.
 
+    - `0.0`: near the center
+    - `1.0`: near the outside of the chart
+
     By default the badge is drawn in the middle of the section.
 
-    Note:
-        Must be between `0.0` (near the center)
-        and `1.0`(near the outside of the chart) inclusive.
+    Raises:
+        ValueError: If it is not between `0.0` and `1.0` inclusive.
+    """
+
+    gradient: Optional[ft.Gradient] = None
+    """
+    Defines the gradient of section. If specified, overrides the color setting.
     """
 
     def before_update(self):
         super().before_update()
-        assert self.title_position is None or (0.0 <= self.title_position <= 1.0), (
-            f"title_position must be between 0.0 and 1.0 inclusive, "
-            f"got {self.title_position}"
-        )
-        assert self.badge_position is None or (0.0 <= self.badge_position <= 1.0), (
-            f"badge_position must be between 0.0 and 1.0 inclusive, "
-            f"got {self.badge_position}"
-        )
+        if self.title_position is not None and not (0.0 <= self.title_position <= 1.0):
+            raise ValueError(
+                "title_position must be between 0.0 and 1.0 inclusive, "
+                f"got {self.title_position}"
+            )
+        if self.badge_position is not None and not (0.0 <= self.badge_position <= 1.0):
+            raise ValueError(
+                "badge_position must be between 0.0 and 1.0 inclusive, "
+                f"got {self.badge_position}"
+            )