flet-charts 1.0.0.dev0__tar.gz → 1.0.0.dev2__tar.gz

{flet_charts-1.0.0.dev0/src/flet_charts.egg-info → flet_charts-1.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-charts
-Version: 1.0.0.dev0
+Version: 1.0.0.dev2
 Summary: Interactive chart controls for Flet apps.
 Author-email: Flet contributors <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -11,7 +11,7 @@ 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==1.0.0.dev0
+Requires-Dist: flet==1.0.0.dev2
 Dynamic: license-file
 
 # flet-charts

{flet_charts-1.0.0.dev0 → flet_charts-1.0.0.dev2}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "flet-charts"
-version = "1.0.0.dev0"
+version = "1.0.0.dev2"
 description = "Interactive chart controls for Flet apps."
 readme = "README.md"
 authors = [{ name = "Flet contributors", email = "hello@flet.dev" }]
 license = "Apache-2.0"
 requires-python = ">=3.10"
 dependencies = [
-    "flet==1.0.0.dev0",
+    "flet==1.0.0.dev2",
 ]
 
 [project.urls]

{flet_charts-1.0.0.dev0 → flet_charts-1.0.0.dev2}/src/flet_charts/matplotlib_chart.py

@@ -433,79 +433,103 @@ class MatplotlibChart(ft.GestureDetector):
         """
         Consume backend messages and apply canvas/state updates.
 
-        The loop handles both binary image frames and JSON control messages
-        (cursor updates, draw requests, rubber-band overlays, status text, and
-        toolbar history state).
+        Message handling is guarded: applying a frame, and Matplotlib's own
+        rendering (which `send_message` runs synchronously, in this task),
+        can both raise. Letting that escape would end the loop - nothing
+        would drain `_receive_queue` again, so the chart would freeze
+        silently and the traceback would only surface later, as an
+        unretrieved task exception when the task is garbage-collected.
         """
 
         while True:
             is_binary, content = await self._receive_queue.get()
-
-            if is_binary:
-                # Hand the frame to the client widget — a raw RGBA frame
-                # (pre-encoded 0x04 packet) or full PNG replaces the
-                # backbuffer, diff PNG composites onto it. `await`
-                # here serialises this receive loop on the Dart-side
-                # frame-applied ack: matplotlib "draw" notifications that
-                # arrive during the round-trip stay queued in
-                # `_receive_queue` and are processed after the ack returns,
-                # instead of being eagerly dropped against a stale
-                # `_waiting=True` gate. This is the same backpressure shape
-                # the 0.85 `_invoke_method` round-trip used to provide.
-                if isinstance(content, tuple) and content[0] == "raw":
-                    logger.debug(f"receive_binary(raw, {len(content[1])})")
-                    await self.mpl_canvas.apply_raw_packet(content[1])
-                elif self.__image_mode == "full":
-                    logger.debug(f"receive_binary(full, {len(content)})")
-                    await self.mpl_canvas.apply_full(bytes(content))
-                else:
-                    logger.debug(f"receive_binary(diff, {len(content)})")
-                    await self.mpl_canvas.apply_diff(bytes(content))
-                self.img_count += 1
+            try:
+                await self._handle_message(is_binary, content)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("Error handling Matplotlib backend message")
+                # A draw that raised never produces the frame that clears
+                # this gate, so clear it here or no further draw is ever
+                # requested.
                 self._waiting = False
+
+    async def _handle_message(self, is_binary: bool, content: Any) -> None:
+        """
+        Apply a single message from the Matplotlib backend.
+
+        Handles both binary image frames and JSON control messages (cursor
+        updates, draw requests, rubber-band overlays, status text, and
+        toolbar history state).
+
+        Args:
+            is_binary: Whether `content` is an image frame rather than JSON.
+            content: Frame payload or JSON control message.
+        """
+
+        if is_binary:
+            # Hand the frame to the client widget — a raw RGBA frame
+            # (pre-encoded 0x04 packet) or full PNG replaces the
+            # backbuffer, diff PNG composites onto it. `await`
+            # here serialises this receive loop on the Dart-side
+            # frame-applied ack: matplotlib "draw" notifications that
+            # arrive during the round-trip stay queued in
+            # `_receive_queue` and are processed after the ack returns,
+            # instead of being eagerly dropped against a stale
+            # `_waiting=True` gate. This is the same backpressure shape
+            # the 0.85 `_invoke_method` round-trip used to provide.
+            if isinstance(content, tuple) and content[0] == "raw":
+                logger.debug(f"receive_binary(raw, {len(content[1])})")
+                await self.mpl_canvas.apply_raw_packet(content[1])
+            elif self.__image_mode == "full":
+                logger.debug(f"receive_binary(full, {len(content)})")
+                await self.mpl_canvas.apply_full(bytes(content))
             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 (
-                        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._rubberband.left = min(x0, x1)
-                        self._rubberband.top = min(y0, y1)
-                        self._rubberband.width = abs(x1 - x0)
-                        self._rubberband.height = abs(y1 - y0)
-                        self._rubberband.visible = True
-                    else:
-                        self._rubberband.visible = False
-                    self._rubberband.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"],
-                        },
-                    )
+                logger.debug(f"receive_binary(diff, {len(content)})")
+                await self.mpl_canvas.apply_diff(bytes(content))
+            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 (
+                    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._rubberband.left = min(x0, x1)
+                    self._rubberband.top = min(y0, y1)
+                    self._rubberband.width = abs(x1 - x0)
+                    self._rubberband.height = abs(y1 - y0)
+                    self._rubberband.visible = True
+                else:
+                    self._rubberband.visible = False
+                self._rubberband.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."""

{flet_charts-1.0.0.dev0 → flet_charts-1.0.0.dev2/src/flet_charts.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-charts
-Version: 1.0.0.dev0
+Version: 1.0.0.dev2
 Summary: Interactive chart controls for Flet apps.
 Author-email: Flet contributors <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -11,7 +11,7 @@ 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==1.0.0.dev0
+Requires-Dist: flet==1.0.0.dev2
 Dynamic: license-file
 
 # flet-charts

{flet_charts-1.0.0.dev0 → flet_charts-1.0.0.dev2}/src/flet_charts.egg-info/SOURCES.txt

@@ -46,4 +46,5 @@ src/flutter/flet_charts/lib/src/utils/line_chart.dart
 src/flutter/flet_charts/lib/src/utils/pie_chart.dart
 src/flutter/flet_charts/lib/src/utils/radar_chart.dart
 src/flutter/flet_charts/lib/src/utils/scatter_chart.dart
-tests/test_matplotlib_chart_canvas.py
+tests/test_matplotlib_chart_canvas.py
+tests/test_matplotlib_chart_receive_loop.py

flet_charts-1.0.0.dev2/src/flet_charts.egg-info/requires.txt

@@ -0,0 +1 @@
+flet==1.0.0.dev2

{flet_charts-1.0.0.dev0 → flet_charts-1.0.0.dev2}/tests/test_matplotlib_chart_canvas.py

@@ -70,6 +70,7 @@ def _make_chart_standin():
     chart._waiting = False
     chart.img_count = 0
     chart._MatplotlibChart__image_mode = "full"
+    chart._handle_message = types.MethodType(MatplotlibChart._handle_message, chart)
     return chart, canvas
 
 

flet_charts-1.0.0.dev2/tests/test_matplotlib_chart_receive_loop.py

@@ -0,0 +1,122 @@
+"""Fault isolation in ``MatplotlibChart._receive_loop``.
+
+The loop is the sole consumer of ``_receive_queue``, and it does more than
+shuffle bytes: ``send_message`` hands a "draw" straight to Matplotlib's
+canvas manager, so the figure renders *inside* this task. Any render error
+— a bad artist, a font that fails to rasterize, a degenerate 3D view —
+therefore surfaces here. Unguarded, it would end the loop: no frame would
+ever be applied again, the chart would freeze with no visible error, and
+the traceback would only appear much later as asyncio's "Task exception was
+never retrieved" when the dead task is garbage-collected.
+
+These tests drive the real ``_receive_loop`` with the failures injected at
+the two points that can raise — the canvas apply, and the synchronous
+Matplotlib render behind ``send_message``.
+"""
+
+import asyncio
+import types
+
+from flet_charts.matplotlib_chart import MatplotlibChart
+
+
+def _make_chart_standin():
+    """Minimal ``self`` for the real ``_receive_loop``: the queue/state
+    attrs ``build()`` would create, plus a fake canvas and ``send_message``
+    so a failure can be injected at either point."""
+    chart = types.SimpleNamespace()
+    chart._receive_queue = asyncio.Queue()
+    chart._waiting = False
+    chart.img_count = 0
+    chart._MatplotlibChart__image_mode = "full"
+    chart.applied = []
+    chart.sent = []
+
+    async def apply_raw_packet(packet):
+        if packet == b"boom":
+            raise RuntimeError("FT_Render_Glyph failed: raster overflow")
+        chart.applied.append(packet)
+
+    chart.mpl_canvas = types.SimpleNamespace(apply_raw_packet=apply_raw_packet)
+
+    def send_message(message):
+        chart.sent.append(message)
+        if chart.render_fails:
+            raise RuntimeError("FT_Render_Glyph failed: raster overflow")
+
+    chart.send_message = send_message
+    chart.render_fails = False
+    chart._handle_message = types.MethodType(MatplotlibChart._handle_message, chart)
+    return chart
+
+
+def _feed_frame(chart, payload=b"frame"):
+    chart._receive_queue.put_nowait((True, ("raw", payload)))
+
+
+async def _drain(chart):
+    """Run the real loop long enough to consume the queue, then stop it.
+
+    Returns whether the loop was still alive at that point — a loop killed
+    by an exception is `done()` before anything cancels it.
+    """
+    task = asyncio.create_task(MatplotlibChart._receive_loop(chart))
+    await asyncio.sleep(0.05)
+    alive = not task.done()
+    task.cancel()
+    return alive
+
+
+def test_failing_render_does_not_kill_the_loop():
+    """A "draw" whose render raises must not stop frames that follow."""
+
+    async def scenario():
+        chart = _make_chart_standin()
+        chart.render_fails = True
+        chart._receive_queue.put_nowait((False, {"type": "draw"}))
+        chart.render_fails = False
+        _feed_frame(chart)
+        alive = await _drain(chart)
+        return chart.applied, chart._waiting, alive
+
+    applied, waiting, alive = asyncio.run(scenario())
+    assert applied == [b"frame"], "loop must keep applying frames after a render error"
+    assert not waiting, "a draw that raised must not leave the draw gate latched"
+    assert alive, "the loop task must still be running"
+
+
+def test_failing_frame_apply_does_not_kill_the_loop():
+    """An error while applying one frame must not lose the next one."""
+
+    async def scenario():
+        chart = _make_chart_standin()
+        _feed_frame(chart, b"boom")
+        _feed_frame(chart, b"good")
+        await _drain(chart)
+        return chart.applied
+
+    assert asyncio.run(scenario()) == [b"good"]
+
+
+def test_draw_gate_reopens_after_a_render_error():
+    """``_waiting`` gates draw requests; a failed draw never produces the
+    frame that clears it, so the loop must clear it itself — otherwise no
+    further draw is ever requested and the chart stays frozen."""
+
+    async def scenario():
+        chart = _make_chart_standin()
+        chart.render_fails = True
+        chart._receive_queue.put_nowait((False, {"type": "draw"}))
+        await _drain(chart)
+        first = list(chart.sent)
+
+        chart.render_fails = False
+        chart._receive_queue.put_nowait((False, {"type": "draw"}))
+        await _drain(chart)
+        return first, chart.sent
+
+    first, sent = asyncio.run(scenario())
+    assert first == [{"type": "draw"}]
+    assert sent == [{"type": "draw"}, {"type": "draw"}], (
+        "a later draw notification must still reach Matplotlib"
+    )

flet_charts-1.0.0.dev0/src/flet_charts.egg-info/requires.txt

@@ -1 +0,0 @@
-flet==1.0.0.dev0