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

pgwidgets/method_types.py

@@ -82,6 +82,17 @@ ACTION_METHODS = {
     "expand_all", "collapse_all", "expand_item", "collapse_item",
     "sort_by_column", "set_optimal_column_widths",
     "select_path", "select_paths", "select_all",
+    "select_cell", "select_cells", "clear_cell_selection",
+    # Per-cell / row / column / table colour overrides — the
+    # ``set_*`` naming would otherwise classify them as SETTERs,
+    # whose single-state-slot semantics can't represent the
+    # accumulated dict of overrides we actually keep.  ACTION
+    # dispatch sends each call straight through to the JS side,
+    # which holds the canonical state in its own maps.
+    "set_cell_color", "set_row_color", "set_column_color",
+    "set_table_color",
+    "clear_cell_color", "clear_row_color", "clear_column_color",
+    "clear_all_colors",
     # TextSource editing
     "insert_text", "delete_range", "create_tag", "remove_tag_def",
     "apply_tag", "remove_tag", "create_ref", "remove_ref",
@@ -338,6 +349,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.
 
@@ -358,6 +397,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(
@@ -365,8 +408,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")
@@ -130,6 +130,17 @@ def _run_queue_loop(cb_queue, stop_event, logger=None):
                 result_slot['event'].set()
 
 
+# MIME types for the font formats register_font accepts.  Used to
+# set the ``Content-Type`` header when the HTTP server delivers a
+# registered font to the browser.
+_FONT_MIME = {
+    ".ttf":   "font/ttf",
+    ".otf":   "font/otf",
+    ".woff":  "font/woff",
+    ".woff2": "font/woff2",
+}
+
+
 class Session:
     """
     A session that owns a widget tree and its associated state.
@@ -169,6 +180,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 +289,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 +323,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 +363,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 +413,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,8 +439,8 @@ 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)
@@ -718,6 +781,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.
 
@@ -1219,12 +1367,14 @@ class Session:
                 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:
@@ -1466,13 +1616,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
@@ -1492,6 +1653,17 @@ class Application:
         self._on_disconnect = None   # user callback: fn(session)
         self._cb_queue = queue.Queue()  # for "serialized" mode
 
+        # Custom-font registry.  Each entry is
+        # ``{id, family, weight, style, bytes, mime}``; ``id`` is a
+        # monotonic int used as the path component of the HTTP URL
+        # the browser fetches the font from.  ``_default_font`` is
+        # ``{family, size, weight, style}`` or ``None``.
+        self._fonts = []
+        self._fonts_by_id = {}
+        self._next_font_id = 1
+        self._default_font = None
+        self._font_lock = threading.Lock()
+
         self._loop = None
         self._shutdown = threading.Event()
         self._thread = None
@@ -1564,6 +1736,141 @@ class Application:
         self._widget_classes[name] = cls
         return cls
 
+    # ----- Custom font registration ---------------------------
+
+    def register_font(self, family, source, *,
+                      weight="normal", style="normal"):
+        """Register a custom font with the application.
+
+        Browsers receive a ``@font-face``-equivalent declaration
+        through the JS ``FontFace`` API, so any widget that does
+        ``set_font(family, ...)`` thereafter renders with this
+        face.  Multiple registrations for the same ``family`` but
+        different ``weight`` / ``style`` combine into a single
+        font family with multiple faces.
+
+        Parameters
+        ----------
+        family : str
+            CSS font-family name to expose to widgets.
+        source : str | os.PathLike | bytes | bytearray | memoryview
+            Path to a font file (``.ttf`` / ``.otf`` / ``.woff`` /
+            ``.woff2``) or raw font bytes.
+        weight : str
+            CSS ``font-weight`` -- ``'normal'``, ``'bold'``, or a
+            numeric string (``'100'`` ... ``'900'``).
+        style : str
+            CSS ``font-style`` -- ``'normal'``, ``'italic'``, or
+            ``'oblique'``.
+
+        Returns
+        -------
+        int
+            The registration id (rarely needed; callers usually
+            just refer to the font by ``family``).
+        """
+        if isinstance(source, (bytes, bytearray, memoryview)):
+            data = bytes(source)
+            mime = "font/ttf"
+        else:
+            p = Path(source)
+            data = p.read_bytes()
+            ext = p.suffix.lower()
+            mime = _FONT_MIME.get(ext, "font/ttf")
+        with self._font_lock:
+            font_id = self._next_font_id
+            self._next_font_id += 1
+            entry = {
+                "id": font_id,
+                "family": str(family),
+                "weight": str(weight),
+                "style": str(style),
+                "bytes": data,
+                "mime": mime,
+            }
+            self._fonts.append(entry)
+            self._fonts_by_id[font_id] = entry
+        # Push to any already-connected sessions so live UIs pick
+        # the font up without a reconnect.
+        msg = self._font_register_msg(entry)
+        for session in list(self._sessions.values()):
+            try:
+                session._send(msg)
+            except Exception:
+                pass
+        return font_id
+
+    def set_default_font(self, family, *, size=None,
+                         weight=None, style=None):
+        """Set the document-level default font.
+
+        Writes ``--pg-default-font-family`` / ``--pg-default-font-size``
+        / ``--pg-default-font-weight`` / ``--pg-default-font-style``
+        CSS variables on ``:root``; the base pgwidgets stylesheet
+        consumes these so any widget that hasn't been given an
+        explicit ``set_font(...)`` follows the default.
+
+        Pass ``family=None`` to clear the default and fall back to
+        the built-in stylesheet."""
+        if family is None:
+            self._default_font = None
+        else:
+            self._default_font = {
+                "family": str(family),
+                "size":   None if size is None else float(size),
+                "weight": None if weight is None else str(weight),
+                "style":  None if style is None else str(style),
+            }
+        msg = self._font_default_msg()
+        for session in list(self._sessions.values()):
+            try:
+                session._send(msg)
+            except Exception:
+                pass
+
+    def _font_register_msg(self, entry):
+        return {
+            "type": "register-font",
+            "id": entry["id"],
+            "family": entry["family"],
+            "weight": entry["weight"],
+            "style": entry["style"],
+            "url": f"/_pgwidgets/font/{entry['id']}",
+        }
+
+    def _font_default_msg(self):
+        return {
+            "type": "set-default-font",
+            "font": self._default_font,
+        }
+
+    def _replay_fonts_to_session(self, session):
+        """Push the full font registry + default font to a freshly
+        connected (or reconnecting) session before any user code
+        creates widgets.  Called from ``_on_session_open``."""
+        with self._font_lock:
+            fonts = list(self._fonts)
+            default = self._default_font
+        for entry in fonts:
+            try:
+                session._send(self._font_register_msg(entry))
+            except Exception:
+                pass
+        if default is not None:
+            try:
+                session._send(self._font_default_msg())
+            except Exception:
+                pass
+
+    def _get_font_bytes(self, font_id):
+        """Return ``(bytes, mime)`` for a registered font, or
+        ``(None, None)`` if unknown.  Called by the HTTP handler."""
+        with self._font_lock:
+            entry = self._fonts_by_id.get(font_id)
+        if entry is None:
+            return None, None
+        return entry["bytes"], entry["mime"]
+
     def start(self):
         """Start the WebSocket server (and HTTP server if enabled).
 
@@ -1595,9 +1902,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
@@ -1681,6 +1993,10 @@ class Application:
             # because _send() blocks with event.wait() while the event
             # loop that must process ws.send() is also blocked.
             def do_reconstruct():
+                # Replay the font registry before reconstruct() so any
+                # widget reconstructed with ``set_font(...)`` finds the
+                # face already declared.
+                self._replay_fonts_to_session(session)
                 self._logger.info(
                     f"Session {session.id}: reconstructing UI.")
                 session._reconstructing = True
@@ -1693,8 +2009,14 @@ class Application:
             self._dispatch(session, do_reconstruct, ())
         else:
             self._logger.info(f"Session {session.id} connected.")
-            if self._on_connect:
-                self._dispatch(session, self._on_connect, (session,))
+            def do_connect():
+                # Replay fonts before the user callback so any widget
+                # the user builds with ``set_font(family, ...)`` sees
+                # the face already declared.
+                self._replay_fonts_to_session(session)
+                if self._on_connect:
+                    self._on_connect(session)
+            self._dispatch(session, do_connect, ())
 
         try:
             async for message in ws:
@@ -1787,6 +2109,7 @@ class Application:
         favicon_path = self._favicon_path
         ws_host = self._host
         ws_port = self._ws_port
+        app = self
 
         class Handler(http.server.SimpleHTTPRequestHandler):
             def __init__(self, *args, **kwargs):
@@ -1796,6 +2119,31 @@ class Application:
                 # serve remote.html at the root, with WS URL injected
                 # Strip query string for path matching (e.g. /?session=1)
                 path = self.path.split("?")[0]
+                # Custom-font registry: /_pgwidgets/font/<id> serves
+                # the bytes the app registered via ``register_font``.
+                # ``Cache-Control: immutable`` is safe because the
+                # registry assigns a fresh id on every call -- the
+                # URL is content-stable for the lifetime of the
+                # registration.
+                if path.startswith("/_pgwidgets/font/"):
+                    try:
+                        font_id = int(path.rsplit("/", 1)[-1])
+                    except ValueError:
+                        self.send_error(404)
+                        return
+                    data, mime = app._get_font_bytes(font_id)
+                    if data is None:
+                        self.send_error(404)
+                        return
+                    self.send_response(200)
+                    self.send_header("Content-Type", mime)
+                    self.send_header("Content-Length", str(len(data)))
+                    self.send_header(
+                        "Cache-Control", "public, max-age=31536000, immutable")
+                    self.send_header("Access-Control-Allow-Origin", "*")
+                    self.end_headers()
+                    self.wfile.write(data)
+                    return
                 if path == "/" or path == "/index.html":
                     html = remote_html.read_text(encoding="utf-8")
                     inject = (

pgwidgets/sync/widget.py

@@ -420,6 +420,11 @@ def _resolve_kwargs(method_name, param_names, args, kwargs):
     are bundled into a dict for that parameter (e.g.
     ``add_widget(child, title="Tab 1")`` becomes
     ``add_widget(child, {"title": "Tab 1"})``).
+
+    Skipped-positional kwargs are supported: a call like
+    ``set_color(fg='red')`` against ``param_names = ['bg', 'fg']``
+    fills the omitted ``bg`` slot with ``None`` (the JS-side
+    default) instead of erroring out.
     """
     if not kwargs:
         return args
@@ -430,7 +435,10 @@ def _resolve_kwargs(method_name, param_names, args, kwargs):
         if name in kwargs:
             merged.append(kwargs.pop(name))
         else:
-            break
+            # Leave a placeholder so subsequent kwargs can land in
+            # later positions.  The JS side reads omitted args as
+            # null / default, which matches ``None`` here.
+            merged.append(None)
     if kwargs and param_names and param_names[-1] == "options":
         # Bundle remaining kwargs into the options dict
         opts_idx = len(param_names) - 1

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgwidgets-python
-Version: 0.2.3
+Version: 0.3.1
 Summary: Python bindings for the pgwidgets JavaScript widget library
 Author: PGWidgets Developers
 License: BSD-3-Clause

pgwidgets_python-0.3.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+pgwidgets/__init__.py,sha256=z6QFxTtjwnduH-s0zT8u_GJb0rT7OZsgPawMIlIzfQE,919
+pgwidgets/_json.py,sha256=o21qywJ6yAldbqxTq3nLwgK9O67r3a8JxhvI_WAJnMY,2184
+pgwidgets/buffer.py,sha256=BYj_nb6fuyGsBqUp3_Z1YrzUm4h5VmoWPGKvpTjWrYk,4048
+pgwidgets/callbacks.py,sha256=gA2FnX0N5BmbmOMyEV35yHySgAfVjfAZcZhZbo7j4-c,3314
+pgwidgets/defs.py,sha256=Q8qhvTeansFU1Av6j5ncdwF2xSNHrpXuKErdHWQ3HiA,436
+pgwidgets/method_types.py,sha256=1gOTR8pdX_t7E_UEyUy4rnWiFoh10tJSUAINA1mE-SU,18298
+pgwidgets/async_/Widgets.py,sha256=vld2xkvusBBEVbhbezaJsjBRRj3L7c17Up0pOVs8PGo,723
+pgwidgets/async_/__init__.py,sha256=rXB-v9XRrYt1imYuYikhkzIyiRqaYhlTpQei2LHaQ18,564
+pgwidgets/async_/application.py,sha256=5tUlfyE9ie0aFPh2WAs2VRvgyuqQmdaGTX0d1IkSB7o,80077
+pgwidgets/async_/widget.py,sha256=gO7eJh9LV3UY7yRLdeml_0gqmHnFB5VU3NWlDURLtfc,38042
+pgwidgets/extras/__init__.py,sha256=AXUmFtnn4RSlp6pJX6z55j-m_29VmfzpYIjQvAy7pO0,325
+pgwidgets/extras/file_browser.py,sha256=CXQSfJx1VQ-fJfhKNrVyqrkKTJEQngmiP954y70Fjo0,17229
+pgwidgets/sync/Widgets.py,sha256=7SaocMVMzFHhi51pjuEAr47Wez90b_a61kDbiv0jOfM,706
+pgwidgets/sync/__init__.py,sha256=SF5RTAvtu8BbYBWzpiCPipy6DJzNXf6nqk9xdvwxUhQ,542
+pgwidgets/sync/application.py,sha256=Gfft77F66PfRnr_8_FBqU0v_gWe4YC9M-q5rww1N-2U,94741
+pgwidgets/sync/widget.py,sha256=yrScNkZB34u0JXn3-kCB-1mPLxLysVbuaPsCjC8kq0E,38343
+pgwidgets_python-0.3.1.dist-info/licenses/LICENSE.md,sha256=LoM3fMTiMnQuHRCJghdjOtjnCrL8soBpu2PFk24Xvyg,1528
+pgwidgets_python-0.3.1.dist-info/METADATA,sha256=QKWuFclVrksOLKxHPqSM-6CoNVskbt_bw_rqaUa3WpI,4568
+pgwidgets_python-0.3.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pgwidgets_python-0.3.1.dist-info/top_level.txt,sha256=wwL6fBq0gU-JwzlM6TdduY1qYpu39ysqnnbQT-1bqAs,10
+pgwidgets_python-0.3.1.dist-info/RECORD,,