Python Mixed Whitespace Debugging Tools and Code Examples

This collection provides ready-to-use Python functions for detecting and fixing mixed tabs and spaces indentation errors. These tools help debug whitespace issues that cause IndentationError and TabError exceptions.

Whitespace Detection Tool #

This comprehensive function analyzes Python files for mixed indentation issues:

🐍 Try it yourself

import re
import os

def analyze_whitespace(file_content):
    """
    Analyze whitespace patterns in Python code
    Returns detailed information about indentation issues
    """
    lines = file_content.split('\n')
    issues = []
    indentation_types = set()
    
    for line_num, line in enumerate(lines, 1):
        # Skip empty lines and comments
        if not line.strip() or line.strip().startswith('#'):
            continue
            
        # Extract leading whitespace
        leading_ws = line[:len(line) - len(line.lstrip())]
        
        if leading_ws:
            # Check for tabs
            has_tabs = '\t' in leading_ws
            has_spaces = ' ' in leading_ws
            
            if has_tabs and has_spaces:
                issues.append({
                    'line': line_num,
                    'type': 'mixed',
                    'whitespace': repr(leading_ws),
                    'content': line.strip()[:50] + ('...' if len(line.strip()) > 50 else '')
                })
            elif has_tabs:
                indentation_types.add('tabs')
            elif has_spaces:
                indentation_types.add('spaces')
    
    return {
        'issues': issues,
        'uses_tabs': 'tabs' in indentation_types,
        'uses_spaces': 'spaces' in indentation_types,
        'is_mixed_file': len(indentation_types) > 1,
        'total_issues': len(issues)
    }

# Test with sample code
sample_code = """def example():
    x = 1  # spaces
	y = 2  # tab
    	z = 3  # mixed
    return x + y + z"""

result = analyze_whitespace(sample_code)
print(f"Mixed indentation issues found: {result['total_issues']}")
for issue in result['issues']:
    print(f"Line {issue['line']}: {issue['whitespace']} -> {issue['content']}")

Output:

Click "Run Code" to see the output

File Whitespace Scanner #

Scan entire files and directories for indentation problems:

🐍 Try it yourself

import os
import glob

def scan_file_whitespace(filepath):
    """
    Scan a single Python file for whitespace issues
    """
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            content = f.read()
    except (IOError, UnicodeDecodeError) as e:
        return {'error': str(e), 'filepath': filepath}
    
    analysis = analyze_whitespace(content)
    analysis['filepath'] = filepath
    return analysis

def scan_directory_whitespace(directory_path, pattern="*.py"):
    """
    Scan all Python files in a directory for whitespace issues
    """
    results = []
    pattern_path = os.path.join(directory_path, "**", pattern)
    
    for filepath in glob.glob(pattern_path, recursive=True):
        result = scan_file_whitespace(filepath)
        if result.get('total_issues', 0) > 0:
            results.append(result)
    
    return results

# Example usage function (for demonstration)
def demo_scanner():
    # This would scan actual files in a real scenario
    print("File scanner ready!")
    print("Usage:")
    print("  scan_file_whitespace('path/to/file.py')")
    print("  scan_directory_whitespace('path/to/project')")
    
    # Demo with sample content
    demo_issues = analyze_whitespace(sample_code)
    return demo_issues

demo_result = demo_scanner()
print(f"\nDemo scan found {demo_result['total_issues']} issues")

Output:

Click "Run Code" to see the output

Whitespace Fixer Tool #

Automatically fix mixed indentation issues:

🐍 Try it yourself

def fix_mixed_indentation(content, tab_size=4, prefer_spaces=True):
    """
    Fix mixed indentation by converting to consistent format
    
    Args:
        content: String content of Python file
        tab_size: Number of spaces per tab (default: 4)
        prefer_spaces: If True, convert tabs to spaces; if False, convert spaces to tabs
    """
    lines = content.split('\n')
    fixed_lines = []
    
    for line in lines:
        if not line.strip():
            # Keep empty lines as-is
            fixed_lines.append(line)
            continue
        
        # Extract leading whitespace and content
        stripped = line.lstrip()
        leading_ws = line[:len(line) - len(stripped)]
        
        if prefer_spaces:
            # Convert tabs to spaces
            fixed_leading = leading_ws.expandtabs(tab_size)
        else:
            # Convert spaces to tabs (more complex)
            space_count = 0
            tab_count = 0
            for char in leading_ws:
                if char == ' ':
                    space_count += 1
                elif char == '\t':
                    tab_count += 1
            
            # Convert spaces to tab equivalents
            total_tabs = tab_count + (space_count // tab_size)
            remaining_spaces = space_count % tab_size
            fixed_leading = '\t' * total_tabs + ' ' * remaining_spaces
        
        fixed_lines.append(fixed_leading + stripped)
    
    return '\n'.join(fixed_lines)

# Test the fixer
mixed_sample = """def function():
\tx = 1  # tab
    y = 2  # 4 spaces
\t    z = 3  # tab + 4 spaces
    return x + y + z"""

print("Original (mixed):")
for i, line in enumerate(mixed_sample.split('\n'), 1):
    print(f"{i}: {repr(line)}")

print("\nFixed (all spaces):")
fixed = fix_mixed_indentation(mixed_sample)
for i, line in enumerate(fixed.split('\n'), 1):
    print(f"{i}: {repr(line)}")

Output:

Click "Run Code" to see the output

Interactive Whitespace Debugger #

Debug whitespace character by character:

🐍 Try it yourself

def debug_whitespace_line(line):
    """
    Provide detailed breakdown of whitespace in a single line
    """
    print(f"Line content: {repr(line)}")
    print(f"Visual: '{line}'")
    print("Character breakdown:")
    
    leading_ws = line[:len(line) - len(line.lstrip())]
    content = line.lstrip()
    
    print(f"Leading whitespace ({len(leading_ws)} chars):")
    for i, char in enumerate(leading_ws):
        if char == ' ':
            print(f"  {i:2d}: SPACE")
        elif char == '\t':
            print(f"  {i:2d}: TAB")
        else:
            print(f"  {i:2d}: {repr(char)}")
    
    print(f"Content: '{content}'")
    
    # Indentation level analysis
    spaces = leading_ws.count(' ')
    tabs = leading_ws.count('\t')
    
    print(f"\nIndentation summary:")
    print(f"  Spaces: {spaces}")
    print(f"  Tabs: {tabs}")
    print(f"  Mixed: {'YES' if spaces > 0 and tabs > 0 else 'NO'}")
    
    if tabs > 0:
        print(f"  Equivalent spaces (tab=4): {spaces + (tabs * 4)}")

# Test with different indentation patterns
test_lines = [
    "    normal_spaces = 'ok'",
    "\ttab_indent = 'ok'",
    "    \tmixed_indent = 'problem'",
    "\t    reverse_mixed = 'problem'"
]

for i, test_line in enumerate(test_lines, 1):
    print(f"\n=== Test Line {i} ===")
    debug_whitespace_line(test_line)

Output:

Click "Run Code" to see the output

Batch File Processing Tool #

Process multiple files with whitespace fixes:

🐍 Try it yourself

import os
import shutil
from datetime import datetime

def batch_fix_whitespace(file_paths, backup=True, tab_size=4):
    """
    Fix whitespace issues in multiple files
    
    Args:
        file_paths: List of file paths to process
        backup: Create backup files before modification
        tab_size: Tab size for conversion
    """
    results = []
    
    for filepath in file_paths:
        try:
            # Read original file
            with open(filepath, 'r', encoding='utf-8') as f:
                original_content = f.read()
            
            # Analyze for issues
            analysis = analyze_whitespace(original_content)
            
            if analysis['total_issues'] == 0:
                results.append({
                    'file': filepath,
                    'status': 'no_issues',
                    'message': 'No whitespace issues found'
                })
                continue
            
            # Create backup if requested
            if backup:
                backup_path = f"{filepath}.backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
                shutil.copy2(filepath, backup_path)
            
            # Fix the content
            fixed_content = fix_mixed_indentation(original_content, tab_size)
            
            # Write fixed content back (in real scenario)
            # with open(filepath, 'w', encoding='utf-8') as f:
            #     f.write(fixed_content)
            
            results.append({
                'file': filepath,
                'status': 'fixed',
                'issues_found': analysis['total_issues'],
                'backup_created': backup_path if backup else None
            })
            
        except Exception as e:
            results.append({
                'file': filepath,
                'status': 'error',
                'message': str(e)
            })
    
    return results

# Demo the batch processor
def demo_batch_processor():
    # Simulate processing results
    demo_files = ['script1.py', 'script2.py', 'script3.py']
    print("Batch processor ready!")
    print(f"Would process: {demo_files}")
    print("\nExample results:")
    
    example_results = [
        {'file': 'script1.py', 'status': 'fixed', 'issues_found': 3},
        {'file': 'script2.py', 'status': 'no_issues', 'message': 'Clean'},
        {'file': 'script3.py', 'status': 'fixed', 'issues_found': 1}
    ]
    
    for result in example_results:
        print(f"  {result['file']}: {result['status']}")
        if result.get('issues_found'):
            print(f"    Fixed {result['issues_found']} issues")
    
    return example_results

demo_batch_processor()

Output:

Click "Run Code" to see the output

Command-Line Integration #

Create a simple CLI tool for whitespace debugging:

#!/usr/bin/env python3
import sys
import argparse

def main():
    parser = argparse.ArgumentParser(description='Python whitespace debugger')
    parser.add_argument('files', nargs='+', help='Python files to check')
    parser.add_argument('--fix', action='store_true', help='Fix issues automatically')
    parser.add_argument('--backup', action='store_true', help='Create backups before fixing')
    parser.add_argument('--tab-size', type=int, default=4, help='Tab size for conversion')
    
    args = parser.parse_args()
    
    for filepath in args.files:
        print(f"\nAnalyzing: {filepath}")
        result = scan_file_whitespace(filepath)
        
        if result.get('error'):
            print(f"Error: {result['error']}")
            continue
            
        if result['total_issues'] > 0:
            print(f"Found {result['total_issues']} mixed indentation issues")
            for issue in result['issues']:
                print(f"  Line {issue['line']}: {issue['whitespace']}")
        else:
            print("No whitespace issues found")

if __name__ == '__main__':
    main()

Usage Examples #

Basic Issue Detection #

# Check a string for mixed indentation
content = "def func():\n    x = 1\n\ty = 2"  # mixed
issues = analyze_whitespace(content)
print(f"Issues: {issues['total_issues']}")

Fix and Save #

# Fix mixed indentation in content
fixed = fix_mixed_indentation(content, prefer_spaces=True)
# In real usage, write to file:
# with open('fixed_file.py', 'w') as f:
#     f.write(fixed)

Batch Directory Processing #

# Scan entire project for whitespace issues
issues = scan_directory_whitespace('/path/to/project')
print(f"Files with issues: {len(issues)}")

Summary #

These debugging tools provide comprehensive solutions for Python indentation error tabs vs spaces mixed whitespace debugging:

analyze_whitespace(): Detect mixed indentation patterns
fix_mixed_indentation(): Convert to consistent format
debug_whitespace_line(): Character-level analysis
batch_fix_whitespace(): Process multiple files
scan_directory_whitespace(): Project-wide scanning

Use these tools to maintain consistent indentation and prevent IndentationError and TabError exceptions in your Python projects.

PyGuide

PyGuide

Python Mixed Whitespace Debugging Tools and Code Examples

Python Mixed Whitespace Debugging Tools and Code Examples

Whitespace Detection Tool #

🐍 Try it yourself

File Whitespace Scanner #

🐍 Try it yourself

Whitespace Fixer Tool #

🐍 Try it yourself

Interactive Whitespace Debugger #

🐍 Try it yourself

Batch File Processing Tool #

🐍 Try it yourself

Command-Line Integration #

Usage Examples #

Basic Issue Detection #

Fix and Save #

Batch Directory Processing #

Summary #

Related Snippets

Python Indentation Error Fix Beginner Debugging Code Utilities

Python Debugging AttributeError Object Has No Attribute Diagnostic Tools

Python Enumerate Zip: Ready-to-Use Code Examples

Python Error Frame Inspection Code Examples