flet-charts 0.85.3.dev0__tar.gz → 0.86.0.dev0__tar.gz

{flet_charts-0.85.3.dev0/src/flet_charts.egg-info → flet_charts-0.86.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-charts
-Version: 0.85.3.dev0
+Version: 0.86.0.dev0
 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==0.85.3.dev0
+Requires-Dist: flet==0.86.0.dev0
 Dynamic: license-file
 
 # flet-charts

{flet_charts-0.85.3.dev0 → flet_charts-0.86.0.dev0}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "flet-charts"
-version = "0.85.3.dev0"
+version = "0.86.0.dev0"
 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==0.85.3.dev0",
+    "flet==0.86.0.dev0",
 ]
 
 [project.urls]

{flet_charts-0.85.3.dev0 → flet_charts-0.86.0.dev0}/src/flet_charts/matplotlib_chart.py

@@ -434,10 +434,15 @@ class MatplotlibChart(ft.GestureDetector):
             if is_binary:
                 assert isinstance(content, (bytes, bytearray))
                 logger.debug(f"receive_binary({len(content)})")
-                # Hand the frame to the client widget — full PNG replaces the
-                # backbuffer, diff PNG composites onto it. Awaiting naturally
-                # rate-limits this loop to the client's processing speed and
-                # yields the asyncio loop for incoming events.
+                # Hand the frame to the client widget — 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 self.__image_mode == "full":
                     await self.mpl_canvas.apply_full(bytes(content))
                 else:

flet_charts-0.86.0.dev0/src/flet_charts/matplotlib_chart_canvas.py

@@ -0,0 +1,166 @@
+import asyncio
+import contextlib
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Callable, Optional
+
+import flet as ft
+
+__all__ = ["MatplotlibChartCanvas", "MatplotlibChartCanvasResizeEvent"]
+
+
+@dataclass
+class MatplotlibChartCanvasResizeEvent(ft.Event["MatplotlibChartCanvas"]):
+    """
+    Event emitted when the canvas reports a new rendered size.
+    """
+
+    width: float = field(metadata={"data_field": "w"})
+    """New width of the canvas in logical pixels."""
+
+    height: float = field(metadata={"data_field": "h"})
+    """New height of the canvas in logical pixels."""
+
+
+@ft.control("MatplotlibChartCanvas")
+class MatplotlibChartCanvas(ft.LayoutControl):
+    """
+    Display widget for matplotlib WebAgg-style image streams.
+
+    Receives full and incremental "diff" PNG frames and composites them in
+    CPU memory, holding at most one decoded image for display at a time.
+    Frames flow over a dedicated [ft.DataChannel] rather than the regular
+    Flet protocol, so the PNG bytes skip MsgPack encode/decode and travel
+    at memory-bandwidth-class speed in embedded native mode (per-channel
+    PythonBridge) and at near-bandwidth speed in web/dev modes (raw-byte
+    frames muxed over the protocol transport).
+
+    Wire format on the data channel (one byte of opcode followed by the
+    PNG payload):
+
+    | opcode | payload    | meaning                                    |
+    |--------|------------|--------------------------------------------|
+    | 0x01   | PNG bytes  | apply_full — replace backdrop              |
+    | 0x02   | PNG bytes  | apply_diff — composite onto backbuffer     |
+    | 0x03   | (empty)    | clear — drop backdrop + backbuffer         |
+
+    The reverse-direction `resize` event (Dart → Python, small JSON-shaped
+    payload) stays on the existing Flet protocol channel — no reason to
+    move tiny control events off it.
+    """
+
+    resize_interval: ft.Number = 10
+    """
+    Sampling interval in milliseconds for `on_resize` event.
+    """
+
+    on_resize: Optional[ft.EventHandler[MatplotlibChartCanvasResizeEvent]] = None
+    """
+    Called when the size of this canvas has changed.
+    """
+
+    on_data_channel_open: Optional[ft.EventHandler[ft.DataChannelOpenEvent]] = None
+    """
+    Framework hook — Dart fires this when it opens the data channel during
+    `initState`. The default handler captures the channel for use by
+    apply_full / apply_diff / clear. Override only if you need to do
+    something extra at attach-time.
+    """
+
+    def init(self) -> None:
+        # `init` is the @ft.control post-construct lifecycle hook (runs
+        # before `did_mount`). Wire up the default channel-capture handler.
+        self._channel: Optional[ft.DataChannel] = None
+        # FIFO of per-frame ack futures. Each `apply_*` enqueues a future
+        # and `awaits` it; `_on_dart_message` pops the head and resolves
+        # it when Dart's `[0xFF]` ack arrives. The await is what makes
+        # producer-side callers (e.g. MatplotlibChart._receive_loop)
+        # block — events queued during the wait are processed *after*
+        # the ack instead of being dropped by stale gate checks.
+        self._pending_acks: deque[asyncio.Future] = deque()
+        # Optional plain callback for observers that want to be notified
+        # on every frame ack (e.g. perf instrumentation). Fires alongside
+        # the future resolution; not load-bearing for backpressure.
+        self._on_frame_applied: Optional[Callable[[], None]] = None
+        if self.on_data_channel_open is None:
+            self.on_data_channel_open = self._capture_channel
+
+    def _capture_channel(self, e: ft.DataChannelOpenEvent) -> None:
+        # Single-channel widget; no need to dispatch on e.channel_name.
+        self._channel = self.get_data_channel(e.channel_id)
+        self._channel.on_bytes(self._on_dart_message)
+
+    def _on_dart_message(self, payload: bytes) -> None:
+        # Wire format on the reverse direction (Dart → Python):
+        #   [0xFF] — frame_applied ack. Sent by Dart after each apply_full /
+        #            apply_diff / clear completes on its end. Restores the
+        #            round-trip backpressure that `_invoke_method` used to
+        #            provide implicitly in 0.85.
+        if not payload or payload[0] != 0xFF:
+            return
+        # Resolve the head future so the matching `apply_*` await returns.
+        if self._pending_acks:
+            fut = self._pending_acks.popleft()
+            if not fut.done():
+                fut.set_result(None)
+        # Then fire the observer callback (if any).
+        cb = self._on_frame_applied
+        if cb is not None:
+            with contextlib.suppress(Exception):
+                cb()
+
+    def set_on_frame_applied(self, cb: Optional[Callable[[], None]]) -> None:
+        """Register a side-channel callback invoked on every frame ack.
+
+        Useful for instrumentation. Backpressure is handled by awaiting
+        the result of `apply_full` / `apply_diff` / `clear` directly —
+        this callback is a fire-and-forget observer, not part of the
+        gating path.
+        """
+        self._on_frame_applied = cb
+
+    async def _send_and_wait(self, packet: bytes) -> None:
+        """Send a channel packet and await Dart's ack.
+
+        Awaiting blocks the caller until `[0xFF]` arrives on the channel,
+        re-creating the 0.85 `_invoke_method` round-trip semantics:
+        events that arrive in the producer's queue during the wait stay
+        queued (instead of being processed eagerly against a stale
+        `_waiting` flag).
+        """
+        if self._channel is None:
+            return
+        loop = asyncio.get_running_loop()
+        fut: asyncio.Future = loop.create_future()
+        self._pending_acks.append(fut)
+        self._channel.send(packet)
+        await fut
+
+    async def apply_full(self, image_bytes: bytes) -> None:
+        """
+        Replace the current displayed image with a full PNG frame.
+
+        Args:
+            image_bytes: PNG bytes of the complete frame.
+        """
+        await self._send_and_wait(b"\x01" + image_bytes)
+
+    async def apply_diff(self, image_bytes: bytes) -> None:
+        """
+        Composite an incremental "diff" PNG frame onto the current image.
+
+        Pixels with non-zero alpha replace the corresponding pixels in the
+        existing backbuffer; transparent pixels leave the backbuffer
+        unchanged. If no backbuffer exists yet, the diff is treated as a
+        full frame.
+
+        Args:
+            image_bytes: PNG bytes of the diff frame.
+        """
+        await self._send_and_wait(b"\x02" + image_bytes)
+
+    async def clear(self) -> None:
+        """
+        Clear the displayed image and discard the backbuffer.
+        """
+        await self._send_and_wait(b"\x03")

{flet_charts-0.85.3.dev0 → flet_charts-0.86.0.dev0/src/flet_charts.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-charts
-Version: 0.85.3.dev0
+Version: 0.86.0.dev0
 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==0.85.3.dev0
+Requires-Dist: flet==0.86.0.dev0
 Dynamic: license-file
 
 # flet-charts

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

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

{flet_charts-0.85.3.dev0 → flet_charts-0.86.0.dev0}/src/flutter/flet_charts/lib/src/matplotlib_chart_canvas.dart

@@ -35,22 +35,9 @@ class MatplotlibChartCanvasControl extends StatefulWidget {
 }
 
 // ---------------------------------------------------------------------------
-// Shared helpers
+// Shared base
 // ---------------------------------------------------------------------------
 
-Uint8List _extractBytes(dynamic args) {
-  final v = args is Map ? args["bytes"] : args;
-  if (v is Uint8List) return v;
-  if (v is ByteData) {
-    return v.buffer.asUint8List(v.offsetInBytes, v.lengthInBytes);
-  }
-  if (v is List<int>) return Uint8List.fromList(v);
-  if (v is List && v.every((e) => e is int)) {
-    return Uint8List.fromList(v.cast<int>());
-  }
-  throw ArgumentError("Expected bytes for image data, got ${v.runtimeType}");
-}
-
 abstract class _MatplotlibChartCanvasStateBase
     extends State<MatplotlibChartCanvasControl> {
   // Serialize concurrent apply_full / apply_diff calls so backdrop mutations
@@ -60,15 +47,30 @@ abstract class _MatplotlibChartCanvasStateBase
   Size _lastSize = Size.zero;
   int _lastResize = DateTime.now().millisecondsSinceEpoch;
 
+  DataChannel? _channel;
+  StreamSubscription<Uint8List>? _channelSub;
+
   @override
-  void initState() {
-    super.initState();
-    widget.control.addInvokeMethodListener(_invokeMethod);
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    // Open the data channel lazily on first dependency lookup — we need
+    // BuildContext to reach FletBackend, which isn't available in initState.
+    if (_channel != null) return;
+    _channel = FletBackend.of(context).openDataChannel();
+    _channelSub = _channel!.messages.listen(_onChannelFrame);
+    // Announce the channel to Python via the standard convention event.
+    widget.control.triggerEvent("data_channel_open", {
+      "channel_name": "frames",
+      "channel_id": _channel!.id,
+    });
   }
 
   @override
   void dispose() {
-    widget.control.removeInvokeMethodListener(_invokeMethod);
+    _channelSub?.cancel();
+    _channelSub = null;
+    _channel?.close();
+    _channel = null;
     disposeResources();
     super.dispose();
   }
@@ -81,22 +83,42 @@ abstract class _MatplotlibChartCanvasStateBase
   Future<void> clearAll();
   CustomPainter buildPainter();
 
-  Future<dynamic> _invokeMethod(String name, dynamic args) async {
-    switch (name) {
-      case "apply_full":
-        await _enqueue(() => applyFull(_extractBytes(args)));
-        return;
-      case "apply_diff":
-        await _enqueue(() => applyDiff(_extractBytes(args)));
-        return;
-      case "clear":
-        await _enqueue(clearAll);
-        return;
+  // 1-byte ack sent back to Python after each apply completes. Restores
+  // round-trip backpressure: matplotlib's producer side keeps `_waiting`
+  // set until this ack arrives, so frames don't pile up in the Dart-side
+  // queue during interactive drags.
+  static final Uint8List _frameAppliedAck = Uint8List.fromList([0xFF]);
+
+  /// Inbound DataChannel frame. Wire format:
+  ///   [0x01][PNG bytes] → apply_full
+  ///   [0x02][PNG bytes] → apply_diff
+  ///   [0x03]            → clear
+  void _onChannelFrame(Uint8List bytes) {
+    if (bytes.isEmpty) return;
+    // Zero-copy slice of the same underlying buffer.
+    final payload = Uint8List.sublistView(bytes, 1);
+    switch (bytes[0]) {
+      case 0x01:
+        _enqueueAndAck(() => applyFull(payload));
+        break;
+      case 0x02:
+        _enqueueAndAck(() => applyDiff(payload));
+        break;
+      case 0x03:
+        _enqueueAndAck(clearAll);
+        break;
       default:
-        throw Exception("Unknown MatplotlibChartCanvas method: $name");
+        debugPrint(
+            "MatplotlibChartCanvas: unknown data-channel opcode 0x${bytes[0].toRadixString(16)}");
     }
   }
 
+  void _enqueueAndAck(Future<void> Function() task) {
+    _enqueue(task).whenComplete(() {
+      _channel?.send(_frameAppliedAck);
+    });
+  }
+
   Future<void> _enqueue(Future<void> Function() task) {
     final prev = _applyChain ?? Future.value();
     final next = prev.then((_) => task());

flet_charts-0.85.3.dev0/src/flet_charts/matplotlib_chart_canvas.py

@@ -1,72 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Optional
-
-import flet as ft
-
-__all__ = ["MatplotlibChartCanvas", "MatplotlibChartCanvasResizeEvent"]
-
-
-@dataclass
-class MatplotlibChartCanvasResizeEvent(ft.Event["MatplotlibChartCanvas"]):
-    """
-    Event emitted when the canvas reports a new rendered size.
-    """
-
-    width: float = field(metadata={"data_field": "w"})
-    """New width of the canvas in logical pixels."""
-
-    height: float = field(metadata={"data_field": "h"})
-    """New height of the canvas in logical pixels."""
-
-
-@ft.control("MatplotlibChartCanvas")
-class MatplotlibChartCanvas(ft.LayoutControl):
-    """
-    Display widget for matplotlib WebAgg-style image streams.
-
-    Receives full and incremental "diff" PNG frames and composites them in
-    CPU memory, holding at most one decoded image for display at a time.
-    Avoids the per-frame `Picture.toImage` allocations that the generic
-    `flet.canvas.Canvas` capture path uses, which on Flutter web
-    (CanvasKit/WASM) accumulate and aren't promptly reclaimed by the JS GC
-    during animation, causing browser memory growth.
-    """
-
-    resize_interval: ft.Number = 10
-    """
-    Sampling interval in milliseconds for `on_resize` event.
-    """
-
-    on_resize: Optional[ft.EventHandler[MatplotlibChartCanvasResizeEvent]] = None
-    """
-    Called when the size of this canvas has changed.
-    """
-
-    async def apply_full(self, image_bytes: bytes) -> None:
-        """
-        Replace the current displayed image with a full PNG frame.
-
-        Args:
-            image_bytes: PNG bytes of the complete frame.
-        """
-        await self._invoke_method("apply_full", arguments={"bytes": image_bytes})
-
-    async def apply_diff(self, image_bytes: bytes) -> None:
-        """
-        Composite an incremental "diff" PNG frame onto the current image.
-
-        Pixels with non-zero alpha replace the corresponding pixels in the
-        existing backbuffer; transparent pixels leave the backbuffer
-        unchanged. If no backbuffer exists yet, the diff is treated as a
-        full frame.
-
-        Args:
-            image_bytes: PNG bytes of the diff frame.
-        """
-        await self._invoke_method("apply_diff", arguments={"bytes": image_bytes})
-
-    async def clear(self) -> None:
-        """
-        Clear the displayed image and discard the backbuffer.
-        """
-        await self._invoke_method("clear")

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

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