sqltidy 0.2.2__tar.gz

sqltidy-0.2.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jayden Rasband
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqltidy-0.2.2/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: sqltidy
+Version: 0.2.2
+Summary: SQL Formatting Made Easy
+Author: Jayden Rasband
+Project-URL: Source, https://github.com/jrasband-dev/sqltidy
+Project-URL: Documentation, https://jrasband-dev.github.io/sqltidy/
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# SQLTidy
+
+[![PyPI version](https://img.shields.io/pypi/v/sqltidy.svg)](https://pypi.org/project/sqltidy/)  
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)  
+[![Documentation Status](https://img.shields.io/badge/docs-online-brightgreen.svg)](https://jrasband-dev.github.io/sqltidy/)
+
+Tidy your SQL Scripts
+
+For full details and usage, see the [official documentation](https://jrasband-dev.github.io/sqltidy/).
+
+## Getting Started
+
+```bash
+pip install sqltidy
+```

sqltidy-0.2.2/README.md

@@ -0,0 +1,15 @@
+# SQLTidy
+
+[![PyPI version](https://img.shields.io/pypi/v/sqltidy.svg)](https://pypi.org/project/sqltidy/)  
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)  
+[![Documentation Status](https://img.shields.io/badge/docs-online-brightgreen.svg)](https://jrasband-dev.github.io/sqltidy/)
+
+Tidy your SQL Scripts
+
+For full details and usage, see the [official documentation](https://jrasband-dev.github.io/sqltidy/).
+
+## Getting Started
+
+```bash
+pip install sqltidy
+```

sqltidy-0.2.2/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.dynamic]
+version = {attr = "sqltidy.__version__"}
+
+[project]
+name = "sqltidy"
+dynamic = ["version"]
+description = "SQL Formatting Made Easy"
+readme = "README.md"
+authors = [{name = "Jayden Rasband"}]
+dependencies = []
+
+[project.urls]
+"Source" = "https://github.com/jrasband-dev/sqltidy"
+"Documentation" = "https://jrasband-dev.github.io/sqltidy/"
+
+[project.scripts]
+sqltidy = "sqltidy.cli:main"

sqltidy-0.2.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqltidy-0.2.2/sqltidy/__init__.py

@@ -0,0 +1,5 @@
+from .api import format_sql, register_plugin, clear_plugins
+
+__version__ = "0.2.2"
+
+__all__ = ["format_sql", "register_plugin", "clear_plugins", "__version__"]

sqltidy-0.2.2/sqltidy/api.py

@@ -0,0 +1,41 @@
+from .config import TidyConfig
+from .rules.base import BaseRule
+from .core import SQLFormatter
+
+# In-memory list to hold extra plugin rules registered at runtime
+_extra_plugins = []
+
+def register_plugin(rule: BaseRule):
+    """
+    Register a plugin rule at runtime.
+
+    Args:
+        rule (BaseRule): An instance of a rule to apply.
+    """
+    if not isinstance(rule, BaseRule):
+        raise TypeError("Plugin must be an instance of BaseRule")
+    _extra_plugins.append(rule)
+
+def clear_plugins():
+    """
+    Clear all runtime-registered plugin rules.
+    """
+    _extra_plugins.clear()
+
+def format_sql(sql: str, config: TidyConfig = None) -> str:
+    """
+    Format a SQL string using all registered rules, including runtime plugins.
+
+    Args:
+        sql (str): The SQL string to format.
+        config (TidyConfig, optional): Formatter configuration.
+
+    Returns:
+        str: Formatted SQL string.
+    """
+    formatter = SQLFormatter(config=config)
+
+    # Inject runtime plugins into the formatter
+    formatter.rules.extend(_extra_plugins)
+
+    return formatter.format(sql)

sqltidy-0.2.2/sqltidy/cli.py

@@ -0,0 +1,185 @@
+import argparse
+import sys
+import json
+from . import __version__
+from .api import format_sql
+from .config import TidyConfig, RewriteConfig
+from .generator import run_generator, load_config_file
+
+
+def create_tidy_config_from_file(config_file: str) -> TidyConfig:
+    """
+    Load TidyConfig from a JSON configuration file.
+    
+    Args:
+        config_file: Path to the configuration JSON file
+    
+    Returns:
+        TidyConfig: Configuration object with loaded values
+    """
+    try:
+        config_data = load_config_file(config_file)
+        
+        # Create TidyConfig with loaded values (no nesting needed)
+        return TidyConfig(**config_data)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        print(f"Error loading config file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def create_rewrite_config_from_file(config_file: str) -> RewriteConfig:
+    """
+    Load RewriteConfig from a JSON configuration file.
+    
+    Args:
+        config_file: Path to the configuration JSON file
+    
+    Returns:
+        RewriteConfig: Configuration object with loaded values
+    """
+    try:
+        config_data = load_config_file(config_file)
+        
+        # Create RewriteConfig with loaded values (no nesting needed)
+        return RewriteConfig(**config_data)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        print(f"Error loading config file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="A SQL formatting tool"
+    )
+    
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"%(prog)s {__version__}"
+    )
+
+    # create subparsers for subcommands
+    subparsers = parser.add_subparsers(title='Commands', dest="command", required=True)
+
+    # -------------------
+    # tidy Command
+    # -------------------
+    tidy_parser = subparsers.add_parser(
+        name="tidy",
+        help="Format a SQL file",
+        description="Format SQL with tidy rules."
+    )
+
+    tidy_input_group = tidy_parser.add_argument_group(title='Input')
+    tidy_input_group.add_argument("input", nargs="?", help="SQL file to format")
+    
+    tidy_parameter_group = tidy_parser.add_argument_group('Parameters')
+    tidy_parameter_group.add_argument("-o", "--output", help="Output file")
+    tidy_parameter_group.add_argument("-cfg","--rules", help="Path to custom rules json file")
+
+
+
+    # -------------------
+    # rewrite Command
+    # -------------------
+
+    rewrite_parser = subparsers.add_parser(
+        "rewrite",
+        help="Rewrite SQL queries",
+        description="Rewrite SQL queries according to specified rules"
+    )
+    
+    rewrite_input_group = rewrite_parser.add_argument_group(title='Input')
+    rewrite_input_group.add_argument("input", nargs="?", help="SQL file to rewrite")
+    
+    rewrite_parameter_group = rewrite_parser.add_argument_group('Parameters')
+    rewrite_parameter_group.add_argument("-o", "--output", help="Output file")
+    rewrite_parameter_group.add_argument("-cfg", "--rules", help="Path to custom rules json file")
+    # Use config.py defaults for rewrite behavior. No CLI enable/disable flags are provided.
+    rewrite_parameter_group.add_argument("--tidy", action="store_true", help="Apply tidy rules after rewriting")
+
+
+    # -------------------
+    # config Command
+    # -------------------
+    config_parser = subparsers.add_parser(
+        "config",
+        help="Interactive config generator",
+        description="Launch an interactive configuration generator for sqltidy"
+    )
+    # You can add config-specific arguments here if needed
+
+
+
+
+
+
+
+    # -------------------
+    # parse arguments
+    # -------------------
+    args = parser.parse_args()
+
+    if args.command == "config":
+        run_generator()
+        return
+
+    # tidy command
+    if args.command == "tidy":
+        if args.input:
+            with open(args.input, "r", encoding="utf-8") as f:
+                sql = f.read()
+        else:
+            sql = sys.stdin.read()
+
+        # Load config from file if provided, otherwise use defaults
+        if args.rules:
+            config = create_tidy_config_from_file(args.rules)
+        else:
+            config = TidyConfig()
+
+        formatted_sql = format_sql(sql, config=config)
+
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(formatted_sql)
+        elif args.input:
+            # overwrite input file if no output specified
+            with open(args.input, "w", encoding="utf-8") as f:
+                f.write(formatted_sql)
+        else:
+            print(formatted_sql)
+
+    # rewrite command
+    if args.command == "rewrite":
+        if args.input:
+            with open(args.input, "r", encoding="utf-8") as f:
+                sql = f.read()
+        else:
+            sql = sys.stdin.read()
+
+        # Load config from file if provided, otherwise use defaults
+        if args.rules:
+            config = create_rewrite_config_from_file(args.rules)
+        else:
+            config = RewriteConfig()
+
+        formatted_sql = format_sql(sql, config=config)
+
+        # Apply tidy rules if requested
+        if args.tidy:
+            tidy_config = TidyConfig()
+            formatted_sql = format_sql(formatted_sql, config=tidy_config)
+
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(formatted_sql)
+        elif args.input:
+            # overwrite input file if no output specified
+            with open(args.input, "w", encoding="utf-8") as f:
+                f.write(formatted_sql)
+        else:
+            print(formatted_sql)
+
+if __name__ == "__main__":
+    main()

sqltidy-0.2.2/sqltidy/config.py

@@ -0,0 +1,19 @@
+# Default Rules
+
+from dataclasses import dataclass, field
+
+@dataclass
+class TidyConfig:
+    uppercase_keywords: bool = True
+    newline_after_select: bool = True
+    compact: bool = True
+    leading_commas: bool = True
+    indent_select_columns: bool = True
+
+
+
+@dataclass
+class RewriteConfig:
+    enable_subquery_to_cte: bool = True
+    enable_alias_style_abc: bool = False
+    enable_alias_style_t_numeric: bool = False

sqltidy-0.2.2/sqltidy/core.py

@@ -0,0 +1,47 @@
+# sqltidy/core.py
+import re
+from typing import List
+from .config import TidyConfig
+from .tokenizer import TOKEN_RE
+
+class SQLFormatter:
+    """Main SQL formatting engine."""
+
+    def __init__(self, config: TidyConfig = None):
+        from .rules import load_rules
+        from .rules.base import FormatterContext
+        self.ctx = FormatterContext(config or TidyConfig())
+        self.rules = load_rules()
+
+    def tokenize(self, sql: str) -> List[str]:
+        """Convert raw SQL into proper tokens without external dependencies."""
+        tokens = []
+        for groups in TOKEN_RE.findall(sql):
+            # Find the first non-empty capturing group
+            for t in groups:
+                if t == "":
+                    continue
+                # normalize whitespace
+                if t.isspace():
+                    if "\n" in t:
+                        tokens.append("\n")
+                    else:
+                        tokens.append(" ")
+                else:
+                    tokens.append(t)
+                break
+
+        return tokens
+
+    def format(self, sql: str) -> str:
+        tokens = self.tokenize(sql)
+
+        # Apply your custom rules
+        for rule in sorted(self.rules, key=lambda r: getattr(r, "order", 100)):
+            tokens = rule.apply(tokens, self.ctx)
+
+        return self.join_tokens(tokens)
+
+    def join_tokens(self, tokens: List[str]) -> str:
+        """Reassemble tokens into formatted SQL text."""
+        return "".join(tokens).strip()

sqltidy-0.2.2/sqltidy/generator.py

@@ -0,0 +1,210 @@
+"""
+Interactive configuration generator for sqltidy.
+Generates config files that can override default settings.
+"""
+
+import json
+from dataclasses import asdict
+from pathlib import Path
+from typing import Dict, Any
+from .config import TidyConfig, RewriteConfig
+
+
+TIDY_DESCRIPTIONS = {
+    "uppercase_keywords": "Convert SQL keywords to uppercase? (e.g., SELECT, FROM, WHERE)",
+    "newline_after_select": "Add newline after SELECT keyword?",
+    "compact": "Use compact formatting (reduce unnecessary whitespace)?",
+    "leading_commas": "Use leading commas in column lists? (e.g., col1\\n  , col2\\n  , col3)",
+    "indent_select_columns": "Indent SELECT columns on separate lines?",
+}
+
+REWRITE_DESCRIPTIONS = {
+    "enable_subquery_to_cte": "Convert subqueries to Common Table Expressions (CTEs)?",
+    "enable_alias_style_abc": "Apply uppercase A, B, C ... table aliases?",
+    "enable_alias_style_t_numeric": "Apply uppercase T1, T2, T3 ... table aliases?",
+}
+
+
+def prompt_yes_no(question: str, default: bool = True) -> bool:
+    """
+    Prompt user for a yes/no question.
+    
+    Args:
+        question: The question to ask
+        default: The default value if user just presses enter
+    
+    Returns:
+        bool: The user's choice
+    """
+    default_str = "[Y/n]" if default else "[y/N]"
+    while True:
+        response = input(f"{question} {default_str}: ").strip().lower()
+        if not response:
+            return default
+        if response in ("y", "yes"):
+            return True
+        if response in ("n", "no"):
+            return False
+        print("Please enter 'y' or 'n'")
+
+
+def generate_tidy_config() -> Dict[str, Any]:
+    """
+    Interactively generate a TidyConfig.
+    Automatically includes any new boolean fields added to TidyConfig.
+    """
+    print("\n" + "=" * 60)
+    print("TIDY CONFIGURATION GENERATOR")
+    print("=" * 60)
+    print("Configure SQL formatting rules for the 'tidy' command.\n")
+    
+    config = {}
+    default_config = asdict(TidyConfig())
+
+    for field_name, default_value in default_config.items():
+        if not isinstance(default_value, bool):
+            continue  # only prompt for boolean options
+        question = TIDY_DESCRIPTIONS.get(
+            field_name,
+            f"Enable {field_name.replace('_', ' ')}?"
+        )
+        config[field_name] = prompt_yes_no(question, default=default_value)
+    
+    return config
+
+
+def generate_rewrite_config() -> Dict[str, Any]:
+    """
+    Interactively generate a RewriteConfig.
+    Automatically includes any new boolean fields added to RewriteConfig.
+    """
+    print("\n" + "=" * 60)
+    print("REWRITE CONFIGURATION GENERATOR")
+    print("=" * 60)
+    print("Configure SQL rewriting rules for the 'rewrite' command.\n")
+    
+    config = {}
+    default_config = asdict(RewriteConfig())
+    
+    for field_name, default_value in default_config.items():
+        if not isinstance(default_value, bool):
+            continue  # only prompt for boolean options
+        question = REWRITE_DESCRIPTIONS.get(
+            field_name,
+            f"Enable {field_name.replace('_', ' ')}?"
+        )
+        config[field_name] = prompt_yes_no(question, default=default_value)
+    
+    return config
+
+
+def select_config_type() -> str:
+    """
+    Prompt user to select which config type to generate.
+    
+    Returns:
+        str: "tidy" or "rewrite"
+    """
+    print("\n" + "=" * 60)
+    print("SQLTIDY CONFIGURATION GENERATOR")
+    print("=" * 60)
+    print("\nSelect which configuration to generate:\n")
+    print("1. Tidy configuration")
+    print("2. Rewrite configuration")
+    
+    while True:
+        choice = input("\nEnter your choice (1-2): ").strip()
+        if choice == "1":
+            return "tidy"
+        elif choice == "2":
+            return "rewrite"
+        print("Please enter 1 or 2")
+
+
+def get_output_filename(config_type: str) -> str:
+    """
+    Prompt user for output filename.
+    
+    Args:
+        config_type: Type of config ("tidy" or "rewrite")
+    
+    Returns:
+        str: Output filename
+    """
+    if config_type == "tidy":
+        default = "tidy_config.json"
+    else:
+        default = "rewrite_config.json"
+    
+    filename = input(f"\nOutput filename [{default}]: ").strip()
+    return filename if filename else default
+
+
+def save_config(config_data: Dict[str, Any], filename: str) -> Path:
+    """
+    Save configuration to a JSON file.
+    
+    Args:
+        config_data: Configuration dictionary
+        filename: Output filename
+    
+    Returns:
+        Path: Path to the saved file
+    """
+    filepath = Path(filename)
+    
+    with open(filepath, "w", encoding="utf-8") as f:
+        json.dump(config_data, f, indent=2)
+    
+    return filepath
+
+
+def run_generator():
+    """
+    Run the interactive configuration generator.
+    """
+    try:
+        config_type = select_config_type()
+        
+        if config_type == "tidy":
+            config_data = generate_tidy_config()
+        else:
+            config_data = generate_rewrite_config()
+        
+        # Get output filename
+        output_file = get_output_filename(config_type)
+        
+        # Save config
+        filepath = save_config(config_data, output_file)
+        
+        print("\n" + "=" * 60)
+        print("✓ Configuration saved successfully!")
+        print(f"File: {filepath.absolute()}")
+        print("=" * 60)
+        print("\nUsage:")
+        if config_type == "tidy":
+            print(f"  sqltidy tidy -cfg {output_file} <input_file>")
+        else:
+            print(f"  sqltidy rewrite -cfg {output_file} <input_file>")
+        print()
+        
+    except KeyboardInterrupt:
+        print("\n\nConfiguration generation cancelled.")
+        return
+    except Exception as e:
+        print(f"\nError: {e}")
+        raise
+
+
+def load_config_file(filepath: str) -> Dict[str, Any]:
+    """
+    Load configuration from a JSON file.
+    
+    Args:
+        filepath: Path to the configuration file
+    
+    Returns:
+        dict: Configuration data
+    """
+    with open(filepath, "r", encoding="utf-8") as f:
+        return json.load(f)

sqltidy-0.2.2/sqltidy/rules/__init__.py

@@ -0,0 +1,3 @@
+from .loader import load_rules
+
+__all__ = ["load_rules"]

sqltidy-0.2.2/sqltidy/rules/base.py

@@ -0,0 +1,14 @@
+from typing import List
+from ..config import TidyConfig
+
+class FormatterContext:
+    """Holds configuration for the formatting run."""
+    def __init__(self, config: TidyConfig):
+        self.config = config
+
+class BaseRule:
+    """All rules must inherit from this."""
+    order = 100
+    rule_type = None  # "tidy" or "rewrite"
+    def apply(self, tokens: List[str], ctx: FormatterContext) -> List[str]:
+        raise NotImplementedError