tidy3syntax 0.1.1__py3-none-any.whl

tidy3syntax/__init__.py

@@ -0,0 +1,39 @@
+"""R syntax in notebook cells, rewritten to Python, shared by tidy3, tidy3a, plot3 and stats3.
+
+Each package describes its syntax as a :class:`Dialect`; :func:`rewrite`
+turns a cell into Python for all of them at once. Repairs (text that is not
+Python) run by the call's name; reinterpretations (valid Python a package
+reads differently) run only in the package's own calls. See
+``docs/design.md``.
+"""
+
+from tidy3syntax.__version__ import __version__
+from tidy3syntax.dialect import Dialect
+from tidy3syntax.ownership import (
+    ModuleRef,
+    Owners,
+    imported_names,
+    module_of,
+    owned_calls,
+)
+from tidy3syntax.pipeline import reinterpret, rewrite
+from tidy3syntax.placeholders import ASSIGN, NAME, RAssign, RName, runtime_values
+from tidy3syntax.repairs import repair
+
+__all__ = [
+    "ASSIGN",
+    "NAME",
+    "Dialect",
+    "ModuleRef",
+    "Owners",
+    "RAssign",
+    "RName",
+    "__version__",
+    "imported_names",
+    "module_of",
+    "owned_calls",
+    "reinterpret",
+    "repair",
+    "rewrite",
+    "runtime_values",
+]

tidy3syntax/__version__.py

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

tidy3syntax/dialect.py

@@ -0,0 +1,94 @@
+"""A package's R syntax, described as data."""
+
+from __future__ import annotations
+
+import importlib
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass, field
+from typing import Literal
+
+
+def _names(values: Iterable[str]) -> frozenset[str]:
+    if isinstance(values, str):
+        raise TypeError(f"expected a collection of names, not the string {values!r}")
+    return frozenset(values)
+
+
+@dataclass(frozen=True)
+class Dialect:
+    """Which calls of one package take which piece of R syntax.
+
+    Fields under *repairs* name calls whose arguments may hold text that is
+    not Python; tidy3syntax rewrites those by the call's name, whoever owns
+    the call. Fields under *reinterpretations* name calls whose arguments
+    may hold valid Python that the package reads differently; tidy3syntax
+    rewrites those only in calls the package owns (see ``ownership``).
+    Names are the functions' names, without a module prefix.
+    """
+
+    package: str
+    # repairs
+    negation_calls: frozenset[str] = frozenset()  # !x -> ~x
+    ordered_calls: frozenset[str] = frozenset()  # name = value before a positional argument
+    settings: frozenset[str] = frozenset()  # keywords of ordered calls that are never moved
+    rule_calls: frozenset[str] = frozenset()  # left ~ right -> (left, right)
+    rule_after_column: frozenset[str] = frozenset()  # rule calls whose first argument is a column
+    formula_calls: frozenset[str] = frozenset()  # y ~ x -> "y ~ x"
+    formula_keywords: frozenset[str] = frozenset()  # keywords whose value may be a formula (facets=)
+    formula_backticks: Literal["keep", "strip"] = "keep"  # backtick names inside a quoted formula
+    stages: tuple[Callable[[str], str], ...] = ()  # the package's own repairs, run after the shared ones
+    # Which module prefixes make ``prefix.name(...)`` one of these calls: None for any
+    # (``ta.filter``), an empty set for bare calls only (so ``df.select(...)``, a method,
+    # is never rewritten), or the names allowed (``{"stats3"}``).
+    prefixes: frozenset[str] | None = None
+    # reinterpretations
+    power_calls: frozenset[str] = frozenset()  # ^ -> **
+    unary_formula_calls: frozenset[str] = frozenset()  # ~x -> "~x"
+    # The names the package exports; None reads the package's __all__ when first needed.
+    exports: frozenset[str] | None = field(default=None, compare=False)
+
+    def __post_init__(self) -> None:
+        for name in (
+            "negation_calls", "ordered_calls", "settings", "rule_calls", "rule_after_column",
+            "formula_calls", "formula_keywords", "power_calls", "unary_formula_calls",
+        ):
+            object.__setattr__(self, name, _names(getattr(self, name)))
+        if self.exports is not None:
+            object.__setattr__(self, "exports", _names(self.exports))
+        if self.prefixes is not None:
+            object.__setattr__(self, "prefixes", _names(self.prefixes))
+        if not self.rule_after_column <= self.rule_calls:
+            raise ValueError("rule_after_column must be a subset of rule_calls")
+        if self.formula_backticks not in ("keep", "strip"):
+            raise ValueError('formula_backticks is "keep" or "strip"')
+        if not self.package or "." in self.package:
+            raise ValueError("package is a top-level module name, such as 'tidy3a'")
+
+    def exported(self) -> frozenset[str]:
+        """The package's public names: ``exports``, or its ``__all__``."""
+        if self.exports is not None:
+            return self.exports
+        try:
+            module = importlib.import_module(self.package)
+        except Exception:
+            names: frozenset[str] = frozenset()
+        else:
+            names = frozenset(getattr(module, "__all__", ()) or (n for n in dir(module) if not n.startswith("_")))
+        object.__setattr__(self, "exports", names)
+        return names
+
+    def accepts_prefix(self, prefix: str | None) -> bool:
+        """Whether a call written ``prefix.name(...)`` (``None`` for a bare call) can be one of this dialect's."""
+        return prefix is None or self.prefixes is None or prefix in self.prefixes
+
+    def lists(self, field: str, name: str, prefix: str | None) -> bool:
+        """Whether the call ``prefix.name(...)`` is in this dialect's *field*."""
+        return name in getattr(self, field) and self.accepts_prefix(prefix)
+
+    def owns_module(self, module: str | None) -> bool:
+        """Whether a dotted module path belongs to this package."""
+        return module is not None and (module == self.package or module.startswith(self.package + "."))
+
+    @property
+    def reinterprets(self) -> bool:
+        return bool(self.power_calls or self.unary_formula_calls)

tidy3syntax/ownership.py

@@ -0,0 +1,207 @@
+"""Which package a call in a cell belongs to.
+
+A reinterpretation changes the meaning of valid Python, so it runs only in
+calls of the package that reads the text that way. The rule, as tidy3
+settled it:
+
+1. A local variable of an enclosing function, lambda or comprehension is
+   the notebook's own.
+2. Otherwise the latest top-level binding of the name in the cell before
+   the call decides: an import gives that module (a star import gives a
+   package's exported names), and any other binding (``def``, assignment,
+   ``for`` target, ...) makes the name the notebook's own.
+3. Otherwise the context decides: in IPython, the module of the live value.
+4. A name the context does not have is the package's that exports it, when
+   exactly one does. Such a cell fails with a NameError whatever a rewrite
+   does, so this changes no result and keeps error messages as they were.
+"""
+
+from __future__ import annotations
+
+import ast
+from collections.abc import Iterable, Mapping, Sequence
+from types import ModuleType
+from typing import Any
+
+from tidy3syntax.dialect import Dialect
+
+
+class ModuleRef(str):
+    """A context value that only says which module a name came from, for contexts
+    without live values, such as an export that read the earlier cells' imports."""
+
+    __slots__ = ()
+
+
+def module_of(value: Any) -> str | None:
+    """The dotted module a value comes from: a module's own name, a function's or
+    class's ``__module__``, or the module of an instance's type."""
+    if isinstance(value, ModuleRef):
+        return str(value)
+    if isinstance(value, ModuleType):
+        return value.__name__
+    if isinstance(value, type) or callable(value):
+        module = getattr(value, "__module__", None)
+        if isinstance(module, str):
+            return module
+    return type(value).__module__
+
+
+_SCOPES = (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda, ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
+
+
+class Owners:
+    """The bindings of one parsed cell, and the rule above applied to them."""
+
+    def __init__(self, tree: ast.Module, context: Mapping[str, Any] | None, dialects: Sequence[Dialect]):
+        self.context = context
+        self.dialects = tuple(dialects)
+        self.bindings: dict[str, list[tuple[tuple[int, int], str | None]]] = {}
+        stack: list[ast.AST] = list(tree.body)
+        while stack:
+            node = stack.pop()
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                self._bind(node.name, node, None)
+                continue
+            if isinstance(node, _SCOPES):
+                continue
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    if alias.asname:
+                        self._bind(alias.asname, node, alias.name)
+                    else:
+                        top = alias.name.split(".")[0]
+                        self._bind(top, node, top)
+            elif isinstance(node, ast.ImportFrom):
+                module = node.module if node.module and node.level == 0 else None
+                for alias in node.names:
+                    if alias.name == "*":
+                        for dialect in self.dialects:
+                            if dialect.owns_module(module):
+                                for name in dialect.exported():
+                                    self._bind(name, node, module)
+                    else:
+                        self._bind(alias.asname or alias.name, node, module)
+            elif isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del)):
+                self._bind(node.id, node, None)
+            elif isinstance(node, ast.ExceptHandler) and node.name:
+                self._bind(node.name, node, None)
+            stack.extend(ast.iter_child_nodes(node))
+        for found in self.bindings.values():
+            found.sort(key=lambda item: item[0])
+
+    def _bind(self, name: str, node: ast.AST, module: str | None) -> None:
+        end = (getattr(node, "end_lineno", None) or node.lineno, getattr(node, "end_col_offset", None) or 0)
+        self.bindings.setdefault(name, []).append((end, module))
+
+    def module(self, name: str, at: tuple[int, int]) -> str | None:
+        """The module *name* comes from when used at ``(line, byte column)`` *at*; ``None`` for the notebook's own."""
+        before = [module for end, module in self.bindings.get(name, ()) if end <= at]
+        if before:
+            return before[-1]
+        if self.context is not None and name in self.context:
+            return module_of(self.context[name])
+        exporting = [d.package for d in self.dialects if name in d.exported()]
+        return exporting[0] if len(exporting) == 1 else None
+
+    def owner(self, func: ast.AST, at: tuple[int, int], local: Iterable[str] = ()) -> str | None:
+        """The package of the dialects that a call's function belongs to, or ``None``."""
+        if isinstance(func, ast.Attribute) and isinstance(func.value, ast.Name):
+            name = func.value.id
+        elif isinstance(func, ast.Name):
+            name = func.id
+        else:
+            return None
+        if name in set(local):
+            return None
+        module = self.module(name, at)
+        for dialect in self.dialects:
+            if dialect.owns_module(module):
+                return dialect.package
+        return None
+
+
+def local_names(node: ast.AST) -> set[str]:
+    """Parameters and names bound in a function's, lambda's or comprehension's own scope."""
+    names: set[str] = set()
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda)):
+        arguments = node.args
+        names.update(a.arg for a in [*arguments.posonlyargs, *arguments.args, *arguments.kwonlyargs])
+        names.update(a.arg for a in (arguments.vararg, arguments.kwarg) if a is not None)
+        body = node.body if isinstance(node.body, list) else [node.body]
+    else:
+        body = [generator.target for generator in getattr(node, "generators", [])]
+    stack = list(body)
+    while stack:
+        child = stack.pop()
+        if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            names.add(child.name)
+            continue
+        if isinstance(child, _SCOPES):
+            continue
+        if isinstance(child, ast.Name) and isinstance(child.ctx, ast.Store):
+            names.add(child.id)
+        stack.extend(ast.iter_child_nodes(child))
+    return names
+
+
+def owned_calls(
+    source: str,
+    tree: ast.Module,
+    dialects: Sequence[Dialect],
+    context: Mapping[str, Any] | None,
+    names: Iterable[str],
+) -> dict[int, str]:
+    """For each call to one of *names* that a dialect's package owns: the offset in *source*
+    just past the function's name, mapped to that package."""
+    owners = Owners(tree, context, dialects)
+    lines = source.split("\n")
+    starts = [0]
+    for line in lines:
+        starts.append(starts[-1] + len(line) + 1)
+    wanted = frozenset(names)
+    found: dict[int, str] = {}
+
+    def visit(node: ast.AST, local: frozenset[str]) -> None:
+        if isinstance(node, _SCOPES):
+            local = local | local_names(node)
+        if isinstance(node, ast.Call):
+            func = node.func
+            name = func.id if isinstance(func, ast.Name) else func.attr if isinstance(func, ast.Attribute) else None
+            if name in wanted:
+                package = owners.owner(func, (func.lineno, func.col_offset), local)
+                if package is not None and func.end_lineno is not None and func.end_col_offset is not None:
+                    row = func.end_lineno
+                    column = len(lines[row - 1].encode()[: func.end_col_offset].decode(errors="ignore"))
+                    found[starts[row - 1] + column] = package
+        for child in ast.iter_child_nodes(node):
+            visit(child, local)
+
+    visit(tree, frozenset())
+    return found
+
+
+def imported_names(*sources: str, dialects: Sequence[Dialect] = ()) -> dict[str, ModuleRef]:
+    """The names the cells' top-level imports bind, in order, as a context for a rewrite
+    that has no live namespace (an export reading a notebook's earlier cells). A star
+    import binds the exported names of the *dialects* whose package it imports."""
+    names: dict[str, ModuleRef] = {}
+    for source in sources:
+        try:
+            tree = ast.parse(source)
+        except SyntaxError:
+            continue
+        for node in tree.body:
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    target = alias.asname or alias.name.split(".")[0]
+                    names[target] = ModuleRef(alias.name if alias.asname else alias.name.split(".")[0])
+            elif isinstance(node, ast.ImportFrom) and node.module and node.level == 0:
+                for alias in node.names:
+                    if alias.name != "*":
+                        names[alias.asname or alias.name] = ModuleRef(node.module)
+                    else:
+                        for dialect in dialects:
+                            if dialect.owns_module(node.module):
+                                names.update(dict.fromkeys(dialect.exported(), ModuleRef(node.module)))
+    return names

tidy3syntax/pipeline.py

@@ -0,0 +1,116 @@
+"""The rewrite of one cell: repairs, then ownership, then reinterpretations.
+
+Phase A runs every repair by name. Phase B parses the result and reads who
+owns each call that a reinterpretation would touch; a cell that does not
+parse keeps Python's meaning. Phase C applies the reinterpretations whose
+calls the dialect's package owns, and those of packages the caller listed in
+``always`` (an explicit scope the user turned on).
+"""
+
+from __future__ import annotations
+
+import ast
+from collections.abc import Collection, Mapping, Sequence
+from typing import Any
+
+from tidy3syntax.dialect import Dialect
+from tidy3syntax.ownership import owned_calls
+from tidy3syntax.repairs import formula_text, is_shell_cell, repair
+from tidy3syntax.scanner import (
+    Call,
+    Spans,
+    apply,
+    calls,
+    keyword,
+    strip_span,
+    top_level_tildes,
+)
+
+
+def rewrite(
+    source: str,
+    dialects: Sequence[Dialect],
+    context: Mapping[str, Any] | None = None,
+    always: Collection[str] = (),
+) -> str:
+    """The cell *source* as Python, with every dialect's R syntax rewritten.
+
+    *context* answers who owns a name the cell does not bind: an IPython
+    namespace, or ``imported_names(...)`` of earlier cells. *always* lists
+    packages whose reinterpretations apply whoever owns the call.
+    """
+    if is_shell_cell(source):
+        return source
+    source = repair(source, dialects)
+    return reinterpret(source, dialects, context, always)
+
+
+def reinterpret(
+    source: str,
+    dialects: Sequence[Dialect],
+    context: Mapping[str, Any] | None = None,
+    always: Collection[str] = (),
+) -> str:
+    """Phases B and C on text the repairs have already run on."""
+    active = [d for d in dialects if d.reinterprets]
+    if not active or ("^" not in source and "~" not in source):
+        return source
+    names = frozenset().union(*(d.power_calls | d.unary_formula_calls for d in active))
+    spans = Spans.of(source)
+    found = calls(source, names, spans)
+    if not found:
+        return source
+    try:
+        tree = ast.parse(source)
+    except (SyntaxError, ValueError):
+        owned: dict[int, str] = {}
+    else:
+        owned = owned_calls(source, tree, active, context, names)
+
+    def applies(call: Call, field: str) -> bool:
+        for dialect in active:
+            if dialect.lists(field, call.name, call.prefix) and (
+                owned.get(call.name_end) == dialect.package or dialect.package in always
+            ):
+                return True
+        return False
+
+    edits = _powers(source, spans, found, lambda call: applies(call, "power_calls"))
+    edits += _unary_formulas(source, active, found, lambda call: applies(call, "unary_formula_calls"))
+    return apply(source, edits)
+
+
+def _powers(source: str, spans: Spans, found: list[Call], applies) -> list[tuple[int, int, str]]:
+    """``^`` → ``**`` where the nearest enclosing power call applies."""
+    edits = []
+    candidates = [call for call in found if "^" in source[call.open : call.close]]
+    for i in spans.code_indices():
+        if source[i] != "^" or source[i + 1 : i + 2] == "=":
+            continue
+        enclosing = [call for call in candidates if call.open < i < call.close]
+        if enclosing and applies(max(enclosing, key=lambda call: call.open)):
+            edits.append((i, i + 1, "**"))
+    return edits
+
+
+def _unary_formulas(source: str, dialects: Sequence[Dialect], found: list[Call], applies) -> list[tuple[int, int, str]]:
+    """``facet_wrap(~cyl)`` → ``facet_wrap('~cyl')`` in unary-formula calls that apply."""
+    keywords = frozenset().union(*(d.formula_keywords for d in dialects))
+    edits = []
+    for call in found:
+        if not applies(call):
+            continue
+        strip = all(
+            d.formula_backticks == "strip" for d in dialects if call.name in d.unary_formula_calls
+        )
+        for a, b in call.arguments:
+            named = keyword(source[a:b])
+            if named is not None:
+                if named[0] not in keywords:
+                    continue
+                a += named[1]
+            a, b = strip_span(source, a, b)
+            tildes = top_level_tildes(source[a:b])
+            if tildes and not any(is_binary for _, is_binary in tildes):
+                edits.append((a, b, repr(formula_text(source[a:b], strip))))
+    return edits

tidy3syntax/placeholders.py

@@ -0,0 +1,47 @@
+"""The placeholders repairs leave in the text, and their values at run time.
+
+A repair runs by the call's name, so its output must not depend on which
+package owns the call. Where the reading does depend on the owner, the
+repair leaves a neutral placeholder, and the owner's AST pass decides what
+it means inside the owner's calls. Where no AST pass claims one, its
+run-time value below is what Python sees.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+NAME = "__r_name__"  # `First Name` -> __r_name__("First Name")
+ASSIGN = "__r_assign__"  # name = value before a positional argument -> __r_assign__("name", value)
+
+
+class RName(str):
+    """A name written in backticks: a column name that need not be a Python identifier."""
+
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        return f"{NAME}({str.__repr__(self)})"
+
+
+class RAssign:
+    """An assignment in the order written: ``target`` is a name, or a list of names; ``value`` is anything."""
+
+    __slots__ = ("target", "value")
+
+    def __init__(self, target: Any, value: Any):
+        self.target = target
+        self.value = value
+
+    def __repr__(self) -> str:
+        return f"{ASSIGN}({self.target!r}, {self.value!r})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, RAssign) and (self.target, self.value) == (other.target, other.value)
+
+    __hash__ = None  # type: ignore[assignment]
+
+
+def runtime_values() -> dict[str, Any]:
+    """The placeholders' values, for a namespace that runs rewritten cells."""
+    return {NAME: RName, ASSIGN: RAssign}

tidy3syntax/repairs.py

@@ -0,0 +1,308 @@
+"""Repairs: rewrites of text that is not Python.
+
+Each repair changes only text that is a syntax error, so no valid program
+can mean anything else by it, and it runs by the call's name, whoever owns
+the call. Each one leaves a cell that parses unchanged, and each is
+idempotent; the tests check both on every case and on the standard
+library's own source.
+
+Adapted from tidy3's ``masking.py`` (``rewrite_bang_not``,
+``rewrite_formula_rules``, ``rewrite_keywords_before_positional``,
+``rewrite_backtick_keyword_assigns``), tidy3a's ``jupyter.py``, plot3's
+``masking.py`` (facet formulas) and stats3's ``masking.py``
+(``quote_formulas``), all MIT.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+from collections.abc import Iterable, Sequence
+
+from tidy3syntax.dialect import Dialect
+from tidy3syntax.placeholders import ASSIGN, NAME
+from tidy3syntax.scanner import (
+    Call,
+    Spans,
+    apply,
+    calls,
+    keyword,
+    strip_span,
+    top_level_tildes,
+)
+
+_BACKTICK = re.compile(r"`([^`\n]+)`")
+# Placeholders a package's own pass may have left before tidy3syntax ran (tidy3, plot3), and tidy3syntax's own.
+_NAME_CALL = re.compile(r"__(?:r_name|tidy3_bt|plot3_bt)__\((['\"])(.*?)\1\)")
+
+
+def _union(dialects: Iterable[Dialect], field: str) -> frozenset[str]:
+    return frozenset().union(*(getattr(d, field) for d in dialects))
+
+
+def _listed(call: Call, dialects: Iterable[Dialect], field: str) -> bool:
+    """Whether some dialect lists *call*, with its prefix, in *field*."""
+    return any(d.lists(field, call.name, call.prefix) for d in dialects)
+
+
+def is_shell_cell(source: str) -> bool:
+    """A cell of IPython shell lines (``!cmd``) and comments only; no repair touches it."""
+    lines = [line.strip() for line in source.splitlines() if line.strip()]
+    return bool(lines) and lines[0].startswith("!") and all(line.startswith(("!", "#")) for line in lines)
+
+
+def _parses(text: str) -> bool:
+    try:
+        ast.parse(text.strip(), mode="eval")
+    except SyntaxError:
+        return False
+    return True
+
+
+# ── formulas ─────────────────────────────────────────────────────────────────
+
+
+def quote_formulas(source: str, dialects: Sequence[Dialect]) -> str:
+    """``lm(y ~ x)`` → ``lm('y ~ x')`` in formula calls; ``facet_wrap(~`my col`)`` → ``facet_wrap('~my col')``.
+
+    A formula with a left side (``y ~ x``, ``. ~ cyl``) is not Python, so it
+    is quoted in any formula call. A one-sided formula is quoted here only
+    when its text does not parse either (``` ~`my col` ```); ``~x`` is
+    bitwise not, and is left for the reinterpretation of unary-formula calls.
+    Keyword arguments are formulas only for the dialects' formula keywords.
+    """
+    binary = _union(dialects, "formula_calls")
+    unary = _union(dialects, "unary_formula_calls")
+    if "~" not in source or not (binary | unary):
+        return source
+    spans = Spans.of(source)
+    keywords = _union(dialects, "formula_keywords")
+    edits = []
+    for call in calls(source, binary | unary, spans):
+        for a, b in call.arguments:
+            named = keyword(source[a:b])
+            if named is not None:
+                if named[0] not in keywords:
+                    continue
+                a += named[1]
+            a, b = strip_span(source, a, b)
+            text = source[a:b]
+            tildes = top_level_tildes(text)
+            if not tildes:
+                continue
+            has_left = any(is_binary for _, is_binary in tildes)
+            if has_left and not _listed(call, dialects, "formula_calls"):
+                continue
+            if not has_left and (not _listed(call, dialects, "unary_formula_calls") or _parses(text)):
+                continue
+            edits.append((a, b, repr(formula_text(text, _strips(dialects, call.name)))))
+    return _outermost_last(edits, source)
+
+
+def _strips(dialects: Sequence[Dialect], name: str) -> bool:
+    listing = [d for d in dialects if name in d.formula_calls or name in d.unary_formula_calls]
+    return bool(listing) and all(d.formula_backticks == "strip" for d in listing)
+
+
+def formula_text(text: str, strip_backticks: bool) -> str:
+    """A formula's text as a string: whitespace collapsed, backtick names kept or stripped."""
+    text = _NAME_CALL.sub(lambda m: f"`{m.group(2)}`", text)
+    if strip_backticks:
+        text = text.replace("`", "")
+    return " ".join(text.split())
+
+
+def rule_pairs(source: str, dialects: Sequence[Dialect]) -> str:
+    """``case_when(x > 6 ~ "big")`` → ``case_when((x > 6, "big"))`` in rule calls.
+
+    ``~`` before a value stays negation (``~is_na(x) ~ 0`` is the rule
+    ``(~is_na(x), 0)``); keyword arguments and ``*args`` are left alone.
+    Raises SyntaxError, naming the function, for a rule that is not exactly
+    ``left ~ right``, and for a rule where a rule-after-column call expects
+    its column.
+    """
+    names = _union(dialects, "rule_calls")
+    if "~" not in source or not names:
+        return source
+    return _until_settled(lambda source: _rules_pass(source, names, dialects), source)
+
+
+def _rules_pass(source: str, names: frozenset[str], dialects: Sequence[Dialect]) -> str:
+    spans = Spans.of(source)
+    edits = []
+    for call in calls(source, names, spans):
+        if not _listed(call, dialects, "rule_calls"):
+            continue
+        for position, (a, b) in enumerate(call.arguments):
+            text = source[a:b]
+            if keyword(text) or text.lstrip().startswith("*"):
+                continue
+            separators = [i for i, is_binary in top_level_tildes(text) if is_binary]
+            if not separators:
+                continue
+            shown = text.strip()
+            if position == 0 and _listed(call, dialects, "rule_after_column"):
+                raise SyntaxError(f"{call.name}() takes the column first, then rules: {shown!r} is a rule, not a column")
+            if len(separators) > 1:
+                raise SyntaxError(
+                    f"{call.name}() rule {shown!r} has more than one ~; write one `left ~ right` per rule, "
+                    "with parentheses around anything that itself contains ~"
+                )
+            left, right = text[: separators[0]].strip(), text[separators[0] + 1 :].strip()
+            if not left or not right:
+                raise SyntaxError(f"{call.name}() rule {shown!r} needs a value on both sides of ~")
+            a, b = strip_span(source, a, b)
+            edits.append((a, b, f"({left}, {right})"))
+    return _outermost_last(edits, source)
+
+
+# ── negation ─────────────────────────────────────────────────────────────────
+
+
+def negation(source: str, dialects: Sequence[Dialect]) -> str:
+    """``filter(!(x > 1))`` → ``filter(~(x > 1))`` inside negation calls.
+
+    Also at the start of a line inside the call. ``!=``, strings, comments,
+    and shell lines outside a call (``!pip install …``, ``x = !ls``) stay.
+    """
+    names = _union(dialects, "negation_calls")
+    if "!" not in source or not names:
+        return source
+    spans = Spans.of(source)
+    inside = [(call.open, call.close) for call in calls(source, names, spans) if _listed(call, dialects, "negation_calls")]
+    edits = [
+        (i, i + 1, "~")
+        for i in spans.code_indices()
+        if source[i] == "!" and source[i + 1 : i + 2] != "=" and any(a < i < b for a, b in inside)
+    ]
+    return apply(source, edits)
+
+
+# ── assignments in the order written ─────────────────────────────────────────
+
+
+def backtick_assignments(source: str) -> str:
+    """`` `new col` = value `` as a call argument → ``__r_assign__('new col', (value))``.
+
+    A backtick name is not a valid keyword, so the assignment becomes a
+    positional placeholder, valid next to other arguments. ``==``, ``<=``,
+    ``>=``, ``!=`` and ``=~`` are not assignments.
+    """
+    if "`" not in source or "=" not in source:
+        return source
+
+    def one_pass(source: str) -> str:
+        spans = Spans.of(source)
+        edits = []
+        for match in re.finditer(r"`([^`\n]+)`\s*=(?![=~])", source):
+            if match.start() not in spans or not re.search(r"[(,]\s*\Z", source[: match.start()]):
+                continue
+            end = _value_end(source, match.end(), spans)
+            value = source[match.end() : end].strip()
+            if end is not None and value:
+                edits.append((match.start(), end, f"{ASSIGN}({match.group(1)!r}, ({value}))"))
+        return _outermost_last(edits, source)
+
+    return _until_settled(one_pass, source)
+
+
+def _outermost_last(edits: list[tuple[int, int, str]], source: str) -> str:
+    """Apply the edits that overlap no later one; an outer edit around an inner one waits for the next pass."""
+    kept: list[tuple[int, int, str]] = []
+    for edit in sorted(edits, reverse=True):
+        if all(edit[1] <= other[0] or edit[0] >= other[1] for other in kept):
+            kept.append(edit)
+    return apply(source, kept)
+
+
+def _until_settled(one_pass, source: str) -> str:
+    for _ in range(100):
+        rewritten = one_pass(source)
+        if rewritten == source:
+            return source
+        source = rewritten
+    return source
+
+
+def _value_end(source: str, start: int, spans: Spans) -> int | None:
+    """Where an argument's value that starts at *start* ends: the next top-level ``,`` or the call's ``)``."""
+    depth = 0
+    for i in spans.code_indices(start):
+        ch = source[i]
+        if ch in "([{":
+            depth += 1
+        elif ch in ")]}":
+            if depth == 0:
+                return i
+            depth -= 1
+        elif ch == "," and depth == 0:
+            return i
+    return None
+
+
+def keywords_before_positional(source: str, dialects: Sequence[Dialect]) -> str:
+    """``group_by(w = bins(t), lat)`` → ``group_by(__r_assign__('w', (bins(t))), lat)`` in ordered calls.
+
+    R takes ``name = value`` before a positional argument and Python does
+    not, so each such keyword becomes the ordered placeholder. Keywords
+    after the last positional argument, ``*args`` and ``**kwargs``, and the
+    dialects' settings are left alone, so valid Python is unchanged.
+    """
+    names = _union(dialects, "ordered_calls")
+    if "=" not in source or not names:
+        return source
+    settings = _union(dialects, "settings")
+    return _until_settled(lambda source: _keywords_pass(source, names, settings, dialects), source)
+
+
+def _keywords_pass(source: str, names: frozenset[str], settings: frozenset[str], dialects: Sequence[Dialect]) -> str:
+    edits = []
+    for call in calls(source, names):
+        if not _listed(call, dialects, "ordered_calls"):
+            continue
+        named = [keyword(source[a:b]) for a, b in call.arguments]
+        positional = [
+            i for i, ((a, b), kw) in enumerate(zip(call.arguments, named))
+            if kw is None and not source[a:b].lstrip().startswith("*")
+        ]
+        if not positional:
+            continue
+        for (a, b), kw in zip(call.arguments[: positional[-1]], named):
+            if kw is None or kw[0] in settings:
+                continue
+            value = source[a + kw[1] : b].strip()
+            a, b = strip_span(source, a, b)
+            edits.append((a, b, f"{ASSIGN}({kw[0]!r}, ({value}))"))
+    return _outermost_last(edits, source)
+
+
+# ── backtick names ───────────────────────────────────────────────────────────
+
+
+def backticks(source: str) -> str:
+    """`` `First Name` `` → ``__r_name__('First Name')``, outside strings and comments."""
+    if "`" not in source:
+        return source
+    spans = Spans.of(source)
+    edits = [
+        (m.start(), m.end(), f"{NAME}({m.group(1)!r})")
+        for m in _BACKTICK.finditer(source)
+        if m.start() in spans
+    ]
+    return apply(source, edits)
+
+
+def repair(source: str, dialects: Sequence[Dialect]) -> str:
+    """Every repair, in order: formulas, rules, negation, backtick assignments, the dialects'
+    own stages, keywords before positional arguments, then backtick names."""
+    if is_shell_cell(source):
+        return source
+    source = quote_formulas(source, dialects)
+    source = rule_pairs(source, dialects)
+    source = negation(source, dialects)
+    source = backtick_assignments(source)
+    for dialect in dialects:
+        for stage in dialect.stages:
+            source = stage(source)
+    source = keywords_before_positional(source, dialects)
+    return backticks(source)

tidy3syntax/scanner.py

@@ -0,0 +1,220 @@
+"""Reading cells that are not yet Python: strings, comments, calls, arguments.
+
+Every rewrite acts on text Python cannot parse yet (that is why it is
+needed), so the scanner works on characters, not on ``tokenize`` or
+``ast``. It knows string literals (single, triple, with any prefix),
+comments, and backtick names, and finds calls by name and their top-level
+arguments outside them.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+
+def string_end(source: str, i: int) -> int:
+    """The index just past the string literal whose opening quote is at ``source[i]``."""
+    quote = source[i]
+    if source.startswith(quote * 3, i):
+        j = i + 3
+        while j < len(source):
+            if source[j] == "\\":
+                j += 2
+                continue
+            if source.startswith(quote * 3, j):
+                return j + 3
+            j += 1
+        return len(source)
+    j = i + 1
+    while j < len(source) and source[j] not in (quote, "\n"):
+        j += 2 if source[j] == "\\" else 1
+    return min(j + 1, len(source))
+
+
+@dataclass(frozen=True)
+class Spans:
+    """Where a cell's code is: everything outside string literals and comments.
+
+    Backtick names count as code, so rewrites can find them, but a backtick
+    never opens a string: ```a b``` is one name, and a quote inside it ends
+    nothing.
+    """
+
+    code: tuple[tuple[int, int], ...]
+
+    @classmethod
+    def of(cls, source: str) -> Spans:
+        spans: list[tuple[int, int]] = []
+        start = i = 0
+        n = len(source)
+        while i < n:
+            ch = source[i]
+            if ch in "'\"":
+                spans.append((start, i))
+                i = start = string_end(source, i)
+            elif ch == "#":
+                spans.append((start, i))
+                newline = source.find("\n", i)
+                i = start = n if newline < 0 else newline
+            elif ch == "`":
+                close = source.find("`", i + 1)
+                newline = source.find("\n", i + 1)
+                i = n if close < 0 else close + 1 if newline < 0 or close < newline else i + 1
+            else:
+                i += 1
+        spans.append((start, n))
+        return cls(tuple((a, b) for a, b in spans if b > a))
+
+    def __contains__(self, index: int) -> bool:
+        return any(a <= index < b for a, b in self.code)
+
+    def code_indices(self, start: int = 0, end: int | None = None) -> Iterable[int]:
+        for a, b in self.code:
+            lo, hi = max(a, start), b if end is None else min(b, end)
+            yield from range(lo, hi)
+
+
+@dataclass(frozen=True)
+class Call:
+    """A call found by name: ``name`` as written (with any ``module.`` prefix), and where its parentheses are."""
+
+    name: str
+    prefix: str | None
+    name_end: int  # just past the function name
+    open: int  # index of "("
+    close: int  # index of ")"
+    arguments: tuple[tuple[int, int], ...]  # top-level argument spans, between the parentheses
+
+
+def calls(source: str, names: Iterable[str], spans: Spans | None = None) -> list[Call]:
+    """Calls to any of *names*, bare or prefixed (``ta.filter(``), outside strings and comments.
+
+    A call whose closing parenthesis is missing is left out. Calls nested in
+    another call's arguments are found too, in source order.
+    """
+    wanted = sorted(set(names), key=len, reverse=True)
+    if not wanted:
+        return []
+    spans = spans or Spans.of(source)
+    pattern = re.compile(r"(?<![\w.])(?:([A-Za-z_]\w*)\s*\.\s*)?(" + "|".join(map(re.escape, wanted)) + r")\s*\(")
+    found = []
+    for match in pattern.finditer(source):
+        if match.start() not in spans:
+            continue
+        open_at = match.end() - 1
+        parsed = arguments(source, open_at, spans)
+        if parsed is None:
+            continue
+        close, args = parsed
+        found.append(Call(match.group(2), match.group(1), match.end(2), open_at, close, tuple(args)))
+    return found
+
+
+def arguments(source: str, open_at: int, spans: Spans | None = None) -> tuple[int, list[tuple[int, int]]] | None:
+    """The index of the ``)`` matching ``source[open_at]``, and the top-level argument spans between them.
+
+    An empty call has no arguments; a trailing comma adds none.
+    """
+    spans = spans or Spans.of(source)
+    depth = 0
+    start = open_at + 1
+    found: list[tuple[int, int]] = []
+    in_name = False  # inside a backtick name, where brackets and commas are text
+    for i in spans.code_indices(open_at):
+        ch = source[i]
+        if ch == "`":
+            in_name = not in_name
+        elif in_name:
+            continue
+        elif ch in "([{":
+            depth += 1
+        elif ch in ")]}":
+            depth -= 1
+            if depth == 0:
+                if source[start:i].strip():
+                    found.append((start, i))
+                return i, found
+        elif ch == "," and depth == 1:
+            found.append((start, i))
+            start = i + 1
+    return None
+
+
+# Words after which a "~" is unary ("a and ~b"), not a formula's separator.
+_OPERATOR_WORDS = frozenset(
+    {"and", "or", "not", "in", "is", "if", "else", "lambda", "return", "yield", "await", "for"}
+)
+
+
+def top_level_tildes(text: str) -> list[tuple[int, bool]]:
+    """Each ``~`` at the top level of *text*, and whether it is binary.
+
+    Python's ``~`` is unary only, so a ``~`` after an operand (a name, a
+    number, a string, a backtick name, a closing bracket, or R's ``.``) can
+    only be a formula's separator: ``y ~ x``, ``. ~ cyl``. ``~x`` and
+    ``a and ~b`` are unary. Adapted from tidy3's ``_binary_tildes``.
+    """
+    found: list[tuple[int, bool]] = []
+    depth = 0
+    after_operand = False
+    i = 0
+    n = len(text)
+    while i < n:
+        c = text[i]
+        if c in "'\"":
+            i = string_end(text, i)
+            after_operand = True
+            continue
+        if c == "`":
+            close = text.find("`", i + 1)
+            i = n if close < 0 else close + 1
+            after_operand = True
+            continue
+        if c == "#":
+            newline = text.find("\n", i)
+            i = n if newline < 0 else newline
+            continue
+        if c.isalnum() or c == "_":
+            j = i
+            while j < n and (text[j].isalnum() or text[j] in "_."):
+                j += 1
+            after_operand = text[i:j] not in _OPERATOR_WORDS
+            i = j
+            continue
+        if c == ".":
+            after_operand = True  # R's "." in ". ~ cyl"
+        elif c in "([{":
+            depth += 1
+            after_operand = False
+        elif c in ")]}":
+            depth -= 1
+            after_operand = True
+        elif c == "~":
+            if depth == 0:
+                found.append((i, after_operand))
+            after_operand = False
+        elif not c.isspace():
+            after_operand = False
+        i += 1
+    return found
+
+
+def keyword(text: str) -> tuple[str, int] | None:
+    """``(name, index after "=")`` when an argument's text is ``name = value``; ``None`` otherwise."""
+    match = re.match(r"\s*([A-Za-z_]\w*)\s*=(?!=)", text)
+    return (match.group(1), match.end()) if match else None
+
+
+def strip_span(source: str, a: int, b: int) -> tuple[int, int]:
+    """*a*..*b* without its leading and trailing whitespace."""
+    text = source[a:b]
+    return a + len(text) - len(text.lstrip()), b - (len(text) - len(text.rstrip()))
+
+
+def apply(source: str, edits: Iterable[tuple[int, int, str]]) -> str:
+    """Replace each ``(start, end, text)`` span; the spans must not overlap."""
+    for start, end, text in sorted(edits, reverse=True):
+        source = source[:start] + text + source[end:]
+    return source

tidy3syntax-0.1.1.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: tidy3syntax
+Version: 0.1.1
+Summary: R syntax in notebook cells, rewritten to Python: shared by tidy3, tidy3a, plot3 and stats3
+Author: Rigoberto Leyva Salmeron
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rleyvasal/tidy3syntax
+Keywords: notebooks,ipython,jupyter,R,formulas,tidyverse
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: IPython
+Classifier: Framework :: Jupyter
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# tidy3syntax
+
+R syntax in notebook cells, rewritten to Python. It is the shared notebook
+layer of [tidy3](https://github.com/rleyvasal/tidy3),
+[tidy3a](https://github.com/rleyvasal/tidy3a),
+[plot3](https://github.com/rleyvasal/plot3) and
+[stats3](https://github.com/rleyvasal/stats3), released on its own so a fix
+reaches all four at once. It needs only the standard library.
+
+```python
+import tidy3syntax as ts
+
+stats3 = ts.Dialect("stats3", formula_calls={"t_test", "lm"})
+tidy3 = ts.Dialect("tidy3", negation_calls={"filter"}, ordered_calls={"select"},
+                   rule_calls={"case_when"})
+
+ts.rewrite("penguins >> t_test(body_mass_g ~ sex)", [stats3, tidy3])
+# "penguins >> t_test('body_mass_g ~ sex')"
+ts.rewrite('df >> filter(!is_na(x)) >> select(Cus = NUM, Row)', [stats3, tidy3])
+# "df >> filter(~is_na(x)) >> select(__r_assign__('Cus', (NUM)), Row)"
+```
+
+## Two kinds of rewrite
+
+**Repairs** change only text that is a syntax error in Python, so no valid
+program can mean anything else by it. They run by the call's name, whoever
+owns the call:
+
+| Written | Becomes | In calls listed as |
+|---|---|---|
+| `` `First Name` `` | `__r_name__('First Name')` | anywhere in code |
+| `` f(`new col` = x) `` | `f(__r_assign__('new col', (x)))` | any call |
+| `filter(!x)` | `filter(~x)` | `negation_calls` |
+| `select(a = x, b)` | `select(__r_assign__('a', (x)), b)` | `ordered_calls` |
+| `case_when(x > 6 ~ "big")` | `case_when((x > 6, "big"))` | `rule_calls` |
+| `t_test(y ~ g)`, `facet_grid(drv ~ cyl)` | `t_test('y ~ g')` | `formula_calls` |
+
+**Reinterpretations** change valid Python, so they run only in calls the
+dialect's package owns:
+
+| Written | Becomes | In calls listed as | Python's meaning |
+|---|---|---|---|
+| `geom_function(lambda x: x^2)` | `x**2` | `power_calls` | XOR |
+| `facet_wrap(~cyl)` | `facet_wrap('~cyl')` | `unary_formula_calls` | bitwise not |
+
+Who owns a call follows tidy3's rule: a function's local variable is the
+notebook's; otherwise the latest top-level binding in the cell before the call
+decides (an import gives its module, any other binding makes the name the
+notebook's); otherwise the `context` does (an IPython namespace, or
+`imported_names(...)` of earlier cells); a name the context lacks is the
+exporting package's. A cell that does not parse gets no reinterpretation.
+With `always={"plot3"}` a caller turns plot3's reinterpretations on everywhere.
+
+```python
+plot3 = ts.Dialect("plot3", power_calls={"geom_function"}, exports={"geom_function"})
+
+ts.rewrite("def geom_function(f):\n    return f(3)\nr = geom_function(lambda x: x ^ 2)", [plot3])
+# unchanged: the notebook's own geom_function keeps XOR
+ts.rewrite("from plot3 import *\ngeom_function(lambda x: x ^ 2)", [plot3])
+# "from plot3 import *\ngeom_function(lambda x: x ** 2)"
+```
+
+The placeholders' run-time values are `RName` and `RAssign`
+(`runtime_values()` gives both, for a namespace); each package's own AST pass
+turns them into its column references inside its calls.
+
+## Status
+
+Phases 1 to 5 of [the design](docs/design.md): the scanner, every repair,
+the ownership rule and the two reinterpretations, used by tidy3 0.15.1, tidy3a
+0.16.1, plot3 0.8.1 and stats3 0.6.1. Not yet
+here: the IPython coordinator that installs one transformer for all packages,
+continuation lines (`>>` for tidy3, `+` for plot3), and entry points.
+
+Until every package's AST pass reads the neutral placeholders, each package
+calls only the repairs whose output the others already read, and tidy3 and
+plot3 turn `__r_name__` and `__r_assign__` back into their own names
+(`__tidy3_bt__`, `__tidy3_assign__`, `__plot3_bt__`). tidy3a writes
+`__r_assign__` and hands it to tidy3 as `__tidy3_assign__` in tidy3's calls.
+
+Where the output differs from a package's own rewrite before the switch:
+
+- stats3: a multi-line formula keeps its indentation and trailing comma
+  (`t_test(\n    'y ~ g',\n)`), and backtick names in formulas are kept.
+- tidy3: a keyword before a positional argument in a method call
+  (`df.select(a = x, b)`) is rewritten like the verb, as `!` in one already
+  was; backticks inside strings and comments stay; a backtick assignment is
+  rewritten only as a call argument.
+- tidy3a: its placeholder is `__r_assign__` (it still reads `__tidy3a_assign__`).
+- plot3: a placeholder another package left inside a one-sided facet formula
+  (`facet_wrap(~__tidy3_bt__('a b'))`) becomes the name again: `'~a b'`.
+
+`scripts/family/` runs all five suites together on another machine: `sync.sh`
+copies the working trees and starts `run.sh` in a tmux session there, and
+`status.sh` reports each suite's result and failures.
+
+Known limits: a Python 3.12 f-string that nests the same quote
+(`f"{d["k"]}"`) is read as two strings, so a rewrite may see code inside it.
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest -q
+```
+
+The tests include properties: repairs leave every cell that parses unchanged,
+`rewrite` leaves the standard library's own source unchanged with every
+dialect registered, and rewriting is idempotent.

tidy3syntax-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+tidy3syntax/__init__.py,sha256=s4fpz-w9lRc0uh0nvbckKSdWwqa2aZxm37-4UL7UEHQ,1046
+tidy3syntax/__version__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+tidy3syntax/dialect.py,sha256=nbs-aakLHV2AD8uCSkwliauR1tB8iuH5CE94yL6SYlc,4705
+tidy3syntax/ownership.py,sha256=cxtCZKkNzrJ8QABgCTwtzoj6W-LQfwD8MIhXz5wZtUk,9225
+tidy3syntax/pipeline.py,sha256=Eu8JeIW1fPstXHCayh0Imh80XvWr3QTaHKEP23kJ71E,4316
+tidy3syntax/placeholders.py,sha256=u9vvAbvcPTLkaO69WXUX4VFXU3Bna0FJ3M3OtfcJ_Ts,1571
+tidy3syntax/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tidy3syntax/repairs.py,sha256=OF9tYgZUXLYNuVvWZ-X6MdHCiwdoP51cYn2tQILkU54,12817
+tidy3syntax/scanner.py,sha256=Dn6ElrKpmi1zsORPnXci0-41IYhAuV-0QXQoyPe38NM,7702
+tidy3syntax-0.1.1.dist-info/licenses/LICENSE,sha256=sjpfmtLhkcM74AL9VMpifL0CRdeiMoLyUO9OKZ_hg9I,1082
+tidy3syntax-0.1.1.dist-info/METADATA,sha256=qIcBqbtkVBFMGOmN4xI1yNeasq7RvUDht4BB5fG6I2U,5714
+tidy3syntax-0.1.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+tidy3syntax-0.1.1.dist-info/top_level.txt,sha256=EEXnC9-T915VwTE8D-CvWi9TH_bOZpkBTPSEmWhQD0E,12
+tidy3syntax-0.1.1.dist-info/RECORD,,

tidy3syntax-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tidy3syntax-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rigoberto Leyva Salmeron 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tidy3syntax-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+tidy3syntax