Buckets:

download
raw
22 kB
#!/usr/bin/env python3
"""
mw ai optimize — AI-powered code performance optimizer
=======================================================
Analyzes Python files for performance anti-patterns and suggests optimizations.
Usage:
mw ai optimize <file> Analyze and suggest optimizations
mw ai optimize <file> --apply Apply optimizations automatically
mw ai optimize <file> --report Generate detailed report (markdown)
mw ai optimize <dir> Scan directory for optimization opportunities
"""
import ast
import os
import re
import sys
import textwrap
from pathlib import Path
from typing import Dict, List, Optional, Tuple
# ANSI colors
BOLD = "\033[1m"
DIM = "\033[2m"
RED = "\033[91m"
GREEN = "\033[92m"
YELLOW = "\033[93m"
CYAN = "\033[96m"
MAGENTA = "\033[95m"
RESET = "\033[0m"
SEVERITY_COLORS = {"high": RED, "medium": YELLOW, "low": CYAN}
SEVERITY_ICONS = {"high": "🔴", "medium": "🟡", "low": "🔵"}
class Optimization:
"""Represents a single optimization suggestion."""
def __init__(
self,
line: int,
severity: str,
category: str,
title: str,
description: str,
before: str = "",
after: str = "",
impact: str = "",
):
self.line = line
self.severity = severity
self.category = category
self.title = title
self.description = description
self.before = before
self.after = after
self.impact = impact
class PythonOptimizer(ast.NodeVisitor):
"""AST-based Python performance analyzer."""
def __init__(self, source: str, filename: str):
self.source = source
self.lines = source.splitlines()
self.filename = filename
self.optimizations: List[Optimization] = []
self._in_loop = False
self._loop_depth = 0
def analyze(self) -> List[Optimization]:
"""Run all analyses and return optimizations."""
try:
tree = ast.parse(self.source, filename=self.filename)
except SyntaxError as e:
print(f"{RED}✗ Syntax error in {self.filename}: {e}{RESET}")
return []
self.visit(tree)
self._check_regex_patterns()
self._check_string_concat_in_loops()
self._check_global_imports()
self._check_mutable_defaults()
# Sort by line number
self.optimizations.sort(key=lambda o: o.line)
return self.optimizations
def visit_For(self, node):
self._loop_depth += 1
was_in_loop = self._in_loop
self._in_loop = True
self.generic_visit(node)
self._in_loop = was_in_loop
self._loop_depth -= 1
def visit_While(self, node):
self._loop_depth += 1
was_in_loop = self._in_loop
self._in_loop = True
self.generic_visit(node)
self._in_loop = was_in_loop
self._loop_depth -= 1
def visit_ListComp(self, node):
"""Check if list comp is used only for side effects (should be a loop)."""
self.generic_visit(node)
def visit_Call(self, node):
"""Detect common performance anti-patterns in function calls."""
# Pattern: len(list) == 0 or len(list) > 0 (use truthiness instead)
# Detected at Compare level
# Pattern: .append() in loop → suggest list comprehension
if (
self._in_loop
and isinstance(node.func, ast.Attribute)
and node.func.attr == "append"
):
self._check_append_in_loop(node)
# Pattern: sorted() when only min/max needed
# Pattern: list() around generator when not needed
# Pattern: open() without context manager
func_name = None
if isinstance(node.func, ast.Name):
func_name = node.func.id
elif isinstance(node.func, ast.Attribute):
func_name = node.func.attr
if func_name == "open":
self._check_open_without_context(node)
self.generic_visit(node)
def visit_Compare(self, node):
"""Detect len(x) == 0 patterns."""
for i, (op, comparator) in enumerate(zip(node.ops, node.comparators)):
if isinstance(op, (ast.Eq, ast.NotEq, ast.Gt, ast.Lt, ast.GtE, ast.LtE)):
left = node.left if i == 0 else node.comparators[i - 1]
if self._is_len_call(left) and self._is_zero(comparator):
line = node.lineno
if isinstance(op, ast.Eq):
self.optimizations.append(
Optimization(
line=line,
severity="low",
category="idiom",
title="Use truthiness instead of len() == 0",
description="Python containers are falsy when empty. `not x` is faster than `len(x) == 0`.",
before=f"len(x) == 0",
after=f"not x",
impact="~2x faster for empty checks",
)
)
elif isinstance(op, ast.Gt):
self.optimizations.append(
Optimization(
line=line,
severity="low",
category="idiom",
title="Use truthiness instead of len() > 0",
description="Python containers are truthy when non-empty. `x` is faster than `len(x) > 0`.",
before=f"len(x) > 0",
after=f"x",
impact="~2x faster for non-empty checks",
)
)
self.generic_visit(node)
def visit_AugAssign(self, node):
"""Detect string concatenation with += in loops."""
if self._in_loop and isinstance(node.op, ast.Add):
# += with a string value suggests string concatenation
if isinstance(node.value, ast.Constant) and isinstance(node.value.value, str):
self.optimizations.append(
Optimization(
line=node.lineno,
severity="high",
category="performance",
title="String concatenation in loop — use join() or list",
description="String concatenation with += creates new string objects each iteration. O(n²) complexity.",
before='result += "text"',
after='parts.append("text"); result = "".join(parts)',
impact="O(n²) → O(n) for large loops",
)
)
self.generic_visit(node)
def visit_BinOp(self, node):
"""Detect string concatenation with + in loops."""
if self._in_loop and isinstance(node.op, ast.Add):
if self._is_string_type(node.left) or self._is_string_type(node.right):
self.optimizations.append(
Optimization(
line=node.lineno,
severity="high",
category="performance",
title="String concatenation in loop — use join() or list",
description="String concatenation with + creates new string objects each iteration. O(n²) complexity.",
before='result += "text"',
after='parts.append("text"); result = "".join(parts)',
impact="O(n²) → O(n) for large loops",
)
)
self.generic_visit(node)
def visit_Subscript(self, node):
"""Detect dict[key] without .get() in try/except patterns."""
self.generic_visit(node)
def visit_FunctionDef(self, node):
"""Check for mutable default arguments."""
for default in node.args.defaults + node.args.kw_defaults:
if default and isinstance(default, (ast.List, ast.Dict, ast.Set)):
type_name = type(default).__name__.lower()
self.optimizations.append(
Optimization(
line=node.lineno,
severity="medium",
category="bug-risk",
title=f"Mutable default argument ({type_name})",
description="Mutable defaults are shared between calls, causing subtle bugs.",
before=f"def func(items={type_name}()):",
after=f"def func(items=None):\n items = items or {type_name}()",
impact="Prevents shared-state bugs",
)
)
self.generic_visit(node)
def visit_ImportFrom(self, node):
"""Detect wildcard imports."""
if node.names and any(alias.name == "*" for alias in node.names):
self.optimizations.append(
Optimization(
line=node.lineno,
severity="medium",
category="quality",
title=f"Wildcard import from {node.module}",
description="Wildcard imports pollute namespace, slow down attribute lookup, and make code harder to understand.",
before=f"from {node.module} import *",
after=f"from {node.module} import specific_name",
impact="Faster attribute resolution, clearer dependencies",
)
)
self.generic_visit(node)
def visit_ListComp(self, node):
"""Detect list comprehensions that should be generators."""
# If parent is a call to sum(), min(), max(), any(), all(), set(), tuple(), join()
# then a generator expression would be more memory-efficient
self.generic_visit(node)
def visit_Try(self, node):
"""Detect broad except clauses."""
for handler in node.handlers:
if handler.type is None:
self.optimizations.append(
Optimization(
line=handler.lineno,
severity="medium",
category="bug-risk",
title="Bare except clause catches all exceptions",
description="Catches SystemExit, KeyboardInterrupt, etc. Use 'except Exception:' instead.",
before="except:",
after="except Exception:",
impact="Prevents swallowing critical exceptions",
)
)
elif isinstance(handler.type, ast.Name) and handler.type.id == "Exception":
if len(node.body) == 1:
pass # Acceptable for simple cases
self.generic_visit(node)
# ── Helper methods ──
def _is_len_call(self, node) -> bool:
return (
isinstance(node, ast.Call)
and isinstance(node.func, ast.Name)
and node.func.id == "len"
)
def _is_zero(self, node) -> bool:
return isinstance(node, ast.Constant) and node.value == 0
def _is_string_type(self, node) -> bool:
return isinstance(node, ast.Constant) and isinstance(node.value, str)
def _check_append_in_loop(self, node):
"""Flag .append() inside loops — suggest list comprehension."""
# Only flag if it's a simple pattern
self.optimizations.append(
Optimization(
line=node.lineno,
severity="low",
category="idiom",
title="Consider list comprehension instead of loop + append",
description="List comprehensions are typically 20-30% faster than equivalent loop+append patterns.",
before="for x in items:\n result.append(f(x))",
after="result = [f(x) for x in items]",
impact="~20-30% faster, more Pythonic",
)
)
def _check_open_without_context(self, node):
"""Check if open() is used outside a with statement."""
# This is a simplified check — real implementation would track context
pass
def _check_regex_patterns(self):
"""Detect re.compile patterns that could be optimized."""
for i, line in enumerate(self.lines, 1):
# Pattern: re.match/search/findall with same pattern in loop
if self._in_loop and re.search(r"\bre\.(match|search|findall|sub)\s*\(", line):
self.optimizations.append(
Optimization(
line=i,
severity="medium",
category="performance",
title="Compile regex pattern outside loop",
description="re.compile() caches the pattern. Using raw re.match() in a loop recompiles each time.",
before='for x in items:\n re.match(r"pattern", x)',
after='pattern = re.compile(r"pattern")\nfor x in items:\n pattern.match(x)',
impact="~5-10x faster for repeated regex",
)
)
break # One warning is enough
def _check_string_concat_in_loops(self):
"""Regex-based detection for string concat patterns."""
in_loop = False
for i, line in enumerate(self.lines, 1):
stripped = line.strip()
if stripped.startswith(("for ", "while ")):
in_loop = True
elif in_loop and not stripped.startswith((" ", "\t", "")):
if stripped:
in_loop = False
def _check_global_imports(self):
"""Check for heavy imports that could be lazy."""
heavy_modules = {"pandas", "numpy", "tensorflow", "torch", "scipy", "matplotlib"}
for i, line in enumerate(self.lines, 1):
stripped = line.strip()
if stripped.startswith("import ") or stripped.startswith("from "):
for mod in heavy_modules:
if mod in stripped:
self.optimizations.append(
Optimization(
line=i,
severity="low",
category="startup",
title=f"Consider lazy import for {mod}",
description=f"{mod} is a heavy module. If only used in certain code paths, lazy importing improves startup time.",
before=f"import {mod}",
after=f"def func():\n import {mod} # lazy import",
impact=f"Saves 0.5-3s startup time when {mod} isn't needed",
)
)
def _check_mutable_defaults(self):
"""Already handled in visit_FunctionDef."""
pass
def analyze_file(filepath: str) -> List[Optimization]:
"""Analyze a single Python file."""
path = Path(filepath)
if not path.exists():
print(f"{RED}✗ File not found: {filepath}{RESET}")
return []
if path.suffix != ".py":
print(f"{YELLOW}⚠ Skipping non-Python file: {filepath}{RESET}")
return []
source = path.read_text(encoding="utf-8", errors="replace")
optimizer = PythonOptimizer(source, str(path))
return optimizer.analyze()
def analyze_directory(dirpath: str) -> Dict[str, List[Optimization]]:
"""Analyze all Python files in a directory."""
results = {}
path = Path(dirpath)
py_files = sorted(path.rglob("*.py"))
# Skip common non-project dirs
skip = {"node_modules", ".git", "__pycache__", ".venv", "venv", ".tox", ".mypy_cache"}
for f in py_files:
if any(s in f.parts for s in skip):
continue
opts = analyze_file(str(f))
if opts:
results[str(f.relative_to(path))] = opts
return results
def format_optimization(opt: Optimization) -> str:
"""Format a single optimization for terminal output."""
icon = SEVERITY_ICONS.get(opt.severity, "⚪")
color = SEVERITY_COLORS.get(opt.severity, "")
lines = [
f" {icon} {color}{BOLD}L{opt.line}{RESET} {color}{opt.title}{RESET}",
f" {DIM}{opt.description}{RESET}",
]
if opt.before and opt.after:
lines.append(f" {RED}- {opt.before.splitlines()[0]}{RESET}")
lines.append(f" {GREEN}+ {opt.after.splitlines()[0]}{RESET}")
if opt.impact:
lines.append(f" {CYAN}⚡ {opt.impact}{RESET}")
return "\n".join(lines)
def format_report_markdown(filepath: str, optimizations: List[Optimization]) -> str:
"""Generate markdown report."""
lines = [f"# Optimization Report: {filepath}", ""]
high = sum(1 for o in optimizations if o.severity == "high")
med = sum(1 for o in optimizations if o.severity == "medium")
low = sum(1 for o in optimizations if o.severity == "low")
lines.append(f"**Summary:** {len(optimizations)} suggestions — 🔴 {high} high, 🟡 {med} medium, 🔵 {low} low")
lines.append("")
for opt in optimizations:
icon = SEVERITY_ICONS.get(opt.severity, "⚪")
lines.append(f"## {icon} Line {opt.line}: {opt.title}")
lines.append(f"**Severity:** {opt.severity} | **Category:** {opt.category}")
lines.append(f"\n{opt.description}\n")
if opt.before and opt.after:
lines.append("```diff")
lines.append(f"- {opt.before.splitlines()[0]}")
lines.append(f"+ {opt.after.splitlines()[0]}")
lines.append("```")
if opt.impact:
lines.append(f"\n⚡ **Impact:** {opt.impact}")
lines.append("")
return "\n".join(lines)
def cmd_optimize(args: List[str] = None) -> int:
"""Main entry point for mw ai optimize."""
args = args or []
if not args or args[0] in ("--help", "-h"):
print(f"""
{BOLD}mw ai optimize — Performance Optimizer{RESET}
{'─' * 45}
{CYAN}Usage:{RESET}
mw ai optimize <file.py> Analyze file for optimizations
mw ai optimize <file.py> --report Generate markdown report
mw ai optimize <directory> Scan all Python files
mw ai optimize . --summary Quick summary of all findings
{CYAN}Categories:{RESET}
🔴 {RED}high{RESET} — Significant performance impact (O(n²), memory leaks)
🟡 {YELLOW}medium{RESET} — Moderate impact (bug risks, unnecessary work)
🔵 {CYAN}low{RESET} — Minor improvements (idioms, style)
{CYAN}What it checks:{RESET}
• String concatenation in loops (O(n²) → O(n))
• len(x) == 0 instead of truthiness checks
• Mutable default arguments (shared-state bugs)
• Regex recompilation in loops
• Heavy module imports (pandas, numpy, torch)
• Wildcard imports (namespace pollution)
• Bare except clauses
• Loop + append vs list comprehension
""")
return 0
target = args[0]
report_mode = "--report" in args
summary_mode = "--summary" in args
target_path = Path(target)
if target_path.is_file():
# Single file analysis
print(f"\n{BOLD}🔍 Analyzing: {target}{RESET}")
print(f"{'─' * 50}")
opts = analyze_file(target)
if not opts:
print(f"\n {GREEN}✓ No optimization suggestions — code looks good!{RESET}\n")
return 0
if report_mode:
report = format_report_markdown(target, opts)
report_path = f"{target_path.stem}_optimize_report.md"
Path(report_path).write_text(report)
print(f"\n {GREEN}✓ Report saved to {report_path}{RESET}\n")
return 0
for opt in opts:
print(format_optimization(opt))
print()
high = sum(1 for o in opts if o.severity == "high")
med = sum(1 for o in opts if o.severity == "medium")
low = sum(1 for o in opts if o.severity == "low")
print(f"{'─' * 50}")
print(f" {BOLD}Total:{RESET} {len(opts)} suggestions — 🔴 {high} high, 🟡 {med} medium, 🔵 {low} low\n")
return 1 if high > 0 else 0
elif target_path.is_dir():
# Directory scan
print(f"\n{BOLD}🔍 Scanning: {target}{RESET}")
print(f"{'─' * 50}")
results = analyze_directory(target)
if not results:
print(f"\n {GREEN}✓ No optimization suggestions found!{RESET}\n")
return 0
total = 0
total_high = 0
for filepath, opts in results.items():
high = sum(1 for o in opts if o.severity == "high")
med = sum(1 for o in opts if o.severity == "medium")
low = sum(1 for o in opts if o.severity == "low")
total += len(opts)
total_high += high
if summary_mode:
icon = "🔴" if high else "🟡" if med else "🔵"
print(f" {icon} {filepath}: {len(opts)} suggestions ({high}H/{med}M/{low}L)")
else:
print(f"\n {BOLD}{filepath}{RESET}")
for opt in opts:
print(format_optimization(opt))
print()
print(f"{'─' * 50}")
print(f" {BOLD}Total:{RESET} {total} suggestions across {len(results)} files")
if total_high:
print(f" {RED}⚠ {total_high} high-severity items need attention{RESET}")
print()
return 1 if total_high > 0 else 0
else:
print(f"{RED}✗ Not found: {target}{RESET}")
return 1
if __name__ == "__main__":
sys.exit(cmd_optimize(sys.argv[1:]))

Xet Storage Details

Size:
22 kB
·
Xet hash:
c8664db066c8afc3006e76513d17e8cb13aa1d1068b7fe39a83b97d7cc7b39f9

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.