# Python Patterns for execute

Practical patterns for using `execute` with `language: python`.
All examples use Python standard library only (no pip installs required).

---

## Data Processing with json Module

### Analyze a large JSON dataset

```python
import json

with open('data/users.json') as f:
    users = json.load(f)

print(f"Total users: {len(users)}")

# Group by status
from collections import Counter
statuses = Counter(u.get('status', 'unknown') for u in users)
print("\n=== Users by Status ===")
for status, count in statuses.most_common():
    print(f"  {status}: {count}")

# Find anomalies
inactive_with_recent = [
    u for u in users
    if u.get('status') == 'inactive' and u.get('last_login', '') > '2025-01-01'
]
if inactive_with_recent:
    print(f"\n=== Anomaly: {len(inactive_with_recent)} inactive users with recent logins ===")
    for u in inactive_with_recent[:10]:
        print(f"  {u['email']} - last login: {u['last_login']}")

# Field completeness
fields = ['name', 'email', 'phone', 'address']
print("\n=== Field Completeness ===")
for field in fields:
    filled = sum(1 for u in users if u.get(field))
    pct = (filled / len(users)) * 100 if users else 0
    print(f"  {field}: {filled}/{len(users)} ({pct:.1f}%)")
```
> summary_prompt: "Report user distribution, data quality issues, and any anomalies found"

### Merge and compare two JSON configs

```python
import json

with open('config.default.json') as f:
    defaults = json.load(f)
with open('config.local.json') as f:
    local = json.load(f)

def compare(d1, d2, path=""):
    diffs = []
    all_keys = set(list(d1.keys()) + list(d2.keys()))
    for key in sorted(all_keys):
        full_path = f"{path}.{key}" if path else key
        if key not in d1:
            diffs.append(f"  + {full_path} = {json.dumps(d2[key])}")
        elif key not in d2:
            diffs.append(f"  - {full_path} = {json.dumps(d1[key])}")
        elif isinstance(d1[key], dict) and isinstance(d2[key], dict):
            diffs.extend(compare(d1[key], d2[key], full_path))
        elif d1[key] != d2[key]:
            diffs.append(f"  ~ {full_path}: {json.dumps(d1[key])} -> {json.dumps(d2[key])}")
    return diffs

diffs = compare(defaults, local)
print(f"Config differences: {len(diffs)}")
if diffs:
    print("\n=== Changes (local overrides) ===")
    for d in diffs:
        print(d)
else:
    print("No differences found — local matches defaults.")
```
> summary_prompt: "List all local config overrides and flag any potentially dangerous changes"

---

## CSV / Log File Analysis

### Analyze a CSV file

```python
import csv
from collections import Counter, defaultdict
from datetime import datetime

with open('data/transactions.csv') as f:
    reader = csv.DictReader(f)
    rows = list(reader)

print(f"Total records: {len(rows)}")
print(f"Columns: {', '.join(rows[0].keys()) if rows else 'none'}")

# Summary statistics for numeric column
amounts = [float(r['amount']) for r in rows if r.get('amount')]
if amounts:
    print(f"\n=== Amount Statistics ===")
    print(f"  Min:    ${min(amounts):,.2f}")
    print(f"  Max:    ${max(amounts):,.2f}")
    print(f"  Mean:   ${sum(amounts)/len(amounts):,.2f}")
    print(f"  Median: ${sorted(amounts)[len(amounts)//2]:,.2f}")
    print(f"  Total:  ${sum(amounts):,.2f}")

# Group by category
if 'category' in rows[0]:
    by_cat = defaultdict(list)
    for r in rows:
        by_cat[r['category']].append(float(r.get('amount', 0)))
    print("\n=== By Category ===")
    for cat, vals in sorted(by_cat.items(), key=lambda x: -sum(x[1])):
        print(f"  {cat}: {len(vals)} txns, total ${sum(vals):,.2f}")
```
> summary_prompt: "Summarize transaction patterns, highlight outliers, report category distribution"

### Parse application logs

```python
import re
from collections import Counter
from datetime import datetime

error_pattern = re.compile(r'\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] (\w+): (.+)')

levels = Counter()
errors_by_type = Counter()
hourly = Counter()

with open('app.log') as f:
    for line in f:
        match = error_pattern.match(line.strip())
        if match:
            timestamp, level, message = match.groups()
            levels[level] += 1
            hour = timestamp[:13]
            hourly[hour] += 1
            if level in ('ERROR', 'FATAL'):
                # Extract error class
                err_type = message.split(':')[0].strip()
                errors_by_type[err_type] += 1

print("=== Log Level Distribution ===")
for level, count in levels.most_common():
    print(f"  {level}: {count}")

print("\n=== Top Error Types ===")
for err, count in errors_by_type.most_common(10):
    print(f"  {err}: {count}")

print("\n=== Hourly Activity (last 24h) ===")
for hour, count in sorted(hourly.items())[-24:]:
    bar = '#' * min(count // 10, 50)
    print(f"  {hour}: {count:>5} {bar}")
```
> summary_prompt: "Report error rates, identify the most common failures, and note any traffic spikes"

---

## Text Extraction and Summarization

### Extract TODOs and FIXMEs from codebase

```python
import os
import re

pattern = re.compile(r'(TODO|FIXME|HACK|XXX|WARN)[:\s](.+)', re.IGNORECASE)
results = []

for root, dirs, files in os.walk('src'):
    # Skip node_modules and hidden dirs
    dirs[:] = [d for d in dirs if not d.startswith('.') and d != 'node_modules']
    for fname in files:
        if fname.endswith(('.ts', '.tsx', '.js', '.jsx', '.py')):
            filepath = os.path.join(root, fname)
            with open(filepath) as f:
                for i, line in enumerate(f, 1):
                    match = pattern.search(line)
                    if match:
                        results.append({
                            'file': filepath,
                            'line': i,
                            'type': match.group(1).upper(),
                            'text': match.group(2).strip()
                        })

from collections import Counter
by_type = Counter(r['type'] for r in results)

print(f"Total annotations found: {len(results)}\n")
print("=== By Type ===")
for t, c in by_type.most_common():
    print(f"  {t}: {c}")

print("\n=== All Items ===")
for r in results:
    print(f"  [{r['type']}] {r['file']}:{r['line']} — {r['text'][:100]}")
```
> summary_prompt: "Categorize TODOs by urgency, group by file area, suggest which to address first"

### Summarize a large text/markdown file

```python
with open('ARCHITECTURE.md') as f:
    content = f.read()

lines = content.split('\n')
print(f"Total lines: {len(lines)}")
print(f"Total words: {len(content.split())}")

# Extract structure
headings = [(i+1, line) for i, line in enumerate(lines) if line.startswith('#')]
print(f"Sections: {len(headings)}\n")

print("=== Document Structure ===")
for line_num, heading in headings:
    level = len(heading) - len(heading.lstrip('#'))
    indent = '  ' * (level - 1)
    print(f"  {indent}{heading.strip()} (line {line_num})")

# Extract code blocks
import re
code_blocks = re.findall(r'```(\w+)?', content)
if code_blocks:
    from collections import Counter
    langs = Counter(b for b in code_blocks if b)
    print(f"\n=== Code Blocks: {len(code_blocks)} total ===")
    for lang, count in langs.most_common():
        print(f"  {lang}: {count}")

# Print first 50 lines for content preview
print("\n=== Content Preview (first 50 lines) ===")
for line in lines[:50]:
    print(line)
```
> summary_prompt: "Summarize the document structure, key architectural decisions, and main components described"

---

## File Comparison

### Compare two source files

```python
import difflib

with open('src/auth/login.ts') as f:
    old_lines = f.readlines()
with open('src/auth/login.new.ts') as f:
    new_lines = f.readlines()

diff = list(difflib.unified_diff(old_lines, new_lines, fromfile='login.ts', tofile='login.new.ts', lineterm=''))

additions = sum(1 for l in diff if l.startswith('+') and not l.startswith('+++'))
deletions = sum(1 for l in diff if l.startswith('-') and not l.startswith('---'))

print(f"Changes: +{additions} -{deletions}\n")

if diff:
    print("=== Diff ===")
    for line in diff:
        print(line)
else:
    print("Files are identical.")
```
> summary_prompt: "Describe the functional changes between the old and new versions"

### Find duplicate content across files

```python
import os
import hashlib
from collections import defaultdict

file_hashes = defaultdict(list)

for root, dirs, files in os.walk('src'):
    dirs[:] = [d for d in dirs if not d.startswith('.') and d != 'node_modules']
    for fname in files:
        if fname.endswith(('.ts', '.tsx', '.js', '.jsx')):
            filepath = os.path.join(root, fname)
            with open(filepath, 'rb') as f:
                content_hash = hashlib.md5(f.read()).hexdigest()
            file_hashes[content_hash].append(filepath)

duplicates = {h: files for h, files in file_hashes.items() if len(files) > 1}

if duplicates:
    print(f"Found {len(duplicates)} sets of duplicate files:\n")
    for h, files in duplicates.items():
        print(f"  Hash: {h[:8]}...")
        for f in files:
            print(f"    {f}")
        print()
else:
    print("No duplicate files found.")
```
> summary_prompt: "List all duplicate files and suggest which copies to remove"