pgwidgets-python 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

pgwidgets/async_/application.py

@@ -434,6 +434,14 @@ class Session:
                         widget._state[spec[0]] = tuple(args)
                     else:
                         widget._state[spec] = args[0]
+            # ComboBox: a value committed with Enter in the browser may be
+            # a new entry the browser appended to its list; mirror that
+            # append so our _items (and thus get_index) stays consistent.
+            if (widget._js_class == "ComboBox" and action == "activated"
+                    and len(args) >= 2):
+                items = widget._state.setdefault("_items", [])
+                if args[1] not in items:
+                    items.append(args[1])
 
         # Dialog autoclose: the JS side auto-hides when a button is
         # clicked.  Sync that to Python so reconstruction doesn't

pgwidgets/extras/file_browser.py

@@ -209,6 +209,10 @@ class FileBrowser(Callbacks):
 
     # ── Public API ──────────────────────────────────────────────
 
+    def set_title(self, title):
+        """Set the dialog's title bar text."""
+        self._dialog.set_title(title)
+
     def set_mode(self, mode):
         """Set the selection mode: 'file', 'files', 'directory', 'save'."""
         self._mode = mode

pgwidgets/method_types.py

@@ -62,7 +62,8 @@ JS_ONLY_METHODS = {
     # MDIWidget
     "get_subwin", "get_subwindows", "get_configuration",
     "get_child_size", "get_child_position",
-    # Button icon (set_icon is an action, so get_icon must round-trip)
+    # Button icon: set_icon stores state (so it reconstructs); get_icon
+    # reads the live browser value, so it round-trips.
     "get_icon",
 }
 
@@ -107,7 +108,7 @@ ACTION_METHODS = {
     # Timer
     "start", "cancel", "set", "cond_set",
     # Table/Tree row-level modifications (tracked via bulk set_data)
-    "add_item", "remove_item", "update_tree", "remove_items",
+    "add_item", "remove_item", "update_tree", "remove_items", "delete_tree",
     "insert_row", "append_row", "delete_row",
     "insert_column", "append_column", "delete_column",
     "set_cell",
@@ -121,8 +122,6 @@ ACTION_METHODS = {
     "set_minimum_size",
     # TreeView per-column
     "set_column_width", "set_column_editable",
-    # TextSource per-line
-    "set_icon",
 }
 
 # Setter methods that DON'T follow the set_* naming convention.
@@ -420,7 +419,34 @@ BINARY_STATE_KEYS = {
 }
 
 
+def _combobox_get_index(self):
+    """Index of the item matching the current text, or -1 when the text is
+    not one of the offerings (e.g. a value typed into an editable combo box
+    but not yet committed with Enter).  Mirrors the JS get_index(), which
+    is items.indexOf(input value), and stays consistent with get_text()
+    (the cached entry text, kept live by the 'modified' callback)."""
+    items = self._state.get("_items", [])
+    try:
+        return items.index(self._state.get("text", ""))
+    except ValueError:
+        return -1
+
+
+def _combobox_set_index(self, idx):
+    """Select the item at *idx*, keeping the cached text consistent with
+    the index so get_text() agrees with get_index() after a programmatic
+    change (the generic setter would leave 'text' stale)."""
+    items = self._state.get("_items", [])
+    if 0 <= idx < len(items):
+        self._state["text"] = items[idx]
+    self._state["index"] = idx
+    self._user_set_state.add("index")
+    return self._call("set_index", idx)
+
+
 CUSTOM_METHODS = {
+    ("ComboBox", "get_index"): _combobox_get_index,
+    ("ComboBox", "set_index"): _combobox_set_index,
     ("TabWidget", "index_to_widget"): _index_to_widget,
     ("TabWidget", "index_of"): _index_of,
     ("StackWidget", "index_to_widget"): _index_to_widget,

pgwidgets/sync/application.py

@@ -524,6 +524,14 @@ class Session:
                         widget._state[spec[0]] = tuple(args)
                     else:
                         widget._state[spec] = args[0]
+            # ComboBox: a value committed with Enter in the browser may be
+            # a new entry the browser appended to its list; mirror that
+            # append so our _items (and thus get_index) stays consistent.
+            if (widget._js_class == "ComboBox" and action == "activated"
+                    and len(args) >= 2):
+                items = widget._state.setdefault("_items", [])
+                if args[1] not in items:
+                    items.append(args[1])
         # Dialog autoclose: the JS side auto-hides when a button is
         # clicked.  Sync that to Python so reconstruction doesn't
         # re-show a dialog that was autoclosed.
@@ -1399,6 +1407,18 @@ class Session:
         #    callbacks transferred by _transfer_proxy during step 3.
         self._reregister_callbacks(widget)
 
+        # 6. Widgets with a Python-authoritative model (TextSource) push
+        #    their full model state (text, tags, cursor) to the freshly
+        #    (re)connected browser.  Guard it: a failure here must not abort
+        #    reconstruction of the whole widget tree.
+        if hasattr(widget, "_reconstruct_model"):
+            try:
+                widget._reconstruct_model()
+            except Exception:
+                self._logger.error(
+                    "TextSource model reconstruction failed for wid=%s",
+                    getattr(widget, "_wid", "?"), exc_info=True)
+
     def _reregister_callbacks(self, widget):
         """Re-register user callbacks and auto-sync listeners on *widget*.
 

pgwidgets/sync/text_source.py

@@ -0,0 +1,200 @@
+"""Python-authoritative TextSource for the synchronous API.
+
+Unlike most widgets (whose state is a handful of scalars), a text buffer
+has rich structure -- content, live position refs, a tag table, cursor and
+selection.  We keep the *authoritative* copy of all of that on the Python
+side in a :class:`~pgwidgets.text_model.TextModel`, so the whole API works
+before a browser is ever connected (the UI can be built up headless and
+replayed on connect).  The browser is driven as a *view*: model changes are
+pushed as offset-based operations through the render hooks, and are no-ops
+(``_call`` returns None) until a browser attaches, at which point
+``_reconstruct_model`` replays the full state.
+
+Refs never cross the wire -- they are ordinary Python ``TextBufferRef``
+objects owned by the local model.  (The in-situ / JS-only case, where the
+browser is authoritative, is handled by the separate pgwidgets-js/pyodide
+wrapper, not here.)
+
+The class subclasses the *generated* TextSource proxy so it inherits all the
+base-widget methods (show/hide/set_tooltip/get_size/...) and the widget
+option setters (set_editable/set_wrap/scrolling); it overrides only the
+methods that manipulate the text model.
+"""
+
+from pgwidgets.sync.widget import build_widget_class
+from pgwidgets.defs import WIDGETS
+from pgwidgets.text_model import TextModel
+
+
+_GeneratedTextSource = build_widget_class("TextSource", WIDGETS["TextSource"])
+
+
+class _BrowserTextModel(TextModel):
+    """A TextModel whose render hooks push offset-based operations to the
+    browser via the owning widget.  When no browser is connected the calls
+    are no-ops, so the model is fully usable headless."""
+
+    def __init__(self, widget):
+        self._widget = widget
+        super().__init__()
+
+    def _push(self, method, *args):
+        # _call round-trips when a browser is connected and is a no-op
+        # returning None otherwise.
+        self._widget._call(method, *args)
+
+    # -- render hooks (see TextModel) --
+    def _set_editor_text(self, text):
+        self._push("set_text", text)
+
+    def _replace_editor_range(self, start, end, new_text):
+        # Drive the JS buffer by offset; pushUndo=False because the Python
+        # model owns undo/redo.
+        self._push("_replaceRange", start, end, new_text, {"pushUndo": False})
+
+    def _apply_all_formats(self, region=None):
+        # Push the current tag intervals; the JS side re-renders styling.
+        # (Tag *definitions* are pushed by TextSource.create_tag.)
+        self._push("_restoreTagIntervals", self._tag_intervals())
+
+    def _apply_selection_to_editor(self):
+        if self._sel_start == self._sel_end:
+            self._push("_setCursorOffset", self._cursor)
+        else:
+            self._push("_setSelectionOffsets", self._sel_start, self._sel_end)
+
+    def _refresh_icon_gutter(self):
+        # TODO: render ref-anchored gutter icons in the browser.
+        pass
+
+    def _mark_clean(self):
+        pass
+
+    def _tag_intervals(self):
+        return [{"name": t["name"], "start": t["start"], "end": t["end"]}
+                for t in self._tags]
+
+
+# Model methods delegated verbatim to self._model.  Refs in/out are the
+# model's own TextBufferRefs; nothing here touches the wire.  These override
+# the generated round-trip proxies of the same name.
+_DELEGATED = (
+    # content
+    "get_length", "get_text", "get_text_range", "clear", "set_text",
+    "insert_text", "delete_range",
+    # refs
+    "create_ref", "remove_ref", "create_named_ref", "get_named_ref",
+    "remove_named_ref", "get_ref_start", "get_ref_end", "get_ref_bounds",
+    "get_ref_line_start", "get_ref_line_end", "set_icon",
+    # tags (create_tag handled explicitly to also push the tag definition)
+    "remove_tag_def", "has_tag", "apply_tag", "remove_tag",
+    "get_tags_at", "get_tags_range", "get_tag_region", "get_tag_regions",
+    # find / replace
+    "find", "find_all", "replace",
+    # cursor / selection
+    "get_cursor", "set_cursor", "has_selection", "get_selection_range",
+    "get_selection_bounds", "set_selection_range",
+    # undo / redo / dirty flag
+    "can_undo", "can_redo", "undo", "redo", "get_modified", "mark_clean",
+    # misc convenience
+    "get_end_lineno", "clear_icons",
+)
+
+# Callback actions that are model-authoritative (fire from the Python model)
+# rather than being browser events.
+_MODEL_CALLBACKS = {"changed", "cursor-moved", "cursor_moved"}
+
+
+class TextSource(_GeneratedTextSource):
+
+    def __init__(self, session, *args, **kwargs):
+        super().__init__(session, *args, **kwargs)
+        # The authoritative model.  Seed its text from the initial value the
+        # generated __init__ recorded (the JS side already has it from the
+        # constructor, so no push).  Text/tags/cursor are reconstructed by
+        # _reconstruct_model(), not by the generic state replay, so drop
+        # 'text' from _state.
+        self._model = _BrowserTextModel(self)
+        text = self._state.get("text")
+        self._model._text = "" if text is None else str(text)
+        self._state.pop("text", None)
+
+    def create_tag(self, name, attrs=None, **kwdargs):
+        """Define a display tag locally and push its styling to the browser."""
+        merged = {} if attrs is None else dict(attrs)
+        merged.update(kwdargs)
+        self._model.create_tag(name, merged)
+        self._call("create_tag", name, merged)
+
+    def scroll_to_ref(self, ref):
+        """Scroll the view to a ref, addressed by its current offset."""
+        self._call("_scrollToOffset", self._model._offset_of(ref))
+
+    def scroll_to_lineno(self, lineno):
+        """Scroll so that line ``lineno`` is visible."""
+        self._call("_scrollToOffset",
+                   self._model._offset_of_line_start(lineno))
+
+    def scroll_to_end(self):
+        """Scroll to the end of the buffer."""
+        self._call("_scrollToOffset", self._model.get_length())
+
+    def show_tooltip(self, text, x, y):
+        """Show a hover tooltip (``text``) near viewport point (x, y), or
+        hide it when ``text`` is empty.  Normally called from a handler of
+        the 'tooltip' callback."""
+        self._call("_showTooltip", text, x, y)
+
+    # -- callbacks: 'changed'/'cursor_moved' are model-authoritative --
+    def add_callback(self, action, handler, *extra_args, **extra_kwargs):
+        if action in _MODEL_CALLBACKS:
+            self._model.add_callback(
+                self._model_cb_name(action),
+                lambda _m, *a: handler(self, *a, *extra_args, **extra_kwargs))
+            return
+        super().add_callback(action, handler, *extra_args, **extra_kwargs)
+
+    def on(self, action, handler, *extra_args, **extra_kwargs):
+        if action in _MODEL_CALLBACKS:
+            self._model.add_callback(
+                self._model_cb_name(action),
+                lambda _m, *a: handler(*a, *extra_args, **extra_kwargs))
+            return
+        super().on(action, handler, *extra_args, **extra_kwargs)
+
+    @staticmethod
+    def _model_cb_name(action):
+        return "cursor-moved" if action in ("cursor_moved",
+                                            "cursor-moved") else "changed"
+
+    # -- reconstruction: push the full model state to a freshly-connected
+    #    browser (called by Session._reconstruct_widget after the generic
+    #    create/state/callback replay) --
+    def _reconstruct_model(self):
+        m = self._model
+        self._call("set_text", m.get_text())
+        for name, attrs in m._tag_defs.items():
+            self._call("create_tag", name, attrs)
+        intervals = m._tag_intervals()
+        if intervals:
+            self._call("_restoreTagIntervals", intervals)
+        if m._sel_start != m._sel_end:
+            self._call("_setSelectionOffsets", m._sel_start, m._sel_end)
+        else:
+            self._call("_setCursorOffset", m._cursor)
+
+
+def _install_delegators():
+    """Override the generated round-trip proxies with model-delegating
+    methods (defined at class scope so ``hasattr(TextSource, name)`` holds)."""
+    for _name in _DELEGATED:
+        def _make(n):
+            def method(self, *args, **kwargs):
+                return getattr(self._model, n)(*args, **kwargs)
+            method.__name__ = n
+            method.__qualname__ = "TextSource." + n
+            return method
+        setattr(TextSource, _name, _make(_name))
+
+
+_install_delegators()

pgwidgets/sync/widget.py

@@ -965,4 +965,9 @@ def build_all_widget_classes():
     classes = {}
     for js_class, defn in WIDGETS.items():
         classes[js_class] = build_widget_class(js_class, defn)
+    # TextSource is hand-written (Python-authoritative local text model)
+    # rather than generated -- see pgwidgets.sync.text_source.  Deferred
+    # import avoids a circular import at module load.
+    from pgwidgets.sync.text_source import TextSource as _TextSource
+    classes['TextSource'] = _TextSource
     return classes

pgwidgets/text_model.py

@@ -0,0 +1,792 @@
+#
+# text_model.py -- toolkit-neutral text buffer model with tags and refs
+#
+# This is open-source software licensed under a BSD license.
+# Please see the file LICENSE.txt for details.
+#
+"""A backend-neutral text buffer model.
+
+``TextModel`` holds the content string, a set of live position references
+(``TextBufferRef``) that follow edits, a named tag table with interval
+bookkeeping, find/replace, and a model-level undo/redo stack.  None of it
+depends on a GUI toolkit.
+
+A toolkit widget (qt, gtk, ...) subclasses ``TextModel`` and implements the
+small set of *render hooks* to reflect model changes in a native widget:
+
+    _set_editor_text(text)              push the whole text into the widget
+    _replace_editor_range(s, e, text)   edit just the changed span
+    _apply_all_formats(region=None)     (re)apply tag styling to a range
+    _apply_selection_to_editor()        mirror model selection into the widget
+    _refresh_icon_gutter()              redraw ref-anchored gutter icons
+    _mark_clean()                       clear the widget's "modified" flag
+
+The default implementations are no-ops, so a bare ``TextModel`` is usable
+headless (e.g. for tests or a non-visual buffer).
+"""
+import weakref
+
+from pgwidgets.callbacks import Callbacks
+
+
+class TextBufferRef:
+    """Live reference to a character offset in a text model buffer.
+
+    The ref follows inserts and deletes performed through the owning buffer.
+    Gravity controls how the ref behaves when text is inserted at exactly the
+    ref's offset.
+    """
+
+    def __init__(self, buffer, offset, gravity='right'):
+        if gravity not in ('left', 'right'):
+            raise ValueError("gravity must be 'left' or 'right'")
+        self._buffer = buffer
+        self._offset = buffer._clamp_offset(offset)
+        self._gravity = gravity
+        self._valid = True
+
+    def get_offset(self):
+        return self._offset
+
+    def get_gravity(self):
+        return self._gravity
+
+    def is_valid(self):
+        return self._valid
+
+    def get_line_column(self):
+        self._check_valid()
+        text = self._buffer.get_text()
+        prefix = text[:self._offset]
+        line = prefix.count('\n')
+        last_nl = prefix.rfind('\n')
+        col = self._offset if last_nl < 0 else self._offset - last_nl - 1
+        return (line, col)
+
+    def get_line(self):
+        self._check_valid()
+        return self._buffer._line_of_offset(self._offset)
+
+    def set_offset(self, offset):
+        self._check_valid()
+        self._set_offset(offset)
+
+    def set_line(self, lineno):
+        self._check_valid()
+        self._set_offset(self._buffer._offset_of_line_start(lineno))
+
+    def to_ref(self, other):
+        self._check_valid()
+        if not isinstance(other, TextBufferRef):
+            raise TypeError("to_ref requires a TextBufferRef")
+        if other._buffer is not self._buffer:
+            raise ValueError("TextBufferRef belongs to a different buffer")
+        if not other._valid:
+            raise ValueError("Source TextBufferRef has been invalidated")
+        self._set_offset(other._offset)
+
+    def copy(self):
+        self._check_valid()
+        return self._buffer.create_ref(self._offset, self._gravity)
+
+    def to_line_start(self):
+        self._check_valid()
+        self._set_offset(self._buffer._offset_of_line_start(self.get_line()))
+
+    def to_line_end(self):
+        self._check_valid()
+        text = self._buffer.get_text()
+        idx = text.find('\n', self._offset)
+        if idx < 0:
+            idx = len(text)
+        self._set_offset(idx)
+
+    def to_next_line(self):
+        self._check_valid()
+        text = self._buffer.get_text()
+        idx = text.find('\n', self._offset)
+        if idx >= 0:
+            self._set_offset(idx + 1)
+
+    def to_prev_line(self):
+        self._check_valid()
+        line = self.get_line()
+        if line > 0:
+            self._set_offset(self._buffer._offset_of_line_start(line - 1))
+
+    def to_next_char(self):
+        self._check_valid()
+        self._set_offset(self._offset + 1)
+
+    def to_prev_char(self):
+        self._check_valid()
+        self._set_offset(self._offset - 1)
+
+    def _check_valid(self):
+        if not self._valid:
+            raise ValueError("TextBufferRef has been invalidated")
+
+    def _set_offset(self, new_offset):
+        self._offset = self._buffer._clamp_offset(new_offset)
+        self._buffer._refresh_icon_gutter()
+
+    def _invalidate(self):
+        self._valid = False
+
+
+class TextModel(Callbacks):
+    """Toolkit-neutral text buffer: content, refs, a tag table, find/replace
+    and model-level undo/redo.  Subclass and implement the render hooks to
+    drive a native widget."""
+
+    def __init__(self):
+        Callbacks.__init__(self)
+
+        self._text = ''
+        self._refs = weakref.WeakSet()
+        self._named_refs = {}
+        self._tag_defs = {}
+        self._tags = []
+        self._tag_seq = 0
+        self._icon_refs = {}
+        self._cursor = 0
+        self._sel_start = 0
+        self._sel_end = 0
+
+        # Model-level undo/redo.  Each entry records a single _replace_range
+        # edit as (start, old_text, new_text, cursor_before, cursor_after) so
+        # it can be inverted with refs and tags kept consistent.
+        self._undo_stack = []
+        self._redo_stack = []
+        self._undo_limit = 500
+        self._in_undo_redo = False
+        # dirty flag: True after any edit, cleared by mark_clean()/set_text()
+        self._modified = False
+
+        for name in ('changed', 'cursor-moved'):
+            self.enable_callback(name)
+
+    # ------------------------------------------------------------------
+    # Render hooks -- subclasses override these to reflect model changes in
+    # a native widget.  Defaults are no-ops so a bare model works headless.
+    # ------------------------------------------------------------------
+    def _set_editor_text(self, text):
+        pass
+
+    def _replace_editor_range(self, start, end, new_text):
+        pass
+
+    def _apply_all_formats(self, region=None):
+        pass
+
+    def _apply_selection_to_editor(self):
+        pass
+
+    def _refresh_icon_gutter(self):
+        pass
+
+    def _mark_clean(self):
+        pass
+
+    # ------------------------------------------------------------------
+    # Content
+    # ------------------------------------------------------------------
+    def get_length(self):
+        return len(self._text)
+
+    def get_text(self):
+        return self._text
+
+    def get_text_range(self, start_ref, end_ref):
+        """Return the text spanning ``[start_ref, end_ref)``."""
+        start = self._offset_of(start_ref)
+        end = self._offset_of(end_ref)
+        if start > end:
+            start, end = end, start
+        return self._text[start:end]
+
+    def clear(self):
+        self.set_text('')
+
+    def set_text(self, text):
+        """Replace the full buffer contents.
+
+        This is destructive with respect to refs and applied tags: existing
+        refs are invalidated and applied tag intervals are cleared.
+        """
+        self._text = '' if text is None else str(text)
+        self._cursor = 0
+        self._sel_start = 0
+        self._sel_end = 0
+        self._tags = []
+        self._undo_stack = []
+        self._redo_stack = []
+        self._invalidate_all_refs()
+        self._named_refs.clear()
+        self._icon_refs.clear()
+        self._modified = False
+        self._set_editor_text(self._text)
+        self._apply_all_formats()
+        self._refresh_icon_gutter()
+        self._mark_clean()
+
+    def insert_text(self, ref, text, tags=None):
+        """Insert text at ``ref`` and optionally apply tags to that range."""
+        if text is None or text == '':
+            return
+        offset = self._offset_of(ref)
+        self._replace_range(offset, offset, str(text), tags=tags)
+
+    def delete_range(self, start_ref, end_ref):
+        """Delete the text spanning ``[start_ref, end_ref)``."""
+        start = self._offset_of(start_ref)
+        end = self._offset_of(end_ref)
+        if start > end:
+            start, end = end, start
+        if start == end:
+            return
+        self._replace_range(start, end, '')
+
+    # ------------------------------------------------------------------
+    # Refs
+    # ------------------------------------------------------------------
+    def create_ref(self, offset, gravity='right'):
+        """Create a live buffer ref at ``offset``."""
+        ref = TextBufferRef(self, offset, gravity=gravity)
+        self._refs.add(ref)
+        return ref
+
+    def remove_ref(self, ref):
+        """Invalidate a ref and detach any named/icon bindings that use it."""
+        if not isinstance(ref, TextBufferRef):
+            return
+        if not ref.is_valid():
+            return
+        for name, named_ref in list(self._named_refs.items()):
+            if named_ref is ref:
+                del self._named_refs[name]
+        if ref in self._icon_refs:
+            del self._icon_refs[ref]
+        ref._invalidate()
+        self._refresh_icon_gutter()
+
+    def create_named_ref(self, name, offset, gravity='right'):
+        """Create a live ref and bind it to ``name``."""
+        existing = self._named_refs.get(name)
+        if existing is not None:
+            self.remove_ref(existing)
+        ref = self.create_ref(offset, gravity=gravity)
+        self._named_refs[name] = ref
+        return ref
+
+    def get_named_ref(self, name):
+        return self._named_refs.get(name)
+
+    def remove_named_ref(self, name):
+        ref = self._named_refs.pop(name, None)
+        if ref is not None:
+            self.remove_ref(ref)
+
+    def get_ref_start(self):
+        return self.create_ref(0, 'right')
+
+    def get_ref_end(self):
+        return self.create_ref(len(self._text), 'right')
+
+    def get_ref_bounds(self):
+        return (self.get_ref_start(), self.get_ref_end())
+
+    def get_ref_line_start(self, lineno):
+        return self.create_ref(self._offset_of_line_start(lineno), 'right')
+
+    def get_ref_line_end(self, lineno):
+        start = self._offset_of_line_start(lineno)
+        idx = self._text.find('\n', start)
+        end = len(self._text) if idx < 0 else idx
+        return self.create_ref(end, 'right')
+
+    def get_end_lineno(self):
+        """Return the 0-based line number of the end of the buffer."""
+        return self._line_of_offset(len(self._text))
+
+    def set_icon(self, ref, image):
+        """Associate an icon with a ref so it follows text movement by line."""
+        if not isinstance(ref, TextBufferRef):
+            raise TypeError("set_icon requires a TextBufferRef")
+        if ref._buffer is not self:
+            raise ValueError("TextBufferRef belongs to a different buffer")
+        if image is None:
+            self._icon_refs.pop(ref, None)
+        else:
+            self._icon_refs.pop(ref, None)
+            self._icon_refs[ref] = image
+        self._refresh_icon_gutter()
+
+    def clear_icons(self):
+        """Remove all ref-anchored gutter icons."""
+        self._icon_refs.clear()
+        self._refresh_icon_gutter()
+
+    # ------------------------------------------------------------------
+    # Tags
+    # ------------------------------------------------------------------
+    def create_tag(self, name, attrs=None, **kwdargs):
+        """Define or redefine a named display tag."""
+        attrs = {} if attrs is None else dict(attrs)
+        attrs.update(kwdargs)
+        self._tag_defs[name] = attrs
+        # A tag definition only affects rendering where the tag is applied.
+        # Defining a brand-new (unapplied) tag needs no reformat, which keeps
+        # bulk tag creation (e.g. one tag per AST node) cheap.
+        if self.has_tag(name):
+            self._apply_all_formats()
+
+    def remove_tag_def(self, name):
+        if name in self._tag_defs:
+            del self._tag_defs[name]
+        self._tags = [tag for tag in self._tags if tag['name'] != name]
+        self._apply_all_formats()
+
+    def has_tag(self, name):
+        return any(tag['name'] == name for tag in self._tags)
+
+    def apply_tag(self, name, start_ref, end_ref):
+        """Apply a previously-defined tag across a buffer range."""
+        if name not in self._tag_defs:
+            raise ValueError("Unknown tag: %s" % (name,))
+        start = self._offset_of(start_ref)
+        end = self._offset_of(end_ref)
+        if start > end:
+            start, end = end, start
+        if start == end:
+            return
+        self._add_tag_interval(name, start, end)
+        self._apply_all_formats(region=(start, end))
+
+    def remove_tag(self, name, start_ref, end_ref):
+        """Clip a tag out of the given buffer range."""
+        start = self._offset_of(start_ref)
+        end = self._offset_of(end_ref)
+        if start > end:
+            start, end = end, start
+        next_tags = []
+        for tag in self._tags:
+            if tag['name'] != name or tag['end'] <= start or tag['start'] >= end:
+                next_tags.append(tag)
+                continue
+            if tag['start'] < start:
+                next_tags.append(dict(tag, end=start))
+            if tag['end'] > end:
+                next_tags.append(dict(tag, start=end))
+        self._tags = next_tags
+        self._apply_all_formats(region=(start, end))
+
+    def get_tags_at(self, ref):
+        offset = self._offset_of(ref)
+        names = []
+        seen = set()
+        for tag in self._tags:
+            if tag['start'] <= offset < tag['end'] and tag['name'] not in seen:
+                names.append(tag['name'])
+                seen.add(tag['name'])
+        return names
+
+    def get_tags_range(self, start_ref, end_ref):
+        start = self._offset_of(start_ref)
+        end = self._offset_of(end_ref)
+        if start > end:
+            start, end = end, start
+        names = []
+        seen = set()
+        for tag in self._tags:
+            if tag['end'] <= start or tag['start'] >= end:
+                continue
+            if tag['name'] not in seen:
+                names.append(tag['name'])
+                seen.add(tag['name'])
+        return names
+
+    def get_tag_region(self, name):
+        """Return the overall ``(start_ref, end_ref)`` span of a named tag.
+
+        This mirrors the old GTK ``get_region`` helper: it returns a single
+        ref pair covering from the first occurrence of the tag to the last.
+        Returns ``None`` if the tag is not applied anywhere.
+        """
+        spans = [tag for tag in self._tags if tag['name'] == name]
+        if not spans:
+            return None
+        start = min(tag['start'] for tag in spans)
+        end = max(tag['end'] for tag in spans)
+        return (self.create_ref(start, 'right'),
+                self.create_ref(end, 'right'))
+
+    def get_tag_regions(self, name):
+        """Return a list of ``(start_ref, end_ref)`` pairs, one per maximal
+        contiguous run of the named tag."""
+        spans = sorted((tag for tag in self._tags if tag['name'] == name),
+                       key=lambda tag: tag['start'])
+        if not spans:
+            return []
+        merged = []
+        cur_start, cur_end = spans[0]['start'], spans[0]['end']
+        for tag in spans[1:]:
+            if tag['start'] <= cur_end:
+                cur_end = max(cur_end, tag['end'])
+            else:
+                merged.append((cur_start, cur_end))
+                cur_start, cur_end = tag['start'], tag['end']
+        merged.append((cur_start, cur_end))
+        return [(self.create_ref(s, 'right'), self.create_ref(e, 'right'))
+                for s, e in merged]
+
+    # ------------------------------------------------------------------
+    # Find / replace
+    # ------------------------------------------------------------------
+    def find(self, query, start=None, case_insensitive=False):
+        """Return the first match as ``(start_ref, end_ref)`` or ``None``."""
+        match = self._find_offset(query, start=start,
+                                  case_insensitive=case_insensitive)
+        if match is None:
+            return None
+        return (self.create_ref(match[0], 'right'),
+                self.create_ref(match[1], 'right'))
+
+    def find_all(self, query, start=None, case_insensitive=False):
+        """Return all non-overlapping matches as ref pairs."""
+        matches = self._find_all_offsets(query, start=start,
+                                         case_insensitive=case_insensitive)
+        return [(self.create_ref(start_off, 'right'),
+                 self.create_ref(end_off, 'right'))
+                for start_off, end_off in matches]
+
+    def replace(self, query, replacement, all=False, start=None,
+                case_insensitive=False):
+        """Replace one or all matches and return the replacement count."""
+        if not query:
+            return 0
+        if all:
+            matches = self._find_all_offsets(query, start=start,
+                                             case_insensitive=case_insensitive)
+        else:
+            match = self._find_offset(query, start=start,
+                                      case_insensitive=case_insensitive)
+            matches = [] if match is None else [match]
+        for start_off, end_off in reversed(matches):
+            self._replace_range(start_off, end_off, replacement)
+        return len(matches)
+
+    # ------------------------------------------------------------------
+    # Cursor / selection
+    # ------------------------------------------------------------------
+    def get_cursor(self):
+        return self.create_ref(self._cursor, 'right')
+
+    def set_cursor(self, ref):
+        """Move the editor cursor to ``ref`` and clear any selection."""
+        offset = self._offset_of(ref)
+        self._cursor = offset
+        self._sel_start = offset
+        self._sel_end = offset
+        self._apply_selection_to_editor()
+
+    def has_selection(self):
+        return self._sel_start != self._sel_end
+
+    def get_selection_range(self):
+        if self._sel_start == self._sel_end:
+            return None
+        start = min(self._sel_start, self._sel_end)
+        end = max(self._sel_start, self._sel_end)
+        return (self.create_ref(start, 'right'),
+                self.create_ref(end, 'right'))
+
+    # get_selection_bounds() is the canonical accessor used by page code;
+    # it returns a (start_ref, end_ref) pair or None when there is no
+    # selection.  Callers guard with has_selection().
+    get_selection_bounds = get_selection_range
+
+    def set_selection_range(self, start_ref, end_ref):
+        """Select the text spanning ``[start_ref, end_ref)``."""
+        start = self._offset_of(start_ref)
+        end = self._offset_of(end_ref)
+        self._sel_start = start
+        self._sel_end = end
+        self._cursor = end
+        self._apply_selection_to_editor()
+
+    # ------------------------------------------------------------------
+    # Undo / redo
+    # ------------------------------------------------------------------
+    def can_undo(self):
+        return len(self._undo_stack) > 0
+
+    def can_redo(self):
+        return len(self._redo_stack) > 0
+
+    def get_modified(self):
+        """True if the buffer has been edited since the last mark_clean()
+        (or set_text)."""
+        return self._modified
+
+    def mark_clean(self):
+        """Reset the modified flag (e.g. after saving)."""
+        self._modified = False
+        self._mark_clean()
+
+    def undo(self):
+        if not self._undo_stack:
+            return False
+        start, old_text, new_text, cursor_before, cursor_after = \
+            self._undo_stack.pop()
+        self._in_undo_redo = True
+        try:
+            self._replace_range(start, start + len(new_text), old_text,
+                                push_undo=False)
+            self._cursor, self._sel_start, self._sel_end = cursor_before
+            self._apply_selection_to_editor()
+        finally:
+            self._in_undo_redo = False
+        self._redo_stack.append((start, old_text, new_text, cursor_before,
+                                 cursor_after))
+        return True
+
+    def redo(self):
+        if not self._redo_stack:
+            return False
+        start, old_text, new_text, cursor_before, cursor_after = \
+            self._redo_stack.pop()
+        self._in_undo_redo = True
+        try:
+            self._replace_range(start, start + len(old_text), new_text,
+                                push_undo=False)
+            self._cursor, self._sel_start, self._sel_end = cursor_after
+            self._apply_selection_to_editor()
+        finally:
+            self._in_undo_redo = False
+        self._undo_stack.append((start, old_text, new_text, cursor_before,
+                                 cursor_after))
+        return True
+
+    # ------------------------------------------------------------------
+    # Internal offset / ref / tag bookkeeping (pure)
+    # ------------------------------------------------------------------
+    def _clamp_offset(self, offset):
+        try:
+            offset = int(offset)
+        except Exception:
+            offset = 0
+        return max(0, min(len(self._text), offset))
+
+    def _offset_of(self, ref):
+        if not isinstance(ref, TextBufferRef):
+            raise TypeError("API requires a TextBufferRef")
+        if ref._buffer is not self:
+            raise ValueError("TextBufferRef belongs to a different buffer")
+        if not ref.is_valid():
+            raise ValueError("TextBufferRef has been invalidated")
+        return self._clamp_offset(ref._offset)
+
+    def _line_of_offset(self, offset):
+        return self._text[:self._clamp_offset(offset)].count('\n')
+
+    def _offset_of_line_start(self, lineno):
+        if lineno <= 0:
+            return 0
+        offset = 0
+        for _idx in range(lineno):
+            nl = self._text.find('\n', offset)
+            if nl < 0:
+                return len(self._text)
+            offset = nl + 1
+        return offset
+
+    def _replace_range(self, start, end, new_text, tags=None,
+                       selection_after=None, sync_editor=True, push_undo=True):
+        """Replace ``[start, end)`` in the model and synchronize the view.
+
+        All ref and tag shifting happens here so every edit path shares the
+        same semantics.  ``sync_editor`` is disabled only when the edit
+        originated from the native widget (which already reflects the new
+        text).  ``push_undo`` is disabled when the edit is itself the result
+        of an undo/redo replay.
+        """
+        old_text = self._text[start:end]
+        if old_text == new_text:
+            if selection_after is not None:
+                self._cursor, self._sel_start, self._sel_end = selection_after
+            return
+
+        cursor_before = (self._cursor, self._sel_start, self._sel_end)
+
+        self._text = self._text[:start] + new_text + self._text[end:]
+        if end > start:
+            self._update_refs_on_delete(start, end)
+            self._update_tags_on_delete(start, end)
+        if new_text:
+            self._update_refs_on_insert(start, len(new_text))
+            self._update_tags_on_insert(start, len(new_text))
+        if tags:
+            for name in tags:
+                self._add_tag_interval(name, start, start + len(new_text))
+        if selection_after is None:
+            new_pos = start + len(new_text)
+            self._cursor = new_pos
+            self._sel_start = new_pos
+            self._sel_end = new_pos
+        else:
+            self._cursor, self._sel_start, self._sel_end = selection_after
+
+        if not self._in_undo_redo and push_undo:
+            self._undo_stack.append((start, old_text, new_text, cursor_before,
+                                     (self._cursor, self._sel_start, self._sel_end)))
+            if len(self._undo_stack) > self._undo_limit:
+                self._undo_stack.pop(0)
+            self._redo_stack = []
+
+        if sync_editor:
+            # Edit only the changed span in the editor (not the whole
+            # document), preserving existing formatting outside it.
+            self._replace_editor_range(start, end, new_text)
+            self._apply_selection_to_editor()
+        # Only the inserted span needs (re)formatting: on an incremental edit
+        # the toolkit keeps the formatting of the surrounding text, which has
+        # merely shifted.  This keeps appends O(edit) rather than O(buffer).
+        self._apply_all_formats(region=(start, start + len(new_text)))
+        self._refresh_icon_gutter()
+
+        self._modified = True
+        self.make_callback('changed')
+
+    def _invalidate_all_refs(self):
+        for ref in list(self._refs):
+            ref._offset = 0
+            ref._invalidate()
+
+    def _update_refs_on_insert(self, offset, amount):
+        for ref in list(self._refs):
+            if not ref.is_valid():
+                continue
+            if ref._offset > offset or (
+                    ref._offset == offset and ref.get_gravity() == 'right'):
+                ref._offset += amount
+
+    def _update_refs_on_delete(self, start, end):
+        amount = end - start
+        for ref in list(self._refs):
+            if not ref.is_valid():
+                continue
+            if ref._offset <= start:
+                continue
+            if ref._offset >= end:
+                ref._offset -= amount
+            else:
+                ref._offset = start
+
+    def _add_tag_interval(self, name, start, end):
+        self._tag_seq += 1
+        self._tags.append(dict(name=name, start=start, end=end,
+                               seq=self._tag_seq))
+
+    def _update_tags_on_insert(self, offset, amount):
+        for tag in self._tags:
+            if tag['start'] >= offset:
+                tag['start'] += amount
+            if tag['end'] > offset or (
+                    tag['end'] == offset and tag['start'] == tag['end']):
+                tag['end'] += amount
+            if tag['end'] < tag['start']:
+                tag['end'] = tag['start']
+
+    def _update_tags_on_delete(self, start, end):
+        amount = end - start
+        next_tags = []
+        for tag in self._tags:
+            tag_start = tag['start']
+            tag_end = tag['end']
+            if tag_end <= start:
+                next_tags.append(tag)
+                continue
+            if tag_start >= end:
+                next_tags.append(dict(tag, start=tag_start - amount,
+                                      end=tag_end - amount))
+                continue
+            new_start = tag_start if tag_start < start else start
+            new_end = tag_end - amount if tag_end > end else start
+            if new_end > new_start:
+                next_tags.append(dict(tag, start=new_start, end=new_end))
+        self._tags = next_tags
+
+    def _segments_for_range(self, start, end):
+        """Split a range into maximal subranges sharing the same tag stack.
+
+        Returns a list of ``(seg_start, seg_end, [tag_name, ...])`` with the
+        tag names ordered by application sequence (so later tags win)."""
+        points = {start, end}
+        active = []
+        for tag in self._tags:
+            if tag['end'] <= start or tag['start'] >= end:
+                continue
+            active.append(tag)
+            points.add(max(tag['start'], start))
+            points.add(min(tag['end'], end))
+        sorted_points = sorted(points)
+        segments = []
+        for idx in range(len(sorted_points) - 1):
+            seg_start = sorted_points[idx]
+            seg_end = sorted_points[idx + 1]
+            if seg_start >= seg_end:
+                continue
+            in_seg = [tag for tag in active
+                      if tag['start'] <= seg_start and tag['end'] >= seg_end]
+            in_seg.sort(key=lambda item: item['seq'])
+            segments.append((seg_start, seg_end,
+                             [tag['name'] for tag in in_seg]))
+        return segments
+
+    def _merged_attrs(self, tag_names):
+        """Merge the attr dicts of the given tags (later tags win)."""
+        attrs = {}
+        for name in tag_names:
+            attrs.update(self._tag_defs.get(name, {}))
+        return attrs
+
+    def _style_list_from_attrs(self, attrs):
+        style = []
+        if attrs.get('bold'):
+            style.append('bold')
+        if attrs.get('italic'):
+            style.append('italic')
+        return style
+
+    def _find_offset(self, query, start=None, case_insensitive=False):
+        if not query:
+            return None
+        offset = 0 if start is None else self._offset_of(start)
+        haystack = self._text
+        needle = query
+        if case_insensitive:
+            haystack = haystack.lower()
+            needle = needle.lower()
+        idx = haystack.find(needle, offset)
+        if idx < 0:
+            return None
+        return (idx, idx + len(query))
+
+    def _find_all_offsets(self, query, start=None, case_insensitive=False):
+        if not query:
+            return []
+        offsets = []
+        offset = 0 if start is None else self._offset_of(start)
+        haystack = self._text
+        needle = query
+        if case_insensitive:
+            haystack = haystack.lower()
+            needle = needle.lower()
+        while True:
+            idx = haystack.find(needle, offset)
+            if idx < 0:
+                break
+            offsets.append((idx, idx + len(query)))
+            offset = idx + max(1, len(query))
+        return offsets

{pgwidgets_python-0.3.3.dist-info → pgwidgets_python-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgwidgets-python
-Version: 0.3.3
+Version: 0.3.5
 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>=0.2.0
+Requires-Dist: pgwidgets-js>=0.3.4
 Requires-Dist: websockets>=12
 Provides-Extra: dev
 Requires-Dist: sphinx; extra == "dev"

{pgwidgets_python-0.3.3.dist-info → pgwidgets_python-0.3.5.dist-info}/RECORD

@@ -3,22 +3,22 @@ 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=_-rdE5BOYLra8x3BMKv5-QS4Z8YB29DBhUCDsGiB-Gw,18314
+pgwidgets/method_types.py,sha256=kfLBghv0nQFKr4ZrF0VC7MGOEU5qvdbW0PCLPhsrFJg,19462
+pgwidgets/text_model.py,sha256=xlSAoh1ikIG9ZYVwx5wHWrohkGkyu7R6Cbs36_xnbMg,29313
 pgwidgets/async_/Widgets.py,sha256=vld2xkvusBBEVbhbezaJsjBRRj3L7c17Up0pOVs8PGo,723
 pgwidgets/async_/__init__.py,sha256=rXB-v9XRrYt1imYuYikhkzIyiRqaYhlTpQei2LHaQ18,564
-pgwidgets/async_/application.py,sha256=2RJNRerXu5LXG_UcMSi9HWOCAlEOu96TrRaoIcUZ86Q,80957
+pgwidgets/async_/application.py,sha256=VndsY-j1nD_MQjCQz6nugww8hQjJVIwsn6nOpp3qBUA,81438
 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/extras/file_browser.py,sha256=Lkz_n56_YW7rV_k8pmhgZrwulGsujk9vrzv66zgIgec,17347
 pgwidgets/icons/pgw-python-logo.png,sha256=_Rxicp9EKy2Pzz1HtobxEnntSI-y5TtAVPlIzZIsfYs,2428840
 pgwidgets/sync/Widgets.py,sha256=7SaocMVMzFHhi51pjuEAr47Wez90b_a61kDbiv0jOfM,706
 pgwidgets/sync/__init__.py,sha256=SF5RTAvtu8BbYBWzpiCPipy6DJzNXf6nqk9xdvwxUhQ,542
-pgwidgets/sync/application.py,sha256=tcAJvSVdijfT_KBP4llY1tyg2AAmQM-1qocw8Zf51nM,96240
-pgwidgets/sync/widget.py,sha256=yrScNkZB34u0JXn3-kCB-1mPLxLysVbuaPsCjC8kq0E,38343
-pgwidgets_python-0.3.3.dist-info/licenses/LICENSE.md,sha256=LoM3fMTiMnQuHRCJghdjOtjnCrL8soBpu2PFk24Xvyg,1528
-pgwidgets_python-0.3.3.dist-info/METADATA,sha256=zGKe1dIOc9aQaTS5ROZQu5NFO0rXlqfv3FuavZmjKsA,4683
-pgwidgets_python-0.3.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pgwidgets_python-0.3.3.dist-info/scm_file_list.json,sha256=EpRYjywwhXPISys2-onyGmwpWbD6-PyVRKtlpIbaRsM,1943
-pgwidgets_python-0.3.3.dist-info/scm_version.json,sha256=QuXBS8rkNOzsOyOLL_7d599vXJRfhJZxVPwFnAqG4fk,160
-pgwidgets_python-0.3.3.dist-info/top_level.txt,sha256=wwL6fBq0gU-JwzlM6TdduY1qYpu39ysqnnbQT-1bqAs,10
-pgwidgets_python-0.3.3.dist-info/RECORD,,
+pgwidgets/sync/application.py,sha256=_2VG9h8tJjZZBD3x1oLA216jN8CxAYt0_fECwwcmx5k,97313
+pgwidgets/sync/text_source.py,sha256=Vz8mJsQXLFOAVwZCOrAXSixNfYQHjYZxxAIZjWBCAnY,8341
+pgwidgets/sync/widget.py,sha256=Kw2CQFOaa7rfroKfn0MwNwXT-PjoecqCErav5BEc0UI,38652
+pgwidgets_python-0.3.5.dist-info/licenses/LICENSE.md,sha256=LoM3fMTiMnQuHRCJghdjOtjnCrL8soBpu2PFk24Xvyg,1528
+pgwidgets_python-0.3.5.dist-info/METADATA,sha256=QpifhF0maJe_O5ECaHL4pd-IaPI2Sd2GT5hL8_cDOao,4683
+pgwidgets_python-0.3.5.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pgwidgets_python-0.3.5.dist-info/top_level.txt,sha256=wwL6fBq0gU-JwzlM6TdduY1qYpu39ysqnnbQT-1bqAs,10
+pgwidgets_python-0.3.5.dist-info/RECORD,,

{pgwidgets_python-0.3.3.dist-info → pgwidgets_python-0.3.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pgwidgets_python-0.3.3.dist-info/scm_file_list.json

@@ -1,68 +0,0 @@
-{
-  "files": [
-    ".flake8",
-    "test_pg2.py",
-    "README.md",
-    "pyproject.toml",
-    "LICENSE.md",
-    ".readthedocs.yaml",
-    ".gitignore",
-    "docs/web-servers.rst",
-    "docs/WhatsNew.rst",
-    "docs/subclassing.rst",
-    "docs/sync.rst",
-    "docs/utilities.rst",
-    "docs/extras.rst",
-    "docs/async.rst",
-    "docs/architecture.rst",
-    "docs/widgets.rst",
-    "docs/conf.py",
-    "docs/Makefile",
-    "docs/index.rst",
-    "docs/callbacks.rst",
-    "docs/getting-started.rst",
-    "docs/api/async.rst",
-    "docs/api/sync.rst",
-    "docs/api/index.rst",
-    "tests/test_protocol.py",
-    "tests/__init__.py",
-    "tests/test_stateful.py",
-    "tests/test_resolve_kwargs.py",
-    "tests/test_async_session.py",
-    "tests/test_defs.py",
-    "tests/test_fonts.py",
-    "tests/test_session.py",
-    "tests/test_extras.py",
-    "tests/test_widget_classes.py",
-    "tests/test_reconstruct.py",
-    "pgwidgets/_json.py",
-    "pgwidgets/__init__.py",
-    "pgwidgets/callbacks.py",
-    "pgwidgets/method_types.py",
-    "pgwidgets/buffer.py",
-    "pgwidgets/defs.py",
-    "pgwidgets/sync/Widgets.py",
-    "pgwidgets/sync/__init__.py",
-    "pgwidgets/sync/application.py",
-    "pgwidgets/sync/widget.py",
-    "pgwidgets/extras/__init__.py",
-    "pgwidgets/extras/file_browser.py",
-    "pgwidgets/icons/pgw-python-logo.png",
-    "pgwidgets/async_/Widgets.py",
-    "pgwidgets/async_/application.py",
-    "pgwidgets/async_/__init__.py",
-    "pgwidgets/async_/widget.py",
-    "examples/demo_sync.py",
-    "examples/all_widgets.py",
-    "examples/all_widgets_async.py",
-    "examples/README.md",
-    "examples/demo_treeview.py",
-    "examples/demo_async.py",
-    "examples/flask-multi-process/server.py",
-    "examples/flask-multi-process/README.md",
-    "examples/flask-multi-process/nginx.conf",
-    "examples/flask-multi-process/gunicorn.conf.py",
-    "examples/flask-multi-process/user_app.py",
-    ".github/workflows/tests.yml"
-  ]
-}

pgwidgets_python-0.3.3.dist-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.3.3",
-  "distance": 0,
-  "node": "g522f05596d51c6b3f6f671895e54ec014515d3c7",
-  "dirty": false,
-  "branch": "main",
-  "node_date": "2026-06-25"
-}