flet-charts 0.2.0.dev524__py3-none-any.whl → 0.70.0.dev6293__py3-none-any.whl

flet_charts/matplotlib_chart.py

@@ -1,22 +1,63 @@
-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 Optional
 
 import flet as ft
+import flet.canvas as fc
 
 try:
+    import matplotlib
     from matplotlib.figure import Figure
 except ImportError as e:
     raise Exception(
         'Install "matplotlib" Python package to use MatplotlibChart control.'
     ) from e
 
-__all__ = ["MatplotlibChart"]
+__all__ = [
+    "MatplotlibChart",
+    "MatplotlibChartMessageEvent",
+    "MatplotlibChartToolbarButtonsUpdateEvent",
+]
 
+logger = logging.getLogger("flet-charts.matplotlib")
 
-@ft.control(kw_only=True)
-class MatplotlibChart(ft.Container):
+matplotlib.use("module://flet_charts.matplotlib_backends.backend_flet_agg")
+
+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,
+}
+
+
+@dataclass
+class MatplotlibChartMessageEvent(ft.Event["MatplotlibChart"]):
+    message: str
+    """
+    Message text.
+    """
+
+
+@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, isolated=True)
+class MatplotlibChart(ft.GestureDetector):
     """
     Displays a [Matplotlib](https://matplotlib.org/) chart.
 
@@ -33,33 +74,309 @@ 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
+    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):
+        self.figure.canvas.manager.remove_web_socket(self)
+
+    def home(self):
+        logger.debug("home)")
+        self.send_message({"type": "toolbar_button", "name": "home"})
+
+    def back(self):
+        logger.debug("back()")
+        self.send_message({"type": "toolbar_button", "name": "back"})
+
+    def forward(self):
+        logger.debug("forward)")
+        self.send_message({"type": "toolbar_button", "name": "forward"})
+
+    def pan(self):
+        logger.debug("pan()")
+        self.send_message({"type": "toolbar_button", "name": "pan"})
+
+    def zoom(self):
+        logger.debug("zoom()")
+        self.send_message({"type": "toolbar_button", "name": "zoom"})
+
+    def download(self, format):
+        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):
+        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):
+        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):
+        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,110 @@
+from dataclasses import field
+
+from matplotlib.figure import Figure
+
+import flet as ft
+import flet_charts
+
+_download_formats = [
+    "eps",
+    "jpeg",
+    "pgf",
+    "pdf",
+    "png",
+    "ps",
+    "raw",
+    "svg",
+    "tif",
+    "webp",
+]
+
+
+@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):
+        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(
+                [
+                    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,7 +2,6 @@ from dataclasses import dataclass, field
 from typing import Optional
 
 import flet as ft
-
 from flet_charts.pie_chart_section import PieChartSection
 from flet_charts.types import ChartEventType
 

flet_charts/plotly_chart.py

@@ -29,7 +29,7 @@ class PlotlyChart(ft.Container):
     figure: Figure = field(metadata={"skip": True})
     """
     Plotly figure to draw.
-    
+
     The value is an instance of [`plotly.graph_objects.Figure`](https://plotly.com/python-api-reference/generated/plotly.graph_objects.Figure.html).
     """
 

flet_charts/scatter_chart.py

@@ -2,7 +2,6 @@ from dataclasses import dataclass, field
 from typing import Any, Optional
 
 import flet as ft
-
 from flet_charts.chart_axis import ChartAxis
 from flet_charts.scatter_chart_spot import ScatterChartSpot
 from flet_charts.types import ChartEventType, ChartGridLines, HorizontalAlignment
@@ -173,22 +172,22 @@ class ScatterChart(ft.LayoutControl):
     Controls drawing of chart's vertical lines.
     """
 
-    left_axis: ChartAxis = field(default_factory=lambda: ChartAxis())
+    left_axis: Optional[ChartAxis] = None
     """
     Configures the appearance of the left axis, its title and labels.
     """
 
-    top_axis: ChartAxis = field(default_factory=lambda: ChartAxis())
+    top_axis: Optional[ChartAxis] = None
     """
     Configures the appearance of the top axis, its title and labels.
     """
 
-    right_axis: ChartAxis = field(default_factory=lambda: ChartAxis())
+    right_axis: Optional[ChartAxis] = None
     """
     Configures the appearance of the right axis, its title and labels.
     """
 
-    bottom_axis: ChartAxis = field(default_factory=lambda: ChartAxis())
+    bottom_axis: Optional[ChartAxis] = None
     """
     Configures the appearance of the bottom axis, its title and labels.
     """

flet_charts/scatter_chart_spot.py

@@ -2,7 +2,6 @@ from dataclasses import dataclass, field
 from typing import Any, Optional, Union
 
 import flet as ft
-
 from flet_charts.types import ChartDataPointTooltip, ChartPointShape
 
 __all__ = ["ScatterChartSpot", "ScatterChartSpotTooltip"]

{flet_charts-0.2.0.dev524.dist-info → flet_charts-0.70.0.dev6293.dist-info}/METADATA

@@ -1,24 +1,24 @@
 Metadata-Version: 2.4
 Name: flet-charts
-Version: 0.2.0.dev524
-Summary: A Flet extension for creating interactive charts and graphs.
+Version: 0.70.0.dev6293
+Summary: Interactive chart controls for Flet apps.
 Author-email: Flet contributors <hello@flet.dev>
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://flet.dev
-Project-URL: Documentation, https://flet-dev.github.io/flet-charts
-Project-URL: Repository, https://github.com/flet-dev/flet-charts
-Project-URL: Issues, https://github.com/flet-dev/flet-charts/issues
+Project-URL: Documentation, https://docs.flet.dev/charts
+Project-URL: Repository, https://github.com/flet-dev/flet/tree/main/sdk/python/packages/flet-charts
+Project-URL: Issues, https://github.com/flet-dev/flet/issues
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flet>=0.70.0.dev0
+Requires-Dist: flet==0.70.0.dev6293
 Dynamic: license-file
 
 # flet-charts
 
 [![pypi](https://img.shields.io/pypi/v/flet-charts.svg)](https://pypi.python.org/pypi/flet-charts)
 [![downloads](https://static.pepy.tech/badge/flet-charts/month)](https://pepy.tech/project/flet-charts)
-[![license](https://img.shields.io/github/license/flet-dev/flet-charts.svg)](https://github.com/flet-dev/flet-charts/blob/main/LICENSE)
+[![license](https://img.shields.io/github/license/flet-dev/flet.svg)](https://github.com/flet-dev/flet/blob/main/sdk/python/packages/flet-charts/LICENSE)
 
 A [Flet](https://flet.dev) extension for creating interactive charts and graphs.
 
@@ -26,12 +26,10 @@ It is based on the [fl_chart](https://pub.dev/packages/fl_chart) Flutter package
 
 ## Documentation
 
-Detailed documentation to this package can be found [here](https://flet-charts.docs.flet.dev/).
+Detailed documentation to this package can be found [here](https://docs.flet.dev/charts/).
 
 ## Platform Support
 
-This package supports the following platforms:
-
 | Platform | Windows | macOS | Linux | iOS | Android | Web |
 |----------|---------|-------|-------|-----|---------|-----|
 | Supported|    ✅    |   ✅   |   ✅   |  ✅  |    ✅    |  ✅  |
@@ -55,4 +53,14 @@ To install the `flet-charts` package and add it to your project dependencies:
 
 ### Examples
 
-For examples, see [these](./examples).
+For examples, see [these](https://github.com/flet-dev/flet/tree/main/sdk/python/examples/controls/charts).
+
+### Available charts
+
+- `BarChart`
+- `CandlestickChart`
+- `LineChart`
+- `MatplotlibChart`
+- `PieChart`
+- `PlotlyChart`
+- `ScatterChart`