sqlinclude 0.1.0__py3-none-any.whl

sqlinclude/__init__.py

@@ -0,0 +1,7 @@
+"""sqlinclude -- tiny SQL source preprocessor.
+
+Expands @include directives and @define variables recursively. No SQL
+parsing, no opinion about any database.
+"""
+
+__version__ = "0.1.0"

sqlinclude/__main__.py

@@ -0,0 +1,8 @@
+"""Entry point for ``python -m sqlinclude``."""
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

sqlinclude/cli.py

@@ -0,0 +1,226 @@
+"""Command-line interface for sqlinclude."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import sys
+
+from . import __version__
+from .editor import (
+    edit_buffer,
+    have_ctrl_tty,
+    parse_buffer,
+    render_buffer,
+    resolve_editor,
+    undefined_count,
+)
+from .preprocess import (
+    ORIGIN_UNDEFINED,
+    STDIN_NAME,
+    collect_tree,
+    collect_vars,
+    render_tree,
+    walk,
+)
+
+
+def _stdout_can_encode(text: str) -> bool:
+    enc = getattr(sys.stdout, "encoding", None) or "ascii"
+    try:
+        text.encode(enc)
+    except (UnicodeEncodeError, LookupError):
+        return False
+    return True
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="sqlinclude",
+        description="Expand @include directives and @define variables in SQL source "
+        "(no SQL parsing).",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "example (analysis.sql):\n"
+            "\n"
+            "  @define start = '2024-01-01'\n"
+            "  @define end = '2024-12-31'\n"
+            "\n"
+            "  WITH users AS (\n"
+            '      @include "users.sql"\n'
+            "  ),\n"
+            "\n"
+            "  orders AS (\n"
+            "      @include orders.sql\n"
+            "  )\n"
+            "\n"
+            "  SELECT ... WHERE created BETWEEN @start AND @end\n"
+            "\n"
+            "run:\n"
+            "\n"
+            "  sqlinclude analysis.sql | bq query\n"
+            "  sqlinclude --vars start='2024-06-01' analysis.sql | bq query\n"
+            "  sqlinclude --tree analysis.sql   # show the include tree, not SQL\n"
+            "\n"
+            "variables:\n"
+            "\n"
+            "  @define name = value   set a variable in a file (first definition wins)\n"
+            "  --vars name=value      set a variable from the command line (repeatable)\n"
+            "  @name                  substituted where defined; undefined names pass\n"
+            "                         through unchanged (BigQuery @params stay intact)\n"
+            "  -e, --edit             open the editor even when nothing is undefined\n"
+            "  --no-edit              never open the editor; no stderr notes\n"
+            "\n"
+            "editing:\n"
+            "\n"
+            "  When a variable is undefined, sqlinclude opens $VISUAL/$EDITOR (or vim,\n"
+            "  notepad on Windows) on the controlling terminal, even if its output is\n"
+            "  piped. Edit values; delete a line to leave that variable undefined; blank\n"
+            "  and # lines are ignored. With -e/--edit the buffer also shows the @include\n"
+            "  tree. Undefined variables are always reported on stderr -- use\n"
+            "  --no-edit to silence everything.\n"
+        ),
+    )
+    parser.add_argument(
+        "file",
+        nargs="?",
+        default="-",
+        help="SQL file to preprocess (default: read stdin)",
+    )
+    parser.add_argument(
+        "-n",
+        "--no-markers",
+        action="store_true",
+        help="do not emit -- #line markers around includes",
+    )
+    parser.add_argument(
+        "--vars",
+        action="append",
+        default=[],
+        metavar="name=value",
+        help="set a variable (repeatable); wins over @define",
+    )
+    parser.add_argument(
+        "-e",
+        "--edit",
+        action="store_true",
+        help="open the editor even when no variable is undefined",
+    )
+    parser.add_argument(
+        "--no-edit",
+        action="store_true",
+        help="never open the editor; leave undefined @names as-is (no stderr notes)",
+    )
+    parser.add_argument(
+        "-t",
+        "--tree",
+        action="store_true",
+        help="print the @include dependency tree as ASCII on stdout instead of expanding SQL",
+    )
+    parser.add_argument(
+        "--ascii",
+        action="store_true",
+        help="use ASCII (not Unicode) box characters in the include tree",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    if argv is None:
+        argv = sys.argv
+    args = build_parser().parse_args(argv[1:])
+
+    cli_vars: dict[str, str] = {}
+    for pair in args.vars:
+        if "=" not in pair:
+            sys.stderr.write(f"sqlinclude: --vars expects name=value, got {pair!r}\n")
+            return 2
+        name, value = pair.split("=", 1)
+        if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name):
+            sys.stderr.write(f"sqlinclude: invalid variable name in --vars: {name!r}\n")
+            return 2
+        cli_vars[name] = value
+
+    if args.file == "-":
+        source = sys.stdin.read()
+        top = None
+    else:
+        try:
+            with open(args.file, encoding="utf-8") as fh:
+                source = fh.read()
+        except OSError as exc:
+            sys.stderr.write(f"sqlinclude: {args.file}: {exc}\n")
+            return 1
+        top = args.file
+    if source and not source.endswith("\n"):
+        source += "\n"
+
+    top_disp = (
+        os.path.relpath(os.path.realpath(top), os.getcwd()).replace("\\", "/")
+        if top
+        else STDIN_NAME
+    )
+
+    if args.tree:
+        root = collect_tree(source, top)
+        if root is None:
+            return 1
+        ascii_only = args.ascii or not _stdout_can_encode("└──")
+        sys.stdout.write(render_tree(root, ascii_only=ascii_only))
+        return 0
+
+    collected = collect_vars(source, top, cli_vars)
+    if collected is None:
+        return 1
+    order, values, sources = collected
+    undefined_present = any(values[n] is None for n in order)
+
+    if (
+        top is not None
+        and not args.no_edit
+        and (undefined_present or args.edit)
+        and have_ctrl_tty()
+    ):
+        editor = resolve_editor()
+        if undefined_present:
+            sys.stderr.write(
+                f"sqlinclude: opening {editor} for {undefined_count(order, values)} "
+                "undefined variable(s)\n"
+            )
+        tree = None
+        if args.edit:
+            tree = collect_tree(source, top)
+            if tree is None:
+                return 1
+        edited = edit_buffer(render_buffer(top_disp, order, values, sources, tree), editor)
+        if edited is None:
+            return 1
+        env = parse_buffer(edited)
+        blocked = set(order) - set(env)
+    else:
+        env = dict(cli_vars)
+        blocked = set()
+        if not args.no_edit and undefined_present:
+            names = [n for n in order if values[n] is None]
+            sys.stderr.write(
+                "sqlinclude: undefined variables "
+                f"({len(names)}): {', '.join('@' + n for n in names)} "
+                "-- left as @name\n"
+            )
+
+    out: list[str] = []
+    stack: list[tuple[str, str]] = []
+    if walk(source, top, out, stack, args.no_markers, env, blocked):
+        return 1
+    sys.stdout.write("".join(out))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

sqlinclude/editor.py

@@ -0,0 +1,179 @@
+"""Cross-platform terminal + editor helpers.
+
+The interactive undefined-variable flow needs to reach the user's controlling
+terminal even when stdout is piped (e.g. ``sqlinclude x.sql | bq query``). On
+POSIX that is ``/dev/tty``; on Windows the console is reached through the
+``CONIN$`` / ``CONOUT$`` device names. This module hides that difference.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import shlex
+import subprocess
+import sys
+import tempfile
+from typing import Iterator
+
+from .preprocess import (
+    ORIGIN_UNDEFINED,
+    DEFINE_RE,
+    render_tree,
+)
+
+IS_WINDOWS = os.name == "nt"
+
+
+def render_buffer(
+    top_disp: str,
+    order: list[str],
+    values: dict[str, str | None],
+    origins: dict[str, str],
+    tree: dict | None = None,
+) -> str:
+    lines = [
+        f"# sqlinclude variables -- {top_disp}",
+        "# Edit values below. Delete a line to leave that variable undefined",
+        "# (it passes through as @name). Blank lines and # comments are ignored.",
+        "#",
+    ]
+    if tree is not None:
+        lines.append("# include tree:")
+        lines.extend(f"# {ln}" for ln in render_tree(tree).splitlines())
+        lines.append("#")
+    for name in order:
+        origin = origins.get(name, ORIGIN_UNDEFINED)
+        lines.append(f"# {origin}")
+        lines.append(f"@define {name} = {values.get(name) or ''}")
+    return "\n".join(lines) + "\n"
+
+
+def parse_buffer(text: str) -> dict[str, str]:
+    """Read an edited buffer; empty values mean 'undefined'. Returns env dict."""
+    env: dict[str, str] = {}
+    for line in text.splitlines():
+        s = line.strip()
+        if not s or s.startswith("#"):
+            continue
+        m = DEFINE_RE.match(s)
+        if m:
+            name, value = m.group(1), m.group(2)
+            if value:
+                env[name] = value
+    return env
+
+
+def resolve_editor() -> str:
+    """Honor $VISUAL / $EDITOR; fall back to a platform-appropriate editor."""
+    editor = os.environ.get("VISUAL") or os.environ.get("EDITOR")
+    if editor:
+        return editor
+    return "notepad" if IS_WINDOWS else "vim"
+
+
+def split_editor(editor: str) -> list[str]:
+    """Split an editor command into argv.
+
+    POSIX shell rules apply off Windows; on Windows backslashes in paths must
+    survive, so we use ``shlex.split(..., posix=False)`` and strip the quotes
+    it leaves behind.
+    """
+    if not IS_WINDOWS:
+        return shlex.split(editor)
+    parts = shlex.split(editor, posix=False)
+    return [
+        p[1:-1] if len(p) >= 2 and p[0] == p[-1] and p[0] in "\"'" else p for p in parts
+    ]
+
+
+def have_ctrl_tty() -> bool:
+    """True if a controlling terminal can be opened."""
+    if IS_WINDOWS:
+        try:
+            with open("CONIN$", "rb"):
+                return True
+        except OSError:
+            return False
+    try:
+        fd = os.open("/dev/tty", os.O_RDWR)
+    except OSError:
+        return False
+    os.close(fd)
+    return True
+
+
+@contextlib.contextmanager
+def _console_streams() -> Iterator[tuple | None]:
+    """Yield ``(stdin, stdout, stderr)`` attached to the controlling console.
+
+    Yields ``None`` when no console is available. On Windows the input and
+    output devices are distinct objects; on POSIX the same tty fd serves all
+    three streams.
+    """
+    if IS_WINDOWS:
+        try:
+            stdin = open("CONIN$", "rb")
+            stdout = open("CONOUT$", "wb")
+            stderr = open("CONOUT$", "wb")
+        except OSError:
+            yield None
+            return
+        try:
+            yield (stdin, stdout, stderr)
+        finally:
+            for handle in (stdin, stdout, stderr):
+                with contextlib.suppress(OSError):
+                    handle.close()
+    else:
+        try:
+            fd = os.open("/dev/tty", os.O_RDWR)
+        except OSError:
+            yield None
+            return
+        try:
+            yield (fd, fd, fd)
+        finally:
+            with contextlib.suppress(OSError):
+                os.close(fd)
+
+
+def undefined_count(order: list[str], values: dict[str, str | None]) -> int:
+    return sum(1 for n in order if values[n] is None)
+
+
+def edit_buffer(text: str, editor: str) -> str | None:
+    """Open ``editor`` on a temp file holding ``text``; return edited contents.
+
+    Returns ``None`` if the editor exits non-zero.
+    """
+    fd, tmp = tempfile.mkstemp(prefix="sqlinclude-", suffix=".sql")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            fh.write(text)
+        with _console_streams() as streams:
+            if IS_WINDOWS:
+                # Editors such as VS Code resolve to ``code.cmd``; those need
+                # the command interpreter, so pass a command line and shell=True.
+                cmdline = editor + " " + subprocess.list2cmdline([tmp])
+                if streams is not None:
+                    rc = subprocess.call(
+                        cmdline, shell=True, stdin=streams[0], stdout=streams[1], stderr=streams[2]
+                    )
+                else:
+                    rc = subprocess.call(cmdline, shell=True)
+            else:
+                cmd = split_editor(editor) + [tmp]
+                if streams is not None:
+                    rc = subprocess.call(
+                        cmd, stdin=streams[0], stdout=streams[1], stderr=streams[2]
+                    )
+                else:
+                    rc = subprocess.call(cmd)
+        if rc != 0:
+            sys.stderr.write(f"sqlinclude: editor exited with status {rc}\n")
+            return None
+        with open(tmp, encoding="utf-8") as fh:
+            return fh.read()
+    finally:
+        os.unlink(tmp)

sqlinclude/preprocess.py

@@ -0,0 +1,185 @@
+"""Core @include / @define expansion.
+
+This module is pure with respect to *policy*: it walks a source tree, records
+variables and include relationships, and emits expanded SQL. It never decides
+which editor to launch or how to reach a terminal -- that lives in
+:mod:`sqlinclude.editor`.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from typing import Callable, Iterable
+
+INCLUDE_RE = re.compile(r'^\s*@include\s+(?:"([^"]+)"|(\S+))')
+DEFINE_RE = re.compile(r"^\s*@define\s+([A-Za-z_][A-Za-z0-9_]*)\s*=?\s*(.*?)\s*$")
+VAR_RE = re.compile(r"@([A-Za-z_][A-Za-z0-9_]*)")
+STDIN_NAME = "<stdin>"
+
+ORIGIN_UNDEFINED = "undefined"
+ORIGIN_CLI = "--vars"
+
+
+def _slashed(path: str) -> str:
+    """Normalize path separators for emitted markers/tree names.
+
+    Keeps output identical across platforms (and friendly to downstream
+    parsers that dislike backslashes in ``#line`` markers).
+    """
+    return path.replace("\\", "/")
+
+
+def walk(
+    source: str,
+    cur: str | None,
+    out: list[str] | None,
+    stack: list[tuple[str, str]],
+    no_markers: bool,
+    env: dict[str, str],
+    blocked: set[str],
+    on_var: Callable[[str, str | None, str, int], None] | None = None,
+    on_define: Callable[[str, str, int], None] | None = None,
+    tree: dict | None = None,
+) -> bool:
+    """Process directives in ``source``.
+
+    Appends expansion to ``out`` (or only collects via callbacks when ``out``
+    is ``None``); ``tree``, when given, records include relationships as
+    ``{"name", "children"}`` nodes. Returns ``True`` on error.
+    """
+    cwd = os.getcwd()
+    cur_disp = _slashed(os.path.relpath(os.path.realpath(cur), cwd)) if cur else STDIN_NAME
+    line_no = 0
+    for raw in source.splitlines(keepends=True):
+        line_no += 1
+        m = INCLUDE_RE.match(raw)
+        if m:
+            inc = m.group(1) or m.group(2)
+            base = os.path.dirname(cur) if cur else cwd
+            path = os.path.normpath(os.path.join(base, inc))
+            canon = os.path.realpath(path)
+            stack_canons = [c for c, _ in stack]
+
+            if not os.path.isfile(canon):
+                sys.stderr.write(f"sqlinclude: {path}: no such file\n")
+                return True
+            if canon in stack_canons:
+                chain = " -> ".join(stack_canons + [canon])
+                sys.stderr.write(f"sqlinclude: include cycle: {chain}\n")
+                return True
+
+            try:
+                with open(canon, encoding="utf-8") as fh:
+                    sub = fh.read()
+            except OSError as exc:
+                sys.stderr.write(f"sqlinclude: {path}: {exc}\n")
+                return True
+            if sub and not sub.endswith("\n"):
+                sub += "\n"
+
+            disp = _slashed(os.path.relpath(canon, cwd))
+            if out is not None and not no_markers:
+                out.append(f'-- #line 1 "{disp}"\n')
+            subtree = None
+            if tree is not None:
+                subtree = {"name": disp, "children": []}
+                tree["children"].append(subtree)
+            stack.append((canon, disp))
+            if walk(
+                sub, path, out, stack, no_markers, env, blocked, on_var, on_define, subtree
+            ):
+                return True
+            stack.pop()
+            if out is not None and not no_markers:
+                parent = stack[-1][1] if stack else cur_disp
+                out.append(f'-- #line {line_no + 1} "{parent}"\n')
+            continue
+
+        m = DEFINE_RE.match(raw)
+        if m:
+            name, value = m.group(1), m.group(2)
+            if name not in blocked and name not in env:
+                env[name] = value
+                if on_define is not None:
+                    on_define(name, cur_disp, line_no)
+            continue
+
+        if on_var is not None:
+            for name in VAR_RE.findall(raw):
+                on_var(name, env.get(name), cur_disp, line_no)
+        if out is not None:
+            out.append(VAR_RE.sub(lambda mm: env.get(mm.group(1), mm.group(0)), raw))
+    return False
+
+
+def collect_vars(
+    source: str, top: str | None, cli_vars: dict[str, str]
+) -> tuple[list[str], dict[str, str | None], dict[str, str]] | None:
+    """Walk the tree without emitting.
+
+    Returns ``(order, values, sources)`` where ``order`` lists each variable's
+    first occurrence, ``values`` its value at that point (``None`` if
+    undefined), and ``sources`` its origin (``"--vars"``, ``"file:line"``, or
+    ``"undefined"``). Returns ``None`` on error.
+    """
+    env = dict(cli_vars)
+    sources = {name: ORIGIN_CLI for name in cli_vars}
+    order: list[str] = []
+    values: dict[str, str | None] = {}
+    origins: dict[str, str] = {}
+
+    def on_define(name: str, disp: str, line: int) -> None:
+        sources[name] = f"{disp}:{line}"
+
+    def on_var(name: str, value: str | None, disp: str, line: int) -> None:
+        if name not in values:
+            order.append(name)
+            values[name] = value
+            origins[name] = sources.get(name, ORIGIN_UNDEFINED)
+
+    if walk(source, top, None, [], True, env, set(), on_var, on_define):
+        return None
+    return order, values, origins
+
+
+def collect_tree(source: str, top: str | None) -> dict | None:
+    """Walk the tree, recording @include relationships.
+
+    Returns the root node ``{"name", "children"}`` or ``None`` on error.
+    """
+    root = {
+        "name": _slashed(os.path.relpath(os.path.realpath(top), os.getcwd()))
+        if top
+        else STDIN_NAME,
+        "children": [],
+    }
+    if walk(source, top, None, [], True, {}, set(), tree=root):
+        return None
+    return root
+
+
+def render_tree(node: dict, ascii_only: bool = False) -> str:
+    """Render an include tree as an ASCII/Unicode diagram (one line per file)."""
+    lines = [node["name"]]
+    children: Iterable[dict] = node["children"]
+    for i, child in enumerate(children):
+        _render_tree_child(child, "", i == len(children) - 1, lines, ascii_only)
+    return "\n".join(lines) + "\n"
+
+
+def _render_tree_child(
+    node: dict, prefix: str, last: bool, lines: list[str], ascii_only: bool
+) -> None:
+    if ascii_only:
+        stem = "`-- " if last else "|-- "
+        bar = "|   "
+    else:
+        stem = "└── " if last else "├── "
+        bar = "│   "
+    lines.append(prefix + stem + node["name"])
+    next_prefix = prefix + ("    " if last else bar)
+    children: Iterable[dict] = node["children"]
+    for i, child in enumerate(children):
+        _render_tree_child(child, next_prefix, i == len(children) - 1, lines, ascii_only)

sqlinclude-0.1.0.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: sqlinclude
+Version: 0.1.0
+Summary: Tiny SQL source preprocessor: expand @include directives and @define variables.
+Author-email: lukasburski <lukasbursky@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/lukasbursky/sqlinclude
+Project-URL: Source, https://github.com/lukasbursky/sqlinclude
+Project-URL: Issues, https://github.com/lukasbursky/sqlinclude/issues
+Keywords: sql,preprocessor,include,bigquery,templating
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Pre-processors
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Dynamic: license-file
+
+# sqlinclude
+
+Tiny SQL source preprocessor. Expands `@include` directives and `@define`
+variables recursively. No SQL parsing, no opinion about any database. Intended
+to be piped into a query tool:
+
+```console
+sqlinclude analysis.sql | bq query
+bq query "$(sqlinclude analysis.sql)"
+```
+
+Written for Unix and Windows alike: it is a single dependency-free Python
+package and installs a `sqlinclude` console command (a `sqlinclude.exe` on
+Windows).
+
+## Install
+
+```console
+pipx install sqlinclude
+```
+
+or, into the current environment:
+
+```console
+pip install sqlinclude
+```
+
+Requires Python 3.12+.
+
+## Directives
+
+Line-oriented, leading whitespace allowed:
+
+```
+@include file.sql
+@include "file.sql"
+@define name = value        (the `= ` is optional; value is the rest of the
+                             line, kept verbatim including quotes)
+```
+
+Include paths are resolved relative to the including file. Includes may nest;
+cycles are detected and reported as errors.
+
+Variables form a single environment filled in expansion order: the first
+`@define name ...` seen anywhere in the tree wins, and later definitions of the
+same name are ignored (so a parent file's definition always overrides an
+included fragment's default). Definitions from an included file leak back to
+the including file. A `@name` with no definition passes through unchanged --
+BigQuery's native `@param` syntax is never touched.
+
+Each include block is bracketed with `-- #line N "file"` markers (with forward
+slashes on every platform) so error messages from downstream tools point at the
+originating source file and line. Use `-n`/`--no-markers` to suppress them.
+
+## Example
+
+`analysis.sql`:
+
+```sql
+@define start = '2024-01-01'
+@define end = '2024-12-31'
+
+WITH users AS (
+    @include "users.sql"
+),
+
+orders AS (
+    @include orders.sql
+)
+
+SELECT ... WHERE created BETWEEN @start AND @end
+```
+
+Run:
+
+```console
+sqlinclude analysis.sql | bq query
+sqlinclude --vars start='2024-06-01' analysis.sql | bq query
+sqlinclude --tree analysis.sql          # show the include tree, not SQL
+sqlinclude --tree --ascii analysis.sql  # ASCII box characters instead of Unicode
+```
+
+## Options
+
+| Option | Description |
+| --- | --- |
+| `file` | SQL file to preprocess (default: read stdin) |
+| `-n`, `--no-markers` | do not emit `-- #line` markers around includes |
+| `--vars name=value` | set a variable (repeatable); wins over `@define` |
+| `-e`, `--edit` | open the editor even when no variable is undefined |
+| `--no-edit` | never open the editor; leave undefined `@name`s as-is |
+| `-t`, `--tree` | print the `@include` dependency tree instead of SQL |
+| `--ascii` | use ASCII box characters in the include tree |
+| `--version` | show the version |
+
+## Editing undefined variables
+
+When a variable is undefined, `sqlinclude` opens the editor named by
+`$VISUAL`/`$EDITOR` on the controlling terminal, even when its output is piped.
+Edit values, or delete a line to leave that variable undefined. Blank lines and
+`#` comments are ignored. On Windows the same variables are honored, falling
+back to `notepad`. With `-e`/`--edit` the buffer also shows the `@include`
+tree. Undefined variables are always reported on stderr; pass `--no-edit` to
+silence everything and pass undefined names through untouched.
+
+## Development
+
+```console
+python -m venv .venv
+. .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT -- see [LICENSE](LICENSE).

sqlinclude-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+sqlinclude/__init__.py,sha256=g04bR85Fwrb70J_5yvLatOM-vAZgsMOfAPNZ8NXsOIo,185
+sqlinclude/__main__.py,sha256=CUYYxHB7ynJKm1CusZWozmjzBP8Na-xkN6Trbof1FIc,132
+sqlinclude/cli.py,sha256=tuh18LCIQQhDPTAfIM2RoxTgzrkgCtNaNg9LhdavvPQ,7090
+sqlinclude/editor.py,sha256=L9UgtFr6z3FB5f98D6YmC81Ynr9I2co38Mz5H-EVW8A,5645
+sqlinclude/preprocess.py,sha256=hND8xXL1wsdz19Mvgon8I8tm61gw5SlFtFRBcsi0ht8,6566
+sqlinclude-0.1.0.dist-info/licenses/LICENSE,sha256=dxVozrE5KYCaDnnUYIJ-pGTwZ9h_W8BN-MTWpM9N_-w,1068
+sqlinclude-0.1.0.dist-info/METADATA,sha256=pvxO43eWpoePeHf_HYQSY_6UP-wiaIhl63kzePg5ymU,4559
+sqlinclude-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sqlinclude-0.1.0.dist-info/entry_points.txt,sha256=CgEfnBZQVk7BrkQnYozQWUSlgpJ2mBG9XMvqt1nkzW8,51
+sqlinclude-0.1.0.dist-info/top_level.txt,sha256=NV8cYeEBTrXNwJHgG5LyGNupfmF52m2rwff6bMOOBxg,11
+sqlinclude-0.1.0.dist-info/RECORD,,

sqlinclude-0.1.0.dist-info/WHEEL

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

sqlinclude-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sqlinclude = sqlinclude.cli:main

sqlinclude-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lukasburski
+
+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.

sqlinclude-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlinclude