wapyt 0.2.0.dev2__tar.gz → 0.3.0__tar.gz

{wapyt-0.2.0.dev2 → wapyt-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wapyt
-Version: 0.2.0.dev2
+Version: 0.3.0
 Summary: DHTMLX-free pyTincture widgetset: layouts, forms, tables, trees, chat, terminal, menus, Kanban and more, declared in Python and rendered in the browser.
 License: MIT
 Project-URL: homepage, https://github.com/WAwesome-AI/wa_pytincture_widgetset

{wapyt-0.2.0.dev2 → wapyt-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wapyt"
-version = "0.2.0.dev2"
+version = "0.3.0"
 description = "DHTMLX-free pyTincture widgetset: layouts, forms, tables, trees, chat, terminal, menus, Kanban and more, declared in Python and rendered in the browser."
 readme = "README.md"
 license = { text = "MIT" }

wapyt-0.3.0/tests/test_config_none.py

@@ -0,0 +1,74 @@
+"""Every config follows one None convention: unset means "not sent"."""
+from __future__ import annotations
+
+import dataclasses
+import importlib
+import inspect
+import pkgutil
+
+import pytest
+
+import wapyt
+from wapyt._config import drop_none
+
+# Fields whose None means "none" (hide it), so JS must see null. Keep short.
+ALLOWED_NULLS = {
+    ("FormConfig", "cancelText"),
+    ("FormConfig", "submitText"),
+    ("SidebarConfig", "title"),
+}
+
+# Classes that cannot be built from defaults alone get minimal arguments.
+ARGS = {
+    "MenuItem": {"id": "m"},
+    "ScheduleItem": {"id": "s", "start": "2026-10-08T09:00"},
+}
+
+
+def _config_classes():
+    for info in pkgutil.walk_packages(wapyt.__path__, "wapyt."):
+        module = importlib.import_module(info.name)
+        for name, cls in inspect.getmembers(module, inspect.isclass):
+            if cls.__module__ == module.__name__ and dataclasses.is_dataclass(cls) and hasattr(cls, "to_dict"):
+                yield cls
+
+
+def _build(cls):
+    if cls.__name__ in ARGS:
+        return cls(**ARGS[cls.__name__])
+    required = {
+        f.name: "x"
+        for f in dataclasses.fields(cls)
+        if f.init and f.default is dataclasses.MISSING and f.default_factory is dataclasses.MISSING
+    }
+    return cls(**required)
+
+
+def _nulls(value, path=""):
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if item is None:
+                yield path + key
+            else:
+                yield from _nulls(item, f"{path}{key}.")
+    elif isinstance(value, list):
+        for index, item in enumerate(value):
+            yield from _nulls(item, f"{path}[{index}].")
+
+
+CLASSES = sorted(set(_config_classes()), key=lambda c: (c.__module__, c.__name__))
+
+
+def test_found_the_configs():
+    assert len(CLASSES) > 40
+
+
+@pytest.mark.parametrize("cls", CLASSES, ids=lambda c: c.__name__)
+def test_defaults_send_no_nulls(cls):
+    payload = _build(cls).to_dict()
+    unexpected = [p for p in _nulls(payload) if (cls.__name__, p) not in ALLOWED_NULLS]
+    assert unexpected == []
+
+
+def test_drop_none_is_shallow():
+    assert drop_none({"a": None, "b": 0, "c": False, "d": {"e": None}}) == {"b": 0, "c": False, "d": {"e": None}}

{wapyt-0.2.0.dev2 → wapyt-0.3.0}/tests/test_new_widget_configs.py

@@ -56,6 +56,11 @@ def test_terminal_clipboard_is_on_by_default_and_can_be_turned_off():
     assert roundtrip(TerminalConfig(clipboard=False))["clipboard"] is False
 
 
+def test_terminal_osc52_is_on_by_default_and_can_be_turned_off():
+    assert roundtrip(TerminalConfig())["osc52"] is True
+    assert roundtrip(TerminalConfig(osc52=False))["osc52"] is False
+
+
 def test_terminal_extra_passes_through():
     payload = roundtrip(TerminalConfig(extra={"customFlag": 7}))
     assert payload["customFlag"] == 7

wapyt-0.3.0/tests/test_quiet_imports.py

@@ -0,0 +1,18 @@
+"""Importing a widget module must not write to stdout or log above DEBUG."""
+import importlib
+import logging
+import sys
+
+import pytest
+
+MODULES = ["wapyt.chat.chat", "wapyt.cardpanel.cardpanel"]
+
+
+@pytest.mark.parametrize("name", MODULES)
+def test_import_is_quiet(name, capsys, caplog):
+    sys.modules.pop(name, None)
+    with caplog.at_level(logging.INFO):
+        importlib.import_module(name)
+    out = capsys.readouterr()
+    assert out.out == "" and out.err == ""
+    assert not [r for r in caplog.records if r.name == name]

wapyt-0.3.0/tests/test_theme_system.py

@@ -0,0 +1,64 @@
+"""
+wapyt.setTheme in layout.js: "system" follows prefers-color-scheme. Run the
+real script under Node with a fake document and matchMedia (skipped when
+node is missing).
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+SCRIPT = Path(__file__).resolve().parents[1] / "wapyt" / "assets" / "layout.js"
+
+HARNESS = """
+const attrs = {};
+globalThis.document = { documentElement: {
+  setAttribute: (k, v) => { attrs[k] = String(v); },
+  getAttribute: (k) => (k in attrs ? attrs[k] : null),
+} };
+const listeners = [];
+const query = { matches: process.argv[2] === "dark",
+  addEventListener: (type, fn) => listeners.push(fn) };
+globalThis.matchMedia = () => query;
+require("vm").runInThisContext(require("fs").readFileSync(process.argv[1], "utf8"));
+const log = [];
+const snap = (label) => log.push([label, attrs["data-wapyt-theme"], attrs["data-wapyt-theme-mode"],
+  globalThis.wapyt.getTheme()]);
+const osTo = (dark) => { query.matches = dark; listeners.forEach((fn) => fn({ matches: dark })); };
+for (const step of JSON.parse(process.argv[3])) {
+  if (step[0] === "set") globalThis.wapyt.setTheme(step[1]);
+  else osTo(step[1] === "dark");
+  snap(step.join(" "));
+}
+console.log(JSON.stringify(log));
+"""
+
+
+def run(os_scheme: str, steps):
+    node = shutil.which("node")
+    if not node:
+        pytest.skip("node is not installed")
+    out = subprocess.run([node, "-e", HARNESS, str(SCRIPT), os_scheme, json.dumps(steps)],
+                         capture_output=True, text=True, check=True)
+    return [(theme, mode, info) for _label, theme, mode, info in json.loads(out.stdout)]
+
+
+def test_system_resolves_and_follows_the_os():
+    result = run("dark", [["set", "system"], ["os", "light"], ["os", "dark"]])
+    assert [r[0] for r in result] == ["dark", "light", "dark"]
+    assert all(r[1] == "system" for r in result)
+    assert result[1][2] == {"mode": "system", "resolved": "light"}
+
+
+def test_explicit_theme_ignores_the_os():
+    result = run("light", [["set", "system"], ["set", "light"], ["os", "dark"]])
+    assert result[-1][:2] == ("light", "light")
+
+
+def test_back_to_system_picks_up_the_current_os_setting():
+    result = run("light", [["set", "dark"], ["os", "light"], ["set", "System"]])
+    assert result[-1][:2] == ("light", "system")

wapyt-0.3.0/tests/test_themeeditor.py

@@ -0,0 +1,120 @@
+"""ThemeEditor config, theme validation and the wrapper's calls."""
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace
+
+import pytest
+
+import wapyt.themeeditor.themeeditor as te_module
+from wapyt import ThemeEditor, ThemeEditorConfig, ThemePalette
+from wapyt.themeeditor import check_theme
+from wapyt.themeeditor.themeeditor_config import normalize_hex
+
+
+def test_default_config():
+    assert ThemeEditorConfig().to_dict() == {
+        "previewMode": True, "apply": True, "showShape": True, "showFont": True,
+        "showExport": True, "title": "Theme",
+    }
+
+
+def test_title_none_is_sent_as_null():
+    assert ThemeEditorConfig(title=None).to_dict()["title"] is None
+
+
+def test_palettes_mix_built_ins_and_custom():
+    brand = ThemePalette("brand", "Brand", light={"accent": "#0A7"}, dark={"accent": "#0c9"})
+    payload = ThemeEditorConfig(palettes=["default", brand], value={"palette": "brand"}).to_dict()
+    assert payload["palettes"] == ["default", {"id": "brand", "label": "Brand",
+                                               "light": {"accent": "#00aa77"}, "dark": {"accent": "#00cc99"}}]
+    assert payload["value"]["palette"] == "brand"
+
+
+@pytest.mark.parametrize("palettes, message", [
+    (["nope"], "unknown palette"),
+    ([], "at least one"),
+    ([ThemePalette("ocean")], "built-in"),
+    ([ThemePalette("x", light={"shadow": "#000"})], "unknown theme token"),
+])
+def test_bad_palettes(palettes, message):
+    with pytest.raises(ValueError, match=message):
+        ThemeEditorConfig(palettes=palettes).to_dict()
+
+
+def test_bad_mode():
+    with pytest.raises(ValueError):
+        ThemeEditorConfig(mode="sepia").to_dict()
+
+
+def test_check_theme_normalises():
+    assert check_theme({"palette": "forest", "dark": {"text": "#FFF"}, "radius": 7.6}) == {
+        "palette": "forest", "light": {}, "dark": {"text": "#ffffff"}, "radius": 8, "font": "system"}
+    assert check_theme(None)["palette"] == "default"
+
+
+@pytest.mark.parametrize("theme, message", [
+    ({"palette": "mystery"}, "unknown palette"),
+    ({"light": {"accent": "blue"}}, "not a hex"),
+    ({"light": {"glow": "#000"}}, "unknown theme token"),
+    ({"radius": 40}, "radius"),
+    ({"radius": True}, "radius"),
+    ({"colours": {}}, "unknown theme keys"),
+])
+def test_check_theme_rejects(theme, message):
+    with pytest.raises(ValueError, match=message):
+        check_theme(theme)
+
+
+def test_custom_palette_ids_are_accepted_when_named():
+    assert check_theme({"palette": "brand"}, ["brand"])["palette"] == "brand"
+
+
+@pytest.mark.parametrize("raw, hex_", [("#ABC", "#aabbcc"), ("123456", "#123456"), (" #0f0f0f ", "#0f0f0f")])
+def test_normalize_hex(raw, hex_):
+    assert normalize_hex(raw) == hex_
+
+
+class FakeEditor:
+    def __init__(self):
+        self.calls = []
+
+    def __getattr__(self, name):
+        return lambda *args: self.calls.append((name, args)) or {"palette": "default"}
+
+
+@pytest.fixture
+def editor(monkeypatch):
+    monkeypatch.setattr(te_module, "_to_js", lambda value: json.loads(json.dumps(value)))
+    w = object.__new__(ThemeEditor)
+    w.config = ThemeEditorConfig(palettes=["default", ThemePalette("brand")])
+    w.editor = FakeEditor()
+    return w
+
+
+def test_set_theme_validates_then_calls_js(editor):
+    editor.set_theme({"palette": "brand", "light": {"accent": "#ABC"}})
+    name, (theme, opts) = editor.editor.calls[-1]
+    assert name == "setTheme" and theme["light"] == {"accent": "#aabbcc"} and opts == {"silent": False}
+    with pytest.raises(ValueError):
+        editor.set_theme({"palette": "unknown"})
+
+
+def test_set_mode_checks_its_argument(editor):
+    editor.set_mode("dark")
+    assert editor.editor.calls[-1] == ("setMode", ("dark",))
+    with pytest.raises(ValueError):
+        editor.set_mode("dusk")
+
+
+def test_apply_theme_registers_palettes(monkeypatch):
+    calls = []
+    ns = SimpleNamespace(registerPalette=lambda spec: calls.append(("register", spec)),
+                         apply=lambda theme: calls.append(("apply", theme)) or theme)
+    monkeypatch.setattr(te_module, "_theme_js", lambda: ns)
+    monkeypatch.setattr(te_module, "_to_js", lambda value: value)
+    result = te_module.apply_theme({"palette": "brand"}, palettes=[ThemePalette("brand", light={"accent": "#000"})])
+    assert calls[0][0] == "register" and calls[1][0] == "apply"
+    assert result["palette"] == "brand"
+    te_module.apply_theme(None)
+    assert calls[-1] == ("apply", None)

wapyt-0.3.0/tests/test_themeeditor_js.py

@@ -0,0 +1,112 @@
+"""
+The theme model in themeeditor.js, run under Node (skipped without node):
+it must agree with the Python lists and with wapyt.css, and every built-in
+palette must meet its own contrast targets.
+"""
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from wapyt.themeeditor import FONTS, PALETTES, THEME_TOKENS
+
+ASSETS = Path(__file__).resolve().parents[1] / "wapyt" / "assets"
+
+HARNESS = r"""
+globalThis.document = { documentElement: { style: { setProperty(){}, removeProperty(){} },
+  setAttribute(){}, removeAttribute(){}, getAttribute(){ return null; } } };
+require("vm").runInThisContext(require("fs").readFileSync(process.argv[1], "utf8"));
+const T = globalThis.wapyt.theme;
+const accents = ["#2563eb", "#0e7490", "#facc15", "#ff00ff", "#111111", "#eeeeee", "#16a34a", "#9333ea"];
+const derived = {};
+for (const a of accents) for (const m of ["light", "dark"]) {
+  const d = T.deriveAccent(a, m);
+  derived[a + "/" + m] = { ...d, ratio: T.contrast(a, d["on-accent"]) };
+}
+console.log(JSON.stringify({
+  tokens: T.TOKENS.map((t) => ({ key: t.key, light: t.light, dark: t.dark, on: t.on || null, min: t.min || null })),
+  fonts: T.FONTS.map((f) => f.id),
+  palettes: T.palettes().map((p) => ({ id: p.id, ...T.resolve({ palette: p.id }) })),
+  defaults: T.DEFAULT,
+  normalized: T.normalize({ palette: "nope", light: { accent: "#ABC", bogus: "#000", text: "red" }, radius: 99 }),
+  ratioWhiteBlack: T.contrast("#ffffff", "#000000"),
+  derived,
+}));
+"""
+
+
+@pytest.fixture(scope="module")
+def model():
+    node = shutil.which("node")
+    if not node:
+        pytest.skip("node is not installed")
+    out = subprocess.run([node, "-e", HARNESS, str(ASSETS / "themeeditor.js")],
+                         capture_output=True, text=True, check=True)
+    return json.loads(out.stdout)
+
+
+def _lum(hex_):
+    def ch(v):
+        c = int(v, 16) / 255
+        return c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4
+    r, g, b = (ch(hex_[i:i + 2]) for i in (1, 3, 5))
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+
+def ratio(a, b):
+    hi, lo = sorted((_lum(a), _lum(b)), reverse=True)
+    return (hi + 0.05) / (lo + 0.05)
+
+
+def test_lists_match_python(model):
+    assert [t["key"] for t in model["tokens"]] == THEME_TOKENS
+    assert [p["id"] for p in model["palettes"]] == PALETTES
+    assert model["fonts"] == FONTS
+
+
+def test_defaults_match_the_stylesheet(model):
+    css = (ASSETS / "wapyt.css").read_text()
+    root = css[css.index(":root {"):css.index("}", css.index(":root {"))]
+    declared = dict(re.findall(r"(--wapyt-[a-z-]+):\s*(#[0-9a-fA-F]{6})", root))
+    for tok in model["tokens"]:
+        for mode in ("light", "dark"):
+            assert declared[tok[mode]].lower() == model["defaults"][mode][tok["key"]], (tok["key"], mode)
+    assert "--wapyt-radius: 6px" in root
+
+
+def test_contrast_maths(model):
+    assert round(model["ratioWhiteBlack"], 2) == 21.0
+
+
+@pytest.mark.parametrize("mode", ["light", "dark"])
+def test_built_in_palettes_meet_their_targets(model, mode):
+    failures = []
+    for p in model["palettes"]:
+        v = p[mode]
+        for tok in model["tokens"]:
+            if not tok["on"] or tok["on"] == "tint":
+                continue
+            r = ratio(v[tok["key"]], v[tok["on"]])
+            if r < tok["min"]:
+                failures.append(f"{p['id']}/{mode}: {tok['key']} on {tok['on']} = {r:.2f} < {tok['min']}")
+        r = ratio(v["text"], v["surface"])
+        if r < 4.5:
+            failures.append(f"{p['id']}/{mode}: text on surface = {r:.2f}")
+    assert failures == []
+
+
+def test_normalize_drops_bad_values(model):
+    n = model["normalized"]
+    assert n["palette"] == "default"
+    assert n["light"] == {"accent": "#aabbcc"}
+    assert n["radius"] == 24
+
+
+def test_derived_accent_text_is_readable(model):
+    assert all(d["ratio"] >= 4.5 for d in model["derived"].values()), {
+        k: round(d["ratio"], 2) for k, d in model["derived"].items() if d["ratio"] < 4.5}

wapyt-0.3.0/tests/test_widget_base.py

@@ -0,0 +1,220 @@
+"""WidgetBase: event binding, payload conversion and proxy release."""
+from __future__ import annotations
+
+import asyncio
+import datetime as dt
+from types import SimpleNamespace
+
+import pytest
+
+import wapyt._base as base
+from wapyt import (
+    CardPanel, Chart, Chat, ContextMenu, DataTable, Form, Kanban, Listbox,
+    MediaPlayer, MenuBar, ModalWindow, Pagination, Popup, ProgressBar,
+    ResourceBoard, Scheduler, Sidebar, TabWidget, Terminal, ThemeEditor, Toolbar, Tree, Window,
+)
+from wapyt._base import WidgetBase, resolve_root
+
+
+class FakeProxy:
+    def __init__(self, fn):
+        self.fn = fn
+        self.destroyed = False
+
+    def __call__(self, *args):
+        assert not self.destroyed, "called a destroyed proxy"
+        return self.fn(*args)
+
+    def destroy(self):
+        self.destroyed = True
+
+
+class FakeJsWidget:
+    """Stands in for a JS widget: on/off/emit/destroy."""
+
+    def __init__(self):
+        self.listeners = {}
+        self.destroyed = False
+        self.closed = False
+
+    def on(self, event, handler):
+        self.listeners.setdefault(event, []).append(handler)
+
+    def off(self, event, handler):
+        self.listeners[event].remove(handler)
+
+    def emit(self, event, *args):
+        return [h(*args) for h in self.listeners.get(event, [])]
+
+    def destroy(self):
+        self.destroyed = True
+
+    def close(self):
+        self.closed = True
+
+
+class JsNull:  # what to_plain recognises by type name
+    pass
+
+
+class Demo(WidgetBase):
+    _js_attr = "thing"
+
+
+@pytest.fixture(autouse=True)
+def fake_proxies(monkeypatch):
+    monkeypatch.setattr(base, "create_proxy", FakeProxy)
+
+
+def make(cls=Demo):
+    widget = object.__new__(cls)  # no __init__, like the Form tests
+    setattr(widget, cls._js_attr, FakeJsWidget())
+    return widget
+
+
+def test_payload_is_converted():
+    w = make()
+    seen = []
+    w._bind_event("select", seen.append)
+    w.thing.emit("select", {"id": JsNull(), "items": [JsNull()]})
+    assert seen == [{"id": None, "items": [None]}]
+
+
+def test_no_argument_event_calls_handler_without_arguments():
+    # CardPanel emits "add" with nothing.
+    w = make()
+    calls = []
+    w._bind_event("add", lambda: calls.append("add"))
+    w.thing.emit("add")
+    assert calls == ["add"]
+
+
+def test_return_value_goes_back_to_js():
+    # Chat marks an event handled when a listener returns True.
+    w = make()
+    w._bind_event("send", lambda payload: True)
+    assert w.thing.emit("send", {}) == [True]
+
+
+def test_async_handler_is_scheduled():
+    w = make()
+    done = []
+
+    async def handler(payload):
+        done.append(payload)
+
+    async def main():
+        w._bind_event("change", handler)
+        assert w.thing.emit("change", 7) == [None]
+        await asyncio.sleep(0)
+
+    asyncio.run(main())
+    assert done == [7]
+
+
+def test_every_handler_is_kept():
+    w = make()
+    seen = []
+    w._bind_event("select", lambda p: seen.append(("a", p)))
+    w._bind_event("select", lambda p: seen.append(("b", p)))
+    w.thing.emit("select", 1)
+    assert seen == [("a", 1), ("b", 1)]
+    assert len(w._proxies["select"]) == 2
+
+
+def test_dispose_destroys_widget_then_unhooks_and_destroys_proxies():
+    w = make()
+    w._bind_event("a", lambda p: None)
+    w._bind_event("b", lambda p: None)
+    proxies = [p for ps in w._proxies.values() for p in ps]
+    w._dispose()
+    assert w.thing.destroyed
+    assert all(p.destroyed for p in proxies)
+    assert w.thing.listeners == {"a": [], "b": []}
+    assert w._proxies == {}
+    # A late event (a socket closing after destroy) reaches nothing.
+    assert w.thing.emit("a", 1) == []
+
+
+def test_release_happens_even_if_js_destroy_fails():
+    w = make()
+    w._bind_event("a", lambda p: None)
+    proxy = w._proxies["a"][0]
+
+    def boom():
+        raise RuntimeError("js failed")
+
+    w.thing.destroy = boom
+    with pytest.raises(RuntimeError):
+        w._dispose()
+    assert proxy.destroyed and w._proxies == {}
+
+
+def test_release_without_off_still_destroys_proxies():
+    w = object.__new__(Demo)
+    w.thing = SimpleNamespace(on=lambda event, handler: None)
+    w._bind_event("a", lambda p: None)
+    proxy = w._proxies["a"][0]
+    w._release_proxies()
+    assert proxy.destroyed
+
+
+def test_resolve_root(monkeypatch):
+    cell = SimpleNamespace(getContainer=lambda: "cell-el")
+    assert resolve_root(cell, None) == "cell-el"
+    assert resolve_root(SimpleNamespace(element="wrapped-el"), None) == "wrapped-el"
+    found = {"#a": None, "a": "by-id"}
+    document = SimpleNamespace(
+        querySelector=lambda sel: found.get(sel),
+        getElementById=lambda id_: found.get(id_),
+    )
+    monkeypatch.setattr(base._runtime, "js", SimpleNamespace(document=document))
+    assert resolve_root(None, "a") == "by-id"
+    element = object()
+    assert resolve_root(None, element) is element
+
+
+def test_scheduler_payloads_become_dates():
+    w = make(Scheduler)
+    seen = []
+    w._bind_event("move", seen.append)
+    w.scheduler.emit("move", {"start": "2026-10-08T09:30", "end": "2026-10-08T10:00"})
+    assert seen[0]["start"] == dt.datetime(2026, 10, 8, 9, 30)
+
+
+WITH_DESTROY = [
+    CardPanel, Chart, Chat, ContextMenu, DataTable, Kanban, Listbox, MediaPlayer,
+    MenuBar, Pagination, Popup, ProgressBar, Scheduler, Sidebar, Terminal, ThemeEditor, Toolbar, Tree,
+]
+WITH_CLOSE = [ModalWindow, Window]
+ALL = WITH_DESTROY + WITH_CLOSE + [Form, ResourceBoard, TabWidget]
+
+
+@pytest.mark.parametrize("cls", ALL, ids=lambda c: c.__name__)
+def test_widget_binds_through_the_base(cls):
+    assert issubclass(cls, WidgetBase) and cls._js_attr
+    w = make(cls)
+    seen = []
+    w._bind_event("x", seen.append)
+    getattr(w, cls._js_attr).emit("x", {"v": JsNull()})
+    assert seen == [{"v": None}]
+
+
+@pytest.mark.parametrize("cls", WITH_DESTROY, ids=lambda c: c.__name__)
+def test_destroy_releases_handlers(cls):
+    w = make(cls)
+    w._bind_event("x", lambda p: None)
+    proxy = w._proxies["x"][0]
+    w.destroy()
+    assert getattr(w, cls._js_attr).destroyed
+    assert proxy.destroyed and w._proxies == {}
+
+
+@pytest.mark.parametrize("cls", WITH_CLOSE, ids=lambda c: c.__name__)
+def test_close_releases_handlers(cls):
+    w = make(cls)
+    w._bind_event("x", lambda p: None)
+    proxy = w._proxies["x"][0]
+    w.close()
+    assert getattr(w, cls._js_attr).closed
+    assert proxy.destroyed and w._proxies == {}

{wapyt-0.2.0.dev2 → wapyt-0.3.0}/wapyt/__init__.py

@@ -7,7 +7,7 @@ import re as _re
 __widgetset__ = "wapyt"
 # A plain string literal: pytincture reads it by parsing this file, and it must
 # match pyproject.toml and the asset manifest (CI and the release workflow check).
-__version__ = "0.2.0.dev2"
+__version__ = "0.3.0"
 # The numeric release part only, so pre-releases ("0.2.0.dev0", "0.2.0rc1")
 # do not break `int()`.
 __version_tuple__ = tuple(int(part) for part in _re.match(r"\d+(?:\.\d+)*", __version__).group(0).split("."))
@@ -41,6 +41,7 @@ from .contextmenu.contextmenu import ContextMenu
 from .progressbar.progressbar import ProgressBar
 from .progressbar.progressbar_config import ProgressBarConfig, progress_html
 from .pagination.pagination import Pagination, page_slice
+from .themeeditor import ThemeEditor, ThemeEditorConfig, ThemePalette, apply_theme, restore_theme, current_theme
 from .pagination.pagination_config import PaginationConfig
 from .contextmenu.contextmenu_config import ContextMenuConfig, MenuItem
 from .menubar.menubar import MenuBar
@@ -128,6 +129,12 @@ __all__ = [
     "ProgressBarConfig",
     "progress_html",
     "Pagination",
+    "ThemeEditor",
+    "ThemeEditorConfig",
+    "ThemePalette",
+    "apply_theme",
+    "restore_theme",
+    "current_theme",
     "PaginationConfig",
     "page_slice",
     "ContextMenuConfig",