wapyt 0.2.0.dev2__tar.gz → 0.3.1__tar.gz

wapyt-0.3.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 wapyt contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wapyt
-Version: 0.2.0.dev2
+Version: 0.3.1
 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
@@ -9,6 +9,8 @@ Project-URL: changelog, https://github.com/WAwesome-AI/wa_pytincture_widgetset/w
 Keywords: pytincture,widgetset,pyodide,wapyt
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
 
 # wA PyTincture Widgetset (`wapyt`)
 
@@ -95,4 +97,4 @@ wapyt/
 
 ## License
 
-MIT – see `pyproject.toml` for details.
+MIT – see [`LICENSE`](LICENSE).

{wapyt-0.2.0.dev2 → wapyt-0.3.1}/README.md

@@ -83,4 +83,4 @@ wapyt/
 
 ## License
 
-MIT – see `pyproject.toml` for details.
+MIT – see [`LICENSE`](LICENSE).

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wapyt"
-version = "0.2.0.dev2"
+version = "0.3.1"
 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.1/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.1}/tests/test_modal_events.py

@@ -6,3 +6,10 @@ from wapyt.modal.modal import ModalWindow
 
 def test_modal_has_event_api():
     assert all(hasattr(ModalWindow, name) for name in ("on_show", "on_hide", "on_close", "is_visible"))
+
+
+def test_backdrop_click_keeps_the_modal_by_default():
+    from wapyt.modal.modal import ModalConfig
+
+    assert ModalConfig().to_dict()["closeOnBackdrop"] is False
+    assert ModalConfig(close_on_backdrop=True).to_dict()["closeOnBackdrop"] is True

{wapyt-0.2.0.dev2 → wapyt-0.3.1}/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.1/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.1/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.1/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.1/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}