Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DansiDanutz_MyWork-AI /tools /ai_optimize.py
| #!/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.