sqlnbfmt 0.1.8__tar.gz → 0.2.0__tar.gz

{sqlnbfmt-0.1.8/sqlnbfmt.egg-info → sqlnbfmt-0.2.0}/PKG-INFO

@@ -1,19 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sqlnbfmt
-Version: 0.1.8
+Version: 0.2.0
 Summary: A tool to format SQL code in Jupyter notebooks.
 Author-email: Qing <qingye779@gmail.com>
 License: MIT
 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: astor>=0.8.1
-Requires-Dist: black>=24.10.0
 Requires-Dist: nbformat>=5.10.4
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: sqlglot>=25.27.0
+Dynamic: license-file
 
 # sqlnbfmt
 
@@ -27,10 +27,10 @@ A SQL formatter designed specifically for Jupyter Notebooks. `sqlnbfmt` automati
 
 - 🎯 **Smart SQL Detection**: Automatically identifies and formats SQL queries in code cells and magic SQL cells
 - 🌳 **AST-Powered**: Uses Abstract Syntax Tree parsing for accurate SQL string identification
-- 🔒 **Safe Formatting**: Preserves query parameters (e.g., `%s`, `?`) and SQL comments
+- 🔒 **Safe Formatting**: Preserves Python comments, query parameters (e.g., `%s`, `?`), and SQL comments
 - ⚙️ **Highly Configurable**: Customize formatting through YAML configuration
 - 🔄 **Pre-commit Ready**: Seamlessly integrates with pre-commit hooks
-- 📦 **Zero Dependencies**: Minimal installation footprint
+- 📦 **Lightweight**: Only three runtime dependencies (sqlglot, nbformat, pyyaml)
 
 ## Installation
 
@@ -63,14 +63,14 @@ pip install pre-commit
 ```yaml
 repos:
   - repo: https://github.com/flyersworder/sqlnbfmt
-    rev: v0.1.1
+    rev: v0.2.0
     hooks:
       - id: sqlnbfmt
         name: sqlnbfmt
         types: [jupyter]
         args: [--config, config.yaml, --dialect, postgres]
 ```
-Please fun the following command in your CMD for help:
+Please run the following command for help:
 
 ```bash
 sqlnbfmt -h

{sqlnbfmt-0.1.8 → sqlnbfmt-0.2.0}/README.md

@@ -10,10 +10,10 @@ A SQL formatter designed specifically for Jupyter Notebooks. `sqlnbfmt` automati
 
 - 🎯 **Smart SQL Detection**: Automatically identifies and formats SQL queries in code cells and magic SQL cells
 - 🌳 **AST-Powered**: Uses Abstract Syntax Tree parsing for accurate SQL string identification
-- 🔒 **Safe Formatting**: Preserves query parameters (e.g., `%s`, `?`) and SQL comments
+- 🔒 **Safe Formatting**: Preserves Python comments, query parameters (e.g., `%s`, `?`), and SQL comments
 - ⚙️ **Highly Configurable**: Customize formatting through YAML configuration
 - 🔄 **Pre-commit Ready**: Seamlessly integrates with pre-commit hooks
-- 📦 **Zero Dependencies**: Minimal installation footprint
+- 📦 **Lightweight**: Only three runtime dependencies (sqlglot, nbformat, pyyaml)
 
 ## Installation
 
@@ -46,14 +46,14 @@ pip install pre-commit
 ```yaml
 repos:
   - repo: https://github.com/flyersworder/sqlnbfmt
-    rev: v0.1.1
+    rev: v0.2.0
     hooks:
       - id: sqlnbfmt
         name: sqlnbfmt
         types: [jupyter]
         args: [--config, config.yaml, --dialect, postgres]
 ```
-Please fun the following command in your CMD for help:
+Please run the following command for help:
 
 ```bash
 sqlnbfmt -h

{sqlnbfmt-0.1.8 → sqlnbfmt-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlnbfmt"
-version = "0.1.8"
+version = "0.2.0"
 description = "A tool to format SQL code in Jupyter notebooks."
 authors = [
   { name = "Qing", email = "qingye779@gmail.com" }
@@ -10,19 +10,19 @@ readme = "README.md"
 requires-python = ">=3.12"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.12"
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13"
 ]
 dependencies = [
-    "astor>=0.8.1",
-    "black>=24.10.0",
     "nbformat>=5.10.4",
     "pyyaml>=6.0.2",
     "sqlglot>=25.27.0",
 ]
 
-[tool.uv]
-dev-dependencies = [
+[dependency-groups]
+dev = [
     "pytest-cov>=5.0.0",
+    "pytest-timeout>=2.3.1",
     "pytest>=8.3.3",
 ]
 
@@ -38,5 +38,8 @@ markers = [
     "integration: mark a test as an integration test."
 ]
 
+[tool.ruff]
+extend-exclude = ["tests/eval/*/"]
+
 [tool.setuptools.package-data]
 sqlnbfmt = [".pre-commit-hooks.yaml"]

{sqlnbfmt-0.1.8 → sqlnbfmt-0.2.0}/sqlnbfmt/formatter.py

@@ -6,13 +6,20 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Set, Optional, Dict, Union, Tuple
 
-import astor
-import black
 import nbformat
 import yaml
 from sqlglot import parse_one, errors
 
 
+@dataclass
+class SQLReplacement:
+    """A text replacement to apply to the source code."""
+
+    start_offset: int
+    end_offset: int
+    new_text: str
+
+
 @dataclass
 class FormattingConfig:
     """Configuration for SQL formatting."""
@@ -21,7 +28,6 @@ class FormattingConfig:
     function_names: Set[str]
     sql_decorators: Set[str]
     single_line_threshold: int = 80
-    preserve_comments: bool = True
     indent_width: int = 4
 
 
@@ -33,7 +39,7 @@ class SQLFormattingError(Exception):
 
 def setup_logging(level: str = "INFO") -> logging.Logger:
     """Sets up logging with the specified level."""
-    logger = logging.getLogger('formatter')
+    logger = logging.getLogger("formatter")
     logger.setLevel(level.upper())
     if not logger.handlers:
         handler = logging.StreamHandler(sys.stdout)
@@ -59,9 +65,6 @@ def load_config(config_path: Union[str, Path] = "config.yaml") -> FormattingConf
                 single_line_threshold=config.get("formatting_options", {}).get(
                     "single_line_threshold", 80
                 ),
-                preserve_comments=config.get("formatting_options", {}).get(
-                    "preserve_comments", True
-                ),
                 indent_width=config.get("formatting_options", {}).get(
                     "indent_width", 4
                 ),
@@ -70,6 +73,22 @@ def load_config(config_path: Union[str, Path] = "config.yaml") -> FormattingConf
         raise yaml.YAMLError(f"Error parsing the configuration file: {e}")
 
 
+def build_line_offsets(source: str) -> list:
+    """Returns list where offsets[i] is the character offset of line i+1 in source."""
+    offsets = [0]
+    for i, ch in enumerate(source):
+        if ch == "\n":
+            offsets.append(i + 1)
+    return offsets
+
+
+def node_offsets(node: ast.AST, line_offsets: list) -> Tuple[int, int]:
+    """Converts AST node line/col positions to (start, end) character offsets."""
+    start = line_offsets[node.lineno - 1] + node.col_offset
+    end = line_offsets[node.end_lineno - 1] + node.end_col_offset
+    return start, end
+
+
 def format_sql_code(
     sql_code: str,
     dialect: Optional[str],
@@ -95,7 +114,7 @@ def format_sql_code(
         str: The formatted SQL code.
     """
     try:
-        logger = logging.getLogger('formatter')
+        logger = logging.getLogger("formatter")
 
         if not sql_code.strip():
             return sql_code
@@ -112,7 +131,7 @@ def format_sql_code(
                 placeholder_mapping[temp_placeholder] = placeholder
 
         # Handle automatic placeholders (%s, ?)
-        auto_placeholder_pattern = re.compile(r'%s|\?')
+        auto_placeholder_pattern = re.compile(r"%s|\?")
         auto_placeholders = auto_placeholder_pattern.findall(temp_sql)
         auto_placeholder_mapping = {}
         for idx, ph in enumerate(auto_placeholders):
@@ -125,9 +144,7 @@ def format_sql_code(
         # 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
+            pretty=not force_single_line, indent=config.indent_width, dialect=dialect
         )
 
         # Apply formatting based on context
@@ -143,14 +160,22 @@ def format_sql_code(
         if placeholders:
             for temp_placeholder, original_placeholder in placeholder_mapping.items():
                 # Remove quotes around placeholders if any
-                formatted_sql = formatted_sql.replace(f"'{temp_placeholder}'", temp_placeholder)
-                formatted_sql = formatted_sql.replace(f'"{temp_placeholder}"', temp_placeholder)
+                formatted_sql = formatted_sql.replace(
+                    f"'{temp_placeholder}'", temp_placeholder
+                )
+                formatted_sql = formatted_sql.replace(
+                    f'"{temp_placeholder}"', temp_placeholder
+                )
                 # Replace temp placeholders with original placeholders
-                formatted_sql = formatted_sql.replace(temp_placeholder, original_placeholder)
+                formatted_sql = formatted_sql.replace(
+                    temp_placeholder, original_placeholder
+                )
 
         # Restore automatic placeholders
         for temp_placeholder, original_placeholder in auto_placeholder_mapping.items():
-            formatted_sql = formatted_sql.replace(temp_placeholder, original_placeholder)
+            formatted_sql = formatted_sql.replace(
+                temp_placeholder, original_placeholder
+            )
 
         # Logging for debugging purposes
         logger.debug(f"Original SQL:\n{sql_code}")
@@ -164,16 +189,22 @@ def format_sql_code(
         raise SQLFormattingError(f"Unexpected error during SQL formatting: {e}")
 
 
-class SQLStringFormatter(ast.NodeTransformer):
-    """AST NodeTransformer that formats SQL strings."""
+class SQLStringFormatter(ast.NodeVisitor):
+    """AST NodeVisitor that collects SQL string replacements."""
 
     def __init__(
-        self, config: FormattingConfig, dialect: Optional[str], logger: logging.Logger
+        self,
+        config: FormattingConfig,
+        dialect: Optional[str],
+        logger: logging.Logger,
+        line_offsets: list,
     ):
         super().__init__()
         self.config = config
         self.dialect = dialect
         self.logger = logger
+        self.line_offsets = line_offsets
+        self.replacements: list = []
         self.changed = False
 
     def is_likely_sql(self, code: str) -> bool:
@@ -215,7 +246,7 @@ class SQLStringFormatter(ast.NodeTransformer):
             if isinstance(value, ast.Constant):
                 sql_parts.append(value.value)
             elif isinstance(value, ast.FormattedValue):
-                expr = astor.to_source(value.value).strip()
+                expr = ast.unparse(value.value)
                 placeholder = f"PLACEHOLDER_{placeholder_counter}"
                 sql_parts.append(placeholder)
                 placeholders[placeholder] = expr
@@ -224,128 +255,52 @@ class SQLStringFormatter(ast.NodeTransformer):
         return "".join(sql_parts), placeholders
 
     def format_sql_node(
-        self, 
-        node: Union[ast.Constant, ast.JoinedStr], 
+        self,
+        node: Union[ast.Constant, ast.JoinedStr],
         force_single_line: bool = False,
-        in_function: bool = False
-    ) -> Optional[ast.AST]:
-        """Formats SQL code in AST nodes."""
+        in_function: bool = False,
+    ) -> Optional[str]:
+        """Formats SQL code in AST nodes. Returns replacement text or None."""
         try:
+            is_fstring = isinstance(node, ast.JoinedStr)
+            placeholders = {}
+
             if isinstance(node, ast.Constant) and isinstance(node.value, str):
                 if not self.is_likely_sql(node.value):
                     return None
+                sql_str = node.value
+            elif isinstance(node, ast.JoinedStr):
+                sql_str, placeholders = self.extract_fstring_parts(node)
+                if not sql_str or not self.is_likely_sql(sql_str):
+                    return None
+            else:
+                return None
 
+            try:
                 formatted_sql = format_sql_code(
-                    node.value,
+                    sql_str,
                     self.dialect,
                     self.config,
+                    placeholders=placeholders if placeholders else None,
                     force_single_line=force_single_line,
                 )
+            except SQLFormattingError:
+                return None
 
-                if formatted_sql != node.value:
-                    self.changed = True
-                    if in_function and '\n' in formatted_sql:
-                        # Apply Black-style indentation for function arguments
-                        lines = formatted_sql.split('\n')
-                        # Indent all lines including the first SQL line
-                        indented_lines = [
-                            " " * 4 + line if line.strip() else line
-                            for line in lines
-                        ]
-                        formatted_sql = '\n'.join(indented_lines)
-                        
-                        # Reconstruct the string with appropriate quotes
-                        formatted_str = f'"""\n{formatted_sql}\n{" " * 4}"""'
-                    else:
-                        # Ensure newlines are added around the formatted SQL
-                        formatted_str = f'"""\n{formatted_sql}\n"""'
-                    
-                    formatted_node = ast.parse(formatted_str).body[0].value
-                    return formatted_node
+            if formatted_sql == sql_str:
+                return None
 
-            elif isinstance(node, ast.JoinedStr):
-                sql_str, placeholders = self.extract_fstring_parts(node)
-                if not sql_str or not self.is_likely_sql(sql_str):
-                    return None
-
-                try:
-                    formatted_sql = format_sql_code(
-                        sql_str,
-                        self.dialect,
-                        self.config,
-                        placeholders=placeholders,
-                        force_single_line=force_single_line,
-                    )
-                except SQLFormattingError:
-                    return None
+            # Restore placeholders as f-string expressions
+            if placeholders:
+                for ph in placeholders:
+                    formatted_sql = formatted_sql.replace(f"'{ph}'", ph)
+                    formatted_sql = formatted_sql.replace(f'"{ph}"', ph)
+                for ph, expr in placeholders.items():
+                    formatted_sql = formatted_sql.replace(ph, f"{{{expr}}}")
 
-                if placeholders:
-                    for placeholder in placeholders.keys():
-                        if not placeholder:
-                            continue
-                        formatted_sql = formatted_sql.replace(f"'{placeholder}'", placeholder)
-                        formatted_sql = formatted_sql.replace(f'"{placeholder}"', placeholder)
-
-                if formatted_sql != sql_str:
-                    self.changed = True
-                    # Apply Black-style indentation for function arguments
-                    if in_function and '\n' in formatted_sql:
-                        lines = formatted_sql.split('\n')
-                        # Indent all lines including the first SQL line
-                        indented_lines = [
-                            " " * 4 + line if line.strip() else line
-                            for line in lines
-                        ]
-                        formatted_sql = '\n'.join(indented_lines)
-
-                    # Reconstruct the f-string
-                    new_values = []
-                    if not placeholders:
-                        new_values.append(ast.Constant(value=formatted_sql))
-                    else:
-                        pattern = re.compile('|'.join(re.escape(k) for k in placeholders.keys() if k))
-                        idx = 0
-                        while idx < len(formatted_sql):
-                            match = pattern.search(formatted_sql, idx)
-                            if match:
-                                if match.start() > idx:
-                                    new_values.append(ast.Constant(value=formatted_sql[idx:match.start()]))
-                                placeholder = match.group()
-                                expr_str = placeholders[placeholder].strip()
-                                try:
-                                    expr_ast = ast.parse(expr_str, mode='eval').body
-                                except SyntaxError as e:
-                                    self.logger.warning(f"Failed to parse expression '{expr_str}': {e}")
-                                    return None
-                                new_values.append(ast.FormattedValue(
-                                    value=expr_ast,
-                                    conversion=-1,
-                                    format_spec=None
-                                ))
-                                idx = match.end()
-                            else:
-                                new_values.append(ast.Constant(value=formatted_sql[idx:]))
-                                break
-
-                    new_node = ast.JoinedStr(values=new_values)
-                    if '\n' in formatted_sql:
-                        if in_function:
-                            formatted_fstring = ast.JoinedStr(values=[
-                                ast.Constant(value='\n'),
-                                *new_node.values,
-                                ast.Constant(value=f'\n{" " * 4}')
-                            ])
-                        else:
-                            formatted_fstring = ast.JoinedStr(values=[
-                                ast.Constant(value='\n'),
-                                *new_node.values,
-                                ast.Constant(value='\n')
-                            ])
-                    else:
-                        formatted_fstring = new_node
-                    return formatted_fstring
+            self.changed = True
+            return self._build_replacement_text(formatted_sql, is_fstring, in_function)
 
-            return None
         except SQLFormattingError as e:
             self.logger.warning(f"SQL formatting skipped: {e}")
             return None
@@ -353,30 +308,54 @@ class SQLStringFormatter(ast.NodeTransformer):
             self.logger.warning(f"Unexpected error during SQL formatting: {e}")
             return None
 
-    def visit_Assign(self, node: ast.Assign) -> ast.AST:
+    def _build_replacement_text(
+        self, formatted_sql: str, is_fstring: bool, in_function: bool
+    ) -> str:
+        """Constructs the replacement string literal text."""
+        prefix = "f" if is_fstring else ""
+        if in_function and "\n" in formatted_sql:
+            indent = " " * 4
+            lines = formatted_sql.split("\n")
+            indented_lines = [indent + line if line.strip() else line for line in lines]
+            indented_sql = "\n".join(indented_lines)
+            return f'\n{indent}{prefix}"""\n{indented_sql}\n{indent}"""\n'
+        elif "\n" in formatted_sql:
+            return f'{prefix}"""\n{formatted_sql}\n"""'
+        else:
+            return f'{prefix}"{formatted_sql}"'
+
+    def visit_Assign(self, node: ast.Assign) -> None:
         """Handles assignments."""
         if isinstance(node.value, (ast.Constant, ast.JoinedStr)):
-            formatted_node = self.format_sql_node(node.value)
-            if formatted_node:
-                node.value = formatted_node
-        return self.generic_visit(node)
+            replacement_text = self.format_sql_node(node.value)
+            if replacement_text:
+                start, end = node_offsets(node.value, self.line_offsets)
+                self.replacements.append(SQLReplacement(start, end, replacement_text))
+        self.generic_visit(node)
 
-    def visit_Call(self, node: ast.Call) -> ast.AST:
+    def visit_Call(self, node: ast.Call) -> None:
         """Handles function calls."""
         func_name = self.get_full_func_name(node.func)
         if any(name in func_name for name in self.config.function_names):
-            for idx, arg in enumerate(node.args):
+            for arg in node.args:
                 if isinstance(arg, (ast.Constant, ast.JoinedStr)):
-                    # Format with Black-style indentation for function arguments
-                    formatted_node = self.format_sql_node(arg, in_function=True)
-                    if formatted_node:
-                        node.args[idx] = formatted_node
+                    replacement_text = self.format_sql_node(arg, in_function=True)
+                    if replacement_text:
+                        start, end = node_offsets(arg, self.line_offsets)
+                        self.replacements.append(
+                            SQLReplacement(start, end, replacement_text)
+                        )
             for keyword in node.keywords:
                 if isinstance(keyword.value, (ast.Constant, ast.JoinedStr)):
-                    formatted_node = self.format_sql_node(keyword.value, in_function=True)
-                    if formatted_node:
-                        keyword.value = formatted_node
-        return self.generic_visit(node)
+                    replacement_text = self.format_sql_node(
+                        keyword.value, in_function=True
+                    )
+                    if replacement_text:
+                        start, end = node_offsets(keyword.value, self.line_offsets)
+                        self.replacements.append(
+                            SQLReplacement(start, end, replacement_text)
+                        )
+        self.generic_visit(node)
 
     @staticmethod
     def get_full_func_name(node: ast.AST) -> str:
@@ -477,19 +456,26 @@ def process_notebook(
 
                 continue  # Move to the next cell after handling magic command
 
-            # Handle regular Python code
+            # Handle regular Python code with surgical string replacement
             try:
                 tree = ast.parse(original_code)
-                formatter = SQLStringFormatter(config, dialect, logger)
-                new_tree = formatter.visit(tree)
-                if formatter.changed:
-                    # Use astor to convert AST back to source code
-                    formatted_code = astor.to_source(new_tree)
-                    # Now format with black
-                    formatted_code = black.format_str(formatted_code, mode=black.FileMode())
-                    
-                    if formatted_code != original_code:
-                        cell.source = formatted_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"Failed to parse cell:\n{original_code}")
@@ -556,4 +542,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

{sqlnbfmt-0.1.8 → sqlnbfmt-0.2.0/sqlnbfmt.egg-info}/PKG-INFO

@@ -1,19 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sqlnbfmt
-Version: 0.1.8
+Version: 0.2.0
 Summary: A tool to format SQL code in Jupyter notebooks.
 Author-email: Qing <qingye779@gmail.com>
 License: MIT
 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: astor>=0.8.1
-Requires-Dist: black>=24.10.0
 Requires-Dist: nbformat>=5.10.4
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: sqlglot>=25.27.0
+Dynamic: license-file
 
 # sqlnbfmt
 
@@ -27,10 +27,10 @@ A SQL formatter designed specifically for Jupyter Notebooks. `sqlnbfmt` automati
 
 - 🎯 **Smart SQL Detection**: Automatically identifies and formats SQL queries in code cells and magic SQL cells
 - 🌳 **AST-Powered**: Uses Abstract Syntax Tree parsing for accurate SQL string identification
-- 🔒 **Safe Formatting**: Preserves query parameters (e.g., `%s`, `?`) and SQL comments
+- 🔒 **Safe Formatting**: Preserves Python comments, query parameters (e.g., `%s`, `?`), and SQL comments
 - ⚙️ **Highly Configurable**: Customize formatting through YAML configuration
 - 🔄 **Pre-commit Ready**: Seamlessly integrates with pre-commit hooks
-- 📦 **Zero Dependencies**: Minimal installation footprint
+- 📦 **Lightweight**: Only three runtime dependencies (sqlglot, nbformat, pyyaml)
 
 ## Installation
 
@@ -63,14 +63,14 @@ pip install pre-commit
 ```yaml
 repos:
   - repo: https://github.com/flyersworder/sqlnbfmt
-    rev: v0.1.1
+    rev: v0.2.0
     hooks:
       - id: sqlnbfmt
         name: sqlnbfmt
         types: [jupyter]
         args: [--config, config.yaml, --dialect, postgres]
 ```
-Please fun the following command in your CMD for help:
+Please run the following command for help:
 
 ```bash
 sqlnbfmt -h

{sqlnbfmt-0.1.8 → sqlnbfmt-0.2.0}/sqlnbfmt.egg-info/SOURCES.txt

@@ -9,4 +9,5 @@ sqlnbfmt.egg-info/dependency_links.txt
 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

{sqlnbfmt-0.1.8 → sqlnbfmt-0.2.0}/sqlnbfmt.egg-info/requires.txt

@@ -1,5 +1,3 @@
-astor>=0.8.1
-black>=24.10.0
 nbformat>=5.10.4
 pyyaml>=6.0.2
 sqlglot>=25.27.0

sqlnbfmt-0.2.0/tests/test_eval.py

@@ -0,0 +1,81 @@
+"""Fixture-based eval test suite for sqlnbfmt.
+
+Auto-discovers test cases from tests/eval/*/ directories.
+Each directory must contain input.ipynb and expected.ipynb.
+"""
+
+import logging
+import shutil
+from pathlib import Path
+
+import nbformat
+import pytest
+
+from sqlnbfmt.formatter import load_config, process_notebook
+
+EVAL_DIR = Path(__file__).resolve().parent / "eval"
+CONFIG_PATH = Path(__file__).resolve().parent.parent / "config.yaml"
+DIALECT = "mysql"
+
+
+def discover_eval_cases():
+    """Find all eval case directories containing input.ipynb + expected.ipynb."""
+    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.ipynb").exists()
+            and (case_dir / "expected.ipynb").exists()
+        ):
+            cases.append(case_dir.name)
+    return cases
+
+
+@pytest.fixture
+def logger():
+    log = logging.getLogger("test_eval")
+    log.setLevel(logging.DEBUG)
+    if not log.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+        log.addHandler(handler)
+    return log
+
+
+@pytest.mark.parametrize("case_name", discover_eval_cases(), ids=lambda c: c)
+def test_eval(case_name, logger, tmp_path):
+    """Run formatter on input.ipynb and compare cell-by-cell with expected.ipynb."""
+    case_dir = EVAL_DIR / case_name
+
+    # Copy input to temp directory so we don't modify fixtures
+    work_path = tmp_path / "notebook.ipynb"
+    shutil.copy2(case_dir / "input.ipynb", work_path)
+
+    # Load config and run formatter
+    config = load_config(CONFIG_PATH)
+    process_notebook(work_path, config, DIALECT, logger)
+
+    # Read formatted and expected
+    formatted_nb = nbformat.read(work_path, as_version=4)
+    expected_nb = nbformat.read(case_dir / "expected.ipynb", as_version=4)
+
+    # Compare cell-by-cell
+    assert len(formatted_nb.cells) == len(expected_nb.cells), (
+        f"[{case_name}] Cell count mismatch: "
+        f"got {len(formatted_nb.cells)}, expected {len(expected_nb.cells)}"
+    )
+
+    for i, (fmt_cell, exp_cell) in enumerate(
+        zip(formatted_nb.cells, expected_nb.cells)
+    ):
+        assert fmt_cell.cell_type == exp_cell.cell_type, (
+            f"[{case_name}] Cell {i} type mismatch: "
+            f"got {fmt_cell.cell_type}, expected {exp_cell.cell_type}"
+        )
+        assert fmt_cell.source == exp_cell.source, (
+            f"[{case_name}] Cell {i} content mismatch.\n"
+            f"Expected:\n{exp_cell.source}\n"
+            f"Actual:\n{fmt_cell.source}"
+        )

sqlnbfmt-0.2.0/tests/test_formatter.py

@@ -0,0 +1,237 @@
+import pytest
+import nbformat
+from nbformat import v4 as nbf
+import logging
+
+from sqlnbfmt.formatter import process_notebook, load_config
+
+
+# Fixture for temporary notebook path
+@pytest.fixture
+def temp_nb_path(tmp_path):
+    return tmp_path / "temp_test_notebook.ipynb"
+
+
+# Fixture for logger
+@pytest.fixture
+def logger():
+    # Set up a logger for testing
+    logger = logging.getLogger("test_formatter")
+    logger.setLevel(logging.DEBUG)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter("[%(levelname)s] %(message)s")
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    return logger
+
+
+# Test function with updated expected outputs
+@pytest.mark.parametrize(
+    "input_cells, expected_cells",
+    [
+        # Test Case 1: Simple SELECT Query
+        (
+            [
+                nbf.new_code_cell(
+                    """query = "select id, name from users where active = 1" """
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''query = """\nSELECT\n  id,\n  name\nFROM users\nWHERE\n  active = 1\n""" '''
+                )
+            ],
+        ),
+        # Test Case 2: SELECT Query with F-String and Variable
+        (
+            [
+                nbf.new_code_cell(
+                    '''table_name = "users"\nquery = f"select * from {table_name}"'''
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''table_name = "users"\nquery = f"""\nSELECT\n  *\nFROM {table_name}\n"""'''
+                )
+            ],
+        ),
+        # Test Case 3: Multi-line SELECT Query with Variables
+        (
+            [
+                nbf.new_code_cell(
+                    '''columns = "id, name"\nquery = f"select {columns} from users where active = 1"'''
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''columns = "id, name"\nquery = f"""\nSELECT\n  {columns}\nFROM users\nWHERE\n  active = 1\n"""'''
+                )
+            ],
+        ),
+        # Test Case 4: SQL Query with Line Magic Command
+        (
+            [nbf.new_code_cell("""%sql select * from users where active = 1""")],
+            [nbf.new_code_cell("""%sql SELECT * FROM users WHERE active = 1""")],
+        ),
+        # Test Case 5: SQL Query with Cell Magic Command
+        (
+            [nbf.new_code_cell("""%%sql\nselect * from users where active = 1""")],
+            [
+                nbf.new_code_cell(
+                    """%%sql\nSELECT\n  *\nFROM users\nWHERE\n  active = 1"""
+                )
+            ],
+        ),
+        # Test Case 6: INSERT Query with Variables (Remains Unchanged)
+        (
+            [
+                nbf.new_code_cell(
+                    '''table_name = "users"\ncolumns = "(id, name)"\nvalues = "(1, 'Alice')"\nquery = f"insert into {table_name} {columns} values {values}"'''
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''table_name = "users"\ncolumns = "(id, name)"\nvalues = "(1, 'Alice')"\nquery = f"insert into {table_name} {columns} values {values}"'''
+                )
+            ],
+        ),
+        # Test Case 7: UPDATE Query with Variables
+        (
+            [
+                nbf.new_code_cell(
+                    '''table_name = "users"\nquery = f"update {table_name} set active = 0 where id = 1"'''
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''table_name = "users"\nquery = f"""\nUPDATE {table_name} SET active = 0\nWHERE\n  id = 1\n"""'''
+                )
+            ],
+        ),
+        # Test Case 8: DELETE Query
+        (
+            [nbf.new_code_cell("""query = "delete from users where active = 0" """)],
+            [
+                nbf.new_code_cell(
+                    '''query = """\nDELETE FROM users\nWHERE\n  active = 0\n""" '''
+                )
+            ],
+        ),
+        # Test Case 9: Query with SQL Comments
+        (
+            [
+                nbf.new_code_cell(
+                    '''query = "-- Select active users\\nselect id, name from users where active = 1"'''
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''query = """\n/* Select active users */\nSELECT\n  id,\n  name\nFROM users\nWHERE\n  active = 1\n"""'''
+                )
+            ],
+        ),
+        # Test Case 10: Non-SQL String (Should Remain Unchanged)
+        (
+            [
+                nbf.new_code_cell(
+                    '''message = "This is not an SQL query: select * from users;"'''
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''message = "This is not an SQL query: select * from users;"'''
+                )
+            ],
+        ),
+        # Test Case 11: F-string without variables
+        (
+            [
+                nbf.new_code_cell(
+                    '''query = f"select id, name from users where active = 1"'''
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''query = f"""\nSELECT\n  id,\n  name\nFROM users\nWHERE\n  active = 1\n"""'''
+                )
+            ],
+        ),
+        # Test Case 12: F-string with only string constants
+        (
+            [nbf.new_code_cell('''query = f"select " f"id, name " f"from users"''')],
+            [
+                nbf.new_code_cell(
+                    '''query = f"""\nSELECT\n  id,\n  name\nFROM users\n"""'''
+                )
+            ],
+        ),
+        # Test Case 13: In-function SQL Query
+        (
+            [
+                nbf.new_code_cell(
+                    '''pd.read_sql("""select id, name from users where active = 1""")'''
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''pd.read_sql(\n    """\n    SELECT\n      id,\n      name\n    FROM users\n    WHERE\n      active = 1\n    """\n)'''
+                )
+            ],
+        ),
+        # Test Case 14: In-function SQL Query with F-String
+        (
+            [
+                nbf.new_code_cell(
+                    """table_name = "users"\npd.read_sql(f"select * from {table_name}")"""
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''table_name = "users"\npd.read_sql(\n    f"""\n    SELECT\n      *\n    FROM {table_name}\n    """\n)'''
+                )
+            ],
+        ),
+        # Test Case 15: Python comment preservation
+        (
+            [
+                nbf.new_code_cell(
+                    '''# This query fetches active users\nquery = "select id, name from users where active = 1"'''
+                )
+            ],
+            [
+                nbf.new_code_cell(
+                    '''# This query fetches active users\nquery = """\nSELECT\n  id,\n  name\nFROM users\nWHERE\n  active = 1\n"""'''
+                )
+            ],
+        ),
+    ],
+)
+def test_sql_formatter(temp_nb_path, logger, input_cells, expected_cells):
+    # Create a new notebook
+    nb = nbf.new_notebook()
+    nb.cells = input_cells
+
+    # Write the notebook to the temporary path
+    nbformat.write(nb, temp_nb_path)
+
+    # Load configuration
+    config = load_config("config.yaml")
+    dialect = "mysql"  # or your preferred SQL dialect
+
+    # Run the formatter on the notebook
+    process_notebook(temp_nb_path, config, dialect, logger=logger)
+
+    # Read the formatted notebook
+    formatted_nb = nbformat.read(temp_nb_path, as_version=4)
+
+    # Compare the cells
+    for formatted_cell, expected_cell in zip(formatted_nb.cells, expected_cells):
+        formatted_code = formatted_cell.source.strip()
+        expected_code = expected_cell.source.strip()
+        assert formatted_code == expected_code, (
+            f"Formatted code does not match expected output.\nExpected:\n{expected_code}\nActual:\n{formatted_code}"
+        )
+
+    # Clean up
+    temp_nb_path.unlink()

sqlnbfmt-0.1.8/tests/test_formatter.py

@@ -1,201 +0,0 @@
-import pytest
-import nbformat
-from nbformat import v4 as nbf
-from pathlib import Path
-import logging
-import sys
-
-# Add the parent directory to sys.path to import the formatter module
-sys.path.append(str(Path(__file__).resolve().parent.parent))
-
-from sqlnbfmt.formatter import process_notebook, FormattingConfig, load_config
-
-# Fixture for temporary notebook path
-@pytest.fixture
-def temp_nb_path(tmp_path):
-    return tmp_path / "temp_test_notebook.ipynb"
-
-# Fixture for logger
-@pytest.fixture
-def logger():
-    # Set up a logger for testing
-    logger = logging.getLogger('test_formatter')
-    logger.setLevel(logging.DEBUG)
-    if not logger.handlers:
-        handler = logging.StreamHandler()
-        formatter = logging.Formatter("[%(levelname)s] %(message)s")
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-    return logger
-
-# Test function with updated expected outputs
-@pytest.mark.parametrize("input_cells, expected_cells", [
-    # Test Case 1: Simple SELECT Query
-    (
-        [nbf.new_code_cell("""query = "select id, name from users where active = 1" """)],
-        [nbf.new_code_cell('''query = """
-SELECT
-  id,
-  name
-FROM users
-WHERE
-  active = 1
-"""''')],
-    ),
-    # Test Case 2: SELECT Query with F-String and Variable
-    (
-        [nbf.new_code_cell('''table_name = "users"\nquery = f"select * from {table_name}"''')],
-        [nbf.new_code_cell('''table_name = "users"
-query = f"""
-SELECT
-  *
-FROM {table_name}
-"""''')],
-    ),
-    # Test Case 3: Multi-line SELECT Query with Variables
-    (
-        [nbf.new_code_cell('''columns = "id, name"\nquery = f"select {columns} from users where active = 1"''')],
-        [nbf.new_code_cell('''columns = "id, name"
-query = f"""
-SELECT
-  {columns}
-FROM users
-WHERE
-  active = 1
-"""''')],
-    ),
-    # Test Case 4: SQL Query with Line Magic Command
-    (
-        [nbf.new_code_cell("""%sql select * from users where active = 1""")],
-        [nbf.new_code_cell("""%sql SELECT * FROM users WHERE active = 1""")],
-    ),
-    # Test Case 5: SQL Query with Cell Magic Command
-    (
-        [nbf.new_code_cell('''%%sql\nselect * from users where active = 1''')],
-        [nbf.new_code_cell('''%%sql
-SELECT
-  *
-FROM users
-WHERE
-  active = 1''')],
-    ),
-    # Test Case 6: INSERT Query with Variables (Remains Unchanged)
-    (
-        [nbf.new_code_cell('''table_name = "users"\ncolumns = "(id, name)"\nvalues = "(1, 'Alice')"\nquery = f"insert into {table_name} {columns} values {values}"''')],
-        [nbf.new_code_cell('''table_name = "users"
-columns = "(id, name)"
-values = "(1, 'Alice')"
-query = f"insert into {table_name} {columns} values {values}"''')],
-    ),
-    # Test Case 7: UPDATE Query with Variables
-    (
-        [nbf.new_code_cell('''table_name = "users"\nquery = f"update {table_name} set active = 0 where id = 1"''')],
-        [nbf.new_code_cell('''table_name = "users"
-query = f"""
-UPDATE {table_name} SET active = 0
-WHERE
-  id = 1
-"""''')],
-    ),
-    # Test Case 8: DELETE Query
-    (
-        [nbf.new_code_cell("""query = "delete from users where active = 0" """)],
-        [nbf.new_code_cell('''query = """
-DELETE FROM users
-WHERE
-  active = 0
-"""''')],
-    ),
-    # Test Case 9: Query with Comments
-    (
-        [nbf.new_code_cell('''query = "-- Select active users\\nselect id, name from users where active = 1"''')],
-        [nbf.new_code_cell('''query = """
-/* Select active users */
-SELECT
-  id,
-  name
-FROM users
-WHERE
-  active = 1
-"""''')],
-    ),
-    # Test Case 10: Non-SQL String (Should Remain Unchanged)
-    (
-        [nbf.new_code_cell('''message = "This is not an SQL query: select * from users;"''')],
-        [nbf.new_code_cell('''message = "This is not an SQL query: select * from users;"''')],
-    ),
-    # Test Case 11: F-string without variables
-    (
-        [nbf.new_code_cell('''query = f"select id, name from users where active = 1"''')],
-        [nbf.new_code_cell('''query = f"""
-SELECT
-  id,
-  name
-FROM users
-WHERE
-  active = 1
-"""''')],
-    ),
-    # Test Case 12: F-string with only string constants
-    (
-        [nbf.new_code_cell('''query = f"select " f"id, name " f"from users"''')],
-        [nbf.new_code_cell('''query = f"""
-SELECT
-  id,
-  name
-FROM users
-"""''')],
-    ),
-    # Test Case 13: In-function SQL Query
-    (
-        [nbf.new_code_cell('''pd.read_sql("""select id, name from users where active = 1""")''')],
-        [nbf.new_code_cell('''pd.read_sql(
-    """
-    SELECT
-      id,
-      name
-    FROM users
-    WHERE
-      active = 1
-    """
-)''')],
-    ),
-    # Test Case 14: In-function SQL Query with F-String
-    (
-        [nbf.new_code_cell('''table_name = "users"\npd.read_sql(f"select * from {table_name}")''')],
-        [nbf.new_code_cell('''table_name = "users"
-pd.read_sql(
-    f"""
-    SELECT
-      *
-    FROM {table_name}
-    """
-)''')],
-    ),
-])
-def test_sql_formatter(temp_nb_path, logger, input_cells, expected_cells):
-    # Create a new notebook
-    nb = nbf.new_notebook()
-    nb.cells = input_cells
-
-    # Write the notebook to the temporary path
-    nbformat.write(nb, temp_nb_path)
-
-    # Load configuration
-    config = load_config('config.yaml')
-    dialect = 'mysql'  # or your preferred SQL dialect
-
-    # Run the formatter on the notebook
-    process_notebook(temp_nb_path, config, dialect, logger=logger)
-
-    # Read the formatted notebook
-    formatted_nb = nbformat.read(temp_nb_path, as_version=4)
-
-    # Compare the cells
-    for formatted_cell, expected_cell in zip(formatted_nb.cells, expected_cells):
-        formatted_code = formatted_cell.source.strip()
-        expected_code = expected_cell.source.strip()
-        assert formatted_code == expected_code, f"Formatted code does not match expected output.\nExpected:\n{expected_code}\nActual:\n{formatted_code}"
-
-    # Clean up
-    temp_nb_path.unlink()