set-soft-AudioSeparation/tool/style_fixer.py

#!/usr/bin/python3
# Copyright (c) 2025 Salvador E. Tropea
# Copyright (c) 2025 Instituto Nacional de Tecnología Industrial
# License: GPLv3
# Project: ComfyUI-AudioSeparation
#
# Tool to fix some common style errors in code generated by Gemini
# Created by Gemini itself ;-)
import argparse
import os
import shutil  # For file backup
import logging

# Setup logging
logger = logging.getLogger("StyleFixer")
logger.setLevel(logging.INFO)  # Default level
# Create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)  # Let handler decide what to show based on logger's effective level
# Create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# Add formatter to ch
ch.setFormatter(formatter)
# Add ch to logger
logger.addHandler(ch)


def expand_tabs(line, tab_size=4):
    """Expands tabs to spaces, respecting tab stops."""
    out_line = []
    current_col = 0
    for char in line:
        if char == '\t':
            spaces_to_add = tab_size - (current_col % tab_size)
            out_line.append(' ' * spaces_to_add)
            current_col += spaces_to_add
        else:
            out_line.append(char)
            current_col += 1
    return "".join(out_line)


def fix_indentation(line, tab_size=4):
    """Rounds leading whitespace indentation to the nearest multiple of tab_size."""
    stripped_line = line.lstrip(' ')
    if not stripped_line or stripped_line == line:  # No leading spaces or empty line
        return line

    leading_spaces_count = len(line) - len(stripped_line)

    remainder = leading_spaces_count % tab_size
    if remainder == 0:
        new_indent_count = leading_spaces_count
    elif remainder <= tab_size / 2:  # Prioritize rounding down or to current if exact multiple
        new_indent_count = leading_spaces_count - remainder
    else:  # Round up
        new_indent_count = leading_spaces_count + (tab_size - remainder)

    new_indent_count = max(0, new_indent_count)  # Ensure non-negative

    if new_indent_count != leading_spaces_count:
        logger.debug(f"Adjusting indent: from {leading_spaces_count} to {new_indent_count} for line: {line.rstrip()!r}")

    return ' ' * new_indent_count + stripped_line


def process_line(line_num, line_content_with_eol, expand_tabs_enabled=True):
    original_line_for_debug = line_content_with_eol  # Keep for debugging if needed
    line = line_content_with_eol

    # 1. Expand tabs (if enabled)
    if expand_tabs_enabled:
        line = expand_tabs(line)
        if line != original_line_for_debug and not line.isspace():  # Log only if actual content changed
            logger.debug(f"L{line_num}: Tabs expanded.")

    # 2. W291: Remove trailing whitespace (done before other checks that might rely on EOL)
    # Also handles W293 (blank line contains whitespace) implicitly if the line becomes empty.
    processed_line = line.rstrip()
    if len(processed_line) < len(line.rstrip('\r\n')):  # Compare lengths without EOL
        logger.debug(f"L{line_num}: Trailing whitespace removed.")

    # If the line became empty after rstrip, it's a truly blank line
    if not processed_line and line.strip() == "":
        # Return an empty string for a blank line, newline char will be added later if original had it
        if line.endswith(('\n', '\r\n', '\r')):
            return '\n'
        return ""

    # 3. Fix indentation (E111) - only if line is not blank
    if processed_line:
        indented_line = fix_indentation(processed_line)
        if indented_line != processed_line:  # Log if indentation changed
            # Already logged inside fix_indentation with more detail
            pass
        processed_line = indented_line

    # 4. E261: At least two spaces before inline comment
    in_string_char = None
    temp_part = ""
    comment_starts_at = -1

    for idx, char_val in enumerate(processed_line):
        if in_string_char:
            temp_part += char_val
            if char_val == in_string_char:
                if len(temp_part) >= 2 and temp_part[-2] == '\\':
                    pass
                else:
                    in_string_char = None
        elif char_val in ("'", '"'):
            temp_part += char_val
            in_string_char = char_val
        elif char_val == '#':
            comment_starts_at = idx
            break  # Found the first non-string comment char
        else:
            temp_part += char_val

    if comment_starts_at != -1:
        code_part = processed_line[:comment_starts_at]
        comment_part = processed_line[comment_starts_at:]  # Includes '#'

        rstripped_code_part = code_part.rstrip()
        # Only add spaces if there's actual code before the comment
        if rstripped_code_part:
            if not code_part.endswith('  '):  # Needs fixing (less than 2 spaces)
                new_line_with_comment_spacing = rstripped_code_part + '  ' + comment_part
                if new_line_with_comment_spacing != processed_line:
                    logger.debug(f"L{line_num}: Adjusted inline comment spacing.")
                processed_line = new_line_with_comment_spacing
        # If rstripped_code_part is empty, it's a comment at the start of the line (after indent), leave it.

    # Add back the newline character that rstrip might have removed, if the original line had one
    # or if it's not an empty line that was purely whitespace
    if line_content_with_eol.endswith('\n'):
        return processed_line + '\n'
    elif line_content_with_eol.endswith('\r\n'):
        return processed_line + '\r\n'
    elif line_content_with_eol.endswith('\r'):
        return processed_line + '\r'
    else:  # Original line did not end with EOL
        return processed_line


def process_file(filepath, expand_tabs_enabled=True, dry_run=False, no_backup=False):
    logger.info(f"Processing {filepath}...")
    try:
        # Read with universal newlines mode, then splitlines to preserve EOLs correctly for rejoining
        with open(filepath, 'r', encoding='utf-8', newline='') as f:
            # original_content = f.read() # Reading all at once
            # original_lines = original_content.splitlines(keepends=True) # This is better
            original_lines = f.readlines()  # Simpler, usually works fine
    except Exception as e:
        logger.error(f"Error reading file {filepath}: {e}")
        return False

    fixed_lines = []
    changes_made = False
    for i, line_content_with_eol in enumerate(original_lines):
        fixed_line_content = process_line(i + 1, line_content_with_eol, expand_tabs_enabled)
        fixed_lines.append(fixed_line_content)
        if fixed_line_content != line_content_with_eol:
            changes_made = True
            logger.debug(f"L{i+1}: Original: {line_content_with_eol.rstrip()!r}")
            logger.debug(f"L{i+1}: Fixed   : {fixed_line_content.rstrip()!r}")

    if changes_made:
        if dry_run:
            logger.info(f"Would fix style issues in {filepath} (dry run)")
        else:
            if not no_backup:
                backup_dir = os.path.dirname(filepath)
                backup_filename = "." + os.path.basename(filepath) + "~"
                backup_path = os.path.join(backup_dir, backup_filename)
                try:
                    shutil.copy2(filepath, backup_path)  # copy2 preserves metadata
                    logger.info(f"Backup of original file created at {backup_path}")
                except Exception as e:
                    logger.error(f"Failed to create backup for {filepath}: {e}. File not modified.")
                    return False

            try:
                # Write back lines using the original EOLs if possible, or common EOL
                with open(filepath, 'w', encoding='utf-8', newline='') as f:
                    f.writelines(fixed_lines)
                logger.info(f"Fixed style issues in {filepath}")
            except Exception as e:
                logger.error(f"Error writing to file {filepath}: {e}")
                return False
    else:
        logger.info(f"No style issues to fix in {filepath}")

    return True


def main():
    parser = argparse.ArgumentParser(description="Fix common Python code style issues (Flake8).")
    parser.add_argument("files", metavar="FILE", type=str, nargs='+',
                        help="Python files to process")
    parser.add_argument("--no-expand-tabs", action="store_false", dest="expand_tabs",
                        help="Disable expansion of tabs to spaces.")
    parser.add_argument("--dry-run", action="store_true",
                        help="Show what would be changed without modifying files.")
    parser.add_argument("--no-backup", action="store_true",
                        help="Do not create a backup of the original file.")
    parser.add_argument("-v", "--verbose", action="store_true",
                        help="Enable verbose (debug) logging.")
    parser.set_defaults(expand_tabs=True)

    args = parser.parse_args()

    if args.verbose:
        logger.setLevel(logging.DEBUG)
    else:
        logger.setLevel(logging.INFO)

    for filepath in args.files:
        if not os.path.isfile(filepath):
            logger.warning(f"File not found: {filepath}. Skipping.")
            continue
        process_file(filepath, args.expand_tabs, args.dry_run, args.no_backup)


if __name__ == "__main__":
    main()