wapyt 0.1.0__tar.gz → 0.2.0.dev1__tar.gz

wapyt-0.2.0.dev1/MANIFEST.in

@@ -0,0 +1,2 @@
+include wapyt/pytincture-assets.json
+recursive-include wapyt/assets *

{wapyt-0.1.0 → wapyt-0.2.0.dev1}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: wapyt
-Version: 0.1.0
-Summary: DHTMLX-free PyTincture widgetset with layout, chat, card panel, and tab widgets.
+Version: 0.2.0.dev1
+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/schapman1974/wA_pytincture_widgetset
+Project-URL: homepage, https://github.com/WAwesome-AI/wa_pytincture_widgetset
+Project-URL: documentation, https://github.com/WAwesome-AI/wa_pytincture_widgetset/wiki
+Project-URL: changelog, https://github.com/WAwesome-AI/wa_pytincture_widgetset/wiki/Widget-Catalog#changes
 Keywords: pytincture,widgetset,pyodide,wapyt
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
-Requires-Dist: pyodide-py>=0.28.0
-Requires-Dist: itsdangerous>=2.2.0
 
 # wA PyTincture Widgetset (`wapyt`)
 
-`wapyt` is a lightweight widgetset for [pyTincture](https://github.com/schapman1974/pytincture) that avoids the commercial DHTMLX dependency used by the legacy package. It focuses on a DOM-driven layout engine and a set of first-class widgets that can be composed entirely from Python when running inside Pyodide.
+`wapyt` is a lightweight widgetset for [pyTincture](https://github.com/pytincture/pytincture) that avoids the commercial DHTMLX dependency used by the legacy package. It focuses on a DOM-driven layout engine and a set of first-class widgets that can be composed entirely from Python when running inside Pyodide.
 
 ## Highlights
 - **Theme-aware layout**: Flexbox-based layout manager that mirrors the familiar `LayoutConfig`/`CellConfig` API, supports nested rows/columns, and exposes helper methods such as `attach_html`, `collapse`, `toggle`, `hide`, etc.
@@ -26,9 +26,18 @@ Requires-Dist: itsdangerous>=2.2.0
 - `Chat`: Streaming chat surface with agent metadata, artifact events, and helpers for incremental responses.
 - `CardPanel`: Searchable, template-driven card grid with add/view/action callbacks and custom renderers.
 - `TabWidget`: Lightweight tab host that supports badges, closable tabs, and attaching HTML or PyTincture components per tab.
-- `Sidebar`: Collapsible navigation rail with badges, icons, and selection events for driving the rest of your layout.
+- `Sidebar`: Collapsible navigation rail with icons, badges, nested groups (a flyout when collapsed), headings, separators and a spacer for bottom-pinned items; keyboard navigable.
 - `ModalWindow`: Simple modal shell that can host arbitrary Layout instances or HTML snippets.
 - `ResourceBoard`: Master/detail resource explorer with selectable rows, action hooks, and optional add button wiring.
+- `message`: Toasts plus awaitable `alert` / `confirm` / `prompt` dialogs, styled and themed, in place of `window.confirm()`.
+- `Toolbar`: Buttons, toggles, one-of-several groups, text, separators and spacers, dropping to icons when space runs out.
+- `ContextMenu`: Right-click menus with icons, shortcut hints, danger and disabled items, checkable and radio items, separators and submenus; keyboard accessible.
+- `MenuBar`: A File / Edit / View application menu whose titles open ContextMenu dropdowns; full menubar keyboard model.
+- `Kanban`: A board of Listbox columns with counts, WIP limits (optionally strict), add-card buttons, collapsible and reorderable columns, a board-wide filter and selection.
+- `Listbox`: Rich list items (fields or an escaped template) that can host live widgets, with actions, selection, a filter, and pointer and keyboard drag-and-drop within and between lists; the base for Kanban.
+- `Popup` and tooltips: An anchored popover for pickers, help and small forms; styled, keyboard-reachable tooltips that replace native `title` text across the widgets.
+- `ProgressBar` / `progress_html`: Determinate or indeterminate bars with active/done/error/paused states, as a live widget or static markup.
+- `Pagination`: First/previous/next/last, a page box or numbered buttons, a page-size selector and a "1–50 of 1,234" summary; copes with totals the server could not count.
 
 ## Runtime Architecture
 - Layouts and widgets are declared in Python but render as DOM nodes through the JavaScript bundles under `wapyt/assets/`. Each helper (e.g., `Layout.add_chat`) forwards config dictionaries directly to the matching JS constructor.
@@ -72,7 +81,16 @@ wapyt/
 
 - The JavaScript bundles define the `window.wapyt` namespace and are evaluated automatically by PyTincture’s loader (see `pytincture/frontend/pytincture.js`).
 - Layout styles live in `assets/wapyt.css`; adjust tokens there to integrate with your design system.
-- The tests are intentionally small, framework-free PyTincture apps so you can copy/paste into your own projects.
+- Message content is rendered by the escaping markdown renderer in `assets/chat.js`. If a page also loads
+  [`marked`](https://marked.js.org/), the widget uses it **only** when `DOMPurify` is present as well —
+  `marked` passes raw HTML through, so without a sanitizer the widget falls back to its own renderer.
+- Artifact previews run in `<iframe sandbox="allow-scripts">` with no `allow-same-origin`: artifact code is
+  treated as untrusted and cannot reach the host page.
+- `tests/` holds two different things: the `*_demo.py` files are small, framework-free PyTincture apps you can
+  copy/paste into your own projects, and `test_*.py` are CPython unit tests for the pure-Python half of the
+  widgetset. Run the latter with `uv run --group dev pytest tests/` (or `pytest tests/` in an activated venv);
+  they need no browser and no demo dependencies, and `tests/conftest.py` puts the repo root on `sys.path` so
+  they work from a fresh clone.
 
 ## License
 

{wapyt-0.1.0 → wapyt-0.2.0.dev1}/README.md

@@ -1,6 +1,6 @@
 # wA PyTincture Widgetset (`wapyt`)
 
-`wapyt` is a lightweight widgetset for [pyTincture](https://github.com/schapman1974/pytincture) that avoids the commercial DHTMLX dependency used by the legacy package. It focuses on a DOM-driven layout engine and a set of first-class widgets that can be composed entirely from Python when running inside Pyodide.
+`wapyt` is a lightweight widgetset for [pyTincture](https://github.com/pytincture/pytincture) that avoids the commercial DHTMLX dependency used by the legacy package. It focuses on a DOM-driven layout engine and a set of first-class widgets that can be composed entirely from Python when running inside Pyodide.
 
 ## Highlights
 - **Theme-aware layout**: Flexbox-based layout manager that mirrors the familiar `LayoutConfig`/`CellConfig` API, supports nested rows/columns, and exposes helper methods such as `attach_html`, `collapse`, `toggle`, `hide`, etc.
@@ -14,9 +14,18 @@
 - `Chat`: Streaming chat surface with agent metadata, artifact events, and helpers for incremental responses.
 - `CardPanel`: Searchable, template-driven card grid with add/view/action callbacks and custom renderers.
 - `TabWidget`: Lightweight tab host that supports badges, closable tabs, and attaching HTML or PyTincture components per tab.
-- `Sidebar`: Collapsible navigation rail with badges, icons, and selection events for driving the rest of your layout.
+- `Sidebar`: Collapsible navigation rail with icons, badges, nested groups (a flyout when collapsed), headings, separators and a spacer for bottom-pinned items; keyboard navigable.
 - `ModalWindow`: Simple modal shell that can host arbitrary Layout instances or HTML snippets.
 - `ResourceBoard`: Master/detail resource explorer with selectable rows, action hooks, and optional add button wiring.
+- `message`: Toasts plus awaitable `alert` / `confirm` / `prompt` dialogs, styled and themed, in place of `window.confirm()`.
+- `Toolbar`: Buttons, toggles, one-of-several groups, text, separators and spacers, dropping to icons when space runs out.
+- `ContextMenu`: Right-click menus with icons, shortcut hints, danger and disabled items, checkable and radio items, separators and submenus; keyboard accessible.
+- `MenuBar`: A File / Edit / View application menu whose titles open ContextMenu dropdowns; full menubar keyboard model.
+- `Kanban`: A board of Listbox columns with counts, WIP limits (optionally strict), add-card buttons, collapsible and reorderable columns, a board-wide filter and selection.
+- `Listbox`: Rich list items (fields or an escaped template) that can host live widgets, with actions, selection, a filter, and pointer and keyboard drag-and-drop within and between lists; the base for Kanban.
+- `Popup` and tooltips: An anchored popover for pickers, help and small forms; styled, keyboard-reachable tooltips that replace native `title` text across the widgets.
+- `ProgressBar` / `progress_html`: Determinate or indeterminate bars with active/done/error/paused states, as a live widget or static markup.
+- `Pagination`: First/previous/next/last, a page box or numbered buttons, a page-size selector and a "1–50 of 1,234" summary; copes with totals the server could not count.
 
 ## Runtime Architecture
 - Layouts and widgets are declared in Python but render as DOM nodes through the JavaScript bundles under `wapyt/assets/`. Each helper (e.g., `Layout.add_chat`) forwards config dictionaries directly to the matching JS constructor.
@@ -60,7 +69,16 @@ wapyt/
 
 - The JavaScript bundles define the `window.wapyt` namespace and are evaluated automatically by PyTincture’s loader (see `pytincture/frontend/pytincture.js`).
 - Layout styles live in `assets/wapyt.css`; adjust tokens there to integrate with your design system.
-- The tests are intentionally small, framework-free PyTincture apps so you can copy/paste into your own projects.
+- Message content is rendered by the escaping markdown renderer in `assets/chat.js`. If a page also loads
+  [`marked`](https://marked.js.org/), the widget uses it **only** when `DOMPurify` is present as well —
+  `marked` passes raw HTML through, so without a sanitizer the widget falls back to its own renderer.
+- Artifact previews run in `<iframe sandbox="allow-scripts">` with no `allow-same-origin`: artifact code is
+  treated as untrusted and cannot reach the host page.
+- `tests/` holds two different things: the `*_demo.py` files are small, framework-free PyTincture apps you can
+  copy/paste into your own projects, and `test_*.py` are CPython unit tests for the pure-Python half of the
+  widgetset. Run the latter with `uv run --group dev pytest tests/` (or `pytest tests/` in an activated venv);
+  they need no browser and no demo dependencies, and `tests/conftest.py` puts the repo root on `sys.path` so
+  they work from a fresh clone.
 
 ## License
 

wapyt-0.2.0.dev1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wapyt"
+version = "0.2.0.dev1"
+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" }
+requires-python = ">=3.13"
+keywords = ["pytincture", "widgetset", "pyodide", "wapyt"]
+# No runtime dependencies: `pyodide.ffi` is provided by the Pyodide runtime itself
+# (soft-imported in _runtime.py), not by the `pyodide-py` distribution. Declaring
+# either here forces micropip to resolve them in the browser at install time.
+dependencies = []
+
+[project.urls]
+homepage = "https://github.com/WAwesome-AI/wa_pytincture_widgetset"
+documentation = "https://github.com/WAwesome-AI/wa_pytincture_widgetset/wiki"
+changelog = "https://github.com/WAwesome-AI/wa_pytincture_widgetset/wiki/Widget-Catalog#changes"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+# Only wapyt: without this, tests/ (demo apps and unit tests) was packed as a
+# top-level `tests` package and installed into site-packages.
+include = ["wapyt*"]

wapyt-0.2.0.dev1/tests/test_chart.py

@@ -0,0 +1,63 @@
+"""CPython tests for the Chart config (no browser needed)."""
+from __future__ import annotations
+
+import pytest
+
+import wapyt
+from wapyt import ChartConfig, ChartDataset
+
+
+def test_exported_with_a_layout_helper():
+    from wapyt.layout.layout import Layout
+    assert {"Chart", "ChartConfig", "ChartDataset"} <= set(wapyt.__all__)
+    assert hasattr(Layout, "add_chart")
+
+
+def test_defaults_are_minimal():
+    assert ChartConfig().to_dict() == {"type": "line", "labels": [], "datasets": [], "legend": "auto"}
+    assert ChartDataset("a", [1, 2]).to_dict() == {"label": "a", "data": [1, 2]}
+
+
+def test_options_are_camel_cased():
+    payload = ChartConfig(type="bar", labels=["Q1"], datasets=[ChartDataset("x", [1], color="#123456")],
+                          title="T", legend="bottom", stacked=True, horizontal=True, x_label="Quarter",
+                          y_label="$", y_min=0, y_max=10, begin_at_zero=False, value_prefix="$", decimals=1,
+                          compact=True, animation=False, resize_delay=80, height=240, table_toggle=True,
+                          aria_label="Rev", options={"plugins": {"legend": {"align": "end"}}}).to_dict()
+    assert payload["format"] == {"prefix": "$", "decimals": 1, "compact": True}
+    assert (payload["stacked"], payload["horizontal"], payload["beginAtZero"], payload["animation"]) == (True, True, False, False)
+    assert (payload["resizeDelay"], payload["height"], payload["tableToggle"]) == (80, 240, True)
+    assert payload["options"] == {"plugins": {"legend": {"align": "end"}}}
+
+
+def test_dataset_options():
+    payload = ChartDataset("t", [1, None], type="line", fill=True, tension=0.3, stack="a", dashed=True,
+                           point_radius=0, hidden=True).to_dict()
+    assert payload == {"label": "t", "data": [1, None], "type": "line", "fill": True, "tension": 0.3,
+                       "stack": "a", "dashed": True, "pointRadius": 0, "hidden": True}
+
+
+@pytest.mark.parametrize("bad", [dict(type="gauge"), dict(legend="middle"), dict(type="line", horizontal=True),
+                                 dict(type="pie", stacked=True)])
+def test_invalid_configs(bad):
+    with pytest.raises(ValueError):
+        ChartConfig(**bad).to_dict()
+
+
+def test_legend_false_means_none():
+    assert ChartConfig(legend=False).to_dict()["legend"] == "none"
+
+
+def test_more_series_than_palette_colours_is_refused():
+    series = [ChartDataset(f"s{i}", [i]) for i in range(9)]
+    with pytest.raises(ValueError, match="palette has 8"):
+        ChartConfig(datasets=series).to_dict()
+    coloured = series[:8] + [ChartDataset("s8", [8], color="#777777")]
+    ChartConfig(datasets=coloured).to_dict()
+
+
+def test_pie_slices_beyond_the_palette_need_colours():
+    labels = [f"l{i}" for i in range(9)]
+    with pytest.raises(ValueError, match="9 slices"):
+        ChartConfig(type="pie", labels=labels, datasets=[ChartDataset("x", list(range(9)))]).to_dict()
+    ChartConfig(type="pie", labels=labels, datasets=[ChartDataset("x", list(range(9)), colors=["#111111"] * 9)]).to_dict()

wapyt-0.2.0.dev1/tests/test_chat_stream.py

@@ -0,0 +1,236 @@
+"""
+Unit tests for `Chat`'s stream consumption.
+
+These cover the Python side of the backend -> widget boundary: how chunks from
+a streaming proxy (see `multiaiproxy.py`) are turned into text, how in-band
+provider errors surface, and how the coroutine is scheduled under Pyodide.
+
+No browser is involved. `Chat.__init__` requires the Pyodide runtime, so the
+tests drive a subclass that replaces only the two JS-facing methods the stream
+helpers call.
+"""
+import asyncio
+
+import pytest
+
+from wapyt.chat import chat as chat_module
+from wapyt.chat.chat import Chat, ChatStreamError
+
+
+class FakeChat(Chat):
+    """
+    A `Chat` with the JS bridge stubbed out.
+
+    Bypasses `Chat.__init__` (which needs `js.wapyt.ChatWidget`) and records
+    what the real widget would have been told to render.
+    """
+
+    def __init__(self) -> None:  # noqa: D107 - deliberately skips super()
+        self.appended: list[str] = []
+        self.finished = 0
+
+    def append_stream(self, message_id: str, chunk: str) -> None:
+        self.appended.append(chunk)
+
+    def finish_stream(self, message_id: str, final_chunk=None) -> None:
+        self.finished += 1
+
+    @property
+    def text(self) -> str:
+        return "".join(self.appended)
+
+
+@pytest.fixture
+def chat() -> FakeChat:
+    return FakeChat()
+
+
+def openai_chunk(text: str) -> dict:
+    """A LiteLLM/OpenAI-shaped content chunk."""
+    return {"choices": [{"delta": {"content": text}}]}
+
+
+# ---------------------------------------------------------------------------
+# Text extraction
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("chunk", "expected"),
+    [
+        (openai_chunk("hi"), "hi"),
+        ({"type": "chunk", "chunk": {"choices": [{"delta": {"content": "hi"}}]}}, "hi"),
+        # `content.delta` used to return "" unconditionally, which dropped the
+        # entire response from any proxy that forwards provider chunks as-is.
+        ({"type": "content.delta", "delta": {"text": "hi"}}, "hi"),
+        ({"type": "content.delta", "delta": {"content": "hi"}}, "hi"),
+        ({"type": "content.delta", "delta": "hi"}, "hi"),
+        ({"type": "response.output_text.delta", "delta": {"text": "hi"}}, "hi"),
+        ({"type": "response.output_text.delta", "delta": "hi"}, "hi"),
+        ("hi", "hi"),
+        (None, ""),
+        ({}, ""),
+        ({"choices": []}, ""),
+    ],
+)
+def test_extract_stream_text(chunk, expected):
+    assert Chat.extract_stream_text(chunk) == expected
+
+
+def test_content_delta_is_assembled_in_order(chat):
+    chat.consume_stream(
+        "msg",
+        [
+            {"type": "content.delta", "delta": {"text": "He"}},
+            {"type": "content.delta", "delta": {"content": "llo"}},
+            {"type": "response.output_text.delta", "delta": "!"},
+        ],
+    )
+    assert chat.text == "Hello!"
+    assert chat.finished == 1
+
+
+# ---------------------------------------------------------------------------
+# In-band provider errors
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("chunk", "expected"),
+    [
+        ({"error": {"message": "boom", "type": "provider_error"}}, "boom"),
+        ({"error": {"detail": "boom"}}, "boom"),
+        ({"error": {"code": "stream_error"}}, "stream_error"),
+        ({"error": "boom"}, "boom"),
+        ({"type": "error", "message": "boom"}, "boom"),
+        ({"error": {}}, "Unknown backend error"),
+        (openai_chunk("hi"), None),
+        ({}, None),
+        ("plain text", None),
+        (None, None),
+    ],
+)
+def test_extract_stream_error(chunk, expected):
+    assert Chat.extract_stream_error(chunk) == expected
+
+
+def test_error_chunk_keeps_partial_text_and_closes_stream(chat):
+    chat.consume_stream(
+        "msg",
+        [
+            openai_chunk("partial "),
+            {"error": {"message": "Model 'x' is not supported."}},
+            openai_chunk("never reached"),
+        ],
+    )
+    assert chat.text == "partial Backend error: Model 'x' is not supported."
+    assert chat.finished == 1
+
+
+def test_error_chunk_reaches_on_error_hook(chat):
+    seen: list[Exception] = []
+
+    chat.consume_stream("msg", [{"error": "boom"}], on_error=seen.append)
+
+    assert len(seen) == 1
+    assert isinstance(seen[0], ChatStreamError)
+    assert str(seen[0]) == "boom"
+    # A custom hook owns the presentation, so nothing is written by default.
+    assert chat.text == ""
+
+
+def test_transport_exception_still_reaches_on_error(chat):
+    def exploding():
+        yield openai_chunk("partial ")
+        raise ConnectionError("socket closed")
+
+    seen: list[Exception] = []
+    chat.consume_stream("msg", exploding(), on_error=seen.append)
+
+    assert chat.text == "partial "
+    assert isinstance(seen[0], ConnectionError)
+
+
+# ---------------------------------------------------------------------------
+# Ordinary streaming
+# ---------------------------------------------------------------------------
+
+
+def test_sync_stream_appends_and_finishes(chat):
+    chat.consume_stream("msg", [openai_chunk("a"), openai_chunk("b")])
+    assert chat.text == "ab"
+    assert chat.finished == 1
+
+
+def test_finish_false_leaves_stream_open(chat):
+    chat.consume_stream("msg", [openai_chunk("a")], finish=False)
+    assert chat.text == "a"
+    assert chat.finished == 0
+
+
+def test_custom_parser_overrides_extraction(chat):
+    chat.consume_stream("msg", [{"raw": "a"}, {"raw": "b"}], parser=lambda c: c["raw"])
+    assert chat.text == "ab"
+
+
+def test_non_iterable_stream_is_rejected(chat):
+    with pytest.raises(ValueError, match="iterable"):
+        chat.consume_stream("msg", 42)
+
+
+# ---------------------------------------------------------------------------
+# Scheduling (item: asyncio.run must never run under Pyodide)
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def browser_loop(monkeypatch):
+    """
+    Stand in for Pyodide: a `js` module is importable and an event loop is the
+    current loop, but nothing is *running* — the state a synchronous JS event
+    handler sees. `asyncio.run` would create and close a second loop here,
+    permanently breaking Pyodide's WebLoop, so it is made fatal.
+    """
+
+    def forbidden(*args, **kwargs):
+        raise AssertionError("asyncio.run() must not be called under Pyodide")
+
+    monkeypatch.setattr(chat_module, "js", object())
+    monkeypatch.setattr(asyncio, "run", forbidden)
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        yield loop
+    finally:
+        asyncio.set_event_loop(None)
+        loop.close()
+
+
+def test_async_stream_is_scheduled_not_blocked(chat, browser_loop):
+    async def agen():
+        for token in ("x", "y"):
+            yield openai_chunk(token)
+
+    chat.consume_stream("msg", agen())
+
+    # consume_stream returns immediately; the browser drives the coroutine.
+    assert chat.text == ""
+
+    browser_loop.run_until_complete(asyncio.sleep(0))
+    assert chat.text == "xy"
+    assert chat.finished == 1
+
+
+def test_async_error_chunk_reaches_on_error(chat, browser_loop):
+    async def agen():
+        yield openai_chunk("partial ")
+        yield {"error": {"message": "upstream died"}}
+
+    seen: list[Exception] = []
+    chat.consume_stream("msg", agen(), on_error=seen.append)
+    browser_loop.run_until_complete(asyncio.sleep(0))
+
+    assert chat.text == "partial "
+    assert isinstance(seen[0], ChatStreamError)
+    assert str(seen[0]) == "upstream died"

wapyt-0.2.0.dev1/tests/test_contextmenu.py

@@ -0,0 +1,64 @@
+"""CPython tests for the ContextMenu config (no browser needed)."""
+from __future__ import annotations
+
+import pytest
+
+from wapyt import ContextMenuConfig, MenuItem
+
+
+def test_exported():
+    import wapyt
+
+    assert {"ContextMenu", "ContextMenuConfig", "MenuItem"} <= set(wapyt.__all__)
+
+
+def test_item_defaults_are_minimal():
+    assert MenuItem("open").to_dict() == {"id": "open"}
+
+
+def test_item_options_are_serialised():
+    assert MenuItem("del", "Delete", "mdi-delete", shortcut="Del", danger=True, disabled=True).to_dict() == {
+        "id": "del", "label": "Delete", "icon": "mdi-delete", "shortcut": "Del",
+        "danger": True, "disabled": True,
+    }
+
+
+def test_separator_ignores_everything_else():
+    assert MenuItem("x", "X", separator=True).to_dict() == {"separator": True}
+    assert MenuItem(separator=True).to_dict() == {"separator": True}
+
+
+def test_item_needs_an_id():
+    with pytest.raises(ValueError, match="needs an id"):
+        MenuItem(label="Nameless").to_dict()
+
+
+def test_submenus_nest():
+    payload = MenuItem("share", "Share", items=[MenuItem("link"), MenuItem("email")]).to_dict()
+    assert payload["items"] == [{"id": "link"}, {"id": "email"}]
+
+
+def test_duplicate_ids_are_rejected_across_submenus():
+    config = ContextMenuConfig(items=[
+        MenuItem("copy"),
+        MenuItem("share", items=[MenuItem("copy")]),
+        MenuItem(separator=True),
+    ])
+    with pytest.raises(ValueError, match="duplicate menu item ids: copy"):
+        config.to_dict()
+
+
+def test_config_payload():
+    payload = ContextMenuConfig(items=[MenuItem("a"), MenuItem(separator=True)], label="Rows").to_dict()
+    assert payload == {"items": [{"id": "a"}, {"separator": True}], "label": "Rows"}
+
+
+def test_payload_jsnull_becomes_none():
+    from wapyt._runtime import to_plain as _plain
+
+    class JsNull:
+        pass
+
+    assert _plain({"id": "a", "context": JsNull(), "target": "row-1"}) == {
+        "id": "a", "context": None, "target": "row-1",
+    }

wapyt-0.2.0.dev1/tests/test_datatable_classes.py

@@ -0,0 +1,20 @@
+"""CPython tests for DataTable row/cell classes and hidden columns (no browser needed)."""
+from __future__ import annotations
+
+from wapyt import ColumnConfig, DataTableConfig
+from wapyt.datatable.datatable import DataTable
+
+
+def test_new_keys_only_sent_when_set():
+    assert not {"hidden", "css", "cellClassBy"} & set(ColumnConfig(id="a").to_dict())
+    assert "rowClassBy" not in DataTableConfig().to_dict()
+
+
+def test_payloads():
+    column = ColumnConfig(id="due", hidden=True, css="num col-due", cell_class_by="due_class").to_dict()
+    assert column["hidden"] is True and column["css"] == "num col-due" and column["cellClassBy"] == "due_class"
+    assert DataTableConfig(row_class_by="status_class").to_dict()["rowClassBy"] == "status_class"
+
+
+def test_wrapper_has_hidden_column_api():
+    assert all(hasattr(DataTable, n) for n in ("hide_column", "show_column", "set_column_hidden", "is_column_hidden"))

wapyt-0.2.0.dev1/tests/test_datatable_csv.py

@@ -0,0 +1,23 @@
+"""CPython tests for DataTable CSV export options (no browser needed)."""
+from __future__ import annotations
+
+import pytest
+
+from wapyt.datatable.datatable import DataTable
+
+
+def test_wrapper_has_csv_api():
+    assert hasattr(DataTable, "to_csv") and hasattr(DataTable, "export_csv")
+
+
+def test_csv_options_payload():
+    opts = DataTable._csv_opts(True, ["a", "b"], True, False, False, ";")
+    assert opts == {"selectedOnly": True, "columns": ["a", "b"], "raw": True, "header": False,
+                    "safe": False, "delimiter": ";"}
+    assert DataTable._csv_opts(False, None, False, True, True, ",")["columns"] is None
+
+
+@pytest.mark.parametrize("bad", ["", ";;", '"', "\n"])
+def test_bad_delimiters(bad):
+    with pytest.raises(ValueError, match="delimiter"):
+        DataTable._csv_opts(False, None, False, True, True, bad)

wapyt-0.2.0.dev1/tests/test_datatable_editing.py

@@ -0,0 +1,36 @@
+"""CPython tests for editable DataTable columns (no browser needed)."""
+from __future__ import annotations
+
+import pytest
+
+from wapyt import ColumnConfig
+
+
+def test_editing_keys_only_sent_when_set():
+    payload = ColumnConfig(id="name").to_dict()
+    assert not {"editable", "editor", "options", "required"} & set(payload)
+
+
+def test_editable_column_payload():
+    payload = ColumnConfig(id="status", editable=True, editor="select", required=True,
+                           options=["open", {"value": "done", "label": "Done"}]).to_dict()
+    assert payload["editable"] is True and payload["editor"] == "select" and payload["required"] is True
+    assert payload["options"] == ["open", {"value": "done", "label": "Done"}]
+
+
+@pytest.mark.parametrize("editor", ["text", "number", "checkbox", "date"])
+def test_editors_accepted(editor):
+    assert ColumnConfig(id="c", editable=True, editor=editor).to_dict()["editor"] == editor
+
+
+def test_bad_editor_and_select_without_options():
+    with pytest.raises(ValueError, match="editor must be one of"):
+        ColumnConfig(id="c", editable=True, editor="textarea").to_dict()
+    with pytest.raises(ValueError, match="needs options"):
+        ColumnConfig(id="c", editable=True, editor="select").to_dict()
+
+
+def test_wrapper_has_editing_api():
+    from wapyt.datatable.datatable import DataTable
+
+    assert all(hasattr(DataTable, n) for n in ("on_edit", "set_cell", "set_cell_error", "edit_cell", "cancel_edit"))

wapyt-0.2.0.dev1/tests/test_datatable_frozen.py

@@ -0,0 +1,11 @@
+"""CPython tests for DataTable frozen columns (no browser needed)."""
+from __future__ import annotations
+
+
+def test_frozen_columns_payload():
+    from wapyt import DataTableConfig
+    from wapyt.datatable.datatable import DataTable
+
+    assert "frozenColumns" not in DataTableConfig().to_dict()
+    assert DataTableConfig(frozen_columns=2).to_dict()["frozenColumns"] == 2
+    assert hasattr(DataTable, "set_frozen_columns")