sqlnbfmt 0.3.1__tar.gz → 0.4.0__tar.gz

{sqlnbfmt-0.3.1 → sqlnbfmt-0.4.0}/PKG-INFO

@@ -1,17 +1,24 @@
 Metadata-Version: 2.4
 Name: sqlnbfmt
-Version: 0.3.1
-Summary: A tool to format SQL code in Jupyter notebooks.
+Version: 0.4.0
+Summary: A tool to format SQL code in Jupyter notebooks and Marimo notebooks.
 Author-email: Qing <qingye779@gmail.com>
 License: MIT
 Project-URL: Homepage, https://github.com/flyersworder/sqlnbfmt
 Project-URL: Repository, https://github.com/flyersworder/sqlnbfmt
 Project-URL: Changelog, https://github.com/flyersworder/sqlnbfmt/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/flyersworder/sqlnbfmt/issues
-Keywords: sql,jupyter,notebook,formatter,sqlglot,pre-commit
+Keywords: sql,jupyter,marimo,notebook,formatter,sqlglot,pre-commit
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Framework :: Jupyter
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -23,19 +30,21 @@ Dynamic: license-file
 # sqlnbfmt
 
 [![PyPI](https://img.shields.io/pypi/v/sqlnbfmt.svg)](https://pypi.org/project/sqlnbfmt/)
+[![Tests](https://github.com/flyersworder/sqlnbfmt/actions/workflows/ci-and-publish.yml/badge.svg)](https://github.com/flyersworder/sqlnbfmt/actions/workflows/ci-and-publish.yml)
 [![License](https://img.shields.io/pypi/l/sqlnbfmt.svg)](https://github.com/flyersworder/sqlnbfmt/blob/main/LICENSE)
 [![Python Versions](https://img.shields.io/pypi/pyversions/sqlnbfmt.svg)](https://pypi.org/project/sqlnbfmt/)
 
 > **Quick start:** `pip install sqlnbfmt && sqlnbfmt notebook.ipynb`
 
-A SQL formatter designed specifically for Jupyter Notebooks. `sqlnbfmt` automatically formats SQL queries embedded in code cells, including both Python strings and SQL magic cells (`%%sql`), helping you maintain clean and consistent code.
+A SQL formatter for Jupyter Notebooks and Marimo notebooks. `sqlnbfmt` automatically formats SQL queries embedded in notebook cells — Python strings, SQL magic cells (`%%sql`), and Marimo `mo.sql()` calls — helping you maintain clean and consistent code.
 
 ## Features
 
 - **Zero-config**: Works out of the box with sensible defaults — no config file needed
-- **Smart SQL Detection**: Automatically identifies and formats SQL queries in code cells and magic SQL cells
+- **Jupyter + Marimo**: Formats SQL in `.ipynb` notebooks and Marimo `.py` notebooks
+- **Smart SQL Detection**: Automatically identifies and formats SQL queries in code cells, magic SQL cells, and `mo.sql()` calls
 - **AST-Powered**: Uses Abstract Syntax Tree parsing for accurate SQL string identification
-- **Safe Formatting**: Preserves Python comments, query parameters (e.g., `%s`, `?`), and SQL comments
+- **Safe Formatting**: Preserves Python comments, query parameters (e.g., `%s`, `?`), f-string placeholders, and SQL comments
 - **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
@@ -51,14 +60,24 @@ pip install sqlnbfmt
 
 ### Command Line
 
-Format a single notebook:
+Format Jupyter notebooks:
 ```bash
 sqlnbfmt path/to/your_notebook.ipynb
 ```
 
+Format Marimo notebooks (or any Python file with SQL strings):
+```bash
+sqlnbfmt path/to/your_notebook.py
+```
+
+Mix both in a single invocation:
+```bash
+sqlnbfmt *.ipynb marimo_app.py
+```
+
 Check formatting without modifying files (useful in CI):
 ```bash
-sqlnbfmt --check path/to/your_notebook.ipynb
+sqlnbfmt --check path/to/your_notebook.ipynb path/to/marimo_app.py
 ```
 
 Show a diff of what would change:
@@ -68,7 +87,7 @@ sqlnbfmt --diff path/to/your_notebook.ipynb
 
 ### Skipping Cells
 
-Add a `# sqlnbfmt: skip` comment anywhere in a cell to skip formatting:
+Add a `# sqlnbfmt: skip` comment to skip formatting. In Jupyter notebooks this applies per-cell; in Python files it applies to the entire file.
 
 ```python
 # sqlnbfmt: skip
@@ -86,12 +105,18 @@ pip install pre-commit
 ```yaml
 repos:
   - repo: https://github.com/flyersworder/sqlnbfmt
-    rev: v0.3.0
+    rev: v0.4.0
     hooks:
       - id: sqlnbfmt
         types: [jupyter]
 ```
 
+To also format Marimo notebooks (Python files), add the Python hook:
+```yaml
+      - id: sqlnbfmt-py
+        files: '\.py$'  # optionally narrow with: files: 'marimo_.*\.py$'
+```
+
 All arguments are optional. To specify a dialect or custom config:
 ```yaml
         args: [--dialect, postgres, --config, config.yaml]
@@ -116,6 +141,7 @@ Use `--check` in GitHub Actions to enforce formatting:
   run: |
     pip install sqlnbfmt
     sqlnbfmt --check **/*.ipynb
+    sqlnbfmt --check marimo_*.py  # if using Marimo
 ```
 
 ## Configuration
@@ -134,7 +160,9 @@ Create a `config.yaml` file to customize formatting behavior. [Here](https://git
 | `single_line_threshold` | Maximum length before splitting SQL | 80 |
 | `indent_width` | Number of spaces for indentation | 4 |
 
-## Example
+## Examples
+
+### Jupyter Notebook
 
 Before formatting:
 ```python
@@ -159,6 +187,35 @@ ORDER BY
 """)
 ```
 
+### Marimo Notebook
+
+Before formatting:
+```python
+@app.cell
+def _(mo):
+    _df = mo.sql(f"select id, name from users where active = 1 order by name")
+    return
+```
+
+After formatting:
+```python
+@app.cell
+def _(mo):
+    _df = mo.sql(
+    f"""
+    SELECT
+      id,
+      name
+    FROM users
+    WHERE
+      active = 1
+    ORDER BY
+      name
+    """
+)
+    return
+```
+
 ## Troubleshooting
 
 **SQL not being formatted?**

sqlnbfmt-0.3.1/sqlnbfmt.egg-info/PKG-INFO → sqlnbfmt-0.4.0/README.md

@@ -1,41 +1,21 @@
-Metadata-Version: 2.4
-Name: sqlnbfmt
-Version: 0.3.1
-Summary: A tool to format SQL code in Jupyter notebooks.
-Author-email: Qing <qingye779@gmail.com>
-License: MIT
-Project-URL: Homepage, https://github.com/flyersworder/sqlnbfmt
-Project-URL: Repository, https://github.com/flyersworder/sqlnbfmt
-Project-URL: Changelog, https://github.com/flyersworder/sqlnbfmt/blob/main/CHANGELOG.md
-Project-URL: Issues, https://github.com/flyersworder/sqlnbfmt/issues
-Keywords: sql,jupyter,notebook,formatter,sqlglot,pre-commit
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: nbformat>=5.10.4
-Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: sqlglot>=25.27.0
-Dynamic: license-file
-
 # sqlnbfmt
 
 [![PyPI](https://img.shields.io/pypi/v/sqlnbfmt.svg)](https://pypi.org/project/sqlnbfmt/)
+[![Tests](https://github.com/flyersworder/sqlnbfmt/actions/workflows/ci-and-publish.yml/badge.svg)](https://github.com/flyersworder/sqlnbfmt/actions/workflows/ci-and-publish.yml)
 [![License](https://img.shields.io/pypi/l/sqlnbfmt.svg)](https://github.com/flyersworder/sqlnbfmt/blob/main/LICENSE)
 [![Python Versions](https://img.shields.io/pypi/pyversions/sqlnbfmt.svg)](https://pypi.org/project/sqlnbfmt/)
 
 > **Quick start:** `pip install sqlnbfmt && sqlnbfmt notebook.ipynb`
 
-A SQL formatter designed specifically for Jupyter Notebooks. `sqlnbfmt` automatically formats SQL queries embedded in code cells, including both Python strings and SQL magic cells (`%%sql`), helping you maintain clean and consistent code.
+A SQL formatter for Jupyter Notebooks and Marimo notebooks. `sqlnbfmt` automatically formats SQL queries embedded in notebook cells — Python strings, SQL magic cells (`%%sql`), and Marimo `mo.sql()` calls — helping you maintain clean and consistent code.
 
 ## Features
 
 - **Zero-config**: Works out of the box with sensible defaults — no config file needed
-- **Smart SQL Detection**: Automatically identifies and formats SQL queries in code cells and magic SQL cells
+- **Jupyter + Marimo**: Formats SQL in `.ipynb` notebooks and Marimo `.py` notebooks
+- **Smart SQL Detection**: Automatically identifies and formats SQL queries in code cells, magic SQL cells, and `mo.sql()` calls
 - **AST-Powered**: Uses Abstract Syntax Tree parsing for accurate SQL string identification
-- **Safe Formatting**: Preserves Python comments, query parameters (e.g., `%s`, `?`), and SQL comments
+- **Safe Formatting**: Preserves Python comments, query parameters (e.g., `%s`, `?`), f-string placeholders, and SQL comments
 - **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
@@ -51,14 +31,24 @@ pip install sqlnbfmt
 
 ### Command Line
 
-Format a single notebook:
+Format Jupyter notebooks:
 ```bash
 sqlnbfmt path/to/your_notebook.ipynb
 ```
 
+Format Marimo notebooks (or any Python file with SQL strings):
+```bash
+sqlnbfmt path/to/your_notebook.py
+```
+
+Mix both in a single invocation:
+```bash
+sqlnbfmt *.ipynb marimo_app.py
+```
+
 Check formatting without modifying files (useful in CI):
 ```bash
-sqlnbfmt --check path/to/your_notebook.ipynb
+sqlnbfmt --check path/to/your_notebook.ipynb path/to/marimo_app.py
 ```
 
 Show a diff of what would change:
@@ -68,7 +58,7 @@ sqlnbfmt --diff path/to/your_notebook.ipynb
 
 ### Skipping Cells
 
-Add a `# sqlnbfmt: skip` comment anywhere in a cell to skip formatting:
+Add a `# sqlnbfmt: skip` comment to skip formatting. In Jupyter notebooks this applies per-cell; in Python files it applies to the entire file.
 
 ```python
 # sqlnbfmt: skip
@@ -86,12 +76,18 @@ pip install pre-commit
 ```yaml
 repos:
   - repo: https://github.com/flyersworder/sqlnbfmt
-    rev: v0.3.0
+    rev: v0.4.0
     hooks:
       - id: sqlnbfmt
         types: [jupyter]
 ```
 
+To also format Marimo notebooks (Python files), add the Python hook:
+```yaml
+      - id: sqlnbfmt-py
+        files: '\.py$'  # optionally narrow with: files: 'marimo_.*\.py$'
+```
+
 All arguments are optional. To specify a dialect or custom config:
 ```yaml
         args: [--dialect, postgres, --config, config.yaml]
@@ -116,6 +112,7 @@ Use `--check` in GitHub Actions to enforce formatting:
   run: |
     pip install sqlnbfmt
     sqlnbfmt --check **/*.ipynb
+    sqlnbfmt --check marimo_*.py  # if using Marimo
 ```
 
 ## Configuration
@@ -134,7 +131,9 @@ Create a `config.yaml` file to customize formatting behavior. [Here](https://git
 | `single_line_threshold` | Maximum length before splitting SQL | 80 |
 | `indent_width` | Number of spaces for indentation | 4 |
 
-## Example
+## Examples
+
+### Jupyter Notebook
 
 Before formatting:
 ```python
@@ -159,6 +158,35 @@ ORDER BY
 """)
 ```
 
+### Marimo Notebook
+
+Before formatting:
+```python
+@app.cell
+def _(mo):
+    _df = mo.sql(f"select id, name from users where active = 1 order by name")
+    return
+```
+
+After formatting:
+```python
+@app.cell
+def _(mo):
+    _df = mo.sql(
+    f"""
+    SELECT
+      id,
+      name
+    FROM users
+    WHERE
+      active = 1
+    ORDER BY
+      name
+    """
+)
+    return
+```
+
 ## Troubleshooting
 
 **SQL not being formatted?**

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

@@ -1,18 +1,25 @@
 [project]
 name = "sqlnbfmt"
-version = "0.3.1"
-description = "A tool to format SQL code in Jupyter notebooks."
+version = "0.4.0"
+description = "A tool to format SQL code in Jupyter notebooks and Marimo notebooks."
 authors = [
   { name = "Qing", email = "qingye779@gmail.com" }
 ]
 license = { text = "MIT" }
 readme = "README.md"
 requires-python = ">=3.12"
-keywords = ["sql", "jupyter", "notebook", "formatter", "sqlglot", "pre-commit"]
+keywords = ["sql", "jupyter", "marimo", "notebook", "formatter", "sqlglot", "pre-commit"]
 classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13"
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Framework :: Jupyter",
 ]
 dependencies = [
     "nbformat>=5.10.4",

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

@@ -4,13 +4,14 @@ import difflib
 import logging
 import re
 import sys
+import textwrap
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Set, Optional, Dict, Union, Tuple
 
 import nbformat
 import yaml
-from sqlglot import parse_one, errors
+from sqlglot import parse, errors
 
 DEFAULT_SQL_KEYWORDS = frozenset(
     {
@@ -49,6 +50,7 @@ DEFAULT_FUNCTION_NAMES = frozenset(
         "fetchone",
         "fetchmany",
         "execute_query",
+        "sql",
     }
 )
 
@@ -206,10 +208,18 @@ def format_sql_code(
         temp_sql = temp_sql.strip()
 
         # Parse and format SQL
-        parsed = parse_one(temp_sql, read=dialect)
-        formatted_sql = parsed.sql(
-            pretty=not force_single_line, indent=config.indent_width, dialect=dialect
-        )
+        statements = parse(temp_sql, read=dialect)
+        formatted_parts = []
+        for stmt in statements:
+            formatted_parts.append(
+                stmt.sql(
+                    pretty=not force_single_line,
+                    indent=config.indent_width,
+                    dialect=dialect,
+                )
+            )
+        separator = "; " if force_single_line else ";\n"
+        formatted_sql = separator.join(formatted_parts)
 
         # Apply formatting based on context
         if is_magic_command and not is_cell_magic:
@@ -351,7 +361,7 @@ class SQLStringFormatter(ast.NodeVisitor):
             except SQLFormattingError:
                 return None
 
-            if formatted_sql == sql_str:
+            if formatted_sql == textwrap.dedent(sql_str).strip():
                 return None
 
             # Restore placeholders as f-string expressions
@@ -566,6 +576,47 @@ def _format_cells(
     return changed
 
 
+def _format_python_source(
+    source: str,
+    config: FormattingConfig,
+    dialect: Optional[str],
+    logger: logging.Logger,
+) -> Tuple[str, bool]:
+    """Format SQL strings in Python source code.
+
+    Returns (formatted_source, changed) tuple.
+    """
+    if not source.strip():
+        return source, False
+
+    if _has_skip_hint(source):
+        return source, False
+
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        logger.warning("Failed to parse Python source")
+        return source, False
+
+    line_offsets = build_line_offsets(source)
+    formatter = SQLStringFormatter(config, dialect, logger, line_offsets)
+    formatter.visit(tree)
+
+    if not formatter.replacements:
+        return source, False
+
+    result = source
+    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 :]
+
+    changed = result != source
+    return result, changed
+
+
 def process_notebook(
     notebook_path: Union[str, Path],
     config: FormattingConfig,
@@ -626,13 +677,69 @@ def diff_notebook(
     return "".join(diff_lines)
 
 
+def process_python_file(
+    file_path: Union[str, Path],
+    config: FormattingConfig,
+    dialect: Optional[str],
+    logger: logging.Logger,
+    check_only: bool = False,
+) -> bool:
+    """Processes a Python file (e.g. Marimo notebook).
+
+    Returns True if changes were made (or would be made in check mode).
+    """
+    try:
+        file_path = Path(file_path)
+        source = file_path.read_text(encoding="utf-8")
+        formatted, changed = _format_python_source(source, config, dialect, logger)
+
+        if changed and not check_only:
+            file_path.write_text(formatted, encoding="utf-8")
+            logger.info(f"Updated file: {file_path}")
+
+        return changed
+
+    except Exception as e:
+        logger.error(f"Failed to process file {file_path}: {e}", exc_info=True)
+        raise
+
+
+def diff_python_file(
+    file_path: Union[str, Path],
+    config: FormattingConfig,
+    dialect: Optional[str],
+    logger: logging.Logger,
+) -> str:
+    """Returns a unified diff of formatting changes for a Python file."""
+    file_path = Path(file_path)
+    source = file_path.read_text(encoding="utf-8")
+    formatted, _ = _format_python_source(source, config, dialect, logger)
+
+    if source == formatted:
+        return ""
+
+    return "".join(
+        difflib.unified_diff(
+            source.splitlines(keepends=True),
+            formatted.splitlines(keepends=True),
+            fromfile=f"{file_path} original",
+            tofile=f"{file_path} formatted",
+        )
+    )
+
+
 def main():
     """Main entry point for the SQL formatter."""
     import argparse
 
-    parser = argparse.ArgumentParser(description="Format SQL code in Jupyter notebooks")
+    parser = argparse.ArgumentParser(
+        description="Format SQL code in Jupyter notebooks and Python files"
+    )
     parser.add_argument(
-        "notebooks", nargs="+", type=Path, help="Notebook paths to process"
+        "files",
+        nargs="+",
+        type=Path,
+        help="Notebook (.ipynb) or Python (.py) file paths to process",
     )
     parser.add_argument(
         "--config", type=Path, default=None, help="Configuration file path (optional)"
@@ -671,41 +778,51 @@ def main():
     try:
         changed_files = []
 
-        for notebook in args.notebooks:
+        for file_path in args.files:
+            is_python = file_path.suffix == ".py"
+
             if args.check or args.diff:
-                # In check/diff mode, use diff_notebook to get both the
-                # diff output and whether changes are needed (single pass).
-                diff_output = diff_notebook(notebook, config, args.dialect, logger)
+                if is_python:
+                    diff_output = diff_python_file(
+                        file_path, config, args.dialect, logger
+                    )
+                else:
+                    diff_output = diff_notebook(file_path, config, args.dialect, logger)
                 needs_formatting = bool(diff_output)
 
                 if args.diff and diff_output:
                     print(diff_output, end="")
 
                 if needs_formatting:
-                    changed_files.append(notebook)
+                    changed_files.append(file_path)
             else:
-                # Normal mode: format in place
-                if process_notebook(notebook, config, args.dialect, logger):
-                    changed_files.append(notebook)
+                if is_python:
+                    changed = process_python_file(
+                        file_path, config, args.dialect, logger
+                    )
+                else:
+                    changed = process_notebook(file_path, config, args.dialect, logger)
+                if changed:
+                    changed_files.append(file_path)
 
         if args.check:
             if changed_files:
-                logger.error(f"{len(changed_files)} notebook(s) would be reformatted:")
+                logger.error(f"{len(changed_files)} file(s) would be reformatted:")
                 for f in changed_files:
                     logger.error(f"  - {f}")
                 sys.exit(1)
             else:
-                logger.info("All notebooks are properly formatted.")
+                logger.info("All files are properly formatted.")
                 sys.exit(0)
 
         # Print summary for normal mode
         if not args.diff:
             if changed_files:
-                logger.info("Changes made to the following notebooks:")
+                logger.info("Changes made to the following files:")
                 for file in changed_files:
                     logger.info(f"  - {file}")
             else:
-                logger.info("No changes needed. All notebooks are properly formatted.")
+                logger.info("No changes needed. All files are properly formatted.")
 
         sys.exit(0)
 

sqlnbfmt-0.3.1/README.md → sqlnbfmt-0.4.0/sqlnbfmt.egg-info/PKG-INFO

@@ -1,19 +1,50 @@
+Metadata-Version: 2.4
+Name: sqlnbfmt
+Version: 0.4.0
+Summary: A tool to format SQL code in Jupyter notebooks and Marimo notebooks.
+Author-email: Qing <qingye779@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/flyersworder/sqlnbfmt
+Project-URL: Repository, https://github.com/flyersworder/sqlnbfmt
+Project-URL: Changelog, https://github.com/flyersworder/sqlnbfmt/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/flyersworder/sqlnbfmt/issues
+Keywords: sql,jupyter,marimo,notebook,formatter,sqlglot,pre-commit
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nbformat>=5.10.4
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: sqlglot>=25.27.0
+Dynamic: license-file
+
 # sqlnbfmt
 
 [![PyPI](https://img.shields.io/pypi/v/sqlnbfmt.svg)](https://pypi.org/project/sqlnbfmt/)
+[![Tests](https://github.com/flyersworder/sqlnbfmt/actions/workflows/ci-and-publish.yml/badge.svg)](https://github.com/flyersworder/sqlnbfmt/actions/workflows/ci-and-publish.yml)
 [![License](https://img.shields.io/pypi/l/sqlnbfmt.svg)](https://github.com/flyersworder/sqlnbfmt/blob/main/LICENSE)
 [![Python Versions](https://img.shields.io/pypi/pyversions/sqlnbfmt.svg)](https://pypi.org/project/sqlnbfmt/)
 
 > **Quick start:** `pip install sqlnbfmt && sqlnbfmt notebook.ipynb`
 
-A SQL formatter designed specifically for Jupyter Notebooks. `sqlnbfmt` automatically formats SQL queries embedded in code cells, including both Python strings and SQL magic cells (`%%sql`), helping you maintain clean and consistent code.
+A SQL formatter for Jupyter Notebooks and Marimo notebooks. `sqlnbfmt` automatically formats SQL queries embedded in notebook cells — Python strings, SQL magic cells (`%%sql`), and Marimo `mo.sql()` calls — helping you maintain clean and consistent code.
 
 ## Features
 
 - **Zero-config**: Works out of the box with sensible defaults — no config file needed
-- **Smart SQL Detection**: Automatically identifies and formats SQL queries in code cells and magic SQL cells
+- **Jupyter + Marimo**: Formats SQL in `.ipynb` notebooks and Marimo `.py` notebooks
+- **Smart SQL Detection**: Automatically identifies and formats SQL queries in code cells, magic SQL cells, and `mo.sql()` calls
 - **AST-Powered**: Uses Abstract Syntax Tree parsing for accurate SQL string identification
-- **Safe Formatting**: Preserves Python comments, query parameters (e.g., `%s`, `?`), and SQL comments
+- **Safe Formatting**: Preserves Python comments, query parameters (e.g., `%s`, `?`), f-string placeholders, and SQL comments
 - **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
@@ -29,14 +60,24 @@ pip install sqlnbfmt
 
 ### Command Line
 
-Format a single notebook:
+Format Jupyter notebooks:
 ```bash
 sqlnbfmt path/to/your_notebook.ipynb
 ```
 
+Format Marimo notebooks (or any Python file with SQL strings):
+```bash
+sqlnbfmt path/to/your_notebook.py
+```
+
+Mix both in a single invocation:
+```bash
+sqlnbfmt *.ipynb marimo_app.py
+```
+
 Check formatting without modifying files (useful in CI):
 ```bash
-sqlnbfmt --check path/to/your_notebook.ipynb
+sqlnbfmt --check path/to/your_notebook.ipynb path/to/marimo_app.py
 ```
 
 Show a diff of what would change:
@@ -46,7 +87,7 @@ sqlnbfmt --diff path/to/your_notebook.ipynb
 
 ### Skipping Cells
 
-Add a `# sqlnbfmt: skip` comment anywhere in a cell to skip formatting:
+Add a `# sqlnbfmt: skip` comment to skip formatting. In Jupyter notebooks this applies per-cell; in Python files it applies to the entire file.
 
 ```python
 # sqlnbfmt: skip
@@ -64,12 +105,18 @@ pip install pre-commit
 ```yaml
 repos:
   - repo: https://github.com/flyersworder/sqlnbfmt
-    rev: v0.3.0
+    rev: v0.4.0
     hooks:
       - id: sqlnbfmt
         types: [jupyter]
 ```
 
+To also format Marimo notebooks (Python files), add the Python hook:
+```yaml
+      - id: sqlnbfmt-py
+        files: '\.py$'  # optionally narrow with: files: 'marimo_.*\.py$'
+```
+
 All arguments are optional. To specify a dialect or custom config:
 ```yaml
         args: [--dialect, postgres, --config, config.yaml]
@@ -94,6 +141,7 @@ Use `--check` in GitHub Actions to enforce formatting:
   run: |
     pip install sqlnbfmt
     sqlnbfmt --check **/*.ipynb
+    sqlnbfmt --check marimo_*.py  # if using Marimo
 ```
 
 ## Configuration
@@ -112,7 +160,9 @@ Create a `config.yaml` file to customize formatting behavior. [Here](https://git
 | `single_line_threshold` | Maximum length before splitting SQL | 80 |
 | `indent_width` | Number of spaces for indentation | 4 |
 
-## Example
+## Examples
+
+### Jupyter Notebook
 
 Before formatting:
 ```python
@@ -137,6 +187,35 @@ ORDER BY
 """)
 ```
 
+### Marimo Notebook
+
+Before formatting:
+```python
+@app.cell
+def _(mo):
+    _df = mo.sql(f"select id, name from users where active = 1 order by name")
+    return
+```
+
+After formatting:
+```python
+@app.cell
+def _(mo):
+    _df = mo.sql(
+    f"""
+    SELECT
+      id,
+      name
+    FROM users
+    WHERE
+      active = 1
+    ORDER BY
+      name
+    """
+)
+    return
+```
+
 ## Troubleshooting
 
 **SQL not being formatted?**

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

@@ -10,4 +10,5 @@ sqlnbfmt.egg-info/entry_points.txt
 sqlnbfmt.egg-info/requires.txt
 sqlnbfmt.egg-info/top_level.txt
 tests/test_eval.py
-tests/test_formatter.py
+tests/test_formatter.py
+tests/test_marimo.py

{sqlnbfmt-0.3.1 → sqlnbfmt-0.4.0}/tests/test_eval.py

@@ -1,7 +1,8 @@
 """Fixture-based eval test suite for sqlnbfmt.
 
 Auto-discovers test cases from tests/eval/*/ directories.
-Each directory must contain input.ipynb and expected.ipynb.
+Jupyter cases: input.ipynb + expected.ipynb.
+Marimo/Python cases: input.py + expected.py.
 """
 
 import logging
@@ -11,7 +12,7 @@ from pathlib import Path
 import nbformat
 import pytest
 
-from sqlnbfmt.formatter import load_config, process_notebook
+from sqlnbfmt.formatter import load_config, process_notebook, process_python_file
 
 EVAL_DIR = Path(__file__).resolve().parent / "eval"
 DIALECT = "mysql"
@@ -78,3 +79,35 @@ def test_eval(case_name, logger, tmp_path):
             f"Expected:\n{exp_cell.source}\n"
             f"Actual:\n{fmt_cell.source}"
         )
+
+
+def discover_marimo_eval_cases():
+    """Find eval case directories containing input.py + expected.py."""
+    if not EVAL_DIR.is_dir():
+        return []
+    cases = []
+    for case_dir in sorted(EVAL_DIR.iterdir()):
+        if (
+            case_dir.is_dir()
+            and (case_dir / "input.py").exists()
+            and (case_dir / "expected.py").exists()
+        ):
+            cases.append(case_dir.name)
+    return cases
+
+
+@pytest.mark.parametrize("case_name", discover_marimo_eval_cases(), ids=lambda c: c)
+def test_marimo_eval(case_name, logger, tmp_path):
+    """Run formatter on input.py and compare with expected.py."""
+    case_dir = EVAL_DIR / case_name
+    work_path = tmp_path / "notebook.py"
+    shutil.copy2(case_dir / "input.py", work_path)
+
+    config = load_config()
+    process_python_file(work_path, config, DIALECT, logger)
+
+    formatted = work_path.read_text()
+    expected = (case_dir / "expected.py").read_text()
+    assert formatted == expected, (
+        f"[{case_name}] Content mismatch.\nExpected:\n{expected}\nActual:\n{formatted}"
+    )

sqlnbfmt-0.4.0/tests/test_marimo.py

@@ -0,0 +1,278 @@
+import logging
+import subprocess
+
+import pytest
+
+from sqlnbfmt.formatter import (
+    _format_python_source,
+    diff_python_file,
+    load_config,
+    process_python_file,
+)
+
+
+@pytest.fixture
+def logger():
+    log = logging.getLogger("test_marimo")
+    log.setLevel(logging.DEBUG)
+    if not log.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+        log.addHandler(handler)
+    return log
+
+
+# ---------------------------------------------------------------------------
+# _format_python_source unit tests
+# ---------------------------------------------------------------------------
+
+
+def test_format_mo_sql_basic(logger):
+    """mo.sql() with a simple SELECT is formatted."""
+    source = """import marimo as mo
+_df = mo.sql(f"select id, name from users where active = 1")
+"""
+    config = load_config()
+    result, changed = _format_python_source(source, config, "mysql", logger)
+    assert changed
+    assert "SELECT" in result
+    assert "FROM users" in result
+
+
+def test_format_mo_sql_fstring_placeholder(logger):
+    """mo.sql() with f-string {expr} placeholders preserved."""
+    source = """import marimo as mo
+table = "users"
+_df = mo.sql(f"select * from {table} where active = 1")
+"""
+    config = load_config()
+    result, changed = _format_python_source(source, config, "mysql", logger)
+    assert changed
+    assert "{table}" in result
+    assert "SELECT" in result
+
+
+def test_format_non_sql_unchanged(logger):
+    """Non-SQL Python code is not modified."""
+    source = """x = 1
+y = "hello world"
+print(x + y)
+"""
+    config = load_config()
+    result, changed = _format_python_source(source, config, "mysql", logger)
+    assert not changed
+    assert result == source
+
+
+def test_format_idempotent(logger):
+    """Formatting already-formatted output produces no changes."""
+    source = """import marimo as mo
+_df = mo.sql(f"select id, name from users where active = 1")
+"""
+    config = load_config()
+    result1, changed1 = _format_python_source(source, config, "mysql", logger)
+    assert changed1
+    result2, changed2 = _format_python_source(result1, config, "mysql", logger)
+    assert not changed2
+    assert result2 == result1
+
+
+def test_format_idempotent_fstring(logger):
+    """Idempotency holds for f-strings with placeholders."""
+    source = """import marimo as mo
+table = "users"
+_df = mo.sql(f"select * from {table} where active = 1")
+"""
+    config = load_config()
+    result1, _ = _format_python_source(source, config, "mysql", logger)
+    result2, changed2 = _format_python_source(result1, config, "mysql", logger)
+    assert not changed2
+
+
+def test_format_skip_hint(logger):
+    """File with skip hint is not modified."""
+    source = """# sqlnbfmt: skip
+import marimo as mo
+_df = mo.sql(f"select id, name from users where active = 1")
+"""
+    config = load_config()
+    result, changed = _format_python_source(source, config, "mysql", logger)
+    assert not changed
+
+
+def test_format_empty_source(logger):
+    """Empty source returns unchanged."""
+    config = load_config()
+    result, changed = _format_python_source("", config, "mysql", logger)
+    assert not changed
+    assert result == ""
+
+
+def test_format_syntax_error(logger):
+    """Invalid Python source returns unchanged."""
+    source = "def foo(:\n"
+    config = load_config()
+    result, changed = _format_python_source(source, config, "mysql", logger)
+    assert not changed
+    assert result == source
+
+
+def test_format_plain_python_with_sql(logger):
+    """Non-Marimo Python file with cursor.execute() is also formatted."""
+    source = """import sqlite3
+conn = sqlite3.connect("db.sqlite")
+cursor = conn.cursor()
+cursor.execute("select id, name from users where active = 1")
+"""
+    config = load_config()
+    result, changed = _format_python_source(source, config, "mysql", logger)
+    assert changed
+    assert "SELECT" in result
+    assert "FROM users" in result
+
+
+# ---------------------------------------------------------------------------
+# process_python_file / diff_python_file tests
+# ---------------------------------------------------------------------------
+
+
+def test_process_python_file(tmp_path, logger):
+    """process_python_file formats and writes back."""
+    source = """import marimo as mo
+_df = mo.sql(f"select id, name from users where active = 1")
+"""
+    py_path = tmp_path / "notebook.py"
+    py_path.write_text(source)
+
+    config = load_config()
+    changed = process_python_file(py_path, config, "mysql", logger)
+    assert changed
+
+    result = py_path.read_text()
+    assert "SELECT" in result
+    assert "FROM users" in result
+
+
+def test_process_python_file_check_only(tmp_path, logger):
+    """check_only=True detects changes without writing."""
+    source = """import marimo as mo
+_df = mo.sql(f"select id, name from users where active = 1")
+"""
+    py_path = tmp_path / "notebook.py"
+    py_path.write_text(source)
+
+    config = load_config()
+    changed = process_python_file(py_path, config, "mysql", logger, check_only=True)
+    assert changed
+    # File unchanged
+    assert py_path.read_text() == source
+
+
+def test_diff_python_file(tmp_path, logger):
+    """diff_python_file returns unified diff."""
+    source = """import marimo as mo
+_df = mo.sql(f"select id, name from users where active = 1")
+"""
+    py_path = tmp_path / "notebook.py"
+    py_path.write_text(source)
+
+    config = load_config()
+    diff = diff_python_file(py_path, config, "mysql", logger)
+    assert diff
+    assert "---" in diff
+    assert "+++" in diff
+
+
+def test_diff_python_file_no_changes(tmp_path, logger):
+    """diff_python_file returns empty string when no changes needed."""
+    source = """x = 1
+y = "hello"
+"""
+    py_path = tmp_path / "notebook.py"
+    py_path.write_text(source)
+
+    config = load_config()
+    diff = diff_python_file(py_path, config, "mysql", logger)
+    assert diff == ""
+
+
+# ---------------------------------------------------------------------------
+# CLI integration tests
+# ---------------------------------------------------------------------------
+
+
+def test_cli_marimo_format(tmp_path):
+    """CLI formats a .py file."""
+    source = """import marimo as mo
+_df = mo.sql(f"select id, name from users where active = 1")
+"""
+    py_path = tmp_path / "notebook.py"
+    py_path.write_text(source)
+
+    result = subprocess.run(
+        ["sqlnbfmt", str(py_path)],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0
+    formatted = py_path.read_text()
+    assert "SELECT" in formatted
+
+
+def test_cli_marimo_check(tmp_path):
+    """CLI --check on unformatted .py exits 1."""
+    source = """import marimo as mo
+_df = mo.sql(f"select id, name from users where active = 1")
+"""
+    py_path = tmp_path / "notebook.py"
+    py_path.write_text(source)
+
+    result = subprocess.run(
+        ["sqlnbfmt", "--check", str(py_path)],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 1
+
+
+def test_cli_marimo_diff(tmp_path):
+    """CLI --diff on .py prints diff and exits 0."""
+    source = """import marimo as mo
+_df = mo.sql(f"select id, name from users where active = 1")
+"""
+    py_path = tmp_path / "notebook.py"
+    py_path.write_text(source)
+
+    result = subprocess.run(
+        ["sqlnbfmt", "--diff", str(py_path)],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0
+    assert "---" in result.stdout
+
+
+def test_cli_mixed_files(tmp_path):
+    """CLI handles .ipynb and .py files in the same invocation."""
+    import nbformat
+    from nbformat import v4 as nbf
+
+    # Create .ipynb
+    nb = nbf.new_notebook()
+    nb.cells = [nbf.new_code_cell('query = "select id from users where active = 1"')]
+    nb_path = tmp_path / "notebook.ipynb"
+    nbformat.write(nb, nb_path)
+
+    # Create .py
+    py_source = """import marimo as mo
+_df = mo.sql(f"select id from users where active = 1")
+"""
+    py_path = tmp_path / "notebook.py"
+    py_path.write_text(py_source)
+
+    result = subprocess.run(
+        ["sqlnbfmt", str(nb_path), str(py_path)],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0