plot3 0.6.8__tar.gz → 0.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.8
+Version: 0.8.0
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT
@@ -17,6 +17,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.24
 Requires-Dist: pandas>=2.0
+Requires-Dist: tidysyntax<0.2,>=0.1
 Provides-Extra: pdf
 Requires-Dist: cairosvg>=2.7; extra == "pdf"
 Provides-Extra: dev

plot3-0.8.0/plot3/__version__.py

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

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

@@ -10,6 +10,7 @@ import pandas as pd
 import copy
 import os
 
+from plot3.kde import EXACT_WORK, gaussian_1d
 from plot3.encode import encode_codes, encode_norm, pack_u16, pack_u32, pack_u8
 from plot3.mathtext import split_math
 from plot3.geoms import (
@@ -100,6 +101,11 @@ def _kde_1d(
     if hi <= lo:
         hi = lo + 1.0
     grid = np.linspace(lo, hi, n)
+    if x.size * n > EXACT_WORK:
+        # Large inputs: linear binning and an FFT, as R's density() does.
+        sums = gaussian_1d(x, lo, hi, n, bw)
+        if sums is not None:
+            return grid, sums / x.size
     # (n_grid, n_obs)
     u = (grid[:, None] - x[None, :]) / bw
     dens = np.exp(-0.5 * u * u).sum(axis=1) / (
@@ -1522,6 +1528,26 @@ def _rug_series(rug, g):
     return out
 
 
+def _remap_codes(codes, remap: dict, default) -> np.ndarray:
+    """``remap.get(int(c), default)`` for every code, as one table lookup."""
+    c = np.asarray(codes)
+    if c.dtype.kind not in "biuf" or (c.dtype.kind == "f" and not np.isfinite(c).all()):
+        # Same per-value rule, errors included (int() of NaN raises).
+        return np.array([remap.get(int(x), default) for x in c.ravel()]).reshape(c.shape)
+    ints = c.astype(np.int64)
+    out = np.full(ints.shape, default)
+    if remap and ints.size:
+        keys = np.fromiter(remap.keys(), dtype=np.int64, count=len(remap))
+        values = np.array(list(remap.values()))
+        order = np.argsort(keys)
+        keys, values = keys[order], values[order]
+        at = np.clip(np.searchsorted(keys, ints), 0, len(keys) - 1)
+        hit = keys[at] == ints
+        out = out.astype(np.result_type(out, values))
+        out[hit] = values[at[hit]]
+    return out
+
+
 def _rug_positions(scale, series) -> np.ndarray:
     """Values in the scale's own units; NaN where they have no place."""
     kind, pos, cats = col_values(series)
@@ -1531,6 +1557,13 @@ def _rug_positions(scale, series) -> np.ndarray:
             lookup = np.array([index.get(c, np.nan) for c in cats] + [np.nan], dtype=np.float64)
             codes = np.where(np.isfinite(pos), pos, len(cats)).astype(np.int64)
             return lookup[codes]
+        values = np.asarray(series)
+        # float32 prints differently as a NumPy scalar than as a float.
+        if values.dtype.kind in "biu" or values.dtype == np.float64:
+            # One text lookup per distinct value (NaN included), not per row.
+            codes, uniques = pd.factorize(values, use_na_sentinel=False)
+            lookup = np.array([index.get(str(u), np.nan) for u in uniques.tolist()], dtype=np.float64)
+            return lookup[codes] if len(codes) else np.array([], dtype=np.float64)
         return np.array([index.get(str(v), np.nan) for v in series], dtype=np.float64)
     if kind == "cat":
         return np.full(len(pos), np.nan)
@@ -2211,10 +2244,8 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             }
             out = np.full(np.size(v), np.nan, dtype=np.float64)
             flat = np.asarray(v, dtype=np.float64).ravel()
-            for i, c in enumerate(flat):
-                if not math.isfinite(c):
-                    continue
-                out[i] = remap.get(int(c), -1)
+            finite = np.isfinite(flat)
+            out[finite] = _remap_codes(flat[finite], remap, -1)
             v = out.reshape(np.shape(v))
             sc.cats = merged
         else:
@@ -3089,9 +3120,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
                             i: color_scale[1].index(c)
                             for i, c in enumerate(local)
                         }
-                        codes = np.array(
-                            [remap.get(int(c), 0) for c in cv], dtype="<u2"
-                        )
+                        codes = _remap_codes(cv, remap, 0).astype("<u2")
                         payloads.append((pid, pack_u16(codes, g.compress)))
                         spec_l["ocolor"] = {
                             "id": pid, "dtype": "u16", "kind": "cat"
@@ -3121,8 +3150,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
                 # remap onto the global cat list
                 local = vals["color"][2]
                 remap = {i: color_scale[1].index(c) for i, c in enumerate(local)}
-                codes = np.array([remap.get(int(c), 0) for c in cv[order]],
-                                 dtype="<u2")
+                codes = _remap_codes(cv[order], remap, 0).astype("<u2")
                 payloads.append((pid, pack_u16(codes, g.compress)))
                 spec_l["color"] = {"id": pid, "dtype": "u16", "kind": "cat"}
             else:
@@ -3140,9 +3168,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             if ckind == "cat":
                 local = vals["color"][2]
                 remap = {i: color_scale[1].index(c) for i, c in enumerate(local)}
-                codes = np.array(
-                    [remap.get(int(c), 0) for c in cv[order]], dtype="<u2"
-                )
+                codes = _remap_codes(cv[order], remap, 0).astype("<u2")
                 payloads.append((pid, pack_u16(codes, g.compress)))
                 spec_l["color"] = {"id": pid, "dtype": "u16", "kind": "cat"}
             else:
@@ -3322,10 +3348,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
                     flat = np.full(raw.shape, 65535, dtype=np.uint16)
                     ok = np.isfinite(raw) & (raw >= 0)
                     if ok.any():
-                        mapped = np.array(
-                            [remap.get(int(c), 0) for c in raw[ok]],
-                            dtype=np.uint16,
-                        )
+                        mapped = _remap_codes(raw[ok], remap, 0).astype(np.uint16)
                         flat[np.flatnonzero(ok)] = mapped
                     enc = encode_codes(flat, g.compress)
                     pid = f"p{li}fc"

{plot3-0.6.8 → plot3-0.8.0}/plot3/encode.py

@@ -7,6 +7,10 @@ import gzip as _gzip
 
 import numpy as np
 
+# gzip is lossless at every level. Level 1 builds large payloads several
+# times faster than 6 for a few percent more bytes.
+_LEVEL = 1
+
 def delta_u16(a: np.ndarray) -> np.ndarray:
     """Column-wise delta mod 2^16 (lossless; tiny values on ordered data)."""
     d = a.astype(np.int32)
@@ -21,7 +25,7 @@ def pack_u16(q: np.ndarray, compress: bool) -> str:
         raw = _gzip.compress(
             np.ascontiguousarray(d[:, 0]).tobytes()
             + np.ascontiguousarray(d[:, 1]).tobytes(),
-            6,
+            compresslevel=_LEVEL, mtime=0,
         )
     else:
         raw = np.ascontiguousarray(q, dtype="<u2").tobytes()
@@ -31,7 +35,7 @@ def pack_u16(q: np.ndarray, compress: bool) -> str:
 def pack_f32(v: np.ndarray, compress: bool) -> str:
     raw = np.ascontiguousarray(v, dtype="<f4").tobytes()
     if compress:
-        raw = _gzip.compress(raw, 6)
+        raw = _gzip.compress(raw, _LEVEL, mtime=0)
     return base64.b64encode(raw).decode("ascii")
 
 
@@ -55,7 +59,7 @@ def pack_u8(values: np.ndarray, compress: bool) -> str:
     """uint8 array -> base64 (optional gzip; no delta)."""
     raw = np.ascontiguousarray(values, dtype=np.uint8).tobytes()
     if compress:
-        raw = _gzip.compress(raw, 6)
+        raw = _gzip.compress(raw, _LEVEL, mtime=0)
     return base64.b64encode(raw).decode("ascii")
 
 
@@ -63,6 +67,6 @@ def pack_u32(values: np.ndarray, compress: bool) -> str:
     """uint32 array -> base64 (optional gzip; no delta)."""
     raw = np.ascontiguousarray(values, dtype="<u4").tobytes()
     if compress:
-        raw = _gzip.compress(raw, 6)
+        raw = _gzip.compress(raw, _LEVEL, mtime=0)
     return base64.b64encode(raw).decode("ascii")
 

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

@@ -1798,7 +1798,7 @@ class facet_wrap:
             # Accept "~cyl", ". ~ cyl", "cyl ~ ."
             parts = [p.strip() for p in name.split("~")]
             candidates = [p for p in parts if p and p != "."]
-            if len(candidates) != 1:
+            if len(candidates) != 1 or "+" in candidates[0]:
                 raise ValueError(
                     "facet_wrap() currently accepts a single facet column "
                     f"(got {facets!r})"

{plot3-0.6.8 → plot3-0.8.0}/plot3/jupyter.py

@@ -22,6 +22,7 @@ from plot3.masking import (
     is_mask_transformer,
     is_tidy3_backtick_transformer,
     plot3_backtick_transform,
+    plot3_formula_transform,
     plot3_layer_transform,
 )
 
@@ -62,16 +63,21 @@ def enable_r_style(ipython: Any | None = None) -> bool:
         # When tidy3 is not loaded, leave tidy3 sentinel unset; plot3 AST
         # still rewrites __tidy3_bt__ if tidy3's preparser ran first.
 
-    # Source preparser: only install plot3's if tidy3 did not already provide one.
+    # Source preparser: when tidy3 already rewrites backticks, run only
+    # plot3's own formula rewrites (^ in geom_function, ~ in facets), after it.
     for attr in ("input_transformers_cleanup", "input_transformers_post"):
         transformers = getattr(ipython, attr, None)
         if not isinstance(transformers, list):
             continue
-        has_tidy3_bt = any(is_tidy3_backtick_transformer(t) for t in transformers)
         transformers[:] = [
             t for t in transformers if not is_backtick_transformer(t)
         ]
-        if not has_tidy3_bt:
+        tidy3_at = [
+            i for i, t in enumerate(transformers) if is_tidy3_backtick_transformer(t)
+        ]
+        if tidy3_at:
+            transformers.insert(tidy3_at[-1] + 1, plot3_formula_transform)
+        else:
             transformers.insert(0, plot3_backtick_transform)
 
     # AST pass for bare names inside aes / facet_wrap.

plot3-0.8.0/plot3/kde.py

@@ -0,0 +1,124 @@
+"""Binned Gaussian kernel density sums (linear binning + FFT convolution).
+
+R's ``density()`` bins too. Values are spread onto a fine grid (at least
+four points per output interval, at most 1/20 of a bandwidth apart in
+1D and 1/4 in 2D),
+convolved with the kernel by FFT, and read back at the output points. The
+relative error is far below what a plot shows. Values more than
+``_REACH`` bandwidths past the output range add nothing in float64 and are
+left out. The callers keep the exact sum for small inputs, and these
+helpers return None when the fine grid would be too large.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+# Below this many (observations x output points) the exact sum is cheap.
+EXACT_WORK = 2_000_000
+# The fine spacing is at most this fraction of the bandwidth (1D, 2D), and
+# the fine grid has at least four points per output interval. Linear
+# binning's error grows with the square of that fraction.
+_MAX_STEP_1D = 0.05
+_MAX_STEP_2D = 0.25
+_MIN_FINE = 4
+# Past this many bandwidths a kernel underflows to zero in float64.
+_REACH = 40.0
+# Largest fine grid (points, or cells in 2D) worth binning onto.
+_MAX_CELLS = 1 << 22
+
+
+def _fine_axis(values: np.ndarray, lo: float, hi: float, n: int, h: float, max_step: float):
+    """``(origin, step, size, first, fine)`` of a fine grid through the output points.
+
+    The output point ``k`` sits at fine index ``first + k * fine``. The grid
+    covers every value within ``_REACH`` bandwidths of the output range;
+    values farther out add nothing to the sums.
+    """
+    if n < 2 or not hi > lo or not h > 0 or not values.size:
+        return None
+    fine = max(_MIN_FINE, int(np.ceil((hi - lo) / ((n - 1) * max_step * h))))
+    step = (hi - lo) / ((n - 1) * fine)
+    low = max(float(values.min()), lo - _REACH * h)
+    high = min(float(values.max()), hi + _REACH * h)
+    below = max(0, int(np.ceil((lo - low) / step)))
+    above = max(0, int(np.ceil((high - hi) / step)))
+    size = (n - 1) * fine + 1 + below + above
+    if size > _MAX_CELLS:
+        return None
+    return lo - below * step, step, size, below, fine
+
+
+def _within(values: np.ndarray, origin: float, step: float, size: int) -> np.ndarray:
+    return (values >= origin) & (values <= origin + (size - 1) * step)
+
+
+def _linear_bins(values: np.ndarray, origin: float, step: float, size: int):
+    """Indices and weights of the two fine points around each value."""
+    pos = (values - origin) / step
+    left = np.clip(np.floor(pos).astype(np.int64), 0, size - 2)
+    frac = np.clip(pos - left, 0.0, 1.0)
+    return left, frac
+
+
+def _kernel_fft(step: float, size: int, h: float, length: int) -> np.ndarray:
+    offsets = np.arange(-(size - 1), size) * step
+    kernel = np.exp(-0.5 * (offsets / h) ** 2) / (h * np.sqrt(2.0 * np.pi))
+    return np.fft.rfft(kernel, length)
+
+
+def _fft_length(size: int) -> int:
+    return 1 << int(np.ceil(np.log2(3 * size - 2)))
+
+
+def _convolve(weights: np.ndarray, step: float, size: int, h: float, axis: int) -> np.ndarray:
+    """``sum_i w[i] K((j - i) step)`` for every fine index ``j`` along *axis*."""
+    length = _fft_length(size)
+    spectrum = np.fft.rfft(weights, length, axis=axis)
+    shape = [1] * weights.ndim
+    shape[axis] = -1
+    full = np.fft.irfft(spectrum * _kernel_fft(step, size, h, length).reshape(shape), length, axis=axis)
+    return np.take(full, np.arange(size - 1, 2 * size - 1), axis=axis)
+
+
+def gaussian_1d(x: np.ndarray, lo: float, hi: float, n: int, h: float) -> np.ndarray | None:
+    """``sum_i phi((g - x_i) / h) / h`` at ``linspace(lo, hi, n)``, or None."""
+    axis = _fine_axis(x, lo, hi, n, h, _MAX_STEP_1D)
+    if axis is None:
+        return None
+    origin, step, size, first, fine = axis
+    x = x[_within(x, origin, step, size)]
+    left, frac = _linear_bins(x, origin, step, size)
+    weights = np.bincount(left, 1.0 - frac, size) + np.bincount(left + 1, frac, size)
+    sums = _convolve(weights, step, size, h, axis=0)
+    return np.maximum(sums[first:first + (n - 1) * fine + 1:fine], 0.0)
+
+
+def gaussian_2d(
+    xs: np.ndarray, ys: np.ndarray, x_lims: tuple[float, float], y_lims: tuple[float, float],
+    n: int, hx: float, hy: float,
+) -> np.ndarray | None:
+    """``sum_i phi_x(gx - x_i) phi_y(gy - y_i)`` as an ``(n, n)`` (y, x) grid, or None."""
+    ax = _fine_axis(xs, x_lims[0], x_lims[1], n, hx, _MAX_STEP_2D)
+    ay = _fine_axis(ys, y_lims[0], y_lims[1], n, hy, _MAX_STEP_2D)
+    if ax is None or ay is None:
+        return None
+    (x_origin, x_step, x_size, x_first, x_fine), (y_origin, y_step, y_size, y_first, y_fine) = ax, ay
+    # Two FFT passes over the fine grid must beat n exponentials per value
+    # on each axis; a grid stretched over wide limits does not.
+    if x_size * y_size > _MAX_CELLS or x_size * y_size * 16 > xs.size * n:
+        return None
+    keep = _within(xs, x_origin, x_step, x_size) & _within(ys, y_origin, y_step, y_size)
+    xs, ys = xs[keep], ys[keep]
+    xl, xf = _linear_bins(xs, x_origin, x_step, x_size)
+    yl, yf = _linear_bins(ys, y_origin, y_step, y_size)
+    cells = y_size * x_size
+    weights = np.zeros(cells)
+    for dy, wy in ((0, 1.0 - yf), (1, yf)):
+        for dx, wx in ((0, 1.0 - xf), (1, xf)):
+            weights += np.bincount((yl + dy) * x_size + xl + dx, wy * wx, cells)
+    weights = weights.reshape(y_size, x_size)
+    sums = _convolve(_convolve(weights, x_step, x_size, hx, axis=1), y_step, y_size, hy, axis=0)
+    rows = slice(y_first, y_first + (n - 1) * y_fine + 1, y_fine)
+    cols = slice(x_first, x_first + (n - 1) * x_fine + 1, x_fine)
+    return np.maximum(sums[rows, cols], 0.0)

{plot3-0.6.8 → plot3-0.8.0}/plot3/masking.py

@@ -30,11 +30,16 @@ from __future__ import annotations
 
 import ast
 import builtins
+import dataclasses
 import io
 import re
 import tokenize
 from typing import Any, Iterable
 
+import tidysyntax
+from tidysyntax import repairs
+from tidysyntax.scanner import Spans, apply
+
 # Sentinels (plot3 own + tidy3 compatibility).
 BT_NAME = "__plot3_bt__"
 TIDY3_BT_NAME = "__tidy3_bt__"
@@ -108,69 +113,121 @@ _PASSTHROUGH_KW = frozenset(
 
 _FORMULA_CALLS = frozenset({"geom_function", "geom_vector_field"})
 
-_BT_RE = re.compile(r"`([^`\n]+)`")
+_FACETS = frozenset({"facet_wrap", "facet_grid"})
+
+# plot3's part of the notebook syntax tidy3, tidy3a, plot3 and stats3 share
+# (tidysyntax). ``drv ~ cyl`` and ``~`my col``` are not Python, so they are
+# quoted in any facet call; ``^`` in geom_function (XOR in Python) and ``~cyl``
+# in a facet (bitwise not) are valid Python, so they are rewritten only where
+# the call is plot3's: a notebook's own geom_function keeps XOR.
+DIALECT = tidysyntax.Dialect(
+    "plot3",
+    formula_calls=_FACETS,
+    formula_keywords={"facets"},
+    formula_backticks="strip",
+    power_calls=_FORMULA_CALLS,
+    unary_formula_calls=_FACETS,
+)
+_POWER_ONLY = dataclasses.replace(DIALECT, formula_calls=(), formula_keywords=(), unary_formula_calls=())
+_FACETS_ONLY = dataclasses.replace(DIALECT, power_calls=())
+
+_SESSION = object()  # default: the running IPython's namespace, if any
+
+
+def _session_namespace(namespace: Any) -> dict[str, Any] | None:
+    if namespace is not _SESSION:
+        return namespace
+    try:
+        from IPython import get_ipython
+
+        ip = get_ipython()
+    except Exception:
+        return None
+    return getattr(ip, "user_ns", None) if ip is not None else None
+
+
+def _plot3_bt(source: str) -> str:
+    """tidysyntax's ``__r_name__`` placeholder as plot3's ``__plot3_bt__``, outside strings and comments."""
+    if tidysyntax.NAME not in source:
+        return source
+    spans = Spans.of(source)
+    edits = [
+        (m.start(), m.end(), BT_NAME)
+        for m in re.finditer(re.escape(tidysyntax.NAME) + r"(?=\s*\()", source)
+        if m.start() in spans
+    ]
+    return apply(source, edits)
+
+
+def _repair(source: str) -> str:
+    """The rewrites of text that is not Python: ``drv ~ cyl``, ``~`my col``` and backticks."""
+    return _plot3_bt(repairs.backticks(repairs.quote_formulas(source, [DIALECT])))
 
 
-def rewrite_formula_carets(source: str) -> str:
+def rewrite_facet_formulas(source: str, *, unary: str = "owned", namespace: Any = _SESSION) -> str:
+    """Quote R formulas inside ``facet_wrap`` / ``facet_grid`` before parsing.
+
+    ``facet_grid(drv ~ cyl)`` → ``facet_grid('drv ~ cyl')``: ``~`` with a left
+    side is not Python, so it is quoted in any facet call, as is a ``~`` formula
+    holding a backtick name. ``facet_wrap(~cyl)`` → ``facet_wrap('~cyl')``
+    only where the facet call is plot3's, since ``~cyl`` is Python's bitwise
+    not (``unary="owned"``); ``unary="never"`` leaves such formulas for a
+    later pass. Backtick names inside the formula lose their backticks
+    (``~`my col``` → ``'~my col'``).
+    """
+    source = repairs.quote_formulas(source, [DIALECT])
+    if unary == "never":
+        return source
+    return tidysyntax.reinterpret(source, [_FACETS_ONLY], _session_namespace(namespace))
+
+
+def rewrite_formulas(source: str, namespace: Any = _SESSION) -> str:
+    """The text rewrites plot3 needs even when tidy3 handles backticks:
+    ``^`` inside ``geom_function`` and ``~`` formulas inside facets.
+
+    ``drv ~ cyl`` is quoted first, since the cell must parse before the
+    ownership of ``geom_function`` and ``facet_wrap`` can be read."""
+    source = repairs.quote_formulas(source, [DIALECT])
+    return tidysyntax.reinterpret(source, [DIALECT], _session_namespace(namespace))
+
+
+def rewrite_formula_carets(source: str, namespace: Any = _SESSION) -> str:
     """Inside ``geom_function(...)``, turn ``^`` into ``**`` before Python parses.
 
     ``2*x^3`` and ``(2*x)^3`` are the same tree once Python has parsed ``^``
-    as xor, so the rewrite has to happen on the text.
+    as xor, so the rewrite has to happen on the text. Only plot3's own
+    ``geom_function`` is rewritten: in a notebook's own function of that
+    name, ``^`` stays XOR.
     """
-    if "^" not in source or not any(name in source for name in _FORMULA_CALLS):
-        return source
-    try:
-        tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))
-    except (tokenize.TokenError, SyntaxError):
-        return source
-    starts = [0]
-    for line in source.splitlines(keepends=True):
-        starts.append(starts[-1] + len(line))
-    hits: list[int] = []
-    depth = 0  # paren depth inside the current geom_function call
-    armed = False  # just saw the name geom_function
-    for tok in tokens:
-        if depth == 0:
-            if tok.type == tokenize.NAME and tok.string in _FORMULA_CALLS:
-                armed = True
-                continue
-            if armed and tok.type == tokenize.OP and tok.string == "(":
-                depth = 1
-            armed = False
-            continue
-        if tok.type == tokenize.OP:
-            if tok.string in "([{":
-                depth += 1
-            elif tok.string in ")]}":
-                depth -= 1
-            elif tok.string == "^":
-                row, col = tok.start
-                hits.append(starts[row - 1] + col)
-    for pos in reversed(hits):
-        source = source[:pos] + "**" + source[pos + 1 :]
-    return source
-
-
-def rewrite_backticks(source: str) -> str:
-    """Preparse backticks, and ``^`` inside ``geom_function``, before parsing.
+    return tidysyntax.reinterpret(source, [_POWER_ONLY], _session_namespace(namespace))
+
+
+def rewrite_backticks(source: str, namespace: Any = _SESSION) -> str:
+    """Preparse backticks, ``^`` inside ``geom_function``, and facet formulas.
 
     `` `col name` `` → ``__plot3_bt__("col name")``. ``^`` → ``**`` only
-    inside a ``geom_function(...)`` call, where it means power.
+    inside plot3's ``geom_function(...)``, where it means power. Backticks
+    inside string literals and comments stay as written. The text that is
+    not Python goes first, so the cell parses when the ownership of
+    ``geom_function`` and ``facet_wrap`` is read.
     """
-    source = rewrite_formula_carets(source)
-    if "`" not in source:
-        return source
-    return _BT_RE.sub(lambda m: f"{BT_NAME}({m.group(1)!r})", source)
+    return tidysyntax.reinterpret(_repair(source), [DIALECT], _session_namespace(namespace))
 
 
-def plot3_backtick_transform(lines: list[str]) -> list[str]:
-    """IPython input transformer: backticks, and ``^`` inside geom_function."""
-    if not lines:
-        return lines
-    src = "".join(lines)
-    if "`" not in src and "^" not in src:
-        return lines
-    out = rewrite_backticks(src)
+def _parse_dedented(source: str) -> tuple[ast.Module, list[int]] | None:
+    """Parse *source* with indented ``+`` lines moved to column 0 (they are
+    joined later); the shift per line maps positions back. ``None`` if the
+    cell does not parse, in which case nothing valid is reinterpreted."""
+    raw = source.split("\n")
+    shift = [len(line) - len(line.lstrip()) if line.lstrip().startswith("+") else 0 for line in raw]
+    try:
+        tree = ast.parse("\n".join(line[n:] for line, n in zip(raw, shift)))
+    except (SyntaxError, ValueError):
+        return None
+    return tree, shift
+
+
+def _as_lines(src: str, out: str, lines: list[str]) -> list[str]:
     if out == src:
         return lines
     if out.endswith("\n"):
@@ -179,6 +236,28 @@ def plot3_backtick_transform(lines: list[str]) -> list[str]:
     return parts or [out]
 
 
+def plot3_backtick_transform(lines: list[str]) -> list[str]:
+    """IPython input transformer: backticks, ``^`` inside geom_function, and
+    ``~`` formulas inside facets."""
+    if not lines:
+        return lines
+    src = "".join(lines)
+    if "`" not in src and "^" not in src and "~" not in src:
+        return lines
+    return _as_lines(src, rewrite_backticks(src), lines)
+
+
+def plot3_formula_transform(lines: list[str]) -> list[str]:
+    """IPython input transformer used beside tidy3's backtick preparser:
+    ``^`` inside geom_function and ``~`` formulas inside facets only."""
+    if not lines:
+        return lines
+    src = "".join(lines)
+    if "^" not in src and "~" not in src:
+        return lines
+    return _as_lines(src, rewrite_formulas(src), lines)
+
+
 _OPENERS = frozenset("([{")
 _CLOSERS = frozenset(")]}")
 _SKIP_TOKENS = frozenset({
@@ -229,7 +308,7 @@ def _value_start(tokens: list[tokenize.TokenInfo]) -> tuple[int, int]:
     return tokens[0].start
 
 
-def join_layer_lines(source: str) -> str | None:
+def join_layer_lines(source: str, namespace: Any = _SESSION) -> str | None:
     """Join ``+`` lines that add plot3 layers to the statement above them.
 
     In a notebook, ``ggplot(df, aes(...))`` followed by lines that start
@@ -240,6 +319,12 @@ def join_layer_lines(source: str) -> str | None:
     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.
+
+    An indented ``+`` line is not Python, so it joins by name. An unindented
+    one is a valid unary-plus statement, so it joins only when the name after
+    ``+`` is plot3's and the statement above starts with a plot3 call or a
+    value not known to be something else: after ``x = 2``, or with the
+    notebook's own ``geom_point``, ``+ geom_point()`` stays a statement.
     """
     if not source or "+" not in source:
         return None
@@ -253,6 +338,36 @@ def join_layer_lines(source: str) -> str | None:
     logical = _logical_lines(analysed)
     if not logical:
         return None
+    parsed = _parse_dedented(_repair(source))
+    owners = tidysyntax.Owners(parsed[0], _session_namespace(namespace), [DIALECT]) if parsed is not None else None
+
+    def plot3_name(name: str, row: int) -> bool:
+        return owners is not None and DIALECT.owns_module(owners.module(name, (row, 0)))
+
+    def plot3_head(tokens: list[tokenize.TokenInfo]) -> bool:
+        start = _value_start(tokens)
+        rest = [t for t in tokens if t.start >= start]
+        while rest and rest[0].string == "(":
+            rest = rest[1:]
+        if owners is None or not rest or rest[0].type != tokenize.NAME:
+            return False
+        name, row = rest[0].string, rest[0].start[0]
+        if len(rest) > 1 and rest[1].string in ("(", "."):
+            return plot3_name(name, row)  # ggplot(...), p3.ggplot(...)
+        # A variable: refused only when its value is known not to be plot3's.
+        bound = [package for end, package in owners.bindings.get(name, ()) if end <= (row, 0)]
+        if bound:
+            return bound[-1] is None or DIALECT.owns_module(bound[-1])
+        if owners.context is not None and name in owners.context:
+            return DIALECT.owns_module(tidysyntax.module_of(owners.context[name]))
+        return True
+
+    def may_join(tokens: list[tokenize.TokenInfo], head: list[tokenize.TokenInfo]) -> bool:
+        """Whether joining this ``+`` line changes valid Python, and may: see above."""
+        row = tokens[0].start[0]
+        if shift[row - 1]:
+            return True  # indented: not Python on its own
+        return plot3_name(tokens[1].string, row) and plot3_head(head)
 
     def is_layer(tokens: list[tokenize.TokenInfo]) -> bool:
         return (
@@ -273,6 +388,7 @@ def join_layer_lines(source: str) -> str | None:
             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"}
+            and may_join(tokens, previous[0])
         ):
             previous.append(tokens)
         else:
@@ -618,7 +734,7 @@ def apply_masking(
     backticks: bool = True,
 ) -> str:
     """Apply backtick rewrite + AST masking; return unparsed source (tests)."""
-    text = rewrite_formula_carets(source)
+    text = rewrite_formulas(source)
     if backticks:
         text = rewrite_backticks(text)
     tree = ast.parse(text)
@@ -637,7 +753,8 @@ def is_mask_transformer(obj: Any) -> bool:
 def is_backtick_transformer(obj: Any) -> bool:
     return (
         getattr(obj, "__module__", "") in {"plot3.masking", "plot3.jupyter"}
-        and getattr(obj, "__name__", "") == "plot3_backtick_transform"
+        and getattr(obj, "__name__", "")
+        in {"plot3_backtick_transform", "plot3_formula_transform"}
     )