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

pgwidgets/async_/application.py

@@ -16,6 +16,7 @@ import logging
 import mimetypes
 import signal
 import secrets
+import threading
 import traceback
 from http.server import SimpleHTTPRequestHandler
 from pathlib import Path
@@ -37,6 +38,15 @@ from pgwidgets.async_.widget import Widget, build_all_widget_classes
 _CONCURRENCY_MODES = ("serialized", "per_session", "concurrent")
 
 
+# MIME types for the font formats register_font accepts.
+_FONT_MIME = {
+    ".ttf":   "font/ttf",
+    ".otf":   "font/otf",
+    ".woff":  "font/woff",
+    ".woff2": "font/woff2",
+}
+
+
 class _Namespace:
     """Holds widget factory methods as attributes (W.Button, W.Label, etc.)."""
     pass
@@ -1428,6 +1438,13 @@ class Application:
         self._session_semaphore = None  # initialized in start()
         self._cb_lock = None         # for "serialized" mode
 
+        # Custom-font registry — see sync.application for details.
+        self._fonts = []
+        self._fonts_by_id = {}
+        self._next_font_id = 1
+        self._default_font = None
+        self._font_lock = threading.Lock()
+
         self._run_future = None      # set in run(), cancelled by close()
         self._httpd = None           # HTTP server instance
 
@@ -1493,6 +1510,113 @@ class Application:
         self._widget_classes[name] = cls
         return cls
 
+    # ----- Custom font registration ---------------------------
+    #
+    # API matches the sync backend; see ``sync.application`` for
+    # full docstrings.  The async variant schedules sends on the
+    # event loop via ``asyncio.run_coroutine_threadsafe`` so the
+    # method is safe to call from outside the loop (e.g. from the
+    # ``on_connect`` callback running on a worker thread).
+
+    def register_font(self, family, source, *,
+                      weight="normal", style="normal"):
+        if isinstance(source, (bytes, bytearray, memoryview)):
+            data = bytes(source)
+            mime = "font/ttf"
+        else:
+            p = Path(source)
+            data = p.read_bytes()
+            mime = _FONT_MIME.get(p.suffix.lower(), "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
+        msg = self._font_register_msg(entry)
+        self._broadcast_font_msg(msg)
+        return font_id
+
+    def set_default_font(self, family, *, size=None,
+                         weight=None, style=None):
+        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),
+            }
+        self._broadcast_font_msg(self._font_default_msg())
+
+    def open_url(self, url):
+        """Ask the connected browser(s) to open *url* in a new tab/window.
+
+        Fire-and-forget app-level command; opens the link in the *user's*
+        browser rather than on the host running Python.  (Reuses the
+        generic per-session broadcast helper.)
+        """
+        self._broadcast_font_msg({"type": "open-url", "url": str(url)})
+
+    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 _broadcast_font_msg(self, msg):
+        loop = getattr(self, "_loop", None) or asyncio.get_event_loop()
+        for session in list(self._sessions.values()):
+            try:
+                asyncio.run_coroutine_threadsafe(
+                    session._send(dict(msg)), loop)
+            except Exception:
+                pass
+
+    async def _replay_fonts_to_session(self, session):
+        """Push the registry + default font to a session before
+        any user code runs.  ``await``-ed from ``_on_session_open``
+        so the JS side has loaded faces (or at least dispatched
+        the load) before reconstruct / on_connect fires."""
+        with self._font_lock:
+            fonts = list(self._fonts)
+            default = self._default_font
+        for entry in fonts:
+            try:
+                await session._send(self._font_register_msg(entry))
+            except Exception:
+                pass
+        if default is not None:
+            try:
+                await session._send(self._font_default_msg())
+            except Exception:
+                pass
+
+    def _get_font_bytes(self, font_id):
+        with self._font_lock:
+            entry = self._fonts_by_id.get(font_id)
+        if entry is None:
+            return None, None
+        return entry["bytes"], entry["mime"]
+
     @property
     def sessions(self):
         """Dict of active sessions (session_id -> Session)."""
@@ -1603,6 +1727,10 @@ class Application:
 
         if is_reconnect:
             async def do_reconstruct():
+                # Replay the font registry before reconstruct() so
+                # any widget reconstructed with ``set_font(...)``
+                # finds the face already declared.
+                await self._replay_fonts_to_session(session)
                 self._logger.info(
                     f"Session {session.id}: reconstructing UI.")
                 session._reconstructing = True
@@ -1615,10 +1743,16 @@ class Application:
             asyncio.ensure_future(do_reconstruct())
         else:
             self._logger.info(f"Session {session.id} connected.")
-            if self._on_connect:
-                result = self._on_connect(session)
-                if hasattr(result, "__await__"):
-                    asyncio.ensure_future(result)
+            async def do_connect():
+                # Replay fonts before the user callback so any
+                # widget the user builds with ``set_font(family,
+                # ...)`` sees the face already declared.
+                await self._replay_fonts_to_session(session)
+                if self._on_connect:
+                    result = self._on_connect(session)
+                    if hasattr(result, "__await__"):
+                        await result
+            asyncio.ensure_future(do_connect())
 
         try:
             async for message in ws:
@@ -1663,8 +1797,14 @@ class Application:
             The newly created session.
         """
         if session_id is None:
+            # skip ids already taken by explicitly-created sessions
+            # (e.g. a pre-created default session) so we never
+            # silently overwrite an existing session
             session_id = self._next_session_id
             self._next_session_id += 1
+            while session_id in self._sessions:
+                session_id = self._next_session_id
+                self._next_session_id += 1
         elif session_id in self._sessions:
             # If the existing session was auto-created by a browser
             # reconnect with the same token, return it so the user's
@@ -1699,6 +1839,7 @@ class Application:
         favicon_path = self._favicon_path
         ws_host = self._host
         ws_port = self._ws_port
+        app = self
 
         class Handler(SimpleHTTPRequestHandler):
             def __init__(self, *a, **kw):
@@ -1707,6 +1848,27 @@ class Application:
             def do_GET(self):
                 # Strip query string for path matching (e.g. /?session=1)
                 path = self.path.split("?")[0]
+                # Custom-font registry: see sync.application for
+                # the matching implementation.
+                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 = (
@@ -1807,12 +1969,14 @@ class Application:
 
         In the async API, callbacks are dispatched by the asyncio event
         loop directly, so this simply yields control for the requested
-        duration.
+        duration.  A *timeout* of ``0`` yields once (a non-blocking drain
+        of ready callbacks), matching the sync API's contract.
 
         Parameters
         ----------
         timeout : float
             Seconds to yield to the event loop (default 0.1).
+            Use ``0`` for a single non-blocking yield.
         """
         await asyncio.sleep(timeout)
 

pgwidgets/async_/widget.py

@@ -446,6 +446,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
@@ -456,7 +461,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/extras/file_browser.py

@@ -352,8 +352,13 @@ class FileBrowser(Callbacks):
                 self._navigate_to(d)
                 self._name_entry.set_text(os.path.basename(path))
 
-    def _on_row_activated(self, values, path):
-        """Double-click on a row."""
+    def _on_row_activated(self, values, path, col_key=None):
+        """Double-click on a row.
+
+        ``col_key`` (TableView ≥ this rev) reports which cell was
+        clicked; unused here since the browser only cares about
+        the row's filename, but the arg has to be in the signature
+        or the new 3-arg dispatch raises TypeError."""
         name = values.get("name", "")
         if name == "..":
             self._go_up()

pgwidgets/method_types.py

@@ -56,7 +56,7 @@ JS_ONLY_METHODS = {
     # ComboBox
     "get_alpha",
     # Container
-    "num_children",
+    "num_children", "is_container",
     # TabWidget lookups
     "get_tab_id", "get_child", "index_of",
     # MDIWidget
@@ -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",

pgwidgets/sync/application.py

@@ -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.
@@ -1642,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
@@ -1714,6 +1736,155 @@ 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 open_url(self, url):
+        """Ask the connected browser(s) to open *url* in a new tab/window.
+
+        Fire-and-forget app-level command (mirrors set_default_font's
+        per-session send).  This opens the link in the *user's* browser
+        rather than on the host running Python.
+        """
+        msg = {"type": "open-url", "url": str(url)}
+        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).
 
@@ -1836,6 +2007,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
@@ -1848,8 +2023,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:
@@ -1895,8 +2076,14 @@ class Application:
         """
         with self._session_lock:
             if session_id is None:
+                # skip ids already taken by explicitly-created sessions
+                # (e.g. a pre-created default session) so we never
+                # silently overwrite an existing session
                 session_id = self._next_session_id
                 self._next_session_id += 1
+                while session_id in self._sessions:
+                    session_id = self._next_session_id
+                    self._next_session_id += 1
             elif session_id in self._sessions:
                 # If the existing session was auto-created by a browser
                 # reconnect with the same token, return it so the user's
@@ -1942,6 +2129,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):
@@ -1951,6 +2139,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 = (
@@ -2086,22 +2299,35 @@ class Application:
         ``concurrent`` modes, callbacks already run on their own threads
         so this method simply yields control briefly.
 
+        A *timeout* of ``0`` drains every callback currently queued and
+        returns immediately without blocking -- useful when pumping from
+        within another event loop (e.g. a Jupyter kernel's asyncio loop).
+
         Parameters
         ----------
         timeout : float
             Maximum seconds to spend processing events (default 0.1).
+            Use ``0`` for a non-blocking drain of the pending queue.
         """
         if self._concurrency == "serialized":
+            non_blocking = (timeout == 0)
             deadline = time.monotonic() + timeout
             while not self._shutdown.is_set():
-                remaining = deadline - time.monotonic()
-                if remaining <= 0:
-                    break
-                try:
-                    handler, args, kwargs, result_slot = \
-                        self._cb_queue.get(timeout=min(remaining, 0.5))
-                except queue.Empty:
-                    continue
+                if non_blocking:
+                    try:
+                        handler, args, kwargs, result_slot = \
+                            self._cb_queue.get_nowait()
+                    except queue.Empty:
+                        break
+                else:
+                    remaining = deadline - time.monotonic()
+                    if remaining <= 0:
+                        break
+                    try:
+                        handler, args, kwargs, result_slot = \
+                            self._cb_queue.get(timeout=min(remaining, 0.5))
+                    except queue.Empty:
+                        continue
                 try:
                     rv = handler(*args, **kwargs)
                     if result_slot is not None:

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.3.0.dist-info → pgwidgets_python-0.3.2.dist-info}/METADATA

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

{pgwidgets_python-0.3.0.dist-info → pgwidgets_python-0.3.2.dist-info}/RECORD

@@ -3,19 +3,19 @@ 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=E_f0CQtDwWKgiPmIPGEftm3OXvntErAY4JZH0C7Dwuo,17699
+pgwidgets/method_types.py,sha256=_-rdE5BOYLra8x3BMKv5-QS4Z8YB29DBhUCDsGiB-Gw,18314
 pgwidgets/async_/Widgets.py,sha256=vld2xkvusBBEVbhbezaJsjBRRj3L7c17Up0pOVs8PGo,723
 pgwidgets/async_/__init__.py,sha256=rXB-v9XRrYt1imYuYikhkzIyiRqaYhlTpQei2LHaQ18,564
-pgwidgets/async_/application.py,sha256=xLt7ZF7jgRYKT5-L95sahohT4Omq2TfW7y8V1f6GM9g,74443
-pgwidgets/async_/widget.py,sha256=H27v7AzHNg5obzr2e8UyOyj2lbGfWhEhZUrIDqrZNbg,37612
+pgwidgets/async_/application.py,sha256=2RJNRerXu5LXG_UcMSi9HWOCAlEOu96TrRaoIcUZ86Q,80957
+pgwidgets/async_/widget.py,sha256=gO7eJh9LV3UY7yRLdeml_0gqmHnFB5VU3NWlDURLtfc,38042
 pgwidgets/extras/__init__.py,sha256=AXUmFtnn4RSlp6pJX6z55j-m_29VmfzpYIjQvAy7pO0,325
-pgwidgets/extras/file_browser.py,sha256=PWzJltjQZbmsD1ykbbC2xJ6ErEkJj7KafhmVkd9q9Ac,16963
+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=0xZDEywx7L7vUe1QAs29iufIqqvmSzOLeu9QQIGiSj0,87160
-pgwidgets/sync/widget.py,sha256=tQDkCOkcevDrGnG4LhBf69law82-UB1fF-r08GUZPSE,37913
-pgwidgets_python-0.3.0.dist-info/licenses/LICENSE.md,sha256=LoM3fMTiMnQuHRCJghdjOtjnCrL8soBpu2PFk24Xvyg,1528
-pgwidgets_python-0.3.0.dist-info/METADATA,sha256=LtcjQx8O8cbpQ_1HcXVm8Jpo7UyFLfVkPCEe8fEmJIY,4568
-pgwidgets_python-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pgwidgets_python-0.3.0.dist-info/top_level.txt,sha256=wwL6fBq0gU-JwzlM6TdduY1qYpu39ysqnnbQT-1bqAs,10
-pgwidgets_python-0.3.0.dist-info/RECORD,,
+pgwidgets/sync/application.py,sha256=tcAJvSVdijfT_KBP4llY1tyg2AAmQM-1qocw8Zf51nM,96240
+pgwidgets/sync/widget.py,sha256=yrScNkZB34u0JXn3-kCB-1mPLxLysVbuaPsCjC8kq0E,38343
+pgwidgets_python-0.3.2.dist-info/licenses/LICENSE.md,sha256=LoM3fMTiMnQuHRCJghdjOtjnCrL8soBpu2PFk24Xvyg,1528
+pgwidgets_python-0.3.2.dist-info/METADATA,sha256=gzz5UD--Uq8I9azawdmXRE-G4KNDrTFDtkVhiNbTSzs,4568
+pgwidgets_python-0.3.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pgwidgets_python-0.3.2.dist-info/top_level.txt,sha256=wwL6fBq0gU-JwzlM6TdduY1qYpu39ysqnnbQT-1bqAs,10
+pgwidgets_python-0.3.2.dist-info/RECORD,,