sqlnbfmt 0.1.2__tar.gz → 0.1.4__tar.gz

{sqlnbfmt-0.1.2/sqlnbfmt.egg-info → sqlnbfmt-0.1.4}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.1
 Name: sqlnbfmt
-Version: 0.1.2
+Version: 0.1.4
 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
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE

{sqlnbfmt-0.1.2 → sqlnbfmt-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlnbfmt"
-version = "0.1.2"
+version = "0.1.4"
 description = "A tool to format SQL code in Jupyter notebooks."
 authors = [
   { name = "Qing", email = "qingye779@gmail.com" }
@@ -8,6 +8,10 @@ authors = [
 license = { text = "MIT" }
 readme = "README.md"
 requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12"
+]
 dependencies = [
     "astor>=0.8.1",
     "nbformat>=5.10.4",
@@ -31,4 +35,7 @@ sqlnbfmt = "sqlnbfmt.formatter:main"
 [tool.pytest.ini_options]
 markers = [
     "integration: mark a test as an integration test."
-]
+]
+
+[tool.setuptools.package-data]
+sqlnbfmt = [".pre-commit-hooks.yaml"]

{sqlnbfmt-0.1.2 → sqlnbfmt-0.1.4}/sqlnbfmt/formatter.py

@@ -206,6 +206,10 @@ class SQLStringFormatter(ast.NodeTransformer):
         placeholders = {}
         placeholder_counter = 0
 
+        # Handle empty f-strings or f-strings with only constants
+        if all(isinstance(value, ast.Constant) for value in node.values):
+            return "".join(value.value for value in node.values), {}
+
         for value in node.values:
             if isinstance(value, ast.Constant):
                 sql_parts.append(value.value)
@@ -236,10 +240,8 @@ class SQLStringFormatter(ast.NodeTransformer):
                     self.changed = True
                     # Reconstruct the string with adjusted triple quotes
                     if '\n' in formatted_sql:
-                        # Multi-line string: place triple quotes on their own lines
                         formatted_str = f'"""\n{formatted_sql}\n"""'
                     else:
-                        # Single-line string
                         formatted_str = f'"""{formatted_sql}"""'
                     # Parse the formatted string back into an AST node
                     formatted_node = ast.parse(formatted_str).body[0].value
@@ -247,19 +249,24 @@ class SQLStringFormatter(ast.NodeTransformer):
 
             elif isinstance(node, ast.JoinedStr):
                 sql_str, placeholders = self.extract_fstring_parts(node)
-                if not self.is_likely_sql(sql_str):
+                if not sql_str or not self.is_likely_sql(sql_str):
                     return None
 
-                formatted_sql = format_sql_code(
-                    sql_str,
-                    self.dialect,
-                    self.config,
-                    placeholders=placeholders,
-                    force_single_line=force_single_line,
-                )
+                try:
+                    formatted_sql = format_sql_code(
+                        sql_str,
+                        self.dialect,
+                        self.config,
+                        placeholders=placeholders,
+                        force_single_line=force_single_line,
+                    )
+                except SQLFormattingError:
+                    return None
 
                 if placeholders:
                     for placeholder in placeholders.keys():
+                        if not placeholder:  # Skip empty placeholders
+                            continue
                         # Remove quotes around placeholders in formatted SQL
                         formatted_sql = formatted_sql.replace(f"'{placeholder}'", placeholder)
                         formatted_sql = formatted_sql.replace(f'"{placeholder}"', placeholder)
@@ -268,31 +275,36 @@ class SQLStringFormatter(ast.NodeTransformer):
                     self.changed = True
                     # Reconstruct the f-string
                     new_values = []
-                    pattern = re.compile('|'.join(re.escape(k) for k in placeholders.keys()))
-                    idx = 0
-                    while idx < len(formatted_sql):
-                        match = pattern.search(formatted_sql, idx)
-                        if match:
-                            if match.start() > idx:
-                                # Add preceding text as Constant
-                                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:
-                            # Add the rest of the string as Constant
-                            new_values.append(ast.Constant(value=formatted_sql[idx:]))
-                            break
+                    if not placeholders:
+                        # If no placeholders, just create a simple f-string
+                        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:
+                                    # Add preceding text as Constant
+                                    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:
+                                # Add the rest of the string as Constant
+                                new_values.append(ast.Constant(value=formatted_sql[idx:]))
+                                break
+
                     new_node = ast.JoinedStr(values=new_values)
                     # Wrap the f-string with adjusted triple quotes
                     if '\n' in formatted_sql:
@@ -310,6 +322,9 @@ class SQLStringFormatter(ast.NodeTransformer):
         except SQLFormattingError as e:
             self.logger.warning(f"SQL formatting skipped: {e}")
             return None
+        except Exception as e:
+            self.logger.warning(f"Unexpected error during SQL formatting: {e}")
+            return None
 
     def visit_Assign(self, node: ast.Assign) -> ast.AST:
         """Handles assignments."""
@@ -456,7 +471,7 @@ def process_notebook(
         return changed
 
     except Exception as e:
-        logger.error(f"Failed to process notebook {notebook_path}: {e}")
+        logger.error(f"Failed to process notebook {notebook_path}: {e}", exc_info=True)
         raise
 
 
@@ -487,16 +502,26 @@ def main():
     try:
         config = load_config(args.config)
         changed = False
+        changed_files = []
 
         for notebook in args.notebooks:
             if process_notebook(notebook, config, args.dialect, logger):
                 changed = True
+                changed_files.append(notebook)
+
+        # Print summary
+        if changed:
+            logger.info("Changes made to the following notebooks:")
+            for file in changed_files:
+                logger.info(f"  - {file}")
+        else:
+            logger.info("No changes needed. All notebooks are properly formatted.")
 
-        sys.exit(0 if changed else 1)
+        sys.exit(0)
 
     except Exception as e:
         logger.error(f"Fatal error: {e}")
-        sys.exit(2)
+        sys.exit(1)
 
 
 if __name__ == "__main__":

{sqlnbfmt-0.1.2 → sqlnbfmt-0.1.4/sqlnbfmt.egg-info}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.1
 Name: sqlnbfmt
-Version: 0.1.2
+Version: 0.1.4
 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
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE

{sqlnbfmt-0.1.2 → sqlnbfmt-0.1.4}/tests/test_formatter.py

@@ -114,6 +114,28 @@ WHERE
         [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
+"""''')],
+    ),
 ])
 def test_sql_formatter(temp_nb_path, logger, input_cells, expected_cells):
     # Create a new notebook