Buckets:

download
raw
9.34 kB
#!/usr/bin/env python3
"""
Badge Generator (mw badge)
===========================
Generate and update project badges (shields.io compatible).
Auto-detects version, test count, health score, and updates README.
Usage:
mw badge # Show all available badges
mw badge update # Update badges in README.md
mw badge generate # Generate badge URLs only
mw badge --format md # Output as Markdown
mw badge --format html # Output as HTML
"""
import os
import re
import sys
import json
import subprocess
from pathlib import Path
from typing import Dict, List, Optional, Tuple
from urllib.parse import quote
GREEN = "\033[92m"
YELLOW = "\033[93m"
RED = "\033[91m"
BLUE = "\033[94m"
BOLD = "\033[1m"
DIM = "\033[2m"
RESET = "\033[0m"
def run(cmd: str, cwd: str = None) -> str:
result = subprocess.run(cmd, shell=True, capture_output=True, text=True, cwd=cwd)
return result.stdout.strip()
def detect_version(project_path: Path) -> Optional[str]:
"""Detect project version from various config files."""
for f in ["pyproject.toml", "setup.py", "package.json", "VERSION", ".version"]:
fp = project_path / f
if not fp.exists():
continue
content = fp.read_text()
if f == "package.json":
try:
return json.loads(content).get("version")
except json.JSONDecodeError:
continue
elif f in ("VERSION", ".version"):
# Support both VERSION and .version files
version = content.strip().splitlines()[0].strip()
return version
else:
m = re.search(r'version\s*=\s*["\']([^"\']+)["\']', content)
if m:
return m.group(1)
return None
def count_tests(project_path: Path) -> int:
"""Count test functions without running them."""
count = 0
tests_dir = project_path / "tests"
if not tests_dir.exists():
return 0
for f in tests_dir.rglob("test_*.py"):
content = f.read_text(errors="ignore")
count += len(re.findall(r"^\s*def test_", content, re.MULTILINE))
return count
def count_commands(project_path: Path) -> int:
"""Count mw commands from mw.py."""
mw = project_path / "tools" / "mw.py"
if not mw.exists():
return 0
content = mw.read_text(errors="ignore")
return len(re.findall(r"^def cmd_\w+", content, re.MULTILINE))
def count_loc(project_path: Path) -> int:
"""Count lines of Python code."""
total = 0
for d in ["tools", "src", "lib"]:
dp = project_path / d
if dp.exists():
for f in dp.rglob("*.py"):
total += sum(1 for line in f.read_text(errors="ignore").splitlines() if line.strip() and not line.strip().startswith("#"))
return total
def detect_license(project_path: Path) -> str:
lic = project_path / "LICENSE"
if not lic.exists():
return "unknown"
content = lic.read_text(errors="ignore")[:500].lower()
if "mit" in content:
return "MIT"
elif "apache" in content:
return "Apache-2.0"
elif "gpl" in content:
return "GPL-3.0"
return "custom"
def detect_python_version(project_path: Path) -> Optional[str]:
pyproject = project_path / "pyproject.toml"
if pyproject.exists():
content = pyproject.read_text()
m = re.search(r'requires-python\s*=\s*["\']([^"\']+)["\']', content)
if m:
return m.group(1)
return None
def shields_url(label: str, value: str, color: str, style: str = "flat-square") -> str:
"""Generate shields.io badge URL."""
label_enc = quote(label, safe="")
value_enc = quote(str(value), safe="")
return f"https://img.shields.io/badge/{label_enc}-{value_enc}-{color}?style={style}"
def generate_badges(project_path: Path) -> List[Dict]:
"""Generate all badges for the project."""
badges = []
# Version
version = detect_version(project_path)
if version:
badges.append({
"name": "version",
"label": "version",
"value": f"v{version}",
"color": "blue",
"url": shields_url("version", f"v{version}", "blue"),
})
# Python version
py_ver = detect_python_version(project_path)
if py_ver:
badges.append({
"name": "python",
"label": "python",
"value": py_ver,
"color": "3776AB",
"url": shields_url("python", py_ver, "3776AB"),
})
# Tests
test_count = count_tests(project_path)
if test_count > 0:
color = "brightgreen" if test_count >= 100 else "green" if test_count >= 50 else "yellow"
badges.append({
"name": "tests",
"label": "tests",
"value": str(test_count),
"color": color,
"url": shields_url("tests", str(test_count), color),
})
# Commands
cmd_count = count_commands(project_path)
if cmd_count > 0:
badges.append({
"name": "commands",
"label": "commands",
"value": str(cmd_count),
"color": "purple",
"url": shields_url("commands", str(cmd_count), "purple"),
})
# Lines of code
loc = count_loc(project_path)
if loc > 0:
if loc >= 10000:
loc_str = f"{loc // 1000}k+"
else:
loc_str = str(loc)
badges.append({
"name": "loc",
"label": "lines of code",
"value": loc_str,
"color": "informational",
"url": shields_url("lines of code", loc_str, "informational"),
})
# License
lic = detect_license(project_path)
if lic != "unknown":
badges.append({
"name": "license",
"label": "license",
"value": lic,
"color": "green",
"url": shields_url("license", lic, "green"),
})
# Platform
badges.append({
"name": "platform",
"label": "platform",
"value": "linux | macOS | windows",
"color": "lightgrey",
"url": shields_url("platform", "linux | macOS | windows", "lightgrey"),
})
return badges
def format_badges_md(badges: List[Dict]) -> str:
return " ".join(f"![{b['label']}]({b['url']})" for b in badges)
def format_badges_html(badges: List[Dict]) -> str:
return "\n".join(f'<img src="{b["url"]}" alt="{b["label"]}">' for b in badges)
def update_readme(project_path: Path, badges: List[Dict]) -> bool:
"""Update README.md with badge line."""
readme = project_path / "README.md"
if not readme.exists():
return False
content = readme.read_text()
badge_line = format_badges_md(badges)
# Replace existing badge section (between <!-- badges-start --> and <!-- badges-end -->)
marker_pattern = r"<!-- badges-start -->.*?<!-- badges-end -->"
new_section = f"<!-- badges-start -->\n{badge_line}\n<!-- badges-end -->"
if re.search(marker_pattern, content, re.DOTALL):
content = re.sub(marker_pattern, new_section, content, flags=re.DOTALL)
else:
# Also try replacing existing badge images at the top
badge_img_pattern = r"^(\!\[.*?\]\(https://img\.shields\.io.*?\)\s*)+\n"
if re.search(badge_img_pattern, content, re.MULTILINE):
content = re.sub(badge_img_pattern, badge_line + "\n\n", content, count=1, flags=re.MULTILINE)
else:
# Insert after first heading
m = re.search(r"^#\s+.+\n", content, re.MULTILINE)
if m:
insert_pos = m.end()
content = content[:insert_pos] + "\n" + new_section + "\n" + content[insert_pos:]
else:
content = new_section + "\n\n" + content
readme.write_text(content)
return True
def main():
args = sys.argv[1:]
project_path = Path.cwd()
# Find project root
check = project_path
while check != check.parent:
if (check / ".git").exists():
project_path = check
break
check = check.parent
fmt = "md"
if "--format" in args:
idx = args.index("--format")
if idx + 1 < len(args):
fmt = args[idx + 1]
args = [a for i, a in enumerate(args) if i != idx and i != idx + 1]
badges = generate_badges(project_path)
if not args or args[0] == "generate":
print(f"\n{BOLD}🏷️ Project Badges{RESET}")
print("=" * 60)
for b in badges:
print(f" {GREEN}●{RESET} {b['label']}: {BOLD}{b['value']}{RESET}")
print(f" {DIM}{b['url']}{RESET}")
print(f"\n{BOLD}Markdown:{RESET}")
print(format_badges_md(badges))
if fmt == "html":
print(f"\n{BOLD}HTML:{RESET}")
print(format_badges_html(badges))
elif args[0] == "update":
if update_readme(project_path, badges):
print(f" {GREEN}✓{RESET} Updated README.md with {len(badges)} badges")
else:
print(f" {RED}✗{RESET} README.md not found")
sys.exit(1)
elif args[0] in ("help", "--help"):
print(__doc__)
else:
print(f"Unknown command: {args[0]}")
sys.exit(1)
if __name__ == "__main__":
main()

Xet Storage Details

Size:
9.34 kB
·
Xet hash:
6c9a7c8ef6601bd706c8617ed715fc13aba0efd4588663a38088092e1c2128eb

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