Python Code Simplifier

Transform complex, hard-to-maintain Python code into clean, readable, idiomatic solutions.

Analysis Scripts

bash
1# Comprehensive analysis (runs all checks)
2python scripts/analyze_all.py /path/to/project
3
4# Individual analyzers:
5python scripts/analyze_complexity.py .       # Cyclomatic/cognitive complexity
6python scripts/find_code_smells.py .         # Mutable defaults, bare excepts, etc.
7python scripts/find_overengineering.py .     # YAGNI violations, unused abstractions
8python scripts/find_dead_code.py .           # Unused imports, functions, variables
9python scripts/find_unpythonic.py .          # Non-idiomatic patterns
10python scripts/find_coupling_issues.py .     # Feature envy, low cohesion
11python scripts/find_duplicates.py .          # Structural duplicate detection
12
13# JSON output for CI/tooling
14python scripts/analyze_all.py . --format json > report.json

Workflow

1. Analyze: Run analyze_all.py to identify all issues
2. Prioritize: Address high-severity issues (🔴) first
3. Simplify: Apply patterns below incrementally
4. Verify: Ensure simplified code is functionally equivalent

Simplification Principles

1. YAGNI: Don't add abstractions until needed
2. Preserve behavior: Simplification ≠ changing functionality
3. One change at a time: Incremental is safer
4. Readability over cleverness: Clear beats "smart"
5. Keep related code together: Locality matters

Common Simplification Patterns

Extract and Name

python
1# Before: Complex inline condition
2if user.age >= 18 and user.country in ALLOWED and not user.banned:
3
4# After: Named condition
5is_eligible = user.age >= 18 and user.country in ALLOWED and not user.banned
6if is_eligible:

Early Returns

python
1# Before: Deep nesting
2def process(data):
3    if data:
4        if data.valid:
5            if data.ready:
6                return compute(data)
7    return None
8
9# After: Guard clauses
10def process(data):
11    if not data or not data.valid or not data.ready:
12        return None
13    return compute(data)

Comprehensions

python
1# Before: Manual loop
2result = []
3for item in items:
4    if item.active:
5        result.append(item.name)
6
7# After: List comprehension
8result = [item.name for item in items if item.active]

Dictionary Techniques

python
1# Before: Verbose key checking
2if key in d:
3    value = d[key]
4else:
5    value = default
6
7# After: get() with default
8value = d.get(key, default)
9
10# Before: Manual grouping
11groups = {}
12for item in items:
13    if item.category not in groups:
14        groups[item.category] = []
15    groups[item.category].append(item)
16
17# After: defaultdict
18from collections import defaultdict
19groups = defaultdict(list)
20for item in items:
21    groups[item.category].append(item)

Context Managers

python
1# Before: Manual cleanup
2f = open('file.txt')
3try:
4    data = f.read()
5finally:
6    f.close()
7
8# After: with statement
9with open('file.txt') as f:
10    data = f.read()

Over-Engineering Anti-Patterns

Code Smells Quick Reference

Script Reference

When NOT to Simplify

• Working legacy code with no tests
• Performance-critical hot paths (measure first)
• Code that will be replaced soon
• External API constraints requiring complexity