plot3 0.6.4__tar.gz → 0.6.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.4
+Version: 0.6.6
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT
@@ -130,6 +130,10 @@ gapminder = pd.read_csv("https://raw.githubusercontent.com/kirenz/datasets/maste
 `{frame_time}` in the title shows the current year as it plays.
 `transition_states("phase")` steps through categories instead of time.
 
+Click a bubble to trace it: its path through every frame appears, with
+the years along it and its name (from `group=`) riding beside it as it
+plays. Click it again, or empty space, to clear it. This works in 3D too.
+
 <details>
 <summary>Run this without downloading anything (made-up gapminder-shaped data)</summary>
 
@@ -256,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.4 → plot3-0.6.6}/README.md

@@ -103,6 +103,10 @@ gapminder = pd.read_csv("https://raw.githubusercontent.com/kirenz/datasets/maste
 `{frame_time}` in the title shows the current year as it plays.
 `transition_states("phase")` steps through categories instead of time.
 
+Click a bubble to trace it: its path through every frame appears, with
+the years along it and its name (from `group=`) riding beside it as it
+plays. Click it again, or empty space, to clear it. This works in 3D too.
+
 <details>
 <summary>Run this without downloading anything (made-up gapminder-shaped data)</summary>
 
@@ -229,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.6/plot3/__version__.py

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

{plot3-0.6.4 → plot3-0.6.6}/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.4 → plot3-0.6.6}/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.4 → plot3-0.6.6}/plot3/viewer.py

@@ -702,6 +702,26 @@ const stepEntries = [];
 let hoverHold = false;
 let trail = null;
 let trailId = null;
+// The clicked bubble's path: points with their frame, its name and colour.
+let trailInfo = null;
+// A click toggles a bubble's path only on the bubble itself (a little
+// slack for tiny dots), so a stray click near one draws nothing.
+function clickRadius(L, i, minimum) {
+  return L._size ? Math.max(minimum, L._size[i] * 0.55) : minimum;
+}
+function trailKey(L, i) { return String(i) + '|' + (L.ids ? L.ids[i] : ''); }
+function trailHint(L, i) {
+  return '<br><span style="opacity:.6;font-size:10px">click to ' +
+    (trailId === trailKey(L, i) ? 'hide' : 'show') + ' its path</span>';
+}
+// The frame's value (the year) for a point on the path, or '' if unknown.
+function trailYear(f) {
+  const tr = S.transition;
+  if (!tr || !tr.times || !trailInfo || tr.times.length !== trailInfo.nF) return '';
+  const v = tr.times[f];
+  if (tr.integer) return String(Math.round(+v));
+  return typeof v === 'number' ? fmt(v) : String(v);
+}
 function framePresent(F, i) {
   if (!F.x || !F.x.maskData || !F.x.maskData[i]) return false;
   if (!F.y || !F.y.maskData || !F.y.maskData[i]) return false;
@@ -1167,6 +1187,7 @@ function clearTrail() {
     trail = null;
   }
   trailId = null;
+  trailInfo = null;
 }
 function setTrail(L, obj) {
   clearTrail();
@@ -1208,7 +1229,18 @@ function setTrail(L, obj) {
   }
   scene.add(group);
   trail = group;
-  trailId = String(obj) + '|' + (L.ids ? L.ids[obj] : '');
+  trailId = trailKey(L, obj);
+  const pts = [];
+  for (let f = 0; f < nF; f++) {
+    const i = obj * nF + f;
+    if (!framePresent(F, i)) continue;
+    pts.push({ x: F.x.data[i], y: F.y.data[i], z: F.z ? F.z.data[i] : 0, f: f });
+  }
+  trailInfo = {
+    L: L, obj: obj, nF: nF, ext: ext, pts: pts,
+    name: L.ids && L.ids[obj] != null ? String(L.ids[obj]) : '',
+    color: 'rgb(' + rgb.map(c => Math.round(c * 255)).join(',') + ')',
+  };
 }
 let frameLabel = '';
 const axisTitleSprites = [];
@@ -2038,10 +2070,48 @@ if (!S.is3d) {
       const AY = Math.min(Math.max(Y, M.t + 12), M.t + H - 10);
       s += '<text x="' + AX + '" y="' + AY + '" fill="' + T.ink + '" text-anchor="middle" dominant-baseline="middle" font-size="12" font-weight="600" paint-order="stroke" stroke="' + T.surface + '" stroke-width="4" stroke-linejoin="round">' + plot3Esc(ann.text) + '</text>';
     }
+    if (trailInfo) s += trailLabels2D();
     svg.innerHTML = s;
     if (gridSvg) gridSvg.innerHTML = grid;
   }
 
+  // The clicked bubble's name rides beside it; years mark its path,
+  // spaced so they do not overlap (the first and last always show).
+  function trailLabels2D() {
+    const t = trailInfo, ext = t.ext;
+    const inside = (X, Y) => X >= M.l && X <= M.l + W && Y >= M.t && Y <= M.t + H;
+    const halo = ' paint-order="stroke" stroke="' + T.surface + '" stroke-width="3" stroke-linejoin="round"';
+    // The name sits right of the bubble's current position; years keep clear.
+    const L = t.L, i = t.obj;
+    let nameBox = null, nameSvg = '';
+    if (t.name && L._x && L._y) {
+      const X = M.l + screenX(L._x[i] * ext[0]), Y = M.t + screenY(L._y[i] * ext[1]);
+      if (inside(X, Y)) {
+        const x0 = X + (L._size ? L._size[i] * 0.5 : 4) + 4;
+        nameBox = [x0 - 4, Y - 9, x0 + 7.2 * t.name.length + 4, Y + 9];
+        nameSvg = '<text x="' + x0 + '" y="' + Y + '" fill="' + t.color +
+          '" font-size="12" font-weight="700" dominant-baseline="middle"' + halo + '>' +
+          plot3Esc(t.name) + '</text>';
+      }
+    }
+    const underName = (X, Y) => nameBox && X + 5 + 26 > nameBox[0] && X + 5 < nameBox[2] &&
+      Y - 5 > nameBox[1] - 6 && Y - 5 - 10 < nameBox[3];
+    const kept = [];
+    t.pts.forEach((p, k) => {
+      const X = M.l + screenX(p.x * ext[0]), Y = M.t + screenY(p.y * ext[1]);
+      const label = trailYear(p.f);
+      if (!label || !inside(X, Y) || underName(X, Y)) return;
+      const prev = kept[kept.length - 1];
+      const near = prev && Math.hypot(X - prev.X, Y - prev.Y) < 34;
+      if (near && k !== t.pts.length - 1) return;
+      if (near && kept.length > 1) kept.pop();   // the last year wins a crowded end
+      else if (near) return;
+      kept.push({ X, Y, label });
+    });
+    return kept.map(k => '<text x="' + (k.X + 5) + '" y="' + (k.Y - 5) + '" fill="' + T.muted +
+      '" font-size="10"' + halo + '>' + plot3Esc(k.label) + '</text>').join('') + nameSvg;
+  }
+
   function layout() {
     placeLegend();
     W = Math.max(50, figEl.clientWidth - M.l - M.r);
@@ -2283,7 +2353,9 @@ if (!S.is3d) {
               : head
                 + fmtSpan('x', xv, xSpan) + ', '
                 + fmtSpan('y', yv, ySpan) + sizeBit;
-            consider(d, sx, sy, html, !!(L.kind === 'point' && L.frames && S.transition));
+            const moving = L.kind === 'point' && L.frames && S.transition;
+            const cr = clickRadius(L, i, 6);
+            consider(d, sx, sy, html + (moving && d <= cr * cr ? trailHint(L, i) : ''), !!moving);
           }
         }
       }
@@ -2311,14 +2383,14 @@ if (!S.is3d) {
       for (let i = 0; i < L.n; i++) {
         if (L._alpha && L._alpha[i] <= 0.04) continue;
         const sx = screenX(L._x[i]), sy = screenY(L._y[i]);
-        const rad = L._size ? Math.max(10, L._size[i] * 0.55) : 12;
+        const rad = clickRadius(L, i, 6);
         const d = (sx - mx) * (sx - mx) + (sy - my) * (sy - my);
         if (d <= rad * rad && d < hitD) { hitD = d; hit = { L, i }; }
       }
     }
+    tip.style.display = 'none';
     if (!hit) { clearTrail(); draw(); return; }
-    const key = String(hit.i) + '|' + (hit.L.ids ? hit.L.ids[hit.i] : '');
-    if (trailId === key) { clearTrail(); draw(); return; }
+    if (trailId === trailKey(hit.L, hit.i)) { clearTrail(); draw(); return; }
     setTrail(hit.L, hit.i);
     draw();
   });
@@ -2660,6 +2732,7 @@ if (!S.is3d) {
       }
     }
     hoverHold = !!(best && best[0].kind === 'point' && best[0].frames && S.transition);
+    const hoverD = bestD;
     if (!best) { tip3.style.display = 'none'; return; }
     const [L, i, sx, sy, xn, yn, zn] = best;
     const xv = fromScale('x', xn);
@@ -2687,6 +2760,10 @@ if (!S.is3d) {
         + axisPair('y', fmt(yv)) + ', '
         + axisPair('z', fmt(zv)) + sizeBit
       : head + fmt(xv) + ', ' + fmt(yv) + ', ' + fmt(zv) + sizeBit;
+    if (hoverHold) {
+      const cr = sizeAtten ? 8 : clickRadius(L, i, 8);
+      if (hoverD <= cr * cr) tip3.innerHTML += trailHint(L, i);
+    }
     plot3Typeset(tip3);
     tip3.style.left = Math.min(w - 8, sx + 12) + 'px';
     tip3.style.top = Math.max(8, sy - 10) + 'px';
@@ -2737,15 +2814,36 @@ if (!S.is3d) {
         v.project(cam);
         const sx = (v.x * 0.5 + 0.5) * w;
         const sy = (-v.y * 0.5 + 0.5) * h;
-        const rad = (L._size && !sizeAtten) ? Math.max(16, L._size[i] * 0.55) : 16;
+        const rad = sizeAtten ? 8 : clickRadius(L, i, 8);
         const d = (sx - mx) * (sx - mx) + (sy - my) * (sy - my);
         if (d <= rad * rad && d < hitD) { hitD = d; hit = { L, i }; }
       }
     }
+    tip3.style.display = 'none';
     if (!hit) { clearTrail(); return; }
-    const key = String(hit.i) + '|' + (hit.L.ids ? hit.L.ids[hit.i] : '');
-    if (trailId === key) { clearTrail(); return; }
+    if (trailId === trailKey(hit.L, hit.i)) { clearTrail(); return; }
     setTrail(hit.L, hit.i);
+    // The scene cannot move text every frame cheaply: label the path's
+    // ends, the first year, and the name with the last year.
+    if (trail && trailInfo && trailInfo.pts.length) {
+      const t = trailInfo;
+      const at = p => new THREE.Vector3(p.x * t.ext[0], p.y * t.ext[1], p.z * t.ext[2]);
+      const first = t.pts[0], last = t.pts[t.pts.length - 1];
+      const startText = trailYear(first.f);
+      if (startText) {
+        const sp = sprite(startText, true);
+        sp.center.set(-0.1, -0.2);
+        sp.position.copy(at(first));
+        trail.add(sp);
+      }
+      const endText = [t.name, trailYear(last.f)].filter(Boolean).join(' ');
+      if (endText) {
+        const sp = sprite(endText, false);
+        sp.center.set(-0.1, -0.2);
+        sp.position.copy(at(last));
+        trail.add(sp);
+      }
+    }
   });
 
   function layout() {

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.4
+Version: 0.6.6
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT
@@ -130,6 +130,10 @@ gapminder = pd.read_csv("https://raw.githubusercontent.com/kirenz/datasets/maste
 `{frame_time}` in the title shows the current year as it plays.
 `transition_states("phase")` steps through categories instead of time.
 
+Click a bubble to trace it: its path through every frame appears, with
+the years along it and its name (from `group=`) riding beside it as it
+plays. Click it again, or empty space, to clear it. This works in 3D too.
+
 <details>
 <summary>Run this without downloading anything (made-up gapminder-shaped data)</summary>
 
@@ -256,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.4 → plot3-0.6.6}/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.4/plot3/__version__.py

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