sqlnbfmt 0.4.0__tar.gz → 0.4.1__tar.gz

{sqlnbfmt-0.4.0/sqlnbfmt.egg-info → sqlnbfmt-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlnbfmt
-Version: 0.4.0
+Version: 0.4.1
 Summary: A tool to format SQL code in Jupyter notebooks and Marimo notebooks.
 Author-email: Qing <qingye779@gmail.com>
 License: MIT
@@ -48,6 +48,7 @@ A SQL formatter for Jupyter Notebooks and Marimo notebooks. `sqlnbfmt` automatic
 - **CI-Friendly**: `--check` mode exits non-zero when formatting is needed; `--diff` shows what would change
 - **Skip Hints**: Add `# sqlnbfmt: skip` to any cell to exclude it from formatting
 - **Pre-commit Ready**: Seamlessly integrates with pre-commit hooks
+- **JupyterLab Plugin**: Works with `jupyterlab-code-formatter` for interactive format-on-save
 - **Lightweight**: Only three runtime dependencies (sqlglot, nbformat, pyyaml)
 
 ## Installation
@@ -94,6 +95,23 @@ Add a `# sqlnbfmt: skip` comment to skip formatting. In Jupyter notebooks this a
 query = "select * from my_special_table where id = 1"
 ```
 
+### JupyterLab Integration
+
+Format SQL cells interactively with [jupyterlab-code-formatter](https://github.com/jupyterlab-contrib/jupyterlab_code_formatter):
+
+1. Install both packages:
+```bash
+pip install sqlnbfmt jupyterlab-code-formatter
+```
+
+2. Register the formatter in `~/.jupyter/jupyter_notebook_config.py`:
+```python
+from sqlnbfmt.jupyterlab_integration import register
+register()                       # or: register(dialect="postgres")
+```
+
+3. In JupyterLab, use **Edit > Format Cell** or configure format-on-save in Settings > Code Formatter.
+
 ### Pre-commit Integration
 
 1. Install pre-commit:

{sqlnbfmt-0.4.0 → sqlnbfmt-0.4.1}/README.md

@@ -19,6 +19,7 @@ A SQL formatter for Jupyter Notebooks and Marimo notebooks. `sqlnbfmt` automatic
 - **CI-Friendly**: `--check` mode exits non-zero when formatting is needed; `--diff` shows what would change
 - **Skip Hints**: Add `# sqlnbfmt: skip` to any cell to exclude it from formatting
 - **Pre-commit Ready**: Seamlessly integrates with pre-commit hooks
+- **JupyterLab Plugin**: Works with `jupyterlab-code-formatter` for interactive format-on-save
 - **Lightweight**: Only three runtime dependencies (sqlglot, nbformat, pyyaml)
 
 ## Installation
@@ -65,6 +66,23 @@ Add a `# sqlnbfmt: skip` comment to skip formatting. In Jupyter notebooks this a
 query = "select * from my_special_table where id = 1"
 ```
 
+### JupyterLab Integration
+
+Format SQL cells interactively with [jupyterlab-code-formatter](https://github.com/jupyterlab-contrib/jupyterlab_code_formatter):
+
+1. Install both packages:
+```bash
+pip install sqlnbfmt jupyterlab-code-formatter
+```
+
+2. Register the formatter in `~/.jupyter/jupyter_notebook_config.py`:
+```python
+from sqlnbfmt.jupyterlab_integration import register
+register()                       # or: register(dialect="postgres")
+```
+
+3. In JupyterLab, use **Edit > Format Cell** or configure format-on-save in Settings > Code Formatter.
+
 ### Pre-commit Integration
 
 1. Install pre-commit:

{sqlnbfmt-0.4.0 → sqlnbfmt-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlnbfmt"
-version = "0.4.0"
+version = "0.4.1"
 description = "A tool to format SQL code in Jupyter notebooks and Marimo notebooks."
 authors = [
   { name = "Qing", email = "qingye779@gmail.com" }

{sqlnbfmt-0.4.0 → sqlnbfmt-0.4.1}/sqlnbfmt/formatter.py

@@ -457,122 +457,119 @@ def _has_skip_hint(source: str) -> bool:
     )
 
 
-def _format_cells(
-    notebook: nbformat.NotebookNode,
+def format_cell_source(
+    code: str,
     config: FormattingConfig,
     dialect: Optional[str],
     logger: logging.Logger,
-) -> bool:
-    """Format cells in-place. Returns True if any cell was modified."""
-    changed = False
+) -> str:
+    """Format SQL in a single cell's source code.
 
-    for cell_index, cell in enumerate(notebook.cells):
-        if cell.cell_type != "code":
-            continue
+    Handles both magic commands (%%sql, %sql) and regular Python code
+    with embedded SQL strings. Returns the formatted source.
+    """
+    if not code.strip():
+        return code
 
-        original_code = cell.source
-        if not original_code.strip():
-            continue
+    if _has_skip_hint(code):
+        return code
 
-        if _has_skip_hint(original_code):
-            logger.debug(f"[Cell {cell_index}] Skipping cell (sqlnbfmt: skip)")
-            continue
+    lines = code.split("\n")
 
-        lines = original_code.split("\n")
+    # Look for magic commands
+    magic_cmd = None
+    magic_cmd_index = None
 
-        # Initialize variables to track magic commands
-        magic_cmd = None
-        magic_cmd_index = None
+    for idx, line in enumerate(lines):
+        stripped = line.strip()
 
-        # Iterate through lines to find the first non-comment magic command
-        for idx, line in enumerate(lines):
-            stripped = line.strip()
+        if not stripped:
+            continue
+        if stripped.startswith("#"):
+            continue
+        if stripped.startswith("%%sql") or stripped.startswith("%sql"):
+            magic_cmd = stripped.split()[0]
+            magic_cmd_index = idx
+            break
+        else:
+            break
 
-            if not stripped:
-                continue  # Skip empty lines
+    if magic_cmd:
+        is_cell_magic = magic_cmd.startswith("%%sql")
 
-            if stripped.startswith("#"):
-                continue  # Skip comment lines
+        if is_cell_magic:
+            sql_code = "\n".join(lines[magic_cmd_index + 1 :]).strip()
+        else:
+            sql_code = lines[magic_cmd_index][len(magic_cmd) :].strip()
 
-            if stripped.startswith("%%sql") or stripped.startswith("%sql"):
-                magic_cmd = stripped.split()[0]
-                magic_cmd_index = idx
-                break  # Magic command found
+        try:
+            formatted_sql = format_sql_code(
+                sql_code,
+                dialect,
+                config,
+                is_magic_command=True,
+                is_cell_magic=is_cell_magic,
+            )
 
+            if is_cell_magic:
+                pre_magic = "\n".join(lines[:magic_cmd_index])
+                if pre_magic:
+                    return f"{pre_magic}\n{magic_cmd}\n{formatted_sql}"
+                return f"{magic_cmd}\n{formatted_sql}"
             else:
-                break  # Non-magic, non-comment line found
+                pre_magic = "\n".join(lines[:magic_cmd_index])
+                if pre_magic:
+                    return f"{pre_magic}\n{magic_cmd} {formatted_sql}"
+                return f"{magic_cmd} {formatted_sql}"
 
-        if magic_cmd:
-            is_cell_magic = magic_cmd.startswith("%%sql")
+        except SQLFormattingError as e:
+            logger.warning(f"SQL magic formatting skipped: {e}")
+            return code
 
-            if is_cell_magic:
-                # Cell magic: SQL code starts from the next line
-                sql_code = "\n".join(lines[magic_cmd_index + 1 :]).strip()
-            else:
-                # Line magic: SQL code is on the same line after the magic command
-                sql_code = lines[magic_cmd_index][len(magic_cmd) :].strip()
+    # Handle regular Python code with surgical string replacement
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        logger.warning(f"Failed to parse cell:\n{code}")
+        return code
 
-            try:
-                formatted_sql = format_sql_code(
-                    sql_code,
-                    dialect,
-                    config,
-                    is_magic_command=True,
-                    is_cell_magic=is_cell_magic,
-                )
+    line_offsets = build_line_offsets(code)
+    formatter = SQLStringFormatter(config, dialect, logger, line_offsets)
+    formatter.visit(tree)
 
-                # Reconstruct the cell content
-                if is_cell_magic:
-                    # Preserve comments before the magic command
-                    pre_magic = "\n".join(lines[:magic_cmd_index])
-                    if pre_magic:
-                        new_content = f"{pre_magic}\n{magic_cmd}\n{formatted_sql}"
-                    else:
-                        new_content = f"{magic_cmd}\n{formatted_sql}"
-                else:
-                    # Preserve comments before the magic command
-                    pre_magic = "\n".join(lines[:magic_cmd_index])
-                    if pre_magic:
-                        new_content = f"{pre_magic}\n{magic_cmd} {formatted_sql}"
-                    else:
-                        new_content = f"{magic_cmd} {formatted_sql}"
+    if not formatter.replacements:
+        return code
 
-                if new_content != original_code:
-                    cell.source = new_content
-                    changed = True
+    result = code
+    for rep in sorted(
+        formatter.replacements,
+        key=lambda r: r.start_offset,
+        reverse=True,
+    ):
+        result = result[: rep.start_offset] + rep.new_text + result[rep.end_offset :]
 
-            except SQLFormattingError as e:
-                logger.warning(f"[Cell {cell_index}] SQL magic formatting skipped: {e}")
+    return result
 
-            continue  # Move to the next cell after handling magic command
 
-        # Handle regular Python code with surgical string replacement
-        try:
-            tree = ast.parse(original_code)
-            line_offsets = build_line_offsets(original_code)
-            formatter = SQLStringFormatter(config, dialect, logger, line_offsets)
-            formatter.visit(tree)
-            if formatter.replacements:
-                result = original_code
-                for rep in sorted(
-                    formatter.replacements,
-                    key=lambda r: r.start_offset,
-                    reverse=True,
-                ):
-                    result = (
-                        result[: rep.start_offset]
-                        + rep.new_text
-                        + result[rep.end_offset :]
-                    )
-                if result != original_code:
-                    cell.source = result
-                    changed = True
-        except SyntaxError:
-            logger.warning(
-                f"[Cell {cell_index}] Failed to parse cell:\n{original_code}"
-            )
+def _format_cells(
+    notebook: nbformat.NotebookNode,
+    config: FormattingConfig,
+    dialect: Optional[str],
+    logger: logging.Logger,
+) -> bool:
+    """Format cells in-place. Returns True if any cell was modified."""
+    changed = False
+
+    for cell in notebook.cells:
+        if cell.cell_type != "code":
             continue
 
+        original_code = cell.source
+        formatted = format_cell_source(original_code, config, dialect, logger)
+        if formatted != original_code:
+            cell.source = formatted
+            changed = True
+
     return changed
 
 

sqlnbfmt-0.4.1/sqlnbfmt/jupyterlab_integration.py

@@ -0,0 +1,74 @@
+"""JupyterLab code formatter integration.
+
+Provides a formatter plugin for jupyterlab-code-formatter that formats
+SQL in notebook cells (both magic commands and Python strings).
+
+Setup: add this to your ``jupyter_notebook_config.py``::
+
+    from sqlnbfmt.jupyterlab_integration import register
+    register()
+
+Then select "Apply SQL Notebook Formatter" in JupyterLab's
+Code > Format Cell menu or configure it for format-on-save.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+
+def _get_formatter_class():
+    """Build the formatter class lazily to avoid hard dependency."""
+    from jupyterlab_code_formatter.formatters import BaseFormatter
+
+    from sqlnbfmt.formatter import FormattingConfig, format_cell_source, load_config
+
+    class SQLNotebookFormatter(BaseFormatter):
+        label = "Apply SQL Notebook Formatter"
+
+        def __init__(
+            self,
+            config: Optional[FormattingConfig] = None,
+            dialect: Optional[str] = None,
+        ):
+            self._config = config or load_config()
+            self._dialect = dialect
+            self._logger = logging.getLogger("sqlnbfmt.jupyterlab")
+
+        @property
+        def importable(self) -> bool:
+            return True
+
+        def format_code(self, code: str, notebook: bool, **options) -> str:
+            dialect = options.pop("dialect", self._dialect)
+            return format_cell_source(code, self._config, dialect, self._logger)
+
+    return SQLNotebookFormatter
+
+
+def register(
+    name: str = "sqlnbfmt",
+    dialect: Optional[str] = None,
+    config_path: Optional[str] = None,
+) -> None:
+    """Register sqlnbfmt with jupyterlab-code-formatter.
+
+    Call this in ``jupyter_notebook_config.py``::
+
+        from sqlnbfmt.jupyterlab_integration import register
+        register()                       # defaults
+        register(dialect="postgres")     # with options
+
+    Args:
+        name: Key used in JupyterLab settings to reference this formatter.
+        dialect: SQL dialect (e.g. ``"postgres"``, ``"mysql"``).
+        config_path: Path to a sqlnbfmt YAML config file.
+    """
+    from jupyterlab_code_formatter.formatters import SERVER_FORMATTERS
+
+    from sqlnbfmt.formatter import load_config
+
+    config = load_config(config_path)
+    cls = _get_formatter_class()
+    SERVER_FORMATTERS[name] = cls(config=config, dialect=dialect)

{sqlnbfmt-0.4.0 → sqlnbfmt-0.4.1/sqlnbfmt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlnbfmt
-Version: 0.4.0
+Version: 0.4.1
 Summary: A tool to format SQL code in Jupyter notebooks and Marimo notebooks.
 Author-email: Qing <qingye779@gmail.com>
 License: MIT
@@ -48,6 +48,7 @@ A SQL formatter for Jupyter Notebooks and Marimo notebooks. `sqlnbfmt` automatic
 - **CI-Friendly**: `--check` mode exits non-zero when formatting is needed; `--diff` shows what would change
 - **Skip Hints**: Add `# sqlnbfmt: skip` to any cell to exclude it from formatting
 - **Pre-commit Ready**: Seamlessly integrates with pre-commit hooks
+- **JupyterLab Plugin**: Works with `jupyterlab-code-formatter` for interactive format-on-save
 - **Lightweight**: Only three runtime dependencies (sqlglot, nbformat, pyyaml)
 
 ## Installation
@@ -94,6 +95,23 @@ Add a `# sqlnbfmt: skip` comment to skip formatting. In Jupyter notebooks this a
 query = "select * from my_special_table where id = 1"
 ```
 
+### JupyterLab Integration
+
+Format SQL cells interactively with [jupyterlab-code-formatter](https://github.com/jupyterlab-contrib/jupyterlab_code_formatter):
+
+1. Install both packages:
+```bash
+pip install sqlnbfmt jupyterlab-code-formatter
+```
+
+2. Register the formatter in `~/.jupyter/jupyter_notebook_config.py`:
+```python
+from sqlnbfmt.jupyterlab_integration import register
+register()                       # or: register(dialect="postgres")
+```
+
+3. In JupyterLab, use **Edit > Format Cell** or configure format-on-save in Settings > Code Formatter.
+
 ### Pre-commit Integration
 
 1. Install pre-commit:

{sqlnbfmt-0.4.0 → sqlnbfmt-0.4.1}/sqlnbfmt.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 sqlnbfmt/__init__.py
 sqlnbfmt/formatter.py
+sqlnbfmt/jupyterlab_integration.py
 sqlnbfmt.egg-info/PKG-INFO
 sqlnbfmt.egg-info/SOURCES.txt
 sqlnbfmt.egg-info/dependency_links.txt
@@ -11,4 +12,5 @@ sqlnbfmt.egg-info/requires.txt
 sqlnbfmt.egg-info/top_level.txt
 tests/test_eval.py
 tests/test_formatter.py
+tests/test_jupyterlab_integration.py
 tests/test_marimo.py

{sqlnbfmt-0.4.0 → sqlnbfmt-0.4.1}/tests/test_formatter.py

@@ -3,7 +3,12 @@ import nbformat
 from nbformat import v4 as nbf
 import logging
 
-from sqlnbfmt.formatter import process_notebook, load_config, diff_notebook
+from sqlnbfmt.formatter import (
+    format_cell_source,
+    process_notebook,
+    load_config,
+    diff_notebook,
+)
 
 
 # Fixture for temporary notebook path
@@ -461,3 +466,50 @@ def test_main_check_diff_exits_one(tmp_path):
     )
     assert result.returncode == 1
     assert "---" in result.stdout  # diff was printed
+
+
+# ---------------------------------------------------------------------------
+# format_cell_source tests
+# ---------------------------------------------------------------------------
+
+
+def test_format_cell_source_magic(logger):
+    """format_cell_source handles %%sql magic cells."""
+    config = load_config()
+    code = "%%sql\nselect id, name from users where active = 1"
+    result = format_cell_source(code, config, "mysql", logger)
+    assert result.startswith("%%sql\n")
+    assert "SELECT" in result
+
+
+def test_format_cell_source_line_magic(logger):
+    """format_cell_source handles %sql line magic."""
+    config = load_config()
+    code = "%sql select * from users where active = 1"
+    result = format_cell_source(code, config, "mysql", logger)
+    assert result.startswith("%sql ")
+    assert "SELECT" in result
+
+
+def test_format_cell_source_python(logger):
+    """format_cell_source handles regular Python code with SQL."""
+    config = load_config()
+    code = 'query = "select id, name from users where active = 1"'
+    result = format_cell_source(code, config, "mysql", logger)
+    assert "SELECT" in result
+
+
+def test_format_cell_source_non_sql(logger):
+    """format_cell_source returns non-SQL code unchanged."""
+    config = load_config()
+    code = "x = 42\nprint(x)"
+    result = format_cell_source(code, config, "mysql", logger)
+    assert result == code
+
+
+def test_format_cell_source_skip_hint(logger):
+    """format_cell_source respects skip hints."""
+    config = load_config()
+    code = '# sqlnbfmt: skip\nquery = "select * from users"'
+    result = format_cell_source(code, config, "mysql", logger)
+    assert result == code

sqlnbfmt-0.4.1/tests/test_jupyterlab_integration.py

@@ -0,0 +1,76 @@
+"""Tests for the JupyterLab code formatter integration.
+
+Since jupyterlab-code-formatter is not a dependency, these tests
+mock the necessary imports and verify the adapter works correctly.
+"""
+
+from unittest.mock import MagicMock, patch
+
+
+def test_register_adds_to_server_formatters():
+    """register() inserts an instance into SERVER_FORMATTERS."""
+    mock_formatters = {}
+    mock_base = type("BaseFormatter", (), {})
+
+    with (
+        patch.dict(
+            "sys.modules",
+            {
+                "jupyterlab_code_formatter": MagicMock(),
+                "jupyterlab_code_formatter.formatters": MagicMock(
+                    BaseFormatter=mock_base,
+                    SERVER_FORMATTERS=mock_formatters,
+                ),
+            },
+        ),
+    ):
+        from sqlnbfmt.jupyterlab_integration import register
+
+        register()
+        assert "sqlnbfmt" in mock_formatters
+
+        register(name="custom_name", dialect="postgres")
+        assert "custom_name" in mock_formatters
+
+
+def test_formatter_class_format_code():
+    """The formatter class delegates to format_cell_source."""
+    mock_base = type("BaseFormatter", (), {})
+
+    with patch.dict(
+        "sys.modules",
+        {
+            "jupyterlab_code_formatter": MagicMock(),
+            "jupyterlab_code_formatter.formatters": MagicMock(
+                BaseFormatter=mock_base,
+                SERVER_FORMATTERS={},
+            ),
+        },
+    ):
+        from sqlnbfmt.jupyterlab_integration import _get_formatter_class
+
+        cls = _get_formatter_class()
+        formatter = cls()
+
+        assert formatter.label == "Apply SQL Notebook Formatter"
+        assert formatter.importable is True
+
+        # Format a cell with SQL
+        result = formatter.format_code(
+            'query = "select id, name from users where active = 1"',
+            notebook=True,
+        )
+        assert "SELECT" in result
+
+        # Format a %%sql magic cell
+        result = formatter.format_code(
+            "%%sql\nselect * from users where active = 1",
+            notebook=True,
+        )
+        assert "%%sql" in result
+        assert "SELECT" in result
+
+        # Non-SQL code passes through unchanged
+        code = "x = 42\nprint(x)"
+        result = formatter.format_code(code, notebook=True)
+        assert result == code