plot3 0.7.0__tar.gz → 0.8.1__tar.gz

{plot3-0.7.0 → plot3-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.7.0
+Version: 0.8.1
 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: tidy3syntax<0.2,>=0.1
 Provides-Extra: pdf
 Requires-Dist: cairosvg>=2.7; extra == "pdf"
 Provides-Extra: dev

plot3-0.8.1/plot3/__version__.py

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

{plot3-0.7.0 → plot3-0.8.1}/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.7.0 → plot3-0.8.1}/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.7.0 → plot3-0.8.1}/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 tidy3syntax
+from tidy3syntax import repairs
+from tidy3syntax.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
+# (tidy3syntax). ``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 = tidy3syntax.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:
+    """tidy3syntax's ``__r_name__`` placeholder as plot3's ``__plot3_bt__``, outside strings and comments."""
+    if tidy3syntax.NAME not in source:
+        return source
+    spans = Spans.of(source)
+    edits = [
+        (m.start(), m.end(), BT_NAME)
+        for m in re.finditer(re.escape(tidy3syntax.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 tidy3syntax.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 tidy3syntax.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 tidy3syntax.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 tidy3syntax.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 = tidy3syntax.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(tidy3syntax.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"}
     )
 
 

{plot3-0.7.0 → plot3-0.8.1}/plot3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.7.0
+Version: 0.8.1
 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: tidy3syntax<0.2,>=0.1
 Provides-Extra: pdf
 Requires-Dist: cairosvg>=2.7; extra == "pdf"
 Provides-Extra: dev

{plot3-0.7.0 → plot3-0.8.1}/plot3.egg-info/requires.txt

@@ -1,5 +1,6 @@
 numpy>=1.24
 pandas>=2.0
+tidy3syntax<0.2,>=0.1
 
 [dev]
 pytest>=7.0

{plot3-0.7.0 → plot3-0.8.1}/pyproject.toml

@@ -22,6 +22,9 @@ classifiers = [
 dependencies = [
   "numpy>=1.24",
   "pandas>=2.0",
+  # The notebook syntax tidy3, tidy3a, plot3 and stats3 share (facet
+  # formulas, ^ in geom_function, backtick names). Standard library only.
+  "tidy3syntax>=0.1,<0.2",
 ]
 
 [project.optional-dependencies]