pgwidgets-python 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

pgwidgets/method_types.py

@@ -235,6 +235,10 @@ STATE_DEFAULTS = {
     "TabWidget": {"index": -1},
     "StackWidget": {"index": -1},
     "MDIWidget": {"index": -1},
+    # ScrollBar uses 1-arg set_scroll_percent / set_thumb_percent,
+    # so a scalar default is correct (not the (0.0, 0.0) tuple used
+    # by the 2-arg scroll widgets in STATE_KEY_DEFAULTS).
+    "ScrollBar": {"scroll_percent": 0.0, "thumb_percent": 0.0},
 }
 
 # Cross-widget default values for state keys, used as a fallback when
@@ -245,6 +249,17 @@ STATE_KEY_DEFAULTS = {
     "size": (0, 0),
     "position": (0, 0),
     "index": -1,
+    # Scroll widgets that take (h_pct, v_pct).  ScrollBar overrides
+    # these in STATE_DEFAULTS with scalar 0.0.
+    "scroll_position": (0.0, 0.0),
+    "scroll_percent": (0.0, 0.0),
+    "thumb_percent": (0.0, 0.0),
+    # set_expanding(horizontal, vertical) → tuple of bools
+    "expanding": (False, False),
+    "enabled": True,
+    "state": False,
+    # HTMLMediaElement convention: 0.0 (muted) to 1.0 (full).
+    "volume": 1.0,
 }
 
 # Widgets with incrementally-built item lists.
@@ -323,6 +338,34 @@ def _menuaction_get_state(self):
     """Alias for MenuAction.get_checked — keeps a single state key."""
     return self.get_checked()
 
+# Above this size (bytes), set_binary_image switches from the single-
+# frame _send_binary transport to the chunked _send_binary_chunked
+# transport.  Keeps small frames cheap and lets multi-megabyte frames
+# yield to other WebSocket traffic between chunks.
+_BINARY_CHUNK_THRESHOLD = 1 * 1024 * 1024  # 1 MiB
+
+
+def _send_binary_auto(session, wid, method, args, data):
+    """Pick single-frame or chunked transport based on payload size.
+
+    If ``data`` is a :class:`pgwidgets.Buffer`, its bytes ship via the
+    chunked transport (regardless of size) with ``shape`` and
+    ``dtype`` attached to the announce so the JS receiver constructs
+    a typed array.  Plain bytes-like input falls back to the size
+    heuristic (chunked above ~1 MiB, single-frame below).
+    """
+    from pgwidgets.buffer import Buffer  # local import to avoid cycle
+    if isinstance(data, Buffer):
+        session._send_binary_chunked(
+            wid, method, args, data.data,
+            shape=data.shape, dtype=data.dtype)
+        return
+    if len(data) > _BINARY_CHUNK_THRESHOLD:
+        session._send_binary_chunked(wid, method, args, data)
+    else:
+        session._send_binary(wid, method, args, data)
+
+
 def _image_set_binary_image(self, data, format="jpeg"):
     """Set the image from raw bytes via a WebSocket binary frame.
 
@@ -343,6 +386,10 @@ def _image_set_binary_image(self, data, format="jpeg"):
     that reconstruction after a browser reconnect re-sends the most
     recently set image.  Earlier set_image (URL-based) state is
     cleared since the two methods are mutually exclusive.
+
+    Large payloads (above ~1 MiB) automatically use the chunked
+    binary transport so the WebSocket can interleave other messages
+    while the image streams.
     """
     if not isinstance(data, (bytes, bytearray, memoryview)):
         raise TypeError(
@@ -350,8 +397,8 @@ def _image_set_binary_image(self, data, format="jpeg"):
     data = bytes(data)
     self._state.pop("image", None)
     self._state["binary_image"] = (format, data)
-    self._session._send_binary(
-        self._wid, "set_binary_image", [format], data)
+    _send_binary_auto(self._session, self._wid,
+                      "set_binary_image", [format], data)
 
 # State keys whose value is a (format, bytes) tuple that must be
 # replayed via _send_binary instead of _call during reconstruction.

pgwidgets/sync/application.py

@@ -33,7 +33,7 @@ from pgwidgets.method_types import (
     STATE_SYNC_CALLBACKS, STATE_SYNC_REQUIRES_OPTION,
     WIDGET_CALLBACK_SYNC, POST_CHILDREN_STATE_KEYS, ITEM_LIST_CONFIG,
     CHILD_CLOSE_CALLBACKS, REPLAY_METHODS, TREE_VIEW_WIDGETS,
-    BINARY_STATE_KEYS,
+    BINARY_STATE_KEYS, _send_binary_auto,
 )
 
 _CONCURRENCY_MODES = ("serialized", "per_session", "concurrent")
@@ -169,6 +169,11 @@ class Session:
 
         self._widget_classes = app._widget_classes
         self._transfers = {}     # transfer_id -> transfer state dict
+        # FIFO of binary-chunk JSON headers (encoding="binary") still
+        # awaiting their paired raw binary frame.  Each connection's
+        # send order on the JS side is single-threaded, so a simple
+        # FIFO suffices on the receive side too.
+        self._pending_binary_headers = []
         self._callback_source_ws = None  # ws that sent current callback
 
         self._reconstructing = False  # suppress callbacks during reconstruction
@@ -273,6 +278,20 @@ class Session:
     # -- Message handling --
 
     def _handle_message(self, data):
+        # Raw binary frames are chunk payloads — pair with the head of
+        # the pending-binary FIFO (a list of binary-chunk JSON headers
+        # whose encoding == "binary").  This is symmetric with the
+        # JS-side intake.
+        if isinstance(data, (bytes, bytearray, memoryview)):
+            queue = self._pending_binary_headers
+            if not queue:
+                self._logger.warning(
+                    "Session %s: unexpected binary frame with no "
+                    "queued header (ignored).", self.id)
+                return
+            header = queue.pop(0)
+            self._handle_binary_chunk(header, bytes(data))
+            return
         msg = json.loads(data)
         if isinstance(msg, list):
             for m in msg:
@@ -293,8 +312,20 @@ class Session:
         elif msg_type == "viewport":
             self._screen_size = (msg.get("width", 0), msg.get("height", 0))
 
-        elif msg_type == "file-chunk":
-            self._handle_file_chunk(msg)
+        elif msg_type == "binary-chunk":
+            # Either reserves the next binary frame (encoding="binary")
+            # or carries an inline base64 payload (encoding="base64").
+            encoding = msg.get("encoding", "binary")
+            if encoding == "binary":
+                self._pending_binary_headers.append(msg)
+            elif encoding == "base64":
+                import base64 as _b64
+                payload = _b64.b64decode(msg.get("data") or "")
+                self._handle_binary_chunk(msg, payload)
+            else:
+                self._logger.warning(
+                    "Session %s: unknown binary-chunk encoding %r "
+                    "(ignored).", self.id, encoding)
 
         elif msg_type == "callback":
             # If the payload has a transfer_id, stash the metadata —
@@ -321,25 +352,45 @@ class Session:
             self._dispatch_callback(
                 msg["wid"], msg["action"], *msg.get("args", []))
 
-    def _handle_file_chunk(self, msg):
-        """Handle a file-chunk message: buffer data and fire callbacks."""
-        tid = msg["transfer_id"]
+    def _handle_binary_chunk(self, header, data):
+        """Buffer one chunk of an in-flight transfer.
+
+        ``header`` is the parsed binary-chunk JSON; ``data`` is the
+        chunk's raw bytes (either from the paired binary WebSocket
+        frame or decoded from an inline base64 ``data`` field).
+
+        For file-upload transfers (drag-drop, FileDialog), the header
+        also carries ``file_index`` / ``file_count`` so multiple files
+        can be reassembled in parallel.  For other future server-bound
+        chunked transports, those fields can be omitted.
+        """
+        tid = header["transfer_id"]
         transfer = self._transfers.get(tid)
         if transfer is None:
             return
 
-        fi = msg["file_index"]
-        fc = msg["file_count"]
+        fi = header.get("file_index", 0)
+        fc = header.get("file_count", 1)
+        ci = header["chunk_index"]
+        nc = header["num_chunks"]
         if fi not in transfer["file_data"]:
-            transfer["file_data"][fi] = []
-            transfer["num_chunks"][fi] = msg["num_chunks"]
-        transfer["file_data"][fi].append(msg["data"])
+            transfer["file_data"][fi] = [None] * nc
+            transfer["num_chunks"][fi] = nc
+        slot = transfer["file_data"][fi]
+        if 0 <= ci < len(slot):
+            slot[ci] = data
+        else:
+            self._logger.warning(
+                "Session %s: chunk_index %d out of range for "
+                "transfer_id %s (num_chunks=%d).",
+                self.id, ci, tid, nc)
+            return
 
         # Check if all files have received all their chunks.
         all_complete = (
             len(transfer["num_chunks"]) == fc
             and all(
-                len(transfer["file_data"][i]) >= transfer["num_chunks"][i]
+                None not in transfer["file_data"][i]
                 for i in range(fc)
             )
         )
@@ -351,16 +402,17 @@ class Session:
         for i, fmeta in enumerate(files_meta):
             fsize = fmeta.get("size", 0)
             total_bytes += fsize
-            nc = transfer["num_chunks"].get(i)
-            if nc:
-                received = len(transfer["file_data"].get(i, []))
-                transferred_bytes += fsize * received // nc
+            n = transfer["num_chunks"].get(i)
+            if n:
+                slots = transfer["file_data"].get(i, [])
+                received = sum(1 for s in slots if s is not None)
+                transferred_bytes += fsize * received // n
 
         progress_info = {
             "transfer_id": tid,
             "file_index": fi,
-            "chunk_index": msg["chunk_index"],
-            "num_chunks": msg["num_chunks"],
+            "chunk_index": ci,
+            "num_chunks": nc,
             "transferred_bytes": transferred_bytes,
             "total_bytes": total_bytes,
             "complete": all_complete,
@@ -376,26 +428,36 @@ class Session:
             # Reassemble file data and fire the original callback.
             payload = transfer["payload"]
             for i, file_meta in enumerate(payload["files"]):
-                file_meta["data"] = "".join(
-                    transfer["file_data"].get(i, []))
+                slots = transfer["file_data"].get(i, [])
+                file_meta["data"] = b"".join(slots)
             del self._transfers[tid]
             self._dispatch_callback(
                 transfer["wid"], action, payload)
 
     def _dispatch_callback(self, wid, action, *args):
         """Dispatch a callback through the configured concurrency mode."""
-        # widget = self._widget_map.get(wid)
-        # cls_name = widget._js_class if widget is not None else "<missing>"
-        # print(f"[PY-CB] receive wid={wid} action={action} "
-        #       f"registered_class={cls_name}", flush=True)
-        if self._reconstructing:
-            return  # suppress callbacks during reconstruction
+        # Suppress callbacks during reconstruction — they are side
+        # effects of state replay, not user actions.  Exception: 'map'
+        # is a one-shot lifecycle event that fires when a widget first
+        # gains a visible layout box; the JS-side observers may fire
+        # it during the reconstruction window and we MUST forward it
+        # or the user's map handler never runs until something later
+        # triggers a re-fire (e.g. a window resize).
+        if self._reconstructing and action != 'map':
+            return
         # Auto-sync: some callbacks carry state that should be reflected
         # in the Python-side widget (e.g. move -> position, resize -> size).
+        # We always *capture* the value so get_size()/get_position() return
+        # current values, but only *push* it to other browsers (and replay
+        # it on reconstruction) when the widget opted in via auto-sync.
+        # Otherwise a layout-determined size would replay as a literal
+        # resize(W, H) — pinning the widget to pixel dimensions and
+        # killing flex growth.
         state_key = STATE_SYNC_CALLBACKS.get(action)
         if state_key is not None:
             widget = self._widget_map.get(wid)
             if widget is not None:
+                auto = action in widget._auto_sync_actions
                 # Normalize: resize sends {width, height} dict, move
                 # sends (x, y) as separate args.  Store as a flat tuple
                 # matching the corresponding setter's signature.
@@ -405,15 +467,17 @@ class Session:
                         new_val = (d["width"], d["height"])
                         if widget._state.get(state_key) != new_val:
                             widget._state[state_key] = new_val
-                            self._push(wid, "resize",
-                                       d["width"], d["height"])
+                            if auto:
+                                self._push(wid, "resize",
+                                           d["width"], d["height"])
                 else:
                     new_val = tuple(args)
                     if widget._state.get(state_key) != new_val:
                         widget._state[state_key] = new_val
-                        setter = (self._STATE_KEY_TO_SETTER.get(state_key)
-                                  or f"set_{state_key}")
-                        self._push(wid, setter, *args)
+                        if auto:
+                            setter = (self._STATE_KEY_TO_SETTER.get(state_key)
+                                      or f"set_{state_key}")
+                            self._push(wid, setter, *args)
                 # If this widget wraps a child (e.g. MDISubWindow),
                 # propagate geometry into the parent's children options
                 # so reconstruction replays with the current pos/size.
@@ -706,6 +770,91 @@ class Session:
                 continue
             fut.add_done_callback(_drain_send_exception)
 
+    def _send_binary_chunked(self, wid, method, args, data,
+                             chunk_size=512 * 1024,
+                             shape=None, dtype=None):
+        """Fire-and-forget chunked binary call.
+
+        Splits ``data`` (bytes) into ``chunk_size`` chunks and sends
+        them as a ``binary-call-chunked`` announce followed by N
+        (``binary-chunk`` JSON + raw binary frame) pairs.  The JS side
+        reassembles into a single ``ArrayBuffer`` and dispatches as
+        ``widget[method](buffer, *args)``.
+
+        When ``shape`` and ``dtype`` are provided, they are attached to
+        the announce header and the JS receiver constructs a typed
+        array (``Uint8Array``, ``Float32Array``, …) instead of a raw
+        ``ArrayBuffer`` before dispatch.  This is what :class:`Buffer`
+        arguments end up doing.
+
+        All chunks for a single transfer ship atomically on each
+        connection (one coroutine per connection) so they can't
+        interleave with other binary sends from another thread.
+        """
+        if not self._connections:
+            return
+        if not isinstance(data, (bytes, bytearray, memoryview)):
+            raise TypeError(
+                "_send_binary_chunked: data must be bytes-like, got "
+                + type(data).__name__)
+        data = bytes(data)
+        n = len(data)
+        if chunk_size <= 0:
+            raise ValueError("chunk_size must be positive")
+        num_chunks = max(1, (n + chunk_size - 1) // chunk_size)
+        with self._lock:
+            msg_id = self._next_id
+            self._next_id += 1
+            transfer_id = self._next_id
+            self._next_id += 1
+        announce_obj = {
+            "type": "binary-call-chunked",
+            "id": msg_id,
+            "wid": wid,
+            "method": method,
+            "args": list(args),
+            "transfer_id": transfer_id,
+            "num_chunks": num_chunks,
+        }
+        if shape is not None:
+            announce_obj["shape"] = list(shape)
+        if dtype is not None:
+            announce_obj["dtype"] = dtype
+        announce = json.dumps(announce_obj, cls=JsonEncoder)
+        # Pre-build chunk headers + slices so JSON encoding cost is
+        # paid once even if multiple browsers are connected.
+        pairs = []
+        for ci in range(num_chunks):
+            start = ci * chunk_size
+            end = min(start + chunk_size, n)
+            header = json.dumps({
+                "type": "binary-chunk",
+                "transfer_id": transfer_id,
+                "chunk_index": ci,
+                "num_chunks": num_chunks,
+                "encoding": "binary",
+            }, cls=JsonEncoder)
+            pairs.append((header, data[start:end]))
+
+        async def _send_all(ws):
+            await ws.send(announce)
+            for header, payload in pairs:
+                await ws.send(header)
+                await ws.send(payload)
+
+        for ws in self._connections:
+            coro = _send_all(ws)
+            try:
+                fut = asyncio.run_coroutine_threadsafe(coro,
+                                                       self._app._loop)
+            except RuntimeError as e:
+                self._logger.warning(
+                    "Session %s: loop refused chunked-binary coroutine: %r",
+                    self.id, e)
+                coro.close()
+                continue
+            fut.add_done_callback(_drain_send_exception)
+
     def _listen(self, wid, action, handler):
         """Register a callback listener.
 
@@ -804,13 +953,33 @@ class Session:
             cls = self._widget_classes.get(cls_name, Widget) if cls_name else Widget
             widget = cls._from_existing(self, wid, cls_name or "Widget")
             self._widget_map[wid] = widget
-            # Auto-listen for state-syncing callbacks (move, resize)
-            # so position/size changes are tracked for reconstruction.
+            # Auto-listen for state-syncing callbacks (move, resize).
+            # For visual widgets we always listen for 'resize' so that
+            # get_size() can return a current value, but we only mark
+            # the action as auto-syncing (which triggers push-to-peers
+            # and replay-on-reconstruction) when the widget defn
+            # actually opts in.  Non-visual Callback-base objects (e.g.
+            # TextBufferRef, Timer) get nothing.
+            defn = WIDGETS.get(cls_name, {}) if cls_name else {}
+            opt_names_set = set(defn.get("options", []))
+            all_callbacks = defn.get("callbacks", [])
+            is_visual = defn.get("base") != "callback"
             for action in STATE_SYNC_CALLBACKS:
-                key = f"{wid}:{action}"
-                if key not in self._callbacks:
-                    self._listen(wid, action, lambda wid, *a: None)
-                widget._auto_sync_actions.add(action)
+                req_opt = STATE_SYNC_REQUIRES_OPTION.get(action)
+                if req_opt is not None:
+                    opted_in = req_opt in opt_names_set
+                else:
+                    opted_in = action in all_callbacks
+                if not is_visual:
+                    continue
+                if action == "resize" or opted_in:
+                    key = f"{wid}:{action}"
+                    if key not in self._callbacks:
+                        self._listen(wid, action, lambda wid, *a: None)
+                if opted_in:
+                    widget._auto_sync_actions.add(action)
+                elif action == "resize":
+                    widget._passive_sync_actions.add(action)
             return widget
         if isinstance(val, list):
             return [self._resolve_return(v) for v in val]
@@ -907,6 +1076,13 @@ class Session:
     _STATE_KEY_TO_SETTER = {v: k for k, v in SPECIAL_SETTERS.items()}
     # e.g. {"size": "resize"}
 
+    # Reverse map: state_key -> callback action that auto-syncs it
+    # (e.g. "size" -> "resize", "position" -> "move").  Used during
+    # state replay to skip keys that weren't actively opted into via
+    # _auto_sync_actions — those were captured passively for getter
+    # support but must not be replayed (would pin layout).
+    _STATE_KEY_TO_SYNC_ACTION = {v: k for k, v in STATE_SYNC_CALLBACKS.items()}
+
     # State keys handled by fixed-value methods (show/hide)
     _FIXED_STATE_KEYS = {}
     for _mname, (_key, _val) in FIXED_SETTERS.items():
@@ -952,12 +1128,23 @@ class Session:
                 self._listen(new_widget._wid, act,
                              lambda wid, *a: None)
                 new_widget._auto_sync_actions.add(act)
-        # Replay any state the proxy accumulated (e.g. set_tooltip)
+        # Replay any state the proxy accumulated (e.g. set_tooltip).
+        # Skip passively-captured auto-sync state (size, position): we
+        # capture those from callbacks so getters work, but replaying
+        # would pin the widget to layout-determined pixel dimensions
+        # (same logic as _reconstruct_widget).
+        user_set = getattr(old_widget, "_user_set_state", set())
+        auto = getattr(old_widget, "_auto_sync_actions", set())
         for key, value in old_widget._state.items():
             if key.startswith("_"):
                 continue
             if key in sync_keys:
                 continue
+            sync_action = self._STATE_KEY_TO_SYNC_ACTION.get(key)
+            if (sync_action is not None
+                    and key not in user_set
+                    and sync_action not in auto):
+                continue
             method_name = (self._STATE_KEY_TO_SETTER.get(key)
                            or f"set_{key}")
             if isinstance(value, tuple):
@@ -965,6 +1152,13 @@ class Session:
             else:
                 self._call(new_widget._wid, method_name, value)
             new_widget._state[key] = value
+            # Propagate user-set / auto-sync membership to the new
+            # widget so subsequent reconstructions replay consistently.
+            if sync_action is not None:
+                if key in user_set:
+                    new_widget._user_set_state.add(key)
+                if sync_action in auto:
+                    new_widget._auto_sync_actions.add(sync_action)
 
     def _ensure_reconstructed(self, widget):
         """Ensure a widget has been created on the JS side.
@@ -1147,13 +1341,29 @@ class Session:
             if key.startswith("_"):
                 continue
 
+            # Skip auto-sync state (size, position) that came in
+            # passively via a callback (e.g. layout-determined size).
+            # We capture those so getters like get_size()/
+            # get_position() work, but replaying them would pin the
+            # widget to pixel dimensions and override flex/expanding
+            # layout.  Replay only if the user explicitly set the
+            # value, or if the widget opted into the sync action
+            # (e.g. an interactively-resizable widget).
+            sync_action = self._STATE_KEY_TO_SYNC_ACTION.get(key)
+            if (sync_action is not None
+                    and key not in widget._user_set_state
+                    and sync_action not in widget._auto_sync_actions):
+                continue
+
             # Binary-payload state (e.g. set_binary_image) replays via
-            # _send_binary so the bytes go in a raw frame, not embedded
-            # as base64 in JSON.
+            # _send_binary / _send_binary_chunked so the bytes go in
+            # raw frame(s), not embedded as base64 in JSON.  Large
+            # payloads switch to chunked transport automatically.
             if key in BINARY_STATE_KEYS:
                 method_name = BINARY_STATE_KEYS[key]
                 fmt, data = value
-                self._send_binary(widget._wid, method_name, [fmt], data)
+                _send_binary_auto(self, widget._wid, method_name,
+                                  [fmt], data)
                 continue
 
             if key in self._STATE_KEY_TO_SETTER:
@@ -1193,10 +1403,13 @@ class Session:
         # _listen calls treat them as first-time registrations and
         # actually send the "listen" message to the browser.
         wid = widget._wid
+        passive = getattr(widget, "_passive_sync_actions", set())
         for action in list(saved_cbs.keys()):
             self._callbacks.pop(f"{wid}:{action}", None)
         for action in widget._auto_sync_actions:
             self._callbacks.pop(f"{wid}:{action}", None)
+        for action in passive:
+            self._callbacks.pop(f"{wid}:{action}", None)
 
         for action, entries in saved_cbs.items():
             for handler, extra_args, extra_kwargs, style in entries:
@@ -1211,6 +1424,12 @@ class Session:
         for action in widget._auto_sync_actions:
             if action not in widget._registered_callbacks:
                 self._listen(widget._wid, action, lambda wid, *a: None)
+        # Passive listeners (e.g. 'resize' for getter support on
+        # widgets that didn't opt into auto-sync).
+        for action in passive:
+            if (action not in widget._registered_callbacks
+                    and action not in widget._auto_sync_actions):
+                self._listen(widget._wid, action, lambda wid, *a: None)
 
     def _child_method_for(self, parent):
         """Determine which child method a container uses."""
@@ -1386,13 +1605,24 @@ class Application:
 
     def __init__(self, ws_port=9500, http_port=9501, host="127.0.0.1",
                  http_server=True, concurrency_handling="per_session",
-                 max_sessions=1, logger=None):
+                 max_sessions=1, logger=None, ws_sock=None):
         if concurrency_handling not in _CONCURRENCY_MODES:
             raise ValueError(
                 f"concurrency_handling must be one of "
                 f"{_CONCURRENCY_MODES!r}, got {concurrency_handling!r}")
         self._host = host
-        self._ws_port = ws_port
+        # ws_sock, if provided, is a bound TCP socket the WebSocket
+        # server should adopt directly.  This removes the TOCTOU race
+        # that would otherwise exist between "find a free port" and
+        # "bind that port" — the caller binds, hands the socket in,
+        # and we never release the port between the two steps.
+        # ``ws_port`` is read back from the socket so logging /
+        # introspection still report a useful value.
+        self._ws_sock = ws_sock
+        if ws_sock is not None:
+            self._ws_port = ws_sock.getsockname()[1]
+        else:
+            self._ws_port = ws_port
         self._http_port = http_port
         self._use_http_server = http_server
         self._concurrency = concurrency_handling
@@ -1515,9 +1745,14 @@ class Application:
         self._loop.run_until_complete(self._serve_ws())
 
     async def _serve_ws(self):
-        async with websockets.serve(self._ws_handler, self._host,
-                                    self._ws_port):
-            await asyncio.Future()
+        if self._ws_sock is not None:
+            async with websockets.serve(self._ws_handler,
+                                        sock=self._ws_sock):
+                await asyncio.Future()
+        else:
+            async with websockets.serve(self._ws_handler, self._host,
+                                        self._ws_port):
+                await asyncio.Future()
 
     async def _ws_handler(self, ws):
         # Init handshake: send init, receive ack which may contain

pgwidgets/sync/widget.py

@@ -75,6 +75,16 @@ class Widget:
         self._constructor_options = {}
         self._registered_callbacks = {}
         self._auto_sync_actions = set()
+        # Actions we listen to passively for getter support
+        # (e.g. 'resize' on every visual widget so get_size() returns
+        # a current value), but that aren't in _auto_sync_actions and
+        # therefore don't push to peers or replay on reconstruction.
+        self._passive_sync_actions = set()
+        # State keys the user explicitly set via a setter call.
+        # Used during reconstruction to decide whether a state key
+        # should be replayed: passively-captured callback state
+        # (e.g. layout-determined size) is NOT in this set.
+        self._user_set_state = set()
         self._replay_calls = []
         self._add_seq = 0  # insertion order across _children + _replay_calls
 
@@ -160,6 +170,8 @@ class Widget:
         obj._constructor_options = {}
         obj._registered_callbacks = {}
         obj._auto_sync_actions = set()
+        obj._passive_sync_actions = set()
+        obj._user_set_state = set()
         obj._replay_calls = []
         obj._add_seq = 0
         obj._stale = False
@@ -177,15 +189,35 @@ class Widget:
         opt_names_set = set(defn.get("options", []))
         all_callbacks = defn.get("callbacks", [])
 
-        # State-sync callbacks (move -> position, resize -> size)
+        # State-sync callbacks (move -> position, resize -> size).
+        # For visual widgets we always *listen* so getters like
+        # get_size() / get_position() can return current values.
+        # But we only add the action to _auto_sync_actions — which
+        # controls push-to-peers and replay-on-reconstruction — when
+        # the widget actually opted in (e.g. via the 'resizable' option
+        # or by declaring the callback in its defn).  This keeps
+        # layout-determined sizes from being replayed as literal
+        # resize() calls that would pin flex/expanding widgets.
+        is_visual = defn.get("base") != "callback"
         for action in STATE_SYNC_CALLBACKS:
             req_opt = STATE_SYNC_REQUIRES_OPTION.get(action)
-            if req_opt and req_opt not in opt_names_set:
-                continue
-            if req_opt is None and action not in all_callbacks:
+            opted_in = False
+            if req_opt is not None:
+                opted_in = req_opt in opt_names_set
+            else:
+                opted_in = action in all_callbacks
+            # Visual widgets get the listen unconditionally for resize
+            # (it's a universal base-class callback) and for any move
+            # they declare.  Non-visual Callback-base objects get
+            # nothing here.
+            if not is_visual:
                 continue
-            session._listen(wid, action, lambda wid, *a: None)
-            self._auto_sync_actions.add(action)
+            if action == "resize" or opted_in:
+                session._listen(wid, action, lambda wid, *a: None)
+            if opted_in:
+                self._auto_sync_actions.add(action)
+            elif action == "resize":
+                self._passive_sync_actions.add(action)
 
         # Per-widget-class state sync (e.g. Slider "activated" -> value)
         cls_sync = WIDGET_CALLBACK_SYNC.get(js_class, {})
@@ -432,6 +464,9 @@ def _make_setter(method_name, param_names, state_key):
             self._state[state_key] = args[0]
         else:
             self._state[state_key] = args
+        # Mark as user-set so reconstruction knows to replay this key
+        # (callback-captured values for the same key don't get marked).
+        self._user_set_state.add(state_key)
         return self._call(method_name, *args)
     method.__name__ = method_name
     method.__qualname__ = f"Widget.{method_name}"
@@ -444,6 +479,7 @@ def _make_fixed_setter(method_name, state_key, fixed_value):
     """Create a no-arg method that sets a fixed state value (show/hide)."""
     def method(self):
         self._state[state_key] = fixed_value
+        self._user_set_state.add(state_key)
         return self._call(method_name)
     method.__name__ = method_name
     method.__qualname__ = f"Widget.{method_name}"