table3 0.4.0__tar.gz → 0.5.0__tar.gz

{table3-0.4.0 → table3-0.5.0}/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.5.0 — 2026-11-03
+
+### Added
+
+- In SolveIt, `view()` hides its cell from the AI (SolveIt's red eye), as
+  plot3 does for plots, so the explorer's rows don't fill the model's
+  context. SolveIt hides the cell's code with its output. `view(hide=False)`
+  keeps one cell visible, and `table3.autohide(False)` turns it off for the
+  session. `show()` and printed tables are not hidden. Outside SolveIt
+  nothing changes.
+
+### Changed
+
+- A paged table writes only its first page as styled cells, and every row
+  as compact JSON its script draws into the other pages: about a quarter
+  of the size (a printed 8-column frame of 100 rows, 23 KB instead of
+  86 KB), which matters in SolveIt, where a cell's output goes to the AI.
+  Where scripts don't run, the first page shows. `pages=False` is
+  unchanged.
+
+### Fixed
+
+- The explorer's headers show that they sort before the first click: a
+  faint ↕ beside each name, which turns into ▲ or ▼ on the sorted column,
+  and "Click to sort by …" on hover.
+
 ## 0.4.0 — 2026-11-03
 
 ### Added

{table3-0.4.0/src/table3.egg-info → table3-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table3
-Version: 0.4.0
+Version: 0.5.0
 Summary: Paged, theme-aware tables in notebook output: shared by tidy3, tidy3a and stats3
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT
@@ -65,6 +65,12 @@ table3.view(penguins);
 table3.view(penguins, n=50_000, height=600);  # more rows, a taller grid
 ```
 
+In SolveIt, which sends every cell's code and output to its AI, `view()`
+hides its cell from the AI (the red eye), so the explorer's rows don't fill
+the model's context; the cell's code is hidden with them. `view(hide=False)`
+keeps a cell visible, and `table3.autohide(False)` stops hiding for the
+session.
+
 `show()` and `view()` return what they were given, so they can sit in the
 middle of a pipe.
 As a cell's last line the notebook also prints that value; end the line with

{table3-0.4.0 → table3-0.5.0}/README.md

@@ -40,6 +40,12 @@ table3.view(penguins);
 table3.view(penguins, n=50_000, height=600);  # more rows, a taller grid
 ```
 
+In SolveIt, which sends every cell's code and output to its AI, `view()`
+hides its cell from the AI (the red eye), so the explorer's rows don't fill
+the model's context; the cell's code is hidden with them. `view(hide=False)`
+keeps a cell visible, and `table3.autohide(False)` stops hiding for the
+session.
+
 `show()` and `view()` return what they were given, so they can sit in the
 middle of a pipe.
 As a cell's last line the notebook also prints that value; end the line with

{table3-0.4.0 → table3-0.5.0}/docs/design.md

@@ -76,9 +76,13 @@ significant digits and converting the column would print its type as `str`.
   scripts don't run, the table stays a box `height` pixels tall (default
   300) that scrolls both ways under a pinned header. `pages=False` asks for
   that box everywhere.
-- **Size.** Every cell carries its style, about 100 bytes a cell: 1,000 rows
-  of 12 columns add about 1.2 MB to a saved notebook. The font is set once
-  on the table to halve that.
+- **Size.** A styled cell is about 100 bytes, and SolveIt sends a cell's
+  output to its AI, so a paged table writes only its first page as cells
+  and every row as compact JSON, which its script draws into the other
+  pages (0.5.0): `penguins`, 8 columns of 100 rows, is 23 KB, not 86 KB.
+  Without scripts the first page shows. `pages=False` writes every row as
+  cells, about 1.2 MB for 1,000 rows of 12 columns; the font is set once on
+  the table to halve that.
 
 ## 4. Interface
 

{table3-0.4.0 → table3-0.5.0}/docs/explorer.md

@@ -41,13 +41,22 @@ sort and filters on them.
 sends each search, sort or filter to polars and gets one screen of rows
 back, so it explores any number of rows lazily. It needs a live kernel and
 shows nothing in a saved notebook, and SolveIt's and CRAFT's support for
-widgets is unknown. It would be an optional extra (`table3[explore]`), and a
-probe like the script probe decides whether to build it.
+widgets was unknown. It would be an optional extra (`table3[explore]`), and a
+probe like the script probe decided whether to build it.
+
+Probed 2026-11-03: SolveIt does not draw Jupyter widgets. An anywidget whose
+button sends a click to the kernel printed as its text,
+`<__main__.Probe object at 0x…>`, with no button, so a widget has no kernel
+connection there. The kernel-backed mode is not built: the in-browser
+explorer is the only one, and `n=` is how to explore more rows. A widget
+mode for VS Code and Jupyter alone would split the explorer by notebook, so
+it waits for a need that `n=` can't meet.
 
 ## 3. Interface
 
 ```python
-table3.view(data, *, n=10_000, height=500, digits=None, caption=None)  # shows, returns data
+table3.view(data, *, n=10_000, height=500, digits=None, caption=None, hide=None)  # shows, returns data
+table3.autohide(on=True)  # whether view() hides its cell from SolveIt's AI
 ```
 
 *data* is anything `html()` and `show()` take, `__table3__` objects
@@ -55,6 +64,15 @@ included. It returns *data* unchanged, like `show()`; `;` hides the
 notebook's own print of it. Outside a notebook it prints the first rows as
 `show()` does.
 
+In SolveIt, which sends each cell's code and output to its AI, `view()`
+then marks its cell hidden from the AI (`dialoghelper.update_msg(skipped=1)`,
+SolveIt's red eye), as plot3 does for plots: the rows would fill the
+model's context. SolveIt has no flag for an output alone, so the cell's code
+is hidden too; a `view()` cell is usually one line. `show()` and printed
+tables are not hidden, since most analysis cells end in a frame and hiding
+those would hide their code. `hide=False`, or `autohide(False)` for the
+session, keeps cells visible. Added in 0.5.0.
+
 tidy3 adds `view()` as a verb and method, as `glimpse()`: `penguins >> view()`,
 `view(penguins)`, `penguins.view()`, passing the frame through. It is the
 only bare `view` in the family; tidy3a and stats3 document `table3.view(x)`.
@@ -122,5 +140,6 @@ saying the explorer needs output scripts.
 1. table3 0.4.0: `table3.view()` in the browser (§2, §4–§6).
 2. tidy3: the `view()` verb and method, reference docs, release.
 3. Probe SolveIt and CRAFT for widgets; if they work and in-browser limits
-   bite, a kernel-backed mode as `table3[explore]`.
+   bite, a kernel-backed mode as `table3[explore]`. Done 2026-11-03: SolveIt
+   does not draw widgets (§2), so there is no kernel-backed mode.
 4. tidy3a and stats3: document `table3.view(x)`.

{table3-0.4.0 → table3-0.5.0}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 [project.optional-dependencies]
 # pandas and pyarrow: the pandas input tests.
 dev = ["pytest>=7.0", "ipython>=8.0", "pandas>=2.1.4", "pyarrow>=15.0"]
-# The explorer's script in headless Chromium (tests/test_explorer_browser.py);
+# The explorer's and the pages' scripts in headless Chromium (tests/test_*_browser.py);
 # also run: python -m playwright install chromium
 browser = ["pytest-playwright>=0.5"]
 

{table3-0.4.0 → table3-0.5.0}/src/table3/__init__.py

@@ -26,8 +26,10 @@ import polars as pl
 
 from table3.__version__ import __version__
 from table3._html import table_html
+from table3 import _solveit
+from table3._solveit import autohide
 
-__all__ = ["__version__", "html", "show", "view"]
+__all__ = ["__version__", "autohide", "html", "show", "view"]
 
 
 def _from_pandas(df: Any) -> pl.DataFrame:
@@ -167,6 +169,7 @@ def view(
     height: int = 500,
     digits: int | str | None = None,
     caption: str | None = None,
+    hide: bool | None = None,
 ) -> Any:
     """Open a data explorer over the first *n* rows of *data*, and return *data*.
 
@@ -178,8 +181,16 @@ def view(
     grid's height in pixels; *digits* and *caption* as in ``html()``. Where
     output scripts don't run, it shows the first 100 rows as ``show()``.
     Outside a notebook it prints the first rows.
+
+    In SolveIt, which sends every cell's code and output to its AI, the
+    cell is then hidden from the AI (SolveIt's red eye), so the rows don't
+    fill its context. *hide* says whether to, for this call: ``True`` or
+    ``False``; ``None`` follows ``table3.autohide()``, on by default.
+    SolveIt hides the cell's code with its output.
     """
     _check(n, True, 10, height, digits)
+    if hide is not None and not isinstance(hide, bool):
+        raise TypeError("table3: hide must be True, False or None")
     if height is None:
         raise ValueError("table3: view() height must be a positive integer")
     from table3._explore import explorer_html
@@ -191,5 +202,7 @@ def view(
     )
     if not _display(page):
         print(_text(data, min(n, 20), digits))
+    elif _solveit.AUTOHIDE if hide is None else hide:
+        _solveit.hide_calling_cell()
     return data
 

table3-0.5.0/src/table3/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.5.0"

{table3-0.4.0 → table3-0.5.0}/src/table3/_explore.py

@@ -4,14 +4,13 @@ plain table for notebooks that don't run output scripts (docs/explorer.md)."""
 from __future__ import annotations
 
 import html as _html
-import json
 import math
 import uuid
 
 import polars as pl
 
 from table3._explorer_js import EXPLORER_JS
-from table3._format import dtype_short, float_text
+from table3._format import dtype_short, float_text, json_for_script
 from table3._html import MONO, table_html
 
 CHOICES_MAX = 50  # a text column with at most this many values filters by pick-list
@@ -84,11 +83,6 @@ def payload(df: pl.DataFrame, total: int | None, n: int, digits: int | str | Non
     }
 
 
-def _json_for_script(obj: dict) -> str:
-    # "<" never appears raw, so a value holding "</script>" or "<!--" can't end the block.
-    return json.dumps(obj, ensure_ascii=False, allow_nan=False).replace("<", "\\u003c")
-
-
 def explorer_html(
     df: pl.DataFrame,
     total: int | None,
@@ -114,7 +108,7 @@ def explorer_html(
             f"<div style='font:{MONO};opacity:.85;margin:0 0 4px 0'>"
             f"{_html.escape(caption)}</div>"
         )
-    data = _json_for_script(payload(df, total, n, digits))
+    data = json_for_script(payload(df, total, n, digits))
     return (
         f"<div id='{uid}' data-height='{height}' style='font:{MONO}'>"
         + cap

{table3-0.4.0 → table3-0.5.0}/src/table3/_explorer_js.py

@@ -104,7 +104,7 @@ EXPLORER_JS = r"""
   cols.forEach(function (col, c) {
     var td = document.createElement("td");
     td.style.cssText = cellStyle(c) + ";cursor:pointer;user-select:none";
-    td.title = "Sort by " + col.name;
+    td.title = "Click to sort by " + col.name;
     var arrow = document.createElement("span");
     arrow.style.cssText = "opacity:.55";
     var name = document.createElement("b");
@@ -226,7 +226,10 @@ EXPLORER_JS = r"""
     for (var r = 0; r < rows.length; r++) if (passes(r)) order.push(r);
     if (sortCol >= 0) order.sort(compare);
     arrows.forEach(function (a, c) {
-      a.textContent = c !== sortCol ? "" : sortDir > 0 ? " ▲ " : " ▼ ";
+      // Every header shows it sorts: a faint ↕, and ▲ or ▼ on the sorted one.
+      var on = c === sortCol;
+      a.textContent = !on ? " ↕ " : sortDir > 0 ? " ▲ " : " ▼ ";
+      a.style.opacity = on ? ".9" : ".5";
     });
     var label = order.length.toLocaleString("en-US") + " of " +
       rows.length.toLocaleString("en-US") + " rows | " + ncol + " columns";

{table3-0.4.0 → table3-0.5.0}/src/table3/_format.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import html as _html
+import json
 
 import polars as pl
 
@@ -23,6 +24,15 @@ def cell(v: object) -> str:
     return f"<span title='{_html.escape(text)}'>{short}</span>"
 
 
+def json_for_script(obj: object) -> str:
+    """*obj* as JSON for a ``<script type="application/json">`` block.
+
+    "<" never appears raw, so a value holding "</script>" or "<!--" can't
+    end the block.
+    """
+    return json.dumps(obj, ensure_ascii=False, allow_nan=False).replace("<", "\\u003c")
+
+
 def dtype_short(t: pl.DataType) -> str:
     """Polars-style short dtype name ("i64"); falls back to str(t)."""
     try:

{table3-0.4.0 → table3-0.5.0}/src/table3/_html.py

@@ -7,9 +7,12 @@ colour (``--card``, an HSL triplet) is drawn as a gradient over a plain colour
 taken from VS Code, then JupyterLab, then the browser. Where ``--card`` is
 undefined the gradient drops out alone.
 
-Paging is a script over this table. Where output scripts don't run, the
-table stays a box of fixed height that scrolls down and sideways, with the
-column names and types pinned at the top.
+A paged table writes only its first page as styled cells, and every row
+as compact JSON beside it, which the paging script turns into the other
+pages: styled cells cost about 100 bytes each, and SolveIt sends a cell's
+output to its AI. Where output scripts don't run, the first page shows in a
+box that scrolls sideways under pinned names and types. ``pages=False``
+writes every row as styled cells, in a box of fixed height that scrolls.
 """
 
 from __future__ import annotations
@@ -19,7 +22,7 @@ import uuid
 
 import polars as pl
 
-from table3._format import cell, display_rows, dtype_short, escape
+from table3._format import cell, display_rows, dtype_short, escape, json_for_script
 from table3._pager import PAGER_JS
 
 MONO = "12px ui-monospace,SFMono-Regular,Menlo,Consolas,monospace"
@@ -76,9 +79,11 @@ def table_html(
     types = _tr(
         [escape(dtype_short(t)) for t in df.dtypes], f"{CELL};opacity:.55;{RULE}"
     )
+    rows = display_rows(df, digits)
+    written = rows[:page_size] if pages else rows
     body = [
         _tr([cell(v) for v in row], CELL, ZEBRA if i % 2 else "")
-        for i, row in enumerate(display_rows(df, digits))
+        for i, row in enumerate(written)
     ]
 
     shape = f"shape: ({'?' if total is None else total}, {df.width})"
@@ -94,7 +99,7 @@ def table_html(
         )
 
     root = "<div>"
-    pager = script = ""
+    pager = script = data = ""
     if pages:
         uid = f"table3-{uuid.uuid4().hex}"
         label = _html.escape(pages_label(df.height, total))
@@ -104,6 +109,9 @@ def table_html(
             "</div>"
         )
         script = f"<script>{PAGER_JS.replace('__ID__', uid)}</script>"
+        if len(written) < len(rows):
+            text = [[None if v is None else str(v) for v in row] for row in rows]
+            data = f"<script type='application/json'>{json_for_script(text)}</script>"
     return (
         root
         + cap
@@ -118,8 +126,9 @@ def table_html(
         + "".join(body)
         + "</tbody></table></div>"
         f"<small data-foot style='{small}'>"
-        f"{rows_label(df.height, total)}</small>"
+        f"{rows_label(len(written), total)}</small>"
         + pager
+        + data
         + "</div>"
         + script
     )

{table3-0.4.0 → table3-0.5.0}/src/table3/_pager.py

@@ -1,7 +1,8 @@
 """The script that pages a table3 table in place."""
 
 # Column widths are measured once over all rows, so a column page keeps its
-# columns whichever row page is shown. __ID__ is the table's root element.
+# columns whichever row page is shown. The rows past the first page arrive as
+# JSON and are drawn into the table first. __ID__ is the table's root element.
 PAGER_JS = """
 (function () {
   var root = document.getElementById("__ID__");
@@ -10,6 +11,29 @@ PAGER_JS = """
   var box = root.querySelector("[data-box]");
   var table = box.querySelector("table");
   var head = [].slice.call(table.tHead.rows);
+  // Only the first page is written as cells; the rest come as JSON text,
+  // drawn here with the first page's cell style ("null", cut at 40 as there).
+  var json = root.querySelector("script[type='application/json']");
+  if (json) {
+    var tb = table.tBodies[0], first = tb.rows[0] && tb.rows[0].cells[0];
+    var style = first ? first.getAttribute("style") : "";
+    var esc = function (t) {
+      return t.replace(/[&<>"']/g, function (ch) {
+        return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#x27;" }[ch];
+      });
+    };
+    var cells = "";
+    JSON.parse(json.textContent).forEach(function (row) {
+      cells += "<tr>";
+      row.forEach(function (v) {
+        var t = v === null ? "null" : v, cut = t.length > 40;
+        cells += "<td style='" + style + "'" + (cut ? " title='" + esc(t) + "'" : "") + ">" +
+          esc(cut ? t.slice(0, 39) + "…" : t) + "</td>";
+      });
+      cells += "</tr>";
+    });
+    tb.innerHTML = cells;
+  }
   var body = [].slice.call(table.tBodies[0].rows);
   var foot = root.querySelector("[data-foot]");
   var pager = root.querySelector("[data-pager]");

table3-0.5.0/src/table3/_solveit.py

@@ -0,0 +1,93 @@
+"""Hide the calling cell from SolveIt's AI (its red eye), as plot3 does for plots.
+
+SolveIt sends every cell's code and output to the model. An explorer's rows
+(about 1 MB for 10,000) would fill that context, so ``view()`` marks its
+cell ``skipped``: SolveIt's "hide from prompt", which hides the cell's code
+with its output, as there is no flag for the output alone. Outside SolveIt
+(no dialoghelper) nothing happens. dialoghelper's calls are async in some
+versions and plain in others, and the cell's id must be resolved while the
+cell still runs, so the call completes before ``view()`` returns.
+"""
+
+from __future__ import annotations
+
+import inspect
+from typing import Any
+
+AUTOHIDE = True
+
+
+def autohide(on: bool = True) -> None:
+    """Whether ``view()`` hides its cell from SolveIt's AI when *hide* isn't given."""
+    global AUTOHIDE
+    AUTOHIDE = bool(on)
+
+
+def _msg_id() -> str | None:
+    """The running cell's id where SolveIt puts it (``__msg_id``), or None."""
+    frame = inspect.currentframe()
+    try:
+        f = frame.f_back if frame is not None else None
+        while f is not None:
+            for ns in (f.f_locals, f.f_globals):
+                mid = ns.get("__msg_id") if isinstance(ns, dict) else None
+                if mid:
+                    return str(mid)
+            f = f.f_back
+    finally:
+        del frame
+    try:
+        from IPython import get_ipython
+
+        ns = getattr(get_ipython(), "user_ns", None) or {}
+        mid = ns.get("__msg_id")
+        return str(mid) if mid else None
+    except Exception:
+        return None
+
+
+async def _hide(update_msg: Any, mid: str | None) -> None:
+    # Without an id, update_msg asks SolveIt for the running cell itself.
+    candidates = [mid, mid[1:] if mid.startswith("_") else "_" + mid] if mid else [None]
+    error = None
+    for cand in candidates:
+        try:
+            result = update_msg(id=cand, skipped=1) if cand else update_msg(skipped=1)
+            if inspect.iscoroutine(result):
+                await result
+            return
+        except Exception as e:  # a version that wants the other id form
+            error = e
+    raise RuntimeError(error)
+
+
+def hide_calling_cell() -> None:
+    """Mark the running SolveIt cell hidden from the AI; a no-op elsewhere."""
+    try:
+        from dialoghelper.core import update_msg
+    except Exception:
+        return
+    coro = _hide(update_msg, _msg_id())
+    try:
+        import asyncio
+
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+        if loop is None:
+            asyncio.run(coro)
+            return
+        try:
+            import nest_asyncio
+
+            nest_asyncio.apply()
+            loop.run_until_complete(coro)
+        except ImportError:
+            import concurrent.futures
+
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+                pool.submit(asyncio.run, coro).result()
+    except Exception as e:
+        print(f"table3: could not hide this cell from SolveIt's AI ({e}); "
+              "view(hide=False) or table3.autohide(False) skips trying")

{table3-0.4.0 → table3-0.5.0/src/table3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: table3
-Version: 0.4.0
+Version: 0.5.0
 Summary: Paged, theme-aware tables in notebook output: shared by tidy3, tidy3a and stats3
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT
@@ -65,6 +65,12 @@ table3.view(penguins);
 table3.view(penguins, n=50_000, height=600);  # more rows, a taller grid
 ```
 
+In SolveIt, which sends every cell's code and output to its AI, `view()`
+hides its cell from the AI (the red eye), so the explorer's rows don't fill
+the model's context; the cell's code is hidden with them. `view(hide=False)`
+keeps a cell visible, and `table3.autohide(False)` stops hiding for the
+session.
+
 `show()` and `view()` return what they were given, so they can sit in the
 middle of a pipe.
 As a cell's last line the notebook also prints that value; end the line with

{table3-0.4.0 → table3-0.5.0}/src/table3.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/table3/_explorer_js.py
 src/table3/_format.py
 src/table3/_html.py
 src/table3/_pager.py
+src/table3/_solveit.py
 src/table3/py.typed
 src/table3.egg-info/PKG-INFO
 src/table3.egg-info/SOURCES.txt
@@ -20,4 +21,6 @@ src/table3.egg-info/requires.txt
 src/table3.egg-info/top_level.txt
 tests/test_explore.py
 tests/test_explorer_browser.py
+tests/test_pager_browser.py
+tests/test_solveit.py
 tests/test_table3.py

{table3-0.4.0 → table3-0.5.0}/tests/test_explorer_browser.py

@@ -67,7 +67,7 @@ def _wait_status(page, start: str) -> None:
 
 
 def _header(page, name: str):
-    return page.locator(f"[data-grid] td[title='Sort by {name}']")
+    return page.locator(f"[data-grid] td[title='Click to sort by {name}']")
 
 
 random.seed(1)
@@ -101,6 +101,22 @@ def test_sort_cycles_and_keeps_row_numbers(explore):
     assert _rows(page)[:3] == [1, 2, 3]
 
 
+def _arrows(page) -> list[str]:
+    return [t.strip() for t in page.eval_on_selector_all(
+        "[data-grid] thead tr:first-child td span", "ss => ss.map(s => s.textContent)")]
+
+
+def test_every_header_shows_it_sorts(explore):
+    page = explore(FRAME)
+    assert _arrows(page) == ["↕"] * 5  # before any click
+    _header(page, "species").click()
+    assert _arrows(page) == ["↕", "▲", "↕", "↕", "↕"]
+    _header(page, "species").click()
+    assert _arrows(page)[1] == "▼"
+    _header(page, "species").click()
+    assert _arrows(page) == ["↕"] * 5
+
+
 def test_nulls_sort_last_both_ways(explore):
     page = explore(FRAME)
     for _ in range(2):

table3-0.5.0/tests/test_pager_browser.py

@@ -0,0 +1,88 @@
+"""The paged table's script, driven in headless Chromium: rows past the first
+page arrive as JSON and are drawn before paging. Skipped without Playwright."""
+
+import polars as pl
+import pytest
+
+import table3
+
+sync_api = pytest.importorskip("playwright.sync_api")
+
+
+@pytest.fixture(scope="module")
+def browser():
+    with sync_api.sync_playwright() as p:
+        try:
+            b = p.chromium.launch()
+        except Exception as e:  # no Chromium installed for Playwright
+            pytest.skip(f"no headless Chromium: {e}")
+        yield b
+        b.close()
+
+
+@pytest.fixture
+def show(browser):
+    pages = []
+
+    def _open(df, width=900, **options):
+        page = browser.new_page(viewport={"width": width, "height": 700})
+        pages.append(page)
+        page.set_content(f"<!doctype html><html><body>{table3.html(df, **options)}</body></html>")
+        return page
+
+    yield _open
+    for page in pages:
+        page.close()
+
+
+def _visible(page) -> list[list[str]]:
+    return page.eval_on_selector_all(
+        "tbody tr", "trs => trs.filter(t => t.style.display !== 'none')"
+        ".map(t => [...t.cells].filter(c => c.style.display !== 'none').map(c => c.textContent))")
+
+
+def _foot(page) -> str:
+    return page.eval_on_selector("[data-foot]", "f => f.textContent")
+
+
+def _click(page, text: str) -> None:
+    page.locator("[data-pager] button", has_text=text).first.click()
+
+
+FRAME = pl.DataFrame({"i": range(35), "s": [f"row {k}" for k in range(35)]})
+
+
+def test_pages_drawn_from_json(show):
+    page = show(FRAME)
+    assert page.eval_on_selector_all("tbody tr", "trs => trs.length") == 35
+    assert _foot(page) == "1–10 of 35 rows"
+    assert [r[0] for r in _visible(page)] == [str(k) for k in range(10)]
+    _click(page, "Next")
+    assert _foot(page) == "11–20 of 35 rows"
+    assert _visible(page)[0] == ["10", "row 10"]
+    _click(page, "4")
+    assert [r[0] for r in _visible(page)] == ["30", "31", "32", "33", "34"]
+
+
+def test_drawn_rows_keep_the_formatting(show):
+    df = pl.DataFrame({"f": [1.0] * 10 + [3.3000000000000003, None],
+                       "s": ["x"] * 10 + ["<b>" + "y" * 60, "ok"]})
+    page = show(df)
+    _click(page, "Next")
+    assert _visible(page) == [["3.3", "<b>" + "y" * 36 + "…"], ["null", "ok"]]
+    cut = page.locator("tbody tr").nth(10).locator("td").nth(1)
+    assert cut.get_attribute("title") == "<b>" + "y" * 60
+    assert cut.get_attribute("style") == page.locator("tbody td").first.get_attribute("style")
+    assert page.locator("tbody b").count() == 0
+
+
+def test_column_pages_over_drawn_rows(show):
+    wide = pl.DataFrame({f"column_{c}": [f"value {r}-{c}" for r in range(25)] for c in range(12)})
+    page = show(wide, width=600)
+    foot = _foot(page)
+    assert foot.startswith("1–10 of 25 rows | 1–") and foot.endswith(" of 12 columns")
+    shown = len(_visible(page)[0])
+    _click(page, "columns ▸")
+    assert _visible(page)[0][0] == f"value 0-{shown}"
+    _click(page, "Next")
+    assert _visible(page)[0][0] == f"value 10-{shown}"

table3-0.5.0/tests/test_solveit.py

@@ -0,0 +1,110 @@
+"""view() hides its cell from SolveIt's AI, through a stand-in dialoghelper."""
+
+import sys
+import types
+
+import polars as pl
+import pytest
+
+import table3
+
+DF = pl.DataFrame({"x": range(5)})
+
+
+class Shell:
+    def __init__(self, user_ns):
+        self.user_ns = user_ns
+
+
+@pytest.fixture
+def solveit(monkeypatch):
+    """A notebook with SolveIt's dialoghelper: records each update_msg call."""
+    import IPython
+    import IPython.display
+
+    calls, user_ns = [], {"__msg_id": "_abc123"}
+
+    async def update_msg(id=None, **fields):
+        calls.append((id, fields))
+
+    core = types.ModuleType("dialoghelper.core")
+    core.update_msg = update_msg
+    package = types.ModuleType("dialoghelper")
+    package.core = core
+    monkeypatch.setitem(sys.modules, "dialoghelper", package)
+    monkeypatch.setitem(sys.modules, "dialoghelper.core", core)
+    monkeypatch.setattr(IPython, "get_ipython", lambda: Shell(user_ns))
+    monkeypatch.setattr(IPython.display, "display", lambda obj: None)
+    monkeypatch.setattr(table3._solveit, "AUTOHIDE", True)
+    return types.SimpleNamespace(calls=calls, user_ns=user_ns, core=core)
+
+
+def test_view_hides_its_cell(solveit):
+    assert table3.view(DF) is DF
+    assert solveit.calls == [("_abc123", {"skipped": 1})]
+
+
+def test_without_an_id_solveit_finds_the_cell(solveit):
+    del solveit.user_ns["__msg_id"]
+    table3.view(DF)
+    assert solveit.calls == [(None, {"skipped": 1})]
+
+
+def test_a_plain_update_msg_works_too(solveit):
+    solveit.core.update_msg = lambda id=None, **fields: solveit.calls.append((id, fields))
+    table3.view(DF)
+    assert solveit.calls == [("_abc123", {"skipped": 1})]
+
+
+def test_the_other_id_form_is_tried(solveit):
+    async def update_msg(id=None, **fields):
+        if id.startswith("_"):
+            raise KeyError(id)
+        solveit.calls.append((id, fields))
+
+    solveit.core.update_msg = update_msg
+    table3.view(DF)
+    assert solveit.calls == [("abc123", {"skipped": 1})]
+
+
+def test_hide_and_autohide(solveit):
+    table3.view(DF, hide=False)
+    assert solveit.calls == []
+    table3.autohide(False)
+    try:
+        table3.view(DF)
+        assert solveit.calls == []
+        table3.view(DF, hide=True)
+        assert len(solveit.calls) == 1
+    finally:
+        table3.autohide(True)
+
+
+def test_show_never_hides(solveit):
+    table3.show(DF)
+    assert solveit.calls == []
+
+
+def test_a_failure_is_reported_not_raised(solveit, capsys):
+    async def update_msg(id=None, **fields):
+        raise ConnectionError("no SolveIt")
+
+    solveit.core.update_msg = update_msg
+    assert table3.view(DF) is DF
+    assert "could not hide this cell" in capsys.readouterr().out
+
+
+def test_nothing_outside_solveit(monkeypatch, capsys):
+    import IPython
+    import IPython.display
+
+    monkeypatch.setitem(sys.modules, "dialoghelper", None)  # import fails
+    monkeypatch.setattr(IPython, "get_ipython", lambda: Shell({}))
+    monkeypatch.setattr(IPython.display, "display", lambda obj: None)
+    assert table3.view(DF) is DF
+    assert capsys.readouterr().out == ""
+
+
+def test_hide_checked():
+    with pytest.raises(TypeError, match="hide"):
+        table3.view(DF, hide="yes")

{table3-0.4.0 → table3-0.5.0}/tests/test_table3.py

@@ -1,3 +1,4 @@
+import json
 import re
 
 import polars as pl
@@ -7,7 +8,14 @@ import table3
 
 
 def _body_rows(html: str) -> int:
-    return html.split("<tbody>")[1].count("<tr")
+    """Rows written as cells: a paged table's first page, or every row."""
+    return html.split("<tbody>")[1].split("</tbody>")[0].count("<tr")
+
+
+def _json_rows(html: str) -> list:
+    """Every row of a paged table, as the JSON its script draws them from."""
+    block = re.search(r"<script type='application/json'>(.*?)</script>", html, re.S)
+    return json.loads(block.group(1)) if block else []
 
 
 @pytest.fixture
@@ -27,14 +35,36 @@ class Frame:
         return self.df.head(n), self.df.height if self.counted else None, "Frame (view)"
 
 
-def test_all_rows_shown(islands):
+def test_first_page_as_cells_every_row_as_json(islands):
     html = table3.html(islands)
-    assert _body_rows(html) == 29
-    assert "island 28" in html
+    assert _body_rows(html) == 10  # the first page, before any script runs
+    rows = _json_rows(html)
+    assert len(rows) == 29 and rows[28] == ["island 28"]
     assert "max-height:300px" in html
+    assert "showing first 10 of 29 rows<" in html  # the footer without scripts
+    assert "data-label='29 rows'" in html
+
+
+def test_one_page_or_less_needs_no_json(islands):
+    html = table3.html(islands, page_size=50)
+    assert _body_rows(html) == 29 and _json_rows(html) == []
     assert ">29 rows<" in html
 
 
+def test_json_is_a_fraction_of_the_cells():
+    df = pl.DataFrame({f"c{i}": [i * 1.5] * 100 for i in range(8)})
+    paged, cells = table3.html(df), table3.html(df, pages=False)
+    assert _body_rows(cells) == 100 and len(_json_rows(paged)) == 100
+    assert len(paged) * 3 < len(cells)
+
+
+def test_json_rows_are_display_text():
+    df = pl.DataFrame({"f": [3.3000000000000003, None], "s": ["</script>", "y" * 50]})
+    html = table3.html(df, page_size=1, digits=None)
+    # "</script>" in a value would cut the block short if it weren't escaped.
+    assert _json_rows(html) == [["3.3", "</script>"], [None, "y" * 50]]
+
+
 def test_header_and_types_pinned(islands):
     thead = table3.html(islands).split("<thead")[1].split("</thead>")[0]
     assert "position:sticky;top:0" in thead
@@ -43,8 +73,8 @@ def test_header_and_types_pinned(islands):
 
 def test_row_limit_labelled():
     html = table3.html(pl.DataFrame({"x": range(2500)}), n=1000)
-    assert _body_rows(html) == 1000
-    assert "showing first 1,000 of 2,500 rows<" in html
+    assert _body_rows(html) == 10 and len(_json_rows(html)) == 1000
+    assert "showing first 10 of 2,500 rows<" in html
     assert "data-label='1,000 rows (first 1,000 of 2,500)'" in html
     assert "shape: (2500, 1)" in html
 
@@ -52,6 +82,7 @@ def test_row_limit_labelled():
 def test_lazy_frame_counted():
     html = table3.html(pl.LazyFrame({"x": range(50)}), n=10)
     assert _body_rows(html) == 10 and "shape: (50, 1)" in html
+    assert _json_rows(html) == []  # ten rows: one page
 
 
 def test_table3_hook_gives_rows_count_and_caption():

table3-0.4.0/src/table3/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.4.0"