pgwidgets-python 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

pgwidgets/__init__.py

@@ -16,4 +16,17 @@ Usage (asynchronous):
     top = await W.TopLevel(title="Hello", resizable=True)
     ...
     await app.run()
+
+Version:
+    import pgwidgets
+    print(pgwidgets.__version__)
 """
+
+from importlib.metadata import version as _pkg_version, PackageNotFoundError
+
+try:
+    __version__ = _pkg_version("pgwidgets")
+except PackageNotFoundError:
+    # Package not installed (e.g. running from a source checkout
+    # without `pip install -e .`).  Fall back to a sentinel.
+    __version__ = "0.0.0+unknown"

pgwidgets/_json.py

@@ -0,0 +1,63 @@
+"""JSON encoding helper for the remote protocol.
+
+The wire format between Python and the browser is JSON.  The stdlib
+encoder has two issues for scientific data:
+
+1. It rejects numpy scalars other than ``np.float64`` (which inherits
+   from float), numpy arrays, and similar buffer-protocol objects —
+   silently dropping a TreeView payload that happens to contain
+   ``np.int64`` cell values.
+
+2. It writes the literal tokens ``NaN`` / ``Infinity`` / ``-Infinity``
+   for non-finite floats, which browsers' ``JSON.parse`` reject — a
+   single masked / missing cell in a float column makes the whole
+   payload silently fail to parse on the JS side.
+
+``JsonEncoder`` handles both: ``.item()`` / ``.tolist()`` fall-backs
+for numpy/pandas types, and a pre-walk that replaces non-finite floats
+with ``None`` (encoded as JSON ``null``).  Use it via
+``json.dumps(obj, cls=JsonEncoder)``.
+"""
+
+import json
+import math
+
+
+def _scrub_nan(obj):
+    """Recursively replace non-finite floats with None so the result
+    is RFC-8259-valid JSON when re-encoded.  Cheap walk: O(n) and
+    only visits dicts/lists/tuples/floats."""
+    if isinstance(obj, float):
+        return obj if math.isfinite(obj) else None
+    if isinstance(obj, dict):
+        return {k: _scrub_nan(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_scrub_nan(v) for v in obj]
+    return obj
+
+
+def _coerce_scalar(v):
+    """If *v* is a float, replace non-finite values with None."""
+    if isinstance(v, float) and not math.isfinite(v):
+        return None
+    return v
+
+
+class JsonEncoder(json.JSONEncoder):
+    def default(self, obj):
+        item = getattr(obj, "item", None)
+        if callable(item):
+            try:
+                return _coerce_scalar(item())
+            except (TypeError, ValueError):
+                pass
+        tolist = getattr(obj, "tolist", None)
+        if callable(tolist):
+            try:
+                return _scrub_nan(tolist())
+            except (TypeError, ValueError):
+                pass
+        return super().default(obj)
+
+    def iterencode(self, o, _one_shot=False):
+        return super().iterencode(_scrub_nan(o), _one_shot=_one_shot)

pgwidgets/async_/application.py

@@ -23,6 +23,7 @@ from pathlib import Path
 import websockets
 
 from pgwidgets_js import get_static_path, get_remote_html
+from pgwidgets._json import JsonEncoder
 from pgwidgets.defs import WIDGETS
 from pgwidgets.method_types import (
     SPECIAL_SETTERS, FIXED_SETTERS, CHILD_METHODS as CHILD_METHOD_NAMES,
@@ -90,6 +91,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():
@@ -299,30 +307,46 @@ class Session:
 
     def _dispatch_callback(self, wid, action, *args):
         """Dispatch a callback through the configured concurrency mode."""
-        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 the JS-side observers fire
+        # when a widget first gains a visible layout box; the timing
+        # can land inside the reconstruction window, and dropping it
+        # means the user's map handler never runs until a later layout
+        # change (e.g. window resize) triggers a re-fire.
+        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
                 if len(args) == 1 and isinstance(args[0], dict):
                     d = args[0]
                     if "width" in d and "height" in d:
                         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.
@@ -492,7 +516,7 @@ class Session:
         self._next_id += 1
         msg["id"] = msg_id
         try:
-            payload = json.dumps(msg)
+            payload = json.dumps(msg, cls=JsonEncoder)
         except Exception as e:
             self._logger.error(
                 f"JSON encode failed for "
@@ -510,7 +534,7 @@ class Session:
             ff_id = self._next_id
             self._next_id += 1
             msg_copy = dict(msg, id=ff_id)
-            ff_payload = json.dumps(msg_copy)
+            ff_payload = json.dumps(msg_copy, cls=JsonEncoder)
             for ws in self._connections[1:]:
                 _schedule_ws_send(ws, ff_payload)
         result = await future
@@ -541,7 +565,7 @@ class Session:
                 "method": method,
                 "args": list(args),
                 "silent": True,
-            })
+            }, cls=JsonEncoder)
         except Exception as e:
             self._logger.error(
                 f"JSON encode failed for push {method} "
@@ -567,7 +591,7 @@ class Session:
             "id": msg_id,
             "wid": wid,
             "action": action,
-        })
+        }, cls=JsonEncoder)
         for ws in self._connections:
             _schedule_ws_send(ws, payload)
 
@@ -630,7 +654,7 @@ class Session:
             "wid": wid,
             "method": method,
             "args": list(args),
-        })
+        }, cls=JsonEncoder)
         async def _pair(ws):
             await ws.send(header)
             await ws.send(data)
@@ -734,17 +758,37 @@ 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).
             # Register locally (sync) and send the listen message as
             # true fire-and-forget (no result awaited) since
-            # _resolve_return is not async.
+            # _resolve_return is not async.  For visual widgets we
+            # always listen for 'resize' so 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 opts in.
+            # Non-visual Callback-base objects (Timer, TextBufferRef,
+            # …) 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._callbacks[key] = [lambda wid, *a: None]
-                    self._fire_and_forget_listen(wid, action)
-                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._callbacks[key] = [lambda wid, *a: None]
+                        self._fire_and_forget_listen(wid, action)
+                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]
@@ -838,12 +882,23 @@ class Session:
                 await 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):
@@ -851,6 +906,13 @@ class Session:
             else:
                 await 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)
 
     async def _ensure_reconstructed(self, widget):
         """Ensure a widget has been created on the JS side."""
@@ -1002,6 +1064,20 @@ 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.
@@ -1046,10 +1122,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:
@@ -1066,6 +1145,13 @@ class Session:
             if action not in widget._registered_callbacks:
                 await 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):
+                await self._listen(widget._wid, action,
+                                   lambda wid, *a: None)
 
     async def reconstruct(self):
         """Replay the entire widget tree to all connected browsers.
@@ -1332,7 +1418,8 @@ class Application:
     async def _ws_handler(self, ws):
         # Init handshake: send init, receive ack which may contain
         # session_id + token for reconnection.
-        await ws.send(json.dumps({"type": "init", "id": 0}))
+        await ws.send(json.dumps({"type": "init", "id": 0},
+                                 cls=JsonEncoder))
         ack_data = await ws.recv()
         ack = json.loads(ack_data)
         reconnect_sid = ack.get("session_id")
@@ -1399,7 +1486,7 @@ class Application:
             "type": "session-info",
             "session_id": session.id,
             "token": session.token,
-        }))
+        }, cls=JsonEncoder))
 
         if is_reconnect:
             async def do_reconstruct():

pgwidgets/async_/widget.py

@@ -79,6 +79,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
 
@@ -196,6 +206,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._stale = False
         return obj
@@ -212,15 +224,31 @@ 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
+            if not is_visual:
                 continue
-            await session._listen(wid, action, lambda wid, *a: None)
-            self._auto_sync_actions.add(action)
+            if action == "resize" or opted_in:
+                await 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, {})
@@ -461,6 +489,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 await self._call(method_name, *args)
     method.__name__ = method_name
     method.__qualname__ = f"Widget.{method_name}"
@@ -473,6 +504,7 @@ def _make_fixed_setter(method_name, state_key, fixed_value):
     """Create a no-arg async method that sets a fixed state value (show/hide)."""
     async def method(self):
         self._state[state_key] = fixed_value
+        self._user_set_state.add(state_key)
         return await self._call(method_name)
     method.__name__ = method_name
     method.__qualname__ = f"Widget.{method_name}"
@@ -776,14 +808,19 @@ def _add_tree_view_methods(attrs, all_methods):
 
 
 def _init_params(pos_names, opt_names):
-    """Build the parameter string for the generated __init__."""
+    """Build the parameter string for the generated __init__.
+
+    Options are exposed as positional-or-keyword (no ``*`` separator)
+    so that single-option widgets like Frame accept ``Frame("Title")``
+    in addition to ``Frame(title="Title")``, matching the pyodide
+    bridge's behavior.  Each option still defaults to ``None`` so
+    omitted ones don't override state from prior calls.
+    """
     params = ["self", "session"]
     for name in pos_names:
         params.append(f"{name}=None")
-    if opt_names:
-        params.append("*")
-        for name in opt_names:
-            params.append(f"{name}=None")
+    for name in opt_names:
+        params.append(f"{name}=None")
     params.append("**kwargs")
     return ", ".join(params)
 

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.

pgwidgets/sync/application.py

@@ -25,6 +25,7 @@ from pathlib import Path
 import websockets
 
 from pgwidgets_js import get_static_path, get_remote_html
+from pgwidgets._json import JsonEncoder
 from pgwidgets.defs import WIDGETS
 from pgwidgets.sync.widget import Widget, build_all_widget_classes
 from pgwidgets.method_types import (
@@ -260,6 +261,15 @@ class Session:
             if threading.current_thread() is not self._cb_thread:
                 self._cb_thread.join(timeout=2)
 
+    def get_session_thread(self):
+        mode = self._app._concurrency
+        if mode == "serialized":
+            return threading.get_ident()
+        elif mode == "per_session":
+            return self._cb_thread
+        else:
+            return None
+
     # -- Message handling --
 
     def _handle_message(self, data):
@@ -374,18 +384,28 @@ class Session:
 
     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.
@@ -395,15 +415,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.
@@ -541,7 +563,7 @@ class Session:
             self._next_id += 1
         msg["id"] = msg_id
         try:
-            payload = json.dumps(msg)
+            payload = json.dumps(msg, cls=JsonEncoder)
         except Exception as e:
             self._logger.error(
                 f"JSON encode failed for "
@@ -565,7 +587,7 @@ class Session:
                 ff_id = self._next_id
                 self._next_id += 1
             msg_copy = dict(msg, id=ff_id)
-            ff_payload = json.dumps(msg_copy)
+            ff_payload = json.dumps(msg_copy, cls=JsonEncoder)
             for ws in self._connections[1:]:
                 _schedule_ws_send(self._app._loop, ws, ff_payload)
         event.wait()
@@ -605,7 +627,7 @@ class Session:
                 "method": method,
                 "args": list(args),
                 "silent": True,
-            })
+            }, cls=JsonEncoder)
         except Exception as e:
             self._logger.error(
                 f"JSON encode failed for push {method} "
@@ -677,7 +699,7 @@ class Session:
             "wid": wid,
             "method": method,
             "args": list(args),
-        })
+        }, cls=JsonEncoder)
         # Send header + binary as an atomic pair on each connection so
         # they can't be interleaved with other sends from another
         # thread.  The pair is wrapped in a single coroutine.
@@ -794,13 +816,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]
@@ -897,6 +939,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():
@@ -942,12 +991,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):
@@ -955,6 +1015,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.
@@ -1137,6 +1204,20 @@ 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.
@@ -1183,10 +1264,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:
@@ -1201,6 +1285,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."""
@@ -1512,7 +1602,8 @@ class Application:
     async def _ws_handler(self, ws):
         # Init handshake: send init, receive ack which may contain
         # session_id + token for reconnection.
-        await ws.send(json.dumps({"type": "init", "id": 0}))
+        await ws.send(json.dumps({"type": "init", "id": 0},
+                                 cls=JsonEncoder))
         ack_data = await ws.recv()
         ack = json.loads(ack_data)
         reconnect_sid = ack.get("session_id")
@@ -1582,7 +1673,7 @@ class Application:
             "type": "session-info",
             "session_id": session.id,
             "token": session.token,
-        }))
+        }, cls=JsonEncoder))
 
         if is_reconnect:
             # Dispatch reconstruction to the session thread — calling

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}"
@@ -842,14 +878,19 @@ def __init__({_init_params(pos_names, opt_names)}):
 
 
 def _init_params(pos_names, opt_names):
-    """Build the parameter string for the generated __init__."""
+    """Build the parameter string for the generated __init__.
+
+    Options are exposed as positional-or-keyword (no ``*`` separator)
+    so that single-option widgets like Frame accept ``Frame("Title")``
+    in addition to ``Frame(title="Title")``, matching the pyodide
+    bridge's behavior.  Each option still defaults to ``None`` so
+    omitted ones don't override state from prior calls.
+    """
     params = ["self", "session"]
     for name in pos_names:
         params.append(f"{name}=None")
-    if opt_names:
-        params.append("*")
-        for name in opt_names:
-            params.append(f"{name}=None")
+    for name in opt_names:
+        params.append(f"{name}=None")
     params.append("**kwargs")
     return ", ".join(params)
 

{pgwidgets_python-0.2.0.dist-info → pgwidgets_python-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgwidgets-python
-Version: 0.2.0
+Version: 0.2.3
 Summary: Python bindings for the pgwidgets JavaScript widget library
 Author: PGWidgets Developers
 License: BSD-3-Clause
@@ -17,7 +17,7 @@ Classifier: Topic :: Software Development :: User Interfaces
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: pgwidgets-js
+Requires-Dist: pgwidgets-js>=0.2.0
 Requires-Dist: websockets>=12
 Provides-Extra: dev
 Requires-Dist: sphinx; extra == "dev"

pgwidgets_python-0.2.3.dist-info/RECORD

@@ -0,0 +1,20 @@
+pgwidgets/__init__.py,sha256=fKKHAt9GxLbficihVyImWsqrnQvdQZQAmeGaRUF8cBE,857
+pgwidgets/_json.py,sha256=o21qywJ6yAldbqxTq3nLwgK9O67r3a8JxhvI_WAJnMY,2184
+pgwidgets/callbacks.py,sha256=gA2FnX0N5BmbmOMyEV35yHySgAfVjfAZcZhZbo7j4-c,3314
+pgwidgets/defs.py,sha256=Q8qhvTeansFU1Av6j5ncdwF2xSNHrpXuKErdHWQ3HiA,436
+pgwidgets/method_types.py,sha256=S5V6EvJ9DZnSQaiaEhPkAuCtqrlHde5wj16TZd0vHvQ,16327
+pgwidgets/async_/Widgets.py,sha256=vld2xkvusBBEVbhbezaJsjBRRj3L7c17Up0pOVs8PGo,723
+pgwidgets/async_/__init__.py,sha256=rXB-v9XRrYt1imYuYikhkzIyiRqaYhlTpQei2LHaQ18,564
+pgwidgets/async_/application.py,sha256=mab8nRl7dNwnvNx64F0RapIJvJXy4HW_eJ1Bbuhw83w,69612
+pgwidgets/async_/widget.py,sha256=H27v7AzHNg5obzr2e8UyOyj2lbGfWhEhZUrIDqrZNbg,37612
+pgwidgets/extras/__init__.py,sha256=AXUmFtnn4RSlp6pJX6z55j-m_29VmfzpYIjQvAy7pO0,325
+pgwidgets/extras/file_browser.py,sha256=PWzJltjQZbmsD1ykbbC2xJ6ErEkJj7KafhmVkd9q9Ac,16963
+pgwidgets/sync/Widgets.py,sha256=7SaocMVMzFHhi51pjuEAr47Wez90b_a61kDbiv0jOfM,706
+pgwidgets/sync/__init__.py,sha256=SF5RTAvtu8BbYBWzpiCPipy6DJzNXf6nqk9xdvwxUhQ,542
+pgwidgets/sync/application.py,sha256=a1Xu5VRif9WKHxMWvPN3oyTqjPsrdw54Smp4Vz16ObY,80309
+pgwidgets/sync/widget.py,sha256=tQDkCOkcevDrGnG4LhBf69law82-UB1fF-r08GUZPSE,37913
+pgwidgets_python-0.2.3.dist-info/licenses/LICENSE.md,sha256=LoM3fMTiMnQuHRCJghdjOtjnCrL8soBpu2PFk24Xvyg,1528
+pgwidgets_python-0.2.3.dist-info/METADATA,sha256=e5O9EkVS7VKRrgwxNwtKgLOcs6emH7hpkFqyfJOKAUE,4568
+pgwidgets_python-0.2.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pgwidgets_python-0.2.3.dist-info/top_level.txt,sha256=wwL6fBq0gU-JwzlM6TdduY1qYpu39ysqnnbQT-1bqAs,10
+pgwidgets_python-0.2.3.dist-info/RECORD,,

pgwidgets_python-0.2.0.dist-info/RECORD

@@ -1,19 +0,0 @@
-pgwidgets/__init__.py,sha256=365yX_Iq5Uh8ZYPVUDmdTWJa0E8PfLQG82LffdZJi88,476
-pgwidgets/callbacks.py,sha256=gA2FnX0N5BmbmOMyEV35yHySgAfVjfAZcZhZbo7j4-c,3314
-pgwidgets/defs.py,sha256=Q8qhvTeansFU1Av6j5ncdwF2xSNHrpXuKErdHWQ3HiA,436
-pgwidgets/method_types.py,sha256=AoNXYY7iU-ttAWPqL104Dpl4AtUvyF6I2OmzpRw2HWQ,15637
-pgwidgets/async_/Widgets.py,sha256=vld2xkvusBBEVbhbezaJsjBRRj3L7c17Up0pOVs8PGo,723
-pgwidgets/async_/__init__.py,sha256=rXB-v9XRrYt1imYuYikhkzIyiRqaYhlTpQei2LHaQ18,564
-pgwidgets/async_/application.py,sha256=hKsa6PBh49n7AxwwXqdWjBfL_cL6eixX-MeU_lkD9CY,64651
-pgwidgets/async_/widget.py,sha256=bL-wL7T9j6Ic5xsAchw5BdJQtgHX1GuCOF732cJEpbQ,35589
-pgwidgets/extras/__init__.py,sha256=AXUmFtnn4RSlp6pJX6z55j-m_29VmfzpYIjQvAy7pO0,325
-pgwidgets/extras/file_browser.py,sha256=PWzJltjQZbmsD1ykbbC2xJ6ErEkJj7KafhmVkd9q9Ac,16963
-pgwidgets/sync/Widgets.py,sha256=7SaocMVMzFHhi51pjuEAr47Wez90b_a61kDbiv0jOfM,706
-pgwidgets/sync/__init__.py,sha256=SF5RTAvtu8BbYBWzpiCPipy6DJzNXf6nqk9xdvwxUhQ,542
-pgwidgets/sync/application.py,sha256=WNT96gG6BhRJug7Dt-AerAjV_AZFq-BE--1XFj6ObgI,75392
-pgwidgets/sync/widget.py,sha256=UkMgM7dKA1g-CtjukL27vjCZD7FAHyMOpJVD9mpN5-w,35655
-pgwidgets_python-0.2.0.dist-info/licenses/LICENSE.md,sha256=LoM3fMTiMnQuHRCJghdjOtjnCrL8soBpu2PFk24Xvyg,1528
-pgwidgets_python-0.2.0.dist-info/METADATA,sha256=NDMZH7W7Va2LzqYHF_kDK3ryykos_aM5rO5IczPT-uE,4561
-pgwidgets_python-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pgwidgets_python-0.2.0.dist-info/top_level.txt,sha256=wwL6fBq0gU-JwzlM6TdduY1qYpu39ysqnnbQT-1bqAs,10
-pgwidgets_python-0.2.0.dist-info/RECORD,,