plot3 0.6.6__tar.gz → 0.6.8__tar.gz

{plot3-0.6.6 → plot3-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.6
+Version: 0.6.8
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT

plot3-0.6.8/plot3/__version__.py

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

{plot3-0.6.6 → plot3-0.6.8}/plot3/build.py

@@ -1726,7 +1726,8 @@ def _formula_legend(legend, formula_geoms, has_title: bool):
     """Tidy the legend rows that function curves add.
 
     * One curve under a title of your own: the title already names it, so
-      the curve gets no row (ggplot2 draws no legend for an unmapped layer).
+      the curve gets no row (ggplot2 draws no legend for an unmapped layer),
+      unless a tangent, derivative or other row sits beside it.
     * Several curves of one formula (a loop over ``a``): the formula moves
       to the legend title and each row lists only its values.
 
@@ -1744,7 +1745,7 @@ def _formula_legend(legend, formula_geoms, has_title: bool):
         return legend, None
     if has_title and len(formula_geoms) == 1:
         kept = [entry for entry in legend if not any(entry is p for p in primary)]
-        return kept or None, None
+        return (legend if kept else None), None
     if len(primary) < 2 or len(primary) != len(formula_geoms):
         return legend, None
     geoms = [entry["_geom"] for entry in primary]
@@ -1970,6 +1971,9 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             "slider() cannot be combined with transition_time() "
             "or transition_states()"
         )
+    if slider is not None:
+        # Default steps shrink to fit while layers expand; keep that per render.
+        slider = copy.copy(slider)
     domains = None
     if any(getattr(layer, "kind", None) == "function" for layer in layers_in):
         from plot3.function import data_domains
@@ -1978,27 +1982,35 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
     addon_map: dict[int, list] = {}
     for index, addon in getattr(g, "_addons", None) or []:
         addon_map.setdefault(int(index), []).append(addon)
-    expanded = []
-    for index, geom in enumerate(layers_in):
-        layer_data = getattr(geom, "layer_data", None)
-        if getattr(geom, "kind", None) == "box3d":
-            # Box classes take the figure theme's group colours.
-            geom = copy.copy(geom)
-            geom._palette = list(theme["cat"])
-        result = expand_stat_geom(
-            geom,
-            g.mapping,
-            data if layer_data is None else layer_data,
-            domains,
-            transition,
-            slider,
-            coord,
-            addon_map.get(index),
-        )
-        if isinstance(result, list):
-            expanded.extend(result)
-        else:
-            expanded.append(result)
+    def expand_all() -> list:
+        out = []
+        for index, geom in enumerate(layers_in):
+            layer_data = getattr(geom, "layer_data", None)
+            if getattr(geom, "kind", None) == "box3d":
+                # Box classes take the figure theme's group colours.
+                geom = copy.copy(geom)
+                geom._palette = list(theme["cat"])
+            result = expand_stat_geom(
+                geom,
+                g.mapping,
+                data if layer_data is None else layer_data,
+                domains,
+                transition,
+                slider,
+                coord,
+                addon_map.get(index),
+            )
+            if isinstance(result, list):
+                out.extend(result)
+            else:
+                out.append(result)
+        return out
+
+    steps_before = getattr(slider, "steps", None)
+    expanded = expand_all()
+    if getattr(slider, "steps", None) != steps_before:
+        # A later layer lowered the default steps: every layer shares one grid.
+        expanded = expand_all()
     from plot3.calculus import mark_intersections
 
     expanded = mark_intersections(expanded)
@@ -2860,6 +2872,28 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
         source = getattr(geom, "_inherit_from", None)
         if source and source in labeled:
             geom.const_color = labeled[source]
+    # Clicking a legend row hides every layer it names: a tangent's line and
+    # its point, a curve and the area shaded under it.
+    legend_keys: dict[int, str] = {}
+    key_of: dict[str, str] = {}
+    for geom, _mapped in resolved:
+        label = getattr(geom, "_legend_label", None)
+        if not label or geom.const_color is None:
+            continue
+        color_key = getattr(geom, "_color_key", None)
+        key = key_of.get(str(label)) or str(color_key or label)
+        legend_keys[id(geom)] = key
+        key_of.setdefault(str(label), key)
+        if color_key:
+            key_of.setdefault(str(color_key), key)
+    for geom, _mapped in resolved:
+        source = getattr(geom, "_inherit_from", None)
+        if id(geom) not in legend_keys and source and str(source) in key_of:
+            legend_keys[id(geom)] = key_of[str(source)]
+    # Stable short keys, so the same figure always builds the same spec.
+    stable: dict[str, str] = {}
+    for gid, key in legend_keys.items():
+        legend_keys[gid] = stable.setdefault(key, f"k{len(stable)}")
 
     payloads: list[tuple[str, str]] = []
     layer_specs = []
@@ -3351,6 +3385,8 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             if tip_latex:
                 tip["latex"] = str(tip_latex)
             spec_l["tip"] = tip
+        if id(geom) in legend_keys:
+            spec_l["lk"] = legend_keys[id(geom)]
         layer_specs.append(spec_l)
 
     # color spec + legend
@@ -3391,6 +3427,8 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             if not label or not geom.const_color:
                 continue
             entry = {"label": str(label), "color": geom.const_color}
+            if id(geom) in legend_keys:
+                entry["lk"] = legend_keys[id(geom)]
             if getattr(geom, "_is_formula", False):
                 entry["formula"] = True
                 entry["_geom"] = geom
@@ -3428,7 +3466,9 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
     raw_title = g.labs.get("title") or ""
     # One function and no title of your own: the formula is the title.
     # A shaded area, a tangent, or roots stay in the legend when they
-    # have a label of their own. The curve's row would only repeat the title.
+    # have a label of their own. The curve keeps its row beside them, so the
+    # legend says which line is the curve; alone, its row would only repeat
+    # the title.
     if not str(raw_title).strip() and len(formula_geoms) == 1:
         shown = formula_geoms[0]
         # Symbolic formula, not the value list. That list stays in the legend
@@ -3445,11 +3485,11 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
         elif title_latex:
             labs_math["title"] = [{"text": title, "latex": str(title_latex)}]
         if legend:
-            legend = [
+            others = [
                 entry for entry in legend
                 if not (entry.get("formula") and entry.get("label") == title)
             ]
-            if not legend:
+            if not others:
                 legend = None
     else:
         title = _take("title", raw_title)

{plot3-0.6.6 → plot3-0.6.8}/plot3/function.py

@@ -938,6 +938,16 @@ def _guard_slider(source: Any, n_samples: int, what: str) -> None:
     cells = int(n_samples) * n_frames
     if cells <= _SLIDER_CELL_CAP:
         return
+    if getattr(source, "auto_steps", False):
+        # Default steps: take the largest count that fits. build_spec hands
+        # each render its own copy and re-expands if this lowered it.
+        count = len(source.ranges)
+        steps = int(source.steps)
+        while steps > 2 and int(n_samples) * steps**count > _SLIDER_CELL_CAP:
+            steps -= 1
+        if int(n_samples) * steps**count <= _SLIDER_CELL_CAP:
+            source.steps = steps
+            return
     raise ValueError(
         f"slider() would sample {n_frames} frames of {n_samples} {what} "
         f"({cells} values). Pass a smaller steps= or n=."

{plot3-0.6.6 → plot3-0.6.8}/plot3/geoms.py

@@ -2181,20 +2181,23 @@ class slider:
 
         ggplot() + geom_function("y = a sin(k x)") + slider(a=(0, 3), k=(1, 5))
 
-    ``steps`` defaults to 25 per parameter. A surface on the default grid
-    is too large for several parameters at that count; pass a smaller
-    ``steps`` or ``n``. Do not combine with ``transition_time()``.
+    ``steps`` defaults to 25 per parameter, lowered as far as needed for
+    the whole grid to fit (three parameters on a curve get 9). An explicit
+    ``steps`` is kept as given and refused if it is too large; pass a
+    smaller ``steps`` or ``n``. Do not combine with ``transition_time()``.
     """
 
     kind = "slider"
 
-    def __init__(self, *, steps: int = 25, **ranges):
+    def __init__(self, *, steps: int | None = None, **ranges):
         if not ranges:
             raise TypeError(
                 "slider() needs a parameter range, for example slider(a=(0, 3))"
             )
+        # Only the default shrinks to fit; an explicit count is the user's.
+        self.auto_steps = steps is None
         try:
-            nsteps = int(steps)
+            nsteps = 25 if steps is None else int(steps)
         except (TypeError, ValueError):
             raise TypeError(
                 "slider() steps= must be an integer, for example steps=25"

{plot3-0.6.6 → plot3-0.6.8}/plot3/ggplot.py

@@ -42,6 +42,25 @@ from plot3.table import as_table, detect_backend
 from plot3.themes import _THEMES
 
 
+def _error_text(exc: BaseException) -> str:
+    return f"plot3 could not draw this figure.\n{type(exc).__name__}: {exc}"
+
+
+def _error_html(exc: BaseException) -> str:
+    import traceback
+
+    trace = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+    return (
+        '<div class="plot3-error" style="border-left:4px solid #d9534f;'
+        "padding:8px 12px;font-family:ui-monospace,Menlo,monospace;"
+        'font-size:13px;white-space:pre-wrap">'
+        "<strong>plot3 could not draw this figure.</strong>\n"
+        f"{_htmlesc.escape(type(exc).__name__)}: {_htmlesc.escape(str(exc))}"
+        '<details style="margin-top:6px"><summary>Traceback</summary>'
+        f"{_htmlesc.escape(trace)}</details></div>"
+    )
+
+
 def _env_flag(name: str) -> bool | None:
     raw = os.environ.get(name)
     if raw is None or raw == "":
@@ -422,7 +441,10 @@ class ggplot:
         # Used by hosts that only understand HTML reprs (and by tests).
         # Prefer ``display(fig)`` / ``fig.show()`` so VS Code can open a browser.
         self._maybe_hide_from_ai()
-        return self._iframe()
+        try:
+            return self._iframe()
+        except Exception as exc:
+            return _error_html(exc)
 
     def _repr_mimebundle_(self, include=None, exclude=None):
         """HTML plus optional PlotPayload mime for CRAFT host handoff.
@@ -435,7 +457,12 @@ class ggplot:
         from plot3.remote import MIME_PLOT3
 
         self._maybe_hide_from_ai()
-        bundle: dict = {"text/html": self._iframe()}
+        try:
+            bundle: dict = {"text/html": self._iframe()}
+        except Exception as exc:
+            # Notebook hosts swallow repr errors and fall back to the bare
+            # object repr, so the reason a plot is missing must be the output.
+            return {"text/html": _error_html(exc), "text/plain": _error_text(exc)}
         try:
             if self.facet is None and (
                 self._payload is not None or self.data is not None or self.layers

{plot3-0.6.6 → plot3-0.6.8}/plot3/viewer.py

@@ -338,8 +338,14 @@ function regCat(ci, obj) {
   if (!catObjs.has(ci)) catObjs.set(ci, []);
   catObjs.get(ci).push(obj);
 }
+// legend click on a formula row (tangent, derivative, curve): row key ->
+// every three.js object its layers drew, e.g. a tangent's line and its point
+const hiddenKeys = new Set();
+const keyObjs = new Map();
+let currentLK = null;   // the key of the layer being drawn, while it draws
+function layerHidden(L) { return L.lk != null && hiddenKeys.has(L.lk); }
 let redraw = () => {};   // 2D assigns its draw(); 3D renders continuously
-window.__plot3 = { hiddenCats, catObjs };
+window.__plot3 = { hiddenCats, catObjs, hiddenKeys, keyObjs };
 function showLegendBox() {
   // theme(legend_position="none"), and all but one panel of a facet_grid.
   if (S.legendPosition === 'none') return;
@@ -414,15 +420,23 @@ if (S.legend) {
   legEl.innerHTML = (S.labs.color ? '<b style="color:'+T.ink+'">' +
       richLabel('color', S.labs.color) + '</b>' : '') +
     S.legend.map((e, i) => '<div class="lg-e" data-ci="' + (e.ci != null ? e.ci : i) +
+      (e.lk != null ? '" data-lk="' + plot3Esc(e.lk) : '') +
       '">' + keyHTML(e, e.color) +
       legendLabel(e) + '</div>').join('') + barHTML() + szHTML;
   legEl.addEventListener('click', ev => {
     const row = ev.target.closest('.lg-e');
     if (!row) return;
-    const ci = +row.dataset.ci;
-    if (hiddenCats.has(ci)) hiddenCats.delete(ci); else hiddenCats.add(ci);
-    row.style.opacity = hiddenCats.has(ci) ? 0.35 : 1;
-    for (const o of (catObjs.get(ci) || [])) o.visible = !hiddenCats.has(ci);
+    const lk = row.dataset.lk;
+    if (lk != null) {
+      if (hiddenKeys.has(lk)) hiddenKeys.delete(lk); else hiddenKeys.add(lk);
+      row.style.opacity = hiddenKeys.has(lk) ? 0.35 : 1;
+      for (const o of (keyObjs.get(lk) || [])) o.visible = !hiddenKeys.has(lk);
+    } else {
+      const ci = +row.dataset.ci;
+      if (hiddenCats.has(ci)) hiddenCats.delete(ci); else hiddenCats.add(ci);
+      row.style.opacity = hiddenCats.has(ci) ? 0.35 : 1;
+      for (const o of (catObjs.get(ci) || [])) o.visible = !hiddenCats.has(ci);
+    }
     if (window.__plot3.afterLegend) window.__plot3.afterLegend();
     tip.style.display = 'none';
     redraw();
@@ -607,6 +621,16 @@ renderer.setPixelRatio(window.devicePixelRatio);
 renderer.setClearColor(0x000000, 0);
 host.appendChild(renderer.domElement);
 const scene = new THREE.Scene();
+{
+  const add0 = scene.add.bind(scene);
+  scene.add = (...objs) => {
+    if (currentLK != null) {
+      if (!keyObjs.has(currentLK)) keyObjs.set(currentLK, []);
+      keyObjs.get(currentLK).push(...objs);
+    }
+    return add0(...objs);
+  };
+}
 const lineMats = [];
 
 // Point symbols (aes(shape=) / geom_point(shape=)) as white sprites tinted
@@ -1614,6 +1638,7 @@ if (!S.is3d) {
     return addToScene(...objs);
   };
   for (const L of S.layers) {
+    currentLK = L.lk != null ? L.lk : null;
     if (L.blank) continue;  // geom_blank: on the scales only
     paintOrder += 1;
     const n = L.n;
@@ -1937,6 +1962,7 @@ if (!S.is3d) {
       });
     }
   }
+  currentLK = null;
   scene.add = addToScene;
 
   function drawAxes() {
@@ -2267,6 +2293,7 @@ if (!S.is3d) {
       if (!best || score < best.score) best = { score, sx, sy, html, hold: !!hold };
     }
     for (const L of S.layers) {
+      if (layerHidden(L)) continue;
       if (L.kind === 'col') {
         // Full bar rectangle (not just the top-center point).
         const hw = (L.width || 0.08) * 0.5;
@@ -2445,6 +2472,7 @@ if (!S.is3d) {
   }
 
   for (const L of S.layers) {
+    currentLK = L.lk != null ? L.lk : null;
     if (L.blank) continue;  // geom_blank: on the scales only
     const n = L.n;
     const cols = layerColors(L, hex2rgb(T.cat[0]));
@@ -2528,6 +2556,7 @@ if (!S.is3d) {
       }
     }
   }
+  currentLK = null;
 
   // Axes box as matplotlib and plotly draw it: the three far walls with
   // grid lines, refreshed as the camera orbits. The edges at the near
@@ -2706,6 +2735,7 @@ if (!S.is3d) {
     let best = null, bestD = Infinity;
     const maxScan = 80000;
     for (const { L } of pickLayers) {
+      if (layerHidden(L)) continue;
       const n = L._stepN != null ? L._stepN : L.n;
       const step = n > maxScan ? Math.ceil(n / maxScan) : 1;
       const xs = L._x || L.x.data;

{plot3-0.6.6 → plot3-0.6.8}/plot3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.6
+Version: 0.6.8
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT

{plot3-0.6.6 → plot3-0.6.8}/tests/test_animation.py

@@ -671,3 +671,33 @@ def test_swept_parameter_is_not_frozen_into_labels():
     )
     assert "t = 0" not in spec
     assert "(a = 2)" in spec  # fixed coefficients still show their value
+
+
+def test_default_slider_steps_shrink_to_fit():
+    from plot3 import geom_function
+
+    g = (
+        ggplot()
+        + geom_function("y = a*(x-h)^2 + k", xlim=(-5, 5))
+        + slider(a=(0.2, 3), h=(-3, 3), k=(-3, 3))
+    )
+    spec, _ = build_spec(g)
+    assert [p["n"] for p in spec["slider"]["params"]] == [9, 9, 9]
+    assert spec["slider"]["nFrames"] == 729
+    # The figure's own slider keeps its default for later renders.
+    assert g.slider.steps == 25
+
+
+def test_render_error_is_shown_instead_of_the_bare_repr():
+    from plot3 import geom_function
+
+    g = (
+        ggplot()
+        + geom_function("y = a x + k")
+        + slider(a=(0, 1), k=(0, 1), steps=2000)
+    )
+    bundle = g._repr_mimebundle_()
+    assert "plot3-error" in bundle["text/html"]
+    assert "smaller steps" in bundle["text/html"]
+    assert "ValueError" in bundle["text/plain"]
+    assert "smaller steps" in g._repr_html_()

{plot3-0.6.6 → plot3-0.6.8}/tests/test_math_layers.py

@@ -13,6 +13,7 @@ from plot3 import (
     geom_vector_field,
     ggplot,
     ggsave,
+    labs,
     slider,
     tangent,
 )
@@ -134,6 +135,39 @@ def test_tangent_at_one_has_slope_two():
     assert any(entry["label"] == "tangent" for entry in spec["legend"])
 
 
+def test_legend_rows_name_the_layers_a_click_hides():
+    # The viewer hides every layer whose key matches the clicked row: the
+    # tangent row covers its line and the point at x = 1.
+    spec, _payloads = build_spec(
+        ggplot() + geom_function("y = x^3 - 3x") + tangent(at=1) + derivative()
+    )
+    keys = {entry["label"]: entry["lk"] for entry in spec["legend"]}
+    tangent_layers = [layer for layer in spec["layers"] if layer.get("lk") == keys["tangent"]]
+    assert sorted(layer["kind"] for layer in tangent_layers) == ["line", "point"]
+    assert len(set(keys.values())) == 3
+    # Stable keys: the same figure builds the same spec.
+    again, _payloads = build_spec(
+        ggplot() + geom_function("y = x^3 - 3x") + tangent(at=1) + derivative()
+    )
+    assert [entry["lk"] for entry in again["legend"]] == list(keys.values())
+
+
+def test_curve_keeps_its_row_beside_a_tangent_and_derivative():
+    spec, _payloads = build_spec(
+        ggplot() + geom_function("y = x^3 - 3x") + tangent(at=1) + derivative()
+    )
+    labels = [entry["label"] for entry in spec["legend"]]
+    assert labels[0] == spec["labs"]["title"]
+    assert "tangent" in labels and len(labels) == 3
+    titled, _payloads = build_spec(
+        ggplot() + geom_function("y = x^2") + tangent(at=1) + labs(title="Slope")
+    )
+    assert len(titled["legend"]) == 2
+    # Alone, the curve's row would only repeat the title.
+    alone, _payloads = build_spec(ggplot() + geom_function("y = x^2"))
+    assert alone["legend"] is None
+
+
 def test_derivative_is_the_slope_curve():
     layers = _layers(ggplot() + geom_function("y = x^2", xlim=(-2, 2), n=11) + derivative())
     curve = next(

plot3-0.6.6/plot3/__version__.py

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