plot3 0.6.5__tar.gz → 0.6.7__tar.gz

{plot3-0.6.5 → plot3-0.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.5
+Version: 0.6.7
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT
@@ -260,6 +260,17 @@ In notebooks, bare column names work as in R: `aes(x=dose, y=response)`.
 - **Jupyter / SolveIt**: bare column names and backticks work in `aes()`,
   `facet_wrap()`, and `facet_grid()` (`aes(x=`First Name`)`). Toggle with
   `enable_r_style()` / `disable_r_style()`. `.py` files keep quoted strings.
+- **Layers on their own lines**, as in R, with no parentheses:
+
+  ```text
+  ggplot(gapminder, aes(x=gdpPercap, y=lifeExp, colour=continent))
+  + geom_point(alpha=0.7)       # comments are fine
+  + scale_x_log10()
+  ```
+
+  A line starting with `+` and a plot3 function continues the plot above
+  it. Import plot3 in an earlier cell: IPython reads a whole cell before
+  running any of it. `.py` files keep the outer parentheses.
 - **SolveIt** draws figures inline and hides their HTML from the model's
   context (`autohide(False)` to opt out).
 - **VS Code notebooks** block WebGL in output cells, so plot3 opens figures

{plot3-0.6.5 → plot3-0.6.7}/README.md

@@ -233,6 +233,17 @@ In notebooks, bare column names work as in R: `aes(x=dose, y=response)`.
 - **Jupyter / SolveIt**: bare column names and backticks work in `aes()`,
   `facet_wrap()`, and `facet_grid()` (`aes(x=`First Name`)`). Toggle with
   `enable_r_style()` / `disable_r_style()`. `.py` files keep quoted strings.
+- **Layers on their own lines**, as in R, with no parentheses:
+
+  ```text
+  ggplot(gapminder, aes(x=gdpPercap, y=lifeExp, colour=continent))
+  + geom_point(alpha=0.7)       # comments are fine
+  + scale_x_log10()
+  ```
+
+  A line starting with `+` and a plot3 function continues the plot above
+  it. Import plot3 in an earlier cell: IPython reads a whole cell before
+  running any of it. `.py` files keep the outer parentheses.
 - **SolveIt** draws figures inline and hides their HTML from the model's
   context (`autohide(False)` to opt out).
 - **VS Code notebooks** block WebGL in output cells, so plot3 opens figures

plot3-0.6.7/plot3/__version__.py

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

{plot3-0.6.5 → plot3-0.6.7}/plot3/build.py

@@ -1970,6 +1970,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 +1981,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)

{plot3-0.6.5 → plot3-0.6.7}/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.5 → plot3-0.6.7}/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.5 → plot3-0.6.7}/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.5 → plot3-0.6.7}/plot3/jupyter.py

@@ -22,6 +22,7 @@ from plot3.masking import (
     is_mask_transformer,
     is_tidy3_backtick_transformer,
     plot3_backtick_transform,
+    plot3_layer_transform,
 )
 
 # R-style bare-name / backtick masking for aes() / facet_wrap().
@@ -463,6 +464,28 @@ def run_plot3_from_magic(line: str = ""):
 # ═════════════════════════════════════════════════════════════════════════════
 
 
+def enable_layer_lines(ipython: Any | None = None) -> bool:
+    """Let ``+ geom_point()`` lines continue the ggplot above them in a cell.
+
+    ``ggplot(df, aes(...))`` then ``+ geom_point()`` on the next lines, with
+    no parentheses, as in R. Only a ``+`` followed by a plot3 name joins, so
+    ordinary Python is never rewritten.
+    """
+    if ipython is None:
+        try:
+            ipython = get_ipython() if get_ipython is not None else None
+        except Exception:
+            ipython = None
+    transformers = getattr(ipython, "input_transformers_cleanup", None)
+    if not isinstance(transformers, list):
+        return False
+    transformers[:] = [
+        t for t in transformers if getattr(t, "__name__", "") != "plot3_layer_transform"
+    ]
+    transformers.append(plot3_layer_transform)
+    return True
+
+
 def register_plot3(*, quiet=True, r_style: bool = True) -> bool:
     if get_ipython is None:
         return False
@@ -495,6 +518,12 @@ def register_plot3(*, quiet=True, r_style: bool = True) -> bool:
             ns[name] = getattr(plot3_pkg, name)
     except Exception:
         pass
+    # ggplot(...) then "+ geom_point()" lines, without parentheses
+    try:
+        enable_layer_lines(ip)
+    except Exception as e:
+        if not quiet:
+            print(f"plot3: multi-line layers not enabled: {e}")
     # R-style bare names / backticks in aes() (ggplot2 parity with tidy3)
     if r_style:
         try:

{plot3-0.6.5 → plot3-0.6.7}/plot3/masking.py

@@ -179,6 +179,138 @@ def plot3_backtick_transform(lines: list[str]) -> list[str]:
     return parts or [out]
 
 
+_OPENERS = frozenset("([{")
+_CLOSERS = frozenset(")]}")
+_SKIP_TOKENS = frozenset({
+    tokenize.COMMENT, tokenize.NL, tokenize.NEWLINE, tokenize.INDENT,
+    tokenize.DEDENT, tokenize.ENCODING, tokenize.ENDMARKER,
+})
+
+
+def _plot3_names() -> set[str]:
+    try:
+        import plot3
+
+        return {str(name) for name in getattr(plot3, "__all__", ())}
+    except Exception:
+        return set()
+
+
+def _logical_lines(text: str) -> list[list[tokenize.TokenInfo]] | None:
+    """Token lists, one per logical line; ``None`` if *text* cannot tokenize."""
+    lines: list[list[tokenize.TokenInfo]] = []
+    current: list[tokenize.TokenInfo] = []
+    try:
+        for token in tokenize.generate_tokens(io.StringIO(text).readline):
+            if token.type in _SKIP_TOKENS:
+                if token.type == tokenize.NEWLINE and current:
+                    lines.append(current)
+                    current = []
+                continue
+            current.append(token)
+    except (tokenize.TokenError, IndentationError, SyntaxError):
+        return None
+    if current:
+        lines.append(current)
+    return lines
+
+
+def _value_start(tokens: list[tokenize.TokenInfo]) -> tuple[int, int]:
+    """Where the expression starts: after a top-level ``=``, else the start."""
+    depth = 0
+    for index, token in enumerate(tokens):
+        if token.string in _OPENERS:
+            depth += 1
+        elif token.string in _CLOSERS:
+            depth -= 1
+        elif depth == 0 and token.type == tokenize.OP and token.string == "=":
+            if index + 1 < len(tokens):
+                return tokens[index + 1].start
+    return tokens[0].start
+
+
+def join_layer_lines(source: str) -> str | None:
+    """Join ``+`` lines that add plot3 layers to the statement above them.
+
+    In a notebook, ``ggplot(df, aes(...))`` followed by lines that start
+    with ``+ geom_point()`` reads like R, but to Python each ``+`` line is
+    a statement of its own (unary plus, or an IndentationError when
+    indented). A line whose first token is ``+`` followed by a plot3 name
+    continues the top-level statement above it, across comments and blank
+    lines; the expression gets parentheses on the lines as typed, so error
+    line numbers still match. Returns ``None`` when nothing needs joining,
+    or when the result would not parse. Pipes (``>>``) are tidy3's.
+    """
+    if not source or "+" not in source:
+        return None
+    raw = source.split("\n")
+    if not any(line.lstrip().startswith("+") for line in raw):
+        return None
+    names = _plot3_names()
+    # Indented "+ geom_point()" lines must not trip the tokenizer.
+    shift = [len(line) - len(line.lstrip()) if line.lstrip().startswith("+") else 0 for line in raw]
+    analysed = "\n".join(line[n:] for line, n in zip(raw, shift))
+    logical = _logical_lines(analysed)
+    if not logical:
+        return None
+
+    def is_layer(tokens: list[tokenize.TokenInfo]) -> bool:
+        return (
+            len(tokens) > 1
+            and tokens[0].type == tokenize.OP
+            and tokens[0].string == "+"
+            and tokens[1].type == tokenize.NAME
+            and tokens[1].string in names
+        )
+
+    groups: list[list[list[tokenize.TokenInfo]]] = []
+    for tokens in logical:
+        previous = groups[-1] if groups else None
+        head = previous[0][0] if previous else None
+        if (
+            previous is not None
+            and is_layer(tokens)
+            and head.start[1] == 0
+            and head.type != tokenize.OP
+            and head.string not in {"if", "for", "while", "with", "def", "class", "try", "elif", "else", "except", "finally", "return", "import", "from"}
+        ):
+            previous.append(tokens)
+        else:
+            groups.append([tokens])
+
+    edits: list[tuple[int, int, str]] = []
+    for group in groups:
+        if len(group) < 2:
+            continue
+        opening = _value_start(group[0])
+        closing = group[-1][-1].end
+        edits.append((opening[0], opening[1] + shift[opening[0] - 1], "("))
+        edits.append((closing[0], closing[1] + shift[closing[0] - 1], ")"))
+    if not edits:
+        return None
+    lines = list(raw)
+    for row, col, piece in sorted(edits, reverse=True):
+        line = lines[row - 1]
+        lines[row - 1] = line[:col] + piece + line[col:]
+    rewritten = "\n".join(lines)
+    try:
+        ast.parse(rewrite_backticks(rewritten))
+    except SyntaxError:
+        return None
+    return rewritten
+
+
+def plot3_layer_transform(lines: list[str]) -> list[str]:
+    """IPython input transformer: ``+`` lines continue a ggplot (see join_layer_lines)."""
+    if not lines:
+        return lines
+    source = "".join(lines)
+    out = join_layer_lines(source)
+    if out is None:
+        return lines
+    return out.splitlines(keepends=True)
+
+
 def _is_bt_call(node: ast.AST) -> bool:
     return (
         isinstance(node, ast.Call)

{plot3-0.6.5 → plot3-0.6.7}/plot3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.5
+Version: 0.6.7
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT
@@ -260,6 +260,17 @@ In notebooks, bare column names work as in R: `aes(x=dose, y=response)`.
 - **Jupyter / SolveIt**: bare column names and backticks work in `aes()`,
   `facet_wrap()`, and `facet_grid()` (`aes(x=`First Name`)`). Toggle with
   `enable_r_style()` / `disable_r_style()`. `.py` files keep quoted strings.
+- **Layers on their own lines**, as in R, with no parentheses:
+
+  ```text
+  ggplot(gapminder, aes(x=gdpPercap, y=lifeExp, colour=continent))
+  + geom_point(alpha=0.7)       # comments are fine
+  + scale_x_log10()
+  ```
+
+  A line starting with `+` and a plot3 function continues the plot above
+  it. Import plot3 in an earlier cell: IPython reads a whole cell before
+  running any of it. `.py` files keep the outer parentheses.
 - **SolveIt** draws figures inline and hides their HTML from the model's
   context (`autohide(False)` to opt out).
 - **VS Code notebooks** block WebGL in output cells, so plot3 opens figures

{plot3-0.6.5 → plot3-0.6.7}/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.5 → plot3-0.6.7}/tests/test_masking.py

@@ -197,3 +197,44 @@ def test_aes_expression_over_columns_passes_whole():
     # Notebook variables and modules keep the old behaviour.
     assert apply_masking("aes(x=np.log(x))", known=known) == "aes(x=np.log('x'))"
     assert apply_masking("aes(x=wt)", known=known) == "aes(x='wt')"
+
+
+def test_plus_lines_continue_a_ggplot():
+    # ggplot(...) then "+ geom_point()" lines, as in R: to Python each "+"
+    # line is its own statement (unary plus, or an IndentationError).
+    import ast
+
+    from plot3.masking import join_layer_lines
+
+    cell = (
+        'ggplot(df, aes(x="a", y="b"))\n'
+        ' + geom_point(alpha=0.7)\n'
+        ' + scale_x_log10()'
+    )
+    joined = join_layer_lines(cell)
+    assert joined == (
+        '(ggplot(df, aes(x="a", y="b"))\n'
+        ' + geom_point(alpha=0.7)\n'
+        ' + scale_x_log10())'
+    )
+    tree = ast.parse(joined)
+    assert len(tree.body) == 1
+
+    # An assignment, with comments and a blank line between layers.
+    cell = 'p = ggplot(df)   # base\n# layers\n+ geom_point()  # points\n\n+ theme_bw()\np'
+    joined = join_layer_lines(cell)
+    assert joined.startswith("p = (ggplot(df)") and "+ theme_bw())" in joined
+    assert len(ast.parse(joined).body) == 2
+
+    # patchwork: a composition takes "+ plot_layout(...)" lines too.
+    assert join_layer_lines("fig = (a | b)\n+ plot_layout(widths=[3, 2])").startswith("fig = ((a | b)")
+
+
+def test_plus_lines_leave_other_python_alone():
+    from plot3.masking import join_layer_lines
+
+    assert join_layer_lines("x = 1\n+2") is None                      # unary plus
+    assert join_layer_lines("y = 1\n+ foo(2)") is None                # not a plot3 name
+    assert join_layer_lines("df\n>> ggplot()\n+ geom_point()") is None  # tidy3's pipe
+    assert join_layer_lines("for i in r:\n    p = ggplot(df)\n    + geom_point()") is None
+    assert join_layer_lines("p = ggplot(df) + geom_point()") is None  # already one line

plot3-0.6.5/plot3/__version__.py

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