genome-spy-python 0.8.0__tar.gz → 0.8.1__tar.gz

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/.github/workflows/ci.yml

@@ -101,6 +101,14 @@ jobs:
           enable-cache: true
           python-version: ${{ matrix.python }}
       - run: uv sync --locked --dev --extra scanpy --group scanpy-test
+      # Run notebooks first so rendering failures surface before the long suites.
+      - if: matrix.python == '3.11'
+        run: uv run --no-sync python -m playwright install --with-deps chromium
+      - name: Render the workflow notebooks in JupyterLab
+        if: matrix.python == '3.11' && (github.ref == 'refs/heads/main' || inputs.full_scanpy)
+        run: |
+          uv run --no-sync python tools/check_notebook_rendering.py integrations/scanpy/notebooks/scanpy_umap.ipynb --screenshot "${{ runner.temp }}/scanpy-notebooks/umap-notebook.png"
+          uv run --no-sync python tools/check_notebook_rendering.py integrations/scanpy/notebooks/scanpy_expression.ipynb --screenshot "${{ runner.temp }}/scanpy-notebooks/expression-notebook.png"
       - name: Fast Scanpy checks
         if: github.ref != 'refs/heads/main' && !inputs.full_scanpy
         run: >-
@@ -112,9 +120,6 @@ jobs:
         run: >-
           uv run --no-sync pytest tests/integrations/scanpy
           --ignore=tests/integrations/scanpy/browser -q --durations=10
-      # The renderer is JavaScript; repeat it once, rather than for each Python.
-      - if: matrix.python == '3.11'
-        run: uv run --no-sync python -m playwright install --with-deps chromium
       - name: Browser smoke checks
         if: matrix.python == '3.11' && github.ref != 'refs/heads/main' && !inputs.full_scanpy
         run: >-
@@ -125,16 +130,13 @@ jobs:
         run: >-
           uv run --no-sync pytest tests/integrations/scanpy/browser -q
           --basetemp="${{ runner.temp }}/scanpy-browser"
-      - name: Render the workflow notebooks in JupyterLab
-        if: matrix.python == '3.11' && (github.ref == 'refs/heads/main' || inputs.full_scanpy)
-        run: |
-          uv run --no-sync python tools/check_notebook_rendering.py integrations/scanpy/notebooks/scanpy_umap.ipynb --screenshot "${{ runner.temp }}/scanpy-browser/umap-notebook.png"
-          uv run --no-sync python tools/check_notebook_rendering.py integrations/scanpy/notebooks/scanpy_expression.ipynb --screenshot "${{ runner.temp }}/scanpy-browser/expression-notebook.png"
       - uses: actions/upload-artifact@v7
         if: always() && matrix.python == '3.11'
         with:
           name: scanpy-browser
-          path: ${{ runner.temp }}/scanpy-browser
+          path: |
+            ${{ runner.temp }}/scanpy-browser
+            ${{ runner.temp }}/scanpy-notebooks
           if-no-files-found: ignore
 
   scanpy-compatibility:
@@ -251,10 +253,10 @@ jobs:
         with:
           name: notebook-rendering
           path: |
-            ${{ runner.temp }}/notebook-rendering.png
-            ${{ runner.temp }}/embed-api.png
-            ${{ runner.temp }}/annotate-intervals.png
-            ${{ runner.temp }}/select-genes.png
-            ${{ runner.temp }}/pick-genes.png
-            ${{ runner.temp }}/edit-sequence.png
+            ${{ runner.temp }}/notebook-rendering.*
+            ${{ runner.temp }}/embed-api.*
+            ${{ runner.temp }}/annotate-intervals.*
+            ${{ runner.temp }}/select-genes.*
+            ${{ runner.temp }}/pick-genes.*
+            ${{ runner.temp }}/edit-sequence.*
           if-no-files-found: ignore

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.1] - 2026-11-03
+
+### Fixed
+
+- Make the clustered heatmap example self-sizing in notebooks through its own
+  authored panel heights, with room for guides and legends. Preserve native
+  plot and container sizing for other charts without a global notebook height.
+
 ## [0.8.0] - 2026-10-29
 
 ### Added

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: genome-spy-python
-Version: 0.8.0
+Version: 0.8.1
 Summary: genome-spy-python is a declarative genomics visualization library for Python, built on top of the genome-spy JSON specification.
 Project-URL: Homepage, https://github.com/genome-spy/genome-spy-python
 Project-URL: Documentation, https://genomespy.app/genome-spy-python/

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/docs/_ext/genomespy_gallery.py

@@ -454,7 +454,9 @@ def _detail_md(example: core.Example, bundle_url: str) -> str:
     spec_output_id = f"gs-spec-output-{example.name}"
     spec_copy_id = f"gs-spec-copy-{example.name}"
     spec_copy_message_id = f"gs-spec-copy-message-{example.name}"
-    host_style = f"height:{example.height}px"
+    host_style = (
+        "height:auto" if example.intrinsic_height else f"height:{example.height}px"
+    )
     if example.max_width is not None:
         host_style += f";max-width:{example.max_width}px"
     chart = (

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/docs/examples/clustered_heatmap.md

@@ -24,7 +24,11 @@ converts the supplied node hierarchies into orthogonal link endpoints.
 
 `gs.surround()` places the gene tree above the matrix, the cell-line tree to its
 left, and a `gs.SurroundSideSpec` with annotation strips and labels to its right.
-Shared index scales align each side with the matrix. Fractional dendrogram
+Shared index scales align each side with the matrix. The matrix reserves eight
+pixels per cell line, with a tree panel one fifth as tall. GenomeSpy adds space
+for titles, labels, and legends, so the same specification works in a notebook
+without setting a widget height. Its width follows the available container.
+The authored panel heights stay stable while zooming. Fractional dendrogram
 offsets use `bandstep()` to stay connected across gaps while zooming. The
 trees' independent height scales use `gs.ViewportDomainRef(mode="contain")`.
 

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/docs/examples/clustered_heatmap.py

@@ -10,10 +10,12 @@ from genome_spy.schema import Encoding, OverhangConfig, StyleConfig
 META = {
     "category": "Expression and heatmaps",
     "order": 10,
-    "height": 760,
+    "height": 800,
+    "intrinsic_height": True,
     "max_width": 1100,
 }
 DATA = "https://data.genomespy.app/datasets/depmap-cell-line-rna-seq/v1/"
+heatmap_height = 60 * 8
 view_width = gs.Expression("width")
 view_height = gs.Expression("height")
 cell_lines = gs.Data(
@@ -69,7 +71,7 @@ column_tree = (
         )
         .legend(None),
     )
-    .properties(name="columnDendrogram", height=gs.SizeDef(grow=0.2))
+    .properties(name="columnDendrogram", height=heatmap_height * 0.2)
 )
 row_tree = (
     gs.Chart(gs.Data(url=DATA + "cell-line-tree.json"))
@@ -317,7 +319,7 @@ feature_labels = (
 
 chart = (
     gs.surround(
-        (cells + feature_labels).properties(name="heatmap"),
+        (cells + feature_labels).properties(name="heatmap", height=heatmap_height),
         surround=gs.SurroundSides(
             top=[column_tree], left=[row_tree], right=annotations
         ),

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/docs/user-guide/notebooks.md

@@ -43,6 +43,17 @@ Leave the chart as the last expression in a cell:
 
 This is enough to display and explore a chart.
 
+GenomeSpy computes the canvas size from the specification, including room for
+titles, axes, and legends. Fixed heights and step-sized plots keep their authored
+dimensions. Container-sized plots use the space provided by their host, including
+an `HBox` or an explicit widget layout size. The notebook wrapper does not impose
+a default width or height.
+
+A fully flexible plot has no intrinsic height. For standalone notebook output,
+author a plot `height` in the specification or provide a sized widget container.
+The clustered heatmap example declares its matrix and tree heights in the chart
+itself; other plots do not inherit those sizes.
+
 ### Create a chart from a dataframe
 
 You can pass a pandas or Polars dataframe directly to `gs.Chart()`. PyArrow

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "genome-spy-python"
-version = "0.8.0"
+version = "0.8.1"
 description = "genome-spy-python is a declarative genomics visualization library for Python, built on top of the genome-spy JSON specification."
 readme = "README.md"
 requires-python = ">=3.11"

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/src/genome_spy/__init__.py

@@ -253,4 +253,4 @@ __all__ = [
     # END GENERATED INTERACTION EXPORTS
 ]
 
-__version__ = "0.8.0"
+__version__ = "0.8.1"

genome_spy_python-0.8.1/tests/browser/test_offline_rendering.py

@@ -0,0 +1,102 @@
+"""Exercise the shipped inline modules in the browser CI environment."""
+
+import json
+from pathlib import Path
+
+import genome_spy as gs
+import pytest
+
+playwright = pytest.importorskip("playwright.sync_api")
+
+
+def test_inline_html_renders_and_opens_inspector_offline(tmp_path: Path) -> None:
+    chart = (
+        gs.Chart([{"x": 1, "y": 2}, {"x": 2, "y": 3}])
+        .mark_point()
+        .encode(x="x:Q", y="y:Q")
+    )
+    output = tmp_path / "chart.html"
+    chart.save(output, inline=True)
+    with playwright.sync_playwright() as runtime:
+        browser = runtime.chromium.launch()
+        try:
+            page = browser.new_page(offline=True)
+            errors: list[str] = []
+            requests: list[str] = []
+            page.on("pageerror", lambda error: errors.append(str(error)))
+            page.on(
+                "request",
+                lambda request: (
+                    requests.append(request.url)
+                    if request.url.startswith(("http:", "https:"))
+                    else None
+                ),
+            )
+            # A host AMD loader must not intercept the packaged ESM runtime.
+            page.add_init_script(
+                "globalThis.define = () => { throw Error('AMD called'); };"
+                "globalThis.define.amd = {};"
+            )
+            page.goto(output.as_uri())
+            page.locator("canvas").first.wait_for(state="visible")
+            inspector = page.get_by_role("button", name="Inspector", exact=True)
+            inspector.wait_for(state="attached")
+            inspector.evaluate("(button) => button.click()")
+            page.get_by_role("dialog", name="GenomeSpy Inspector").wait_for(
+                state="visible"
+            )
+            page.locator("gs-inspector-panel").wait_for(state="attached")
+            assert page.locator(".message-box").count() == 0
+            assert not errors, errors
+            assert not requests, requests
+        finally:
+            browser.close()
+
+
+@pytest.mark.parametrize("painted", [False, True])
+def test_notebook_canvas_check_keeps_blank_failure_and_records_state(tmp_path, painted):
+    from tools.check_notebook_rendering import _check_canvas, _observe_rendering
+
+    with playwright.sync_playwright() as runtime:
+        browser = runtime.chromium.launch()
+        try:
+            page = browser.new_page()
+            console = []
+            _observe_rendering(page, console)
+            page.goto("""data:text/html,<div class="jp-CodeCell">
+                <div class="jp-InputArea">chart.display()</div>
+                <div class="jp-OutputArea"><canvas width="100" height="80"></canvas></div>
+                </div>""")
+            canvas = page.locator("canvas")
+            canvas.evaluate(
+                """(canvas, painted) => {
+                canvas.dispatchEvent(new WebGLContextEvent('webglcontextlost'));
+                console.warn('test-secret');
+                const ctx = canvas.getContext('2d');
+                const fill = ctx.createLinearGradient(0, 0, 100, 0);
+                fill.addColorStop(0, 'red'); fill.addColorStop(1, 'blue');
+                ctx.fillStyle = painted ? fill : 'white';
+                ctx.fillRect(0, 0, 100, 80);
+            }""",
+                painted,
+            )
+            screenshot = tmp_path / "chart.png"
+            if painted:
+                _check_canvas(page, canvas, screenshot, console, [], "test-secret")
+                assert not screenshot.with_suffix(".json").exists()
+            else:
+                with pytest.raises(AssertionError, match="canvas is blank"):
+                    _check_canvas(page, canvas, screenshot, console, [], "test-secret")
+                report = screenshot.with_suffix(".json").read_text()
+                assert "test-secret" not in report
+                state = json.loads(report)
+                assert state["cellIndex"] == 0
+                assert state["source"] == "chart.display()"
+                assert state["canvas"]["bufferWidth"] == 100
+                assert state["colorCount"] == 1
+                assert state["contextEvents"][0]["type"] == "webglcontextlost"
+                assert state["console"] == [{"type": "warning", "text": "<redacted>"}]
+                assert screenshot.with_suffix(".page.png").is_file()
+            assert screenshot.is_file()
+        finally:
+            browser.close()

genome_spy_python-0.8.1/tests/browser/test_widget_sizing.py

@@ -0,0 +1,216 @@
+"""Check notebook container sizing against the packaged GenomeSpy runtime."""
+
+import json
+from pathlib import Path
+from urllib.parse import quote
+
+import genome_spy as gs
+import pytest
+
+playwright = pytest.importorskip("playwright.sync_api")
+
+
+@pytest.mark.parametrize(
+    (
+        "kind",
+        "width",
+        "height",
+        "host_width",
+        "host_height",
+        "layout_height",
+        "expected",
+    ),
+    [
+        ("unit", None, None, 500, None, None, None),
+        ("unit", 200, 120, 800, None, None, [220, 140]),
+        ("unit", None, 240, 800, None, None, [800, 260]),
+        ("step", None, None, 500, None, None, [500, 80]),
+        ("vconcat", None, None, 500, None, None, [500, 330]),
+        ("unit", None, None, 500, 350, None, [500, 350]),
+        ("unit", None, None, 900, 600, None, [900, 600]),
+        ("unit", None, None, 800, None, 400, [800, 400]),
+    ],
+)
+def test_widget_uses_native_plot_and_container_dimensions(
+    kind, width, height, host_width, host_height, layout_height, expected
+):
+    chart = (
+        gs.Chart([{"x": i, "y": i} for i in range(3)])
+        .mark_point()
+        .encode(x=gs.X("x:Q").axis(None), y=gs.Y("y:Q").axis(None))
+    )
+    if kind == "step":
+        chart = chart.encode(
+            y=gs.Y("y:O").scale(paddingInner=0, paddingOuter=0).axis(None)
+        ).properties(height=gs.step(20))
+    elif kind == "vconcat":
+        chart = gs.vconcat(
+            chart.properties(height=100), chart.properties(height=200), spacing=10
+        )
+    else:
+        if width is not None:
+            chart = chart.properties(width=width)
+        if height is not None:
+            chart = chart.properties(height=height)
+    widget = chart.widget(inline=True, controls=False)
+    state = {
+        name: getattr(widget, name)
+        for name in (
+            "spec",
+            "bundle_url",
+            "embed_options",
+            "controls",
+            "dataset_manifest",
+        )
+    }
+    with playwright.sync_playwright() as runtime:
+        browser = runtime.chromium.launch()
+        try:
+            page = browser.new_page()
+            page.set_content(f'<div id="widget" style="width: {host_width}px"></div>')
+            if host_height is not None:
+                page.locator("#widget").evaluate(
+                    """(el, height) => {
+                        const parent = document.createElement('div');
+                        parent.style.cssText = `display: flex; height: ${height}px`;
+                        el.before(parent);
+                        parent.append(el);
+                    }""",
+                    host_height,
+                )
+            if css := getattr(widget, "_css", ""):
+                page.add_style_tag(content=str(css))
+            if layout_height is not None:
+                page.locator("#widget").evaluate(
+                    "(el, height) => el.style.height = `${height}px`", layout_height
+                )
+            page.add_script_tag(
+                type="module",
+                content=f"""
+                const {{renderChart}} = await import({json.dumps("data:text/javascript," + quote(str(widget._esm)))});
+                const values = {json.dumps(state)};
+                const model = {{get: name => values[name], set() {{}},
+                    save_changes() {{}}, on() {{}}, off() {{}}}};
+                window.controller = new AbortController();
+                await renderChart({{model, el: document.querySelector('#widget'),
+                    signal: controller.signal}});
+                if ({json.dumps(expected is None)}) {{
+                    const reference = document.createElement('div');
+                    reference.style.width = '{host_width}px';
+                    document.body.append(reference);
+                    const core = await import(values.bundle_url);
+                    await core.embed(reference, structuredClone(values.spec), values.embed_options);
+                    const canvas = reference.querySelector('canvas');
+                    window.nativeSize = [canvas.width, canvas.height];
+                }}
+                window.rendered = true;
+                """,
+            )
+            page.wait_for_function("window.rendered")
+            if expected is None:
+                expected = page.evaluate("window.nativeSize")
+            page.wait_for_function(
+                """size => {
+                    const canvas = document.querySelector('canvas');
+                    return canvas.width === size[0] && canvas.height === size[1];
+                }""",
+                arg=expected,
+            )
+            assert page.locator("#widget").bounding_box()["width"] == host_width
+            assert page.locator("#widget").bounding_box()["height"] == expected[1]
+            if host_height is not None:
+                assert (
+                    page.locator("#widget").evaluate(
+                        "el => el.parentElement.getBoundingClientRect().height"
+                    )
+                    == host_height
+                )
+            assert page.locator(".message-box").count() == 0
+        finally:
+            browser.close()
+
+
+@pytest.mark.parametrize("plot", ["hbox", "clustered_heatmap"])
+def test_widget_dimensions_in_real_jupyter(tmp_path, monkeypatch, plot):
+    import sys
+
+    import nbformat
+
+    from tools import check_notebook_rendering
+
+    notebook = nbformat.v4.new_notebook(
+        cells=[
+            nbformat.v4.new_code_cell("""import genome_spy as gs
+from ipywidgets import HBox, Layout
+
+chart = gs.Chart([
+    {"x": x, "y": y, "value": x + 10 * y}
+    for x in range(10) for y in range(10)
+]).mark_rect().encode(
+    x=gs.X("x:O").axis(None), y=gs.Y("y:O").axis(None), color="value:Q"
+)
+widget = chart.widget(inline=True, controls=False)
+display(HBox([widget], layout=Layout(height="400px")))
+""")
+        ],
+        metadata={
+            "kernelspec": {
+                "name": "python3",
+                "display_name": "Python 3",
+                "language": "python",
+            }
+        },
+    )
+    if plot == "clustered_heatmap":
+        example = (
+            Path(__file__).resolve().parents[2] / "docs/examples/clustered_heatmap.py"
+        )
+        notebook.cells[0].source = f"""import runpy
+chart = runpy.run_path({str(example)!r})["chart"]
+widget = chart.widget(inline=True, controls=False)
+widget.layout.width = "900px"
+display(widget)
+"""
+    source = tmp_path / "hbox.ipynb"
+    source.write_text(nbformat.writes(notebook))
+    check_canvas = check_notebook_rendering._check_canvas
+
+    def check_hbox(page, canvas, *args):
+        if plot == "clustered_heatmap":
+            initial_height = canvas.evaluate("el => el.height")
+            assert initial_height > 480 + 96
+            assert canvas.evaluate("el => el.width") == 900
+            bounds = canvas.bounding_box()
+            page.mouse.move(
+                bounds["x"] + bounds["width"] * 0.55,
+                bounds["y"] + bounds["height"] * 0.5,
+            )
+            page.mouse.wheel(0, -180)
+            page.wait_for_timeout(500)
+            assert canvas.evaluate("el => el.height") == initial_height
+            check_notebook_rendering._run_kernel(page, 'widget.layout.width = "600px"')
+            page.wait_for_function("document.querySelector('canvas').width === 600")
+            assert canvas.evaluate("el => el.height") > 480 + 96
+            assert (
+                abs(
+                    canvas.evaluate("""el => el.height -
+                el.closest('.genome-spy').getBoundingClientRect().height""")
+                )
+                < 1
+            )
+            check_canvas(page, canvas, *args)
+            return
+        heights = canvas.evaluate("""canvas => {
+            const widget = canvas.closest('.genome-spy');
+            const parent = widget.closest('.widget-hbox');
+            return [parent.getBoundingClientRect().height,
+                widget.getBoundingClientRect().height, canvas.height];
+        }""")
+        assert heights == [400, 400, 400]
+        check_canvas(page, canvas, *args)
+
+    monkeypatch.setattr(check_notebook_rendering, "_check_canvas", check_hbox)
+    monkeypatch.setattr(
+        sys, "argv", ["check", str(source), "--screenshot", str(tmp_path / "hbox.png")]
+    )
+    check_notebook_rendering.main()

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/tests/test_chart.py

@@ -61,7 +61,7 @@ from genome_spy.schemapi import SchemaBase, SchemaValidationError
 
 
 def test_package_exposes_version() -> None:
-    assert gs.__version__ == "0.8.0"
+    assert gs.__version__ == "0.8.1"
 
 
 def test_public_api_exports_are_unique() -> None:

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/tests/test_docs_gallery.py

@@ -2134,6 +2134,17 @@ def test_gallery_example_can_cap_embed_width() -> None:
     assert 'class="gs-doc-embed" style="height:500px;max-width:980px"' in markdown
 
 
+def test_intrinsic_heatmap_gallery_height_follows_the_spec() -> None:
+    gallery = _load_gallery()
+    extension = _load_gallery_extension()
+    example = gallery.collect_example(EXAMPLES_DIR / "clustered_heatmap.py")
+    markdown = extension._detail_md(example, "https://example.test/bundle.js")
+
+    assert example.spec["spec"]["height"] == 480
+    assert example.spec["surround"]["top"][0]["height"] == 96
+    assert 'class="gs-doc-embed" style="height:auto;max-width:1100px"' in markdown
+
+
 def test_minigallery_links_include_cache_busting_query(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

{genome_spy_python-0.8.0 → genome_spy_python-0.8.1}/tests/test_upstream_surround_gallery.py

@@ -68,7 +68,13 @@ def test_python_reproduces_upstream_surround_structure(
     example: str, upstream: str
 ) -> None:
     spec, reference = _specs(example, upstream)
-    assert _structure(spec) == _structure(reference)
+    actual = _structure(spec)
+    if example == "clustered_heatmap":
+        # The local example authors its own notebook heights, unlike the reference.
+        assert actual["spec"].pop("height") == 480
+        assert actual["surround"]["top"][0]["height"] == 96
+        actual["surround"]["top"][0]["height"] = {"grow": 0.2}
+    assert actual == _structure(reference)
 
 
 @pytest.mark.parametrize(("example", "upstream"), EXAMPLES)