496 lines
16 KiB
Python
Executable File
496 lines
16 KiB
Python
Executable File
#!/usr/bin/env -S uv run --script --quiet
|
|
# /// script
|
|
# requires-python = ">=3.11"
|
|
# dependencies = [
|
|
# "httpx>=0.27.0",
|
|
# ]
|
|
# ///
|
|
"""
|
|
Convert Python scripts to uv single-file format (PEP 723)
|
|
|
|
Purpose: script-conversion-automation
|
|
Team: devops
|
|
Author: devops@spaceships.work
|
|
|
|
Converts existing Python scripts to use inline dependency management.
|
|
Reads dependencies from requirements.txt or detects from imports.
|
|
|
|
Usage:
|
|
convert_to_uv.py <script.py>
|
|
convert_to_uv.py <script.py> --requirements requirements.txt
|
|
convert_to_uv.py <script.py> --detect-imports
|
|
convert_to_uv.py <script.py> --dry-run
|
|
|
|
Examples:
|
|
# Convert script with requirements.txt in same directory
|
|
convert_to_uv.py my_script.py
|
|
|
|
# Convert script with specific requirements file
|
|
convert_to_uv.py my_script.py --requirements ../requirements.txt
|
|
|
|
# Detect dependencies from imports (basic detection)
|
|
convert_to_uv.py my_script.py --detect-imports
|
|
|
|
# Preview conversion without creating file
|
|
convert_to_uv.py my_script.py --dry-run
|
|
|
|
# Specify output filename
|
|
convert_to_uv.py my_script.py --output my_script_new.py
|
|
"""
|
|
|
|
import ast
|
|
import re
|
|
import sys
|
|
import tomllib
|
|
from pathlib import Path
|
|
|
|
# Common import name -> PyPI package name mappings
|
|
IMPORT_TO_PACKAGE = {
|
|
'cv2': 'opencv-python',
|
|
'PIL': 'Pillow',
|
|
'yaml': 'PyYAML',
|
|
'bs4': 'beautifulsoup4',
|
|
'sklearn': 'scikit-learn',
|
|
'dotenv': 'python-dotenv',
|
|
'claude_agent_sdk': 'claude-agent-sdk',
|
|
}
|
|
|
|
|
|
def get_pypi_latest_version(package_name: str) -> str | None:
|
|
"""
|
|
Query PyPI API for latest version of package.
|
|
|
|
Returns version string like "1.2.3" or None if not found.
|
|
"""
|
|
try:
|
|
import httpx
|
|
|
|
url = f"https://pypi.org/pypi/{package_name}/json"
|
|
with httpx.Client(timeout=5.0) as client:
|
|
response = client.get(url)
|
|
if response.status_code == 200:
|
|
data = response.json()
|
|
return data['info']['version']
|
|
except Exception:
|
|
# Network error, package not found, etc. - fail silently
|
|
pass
|
|
return None
|
|
|
|
|
|
def find_version_in_project(package_name: str, script_path: Path) -> str | None:
|
|
"""
|
|
Look for version constraint in project's pyproject.toml.
|
|
|
|
Searches up directory tree from script location.
|
|
"""
|
|
current = script_path.parent
|
|
|
|
# Search up to 3 levels for pyproject.toml
|
|
for _ in range(3):
|
|
pyproject_path = current / "pyproject.toml"
|
|
if pyproject_path.exists():
|
|
try:
|
|
content = pyproject_path.read_text(encoding='utf-8')
|
|
data = tomllib.loads(content)
|
|
|
|
# Check [project.dependencies]
|
|
deps = data.get('project', {}).get('dependencies', [])
|
|
for dep in deps:
|
|
if isinstance(dep, str) and dep.startswith(package_name):
|
|
# Extract version constraint
|
|
# e.g., "package>=1.0.0" -> ">=1.0.0"
|
|
version_part = dep[len(package_name):].strip()
|
|
if version_part:
|
|
return version_part
|
|
|
|
# Check [tool.uv.sources] or other sections if needed
|
|
# (could expand this to check dev-dependencies, etc.)
|
|
|
|
except Exception:
|
|
pass
|
|
|
|
# Move up one directory
|
|
parent = current.parent
|
|
if parent == current: # Reached filesystem root
|
|
break
|
|
current = parent
|
|
|
|
return None
|
|
|
|
|
|
def normalize_package_name(import_name: str, use_pypi: bool = True) -> str:
|
|
"""
|
|
Normalize import name to PyPI package name.
|
|
|
|
Strategy:
|
|
1. Check known mappings first (fast)
|
|
2. Try hyphen normalization (common pattern: my_package → my-package)
|
|
3. Validate with PyPI if enabled
|
|
4. Fall back to original
|
|
|
|
Returns: Normalized package name
|
|
"""
|
|
# Known mapping takes precedence
|
|
if import_name in IMPORT_TO_PACKAGE:
|
|
return IMPORT_TO_PACKAGE[import_name]
|
|
|
|
# Try hyphen normalization (most common pattern)
|
|
if '_' in import_name:
|
|
hyphenated = import_name.replace('_', '-')
|
|
|
|
# Validate with PyPI if enabled
|
|
if use_pypi and get_pypi_latest_version(hyphenated):
|
|
return hyphenated
|
|
|
|
# Without PyPI, trust the normalization (common convention)
|
|
if not use_pypi:
|
|
return hyphenated
|
|
|
|
# Fall back to original
|
|
return import_name
|
|
|
|
|
|
def resolve_package_version(
|
|
import_name: str,
|
|
script_path: Path,
|
|
use_pypi: bool = True
|
|
) -> str:
|
|
"""
|
|
Resolve package name and version constraint.
|
|
|
|
Returns: "package>=X.Y.Z" format
|
|
|
|
Strategy:
|
|
1. Normalize import name to package name (handles underscore → hyphen)
|
|
2. Check project's pyproject.toml for version
|
|
3. Query PyPI for latest version
|
|
4. Fall back to unversioned package name
|
|
"""
|
|
# Normalize import name to package name
|
|
package_name = normalize_package_name(import_name, use_pypi)
|
|
|
|
# Try to find version in project
|
|
version = find_version_in_project(package_name, script_path)
|
|
if version:
|
|
return f"{package_name}{version}"
|
|
|
|
# Try PyPI if enabled
|
|
if use_pypi:
|
|
latest = get_pypi_latest_version(package_name)
|
|
if latest:
|
|
# Use minimum version constraint with latest
|
|
return f"{package_name}>={latest}"
|
|
|
|
# Fall back to unversioned (let uv resolve)
|
|
return package_name
|
|
|
|
|
|
def has_pep723_metadata(content: str) -> bool:
|
|
"""Check if script already has PEP 723 metadata"""
|
|
pattern = r'# /// script\r?\n((?:#.*(?:\r?\n|(?=\r?\n?#\s*///)))+)(?:\r?\n)?#\s*///'
|
|
return bool(re.search(pattern, content, re.MULTILINE))
|
|
|
|
|
|
def read_requirements_file(req_path: Path) -> list[str]:
|
|
"""Read dependencies from requirements.txt"""
|
|
if not req_path.exists():
|
|
return []
|
|
|
|
try:
|
|
content = req_path.read_text(encoding='utf-8')
|
|
deps = []
|
|
for line in content.splitlines():
|
|
line = line.strip()
|
|
# Skip empty lines and comments
|
|
if not line or line.startswith('#'):
|
|
continue
|
|
# Skip -e and --editable
|
|
if line.startswith('-e') or line.startswith('--editable'):
|
|
continue
|
|
# Skip -r and --requirement
|
|
if line.startswith('-r') or line.startswith('--requirement'):
|
|
continue
|
|
deps.append(line)
|
|
return deps
|
|
except (UnicodeDecodeError, OSError) as e:
|
|
print(f"Warning: Could not read {req_path}: {e}", file=sys.stderr)
|
|
return []
|
|
|
|
|
|
def detect_imports(content: str) -> list[str]:
|
|
"""
|
|
Detect third-party imports from script (basic detection).
|
|
|
|
Returns import names, not package names (caller should map these).
|
|
"""
|
|
imports = set()
|
|
|
|
try:
|
|
tree = ast.parse(content)
|
|
for node in ast.walk(tree):
|
|
if isinstance(node, ast.Import):
|
|
for alias in node.names:
|
|
# Get base module name
|
|
base = alias.name.split('.')[0]
|
|
imports.add(base)
|
|
elif isinstance(node, ast.ImportFrom):
|
|
if node.module:
|
|
base = node.module.split('.')[0]
|
|
imports.add(base)
|
|
except SyntaxError as e:
|
|
print(f"Warning: Could not parse script for imports: {e}", file=sys.stderr)
|
|
return []
|
|
|
|
# Filter out standard library modules (basic filter)
|
|
stdlib_modules = {
|
|
'abc', 'argparse', 'ast', 'asyncio', 'base64', 'collections', 'contextlib',
|
|
'copy', 'csv', 'dataclasses', 'datetime', 'decimal', 'email', 'enum', 'functools',
|
|
'glob', 'hashlib', 'http', 'inspect', 'io', 'itertools', 'json', 'logging',
|
|
'math', 'multiprocessing', 'operator', 'os', 'pathlib', 'pickle', 'platform',
|
|
'pprint', 'queue', 're', 'secrets', 'shutil', 'socket', 'sqlite3', 'ssl',
|
|
'string', 'subprocess', 'sys', 'tempfile', 'threading', 'time', 'tomllib',
|
|
'traceback', 'typing', 'unittest', 'urllib', 'uuid', 'warnings', 'weakref',
|
|
'xml', 'zipfile', 'zoneinfo'
|
|
}
|
|
|
|
third_party = [imp for imp in imports if imp not in stdlib_modules]
|
|
return sorted(third_party)
|
|
|
|
|
|
def generate_header(
|
|
dependencies: list[str],
|
|
python_version: str = ">=3.11",
|
|
quiet: bool = False
|
|
) -> str:
|
|
"""Generate PEP 723 header with shebang"""
|
|
shebang = "#!/usr/bin/env -S uv run --script"
|
|
if quiet:
|
|
shebang += " --quiet"
|
|
|
|
# Format dependencies for TOML array
|
|
if dependencies:
|
|
deps_str = ",\n# ".join(f'"{dep}"' for dep in dependencies)
|
|
deps_section = f"# dependencies = [\n# {deps_str},\n# ]"
|
|
else:
|
|
deps_section = "# dependencies = []"
|
|
|
|
header = f"""{shebang}
|
|
# /// script
|
|
# requires-python = "{python_version}"
|
|
{deps_section}
|
|
# ///
|
|
"""
|
|
return header
|
|
|
|
|
|
def convert_script(
|
|
script_path: Path,
|
|
output_path: Path | None = None,
|
|
requirements_path: Path | None = None,
|
|
detect_imports_flag: bool = False,
|
|
dry_run: bool = False,
|
|
python_version: str = ">=3.11",
|
|
quiet_mode: bool = False,
|
|
use_pypi: bool = True
|
|
) -> bool:
|
|
"""
|
|
Convert script to uv format.
|
|
|
|
Returns True if successful, False otherwise.
|
|
"""
|
|
# Read original script
|
|
try:
|
|
content = script_path.read_text(encoding='utf-8')
|
|
except (FileNotFoundError, PermissionError, OSError, UnicodeDecodeError) as e:
|
|
print(f"Error: Cannot read {script_path}: {e}", file=sys.stderr)
|
|
return False
|
|
|
|
# Check if already has metadata
|
|
if has_pep723_metadata(content):
|
|
print(f"Error: {script_path} already has PEP 723 metadata", file=sys.stderr)
|
|
print(" Use validate_script.py to check the existing metadata", file=sys.stderr)
|
|
return False
|
|
|
|
# Determine dependencies
|
|
dependencies = []
|
|
|
|
if requirements_path:
|
|
# Use specified requirements file
|
|
dependencies = read_requirements_file(requirements_path)
|
|
if dependencies:
|
|
print(f"Found {len(dependencies)} dependencies in {requirements_path}")
|
|
else:
|
|
# Look for requirements.txt in same directory
|
|
default_req = script_path.parent / "requirements.txt"
|
|
if default_req.exists():
|
|
dependencies = read_requirements_file(default_req)
|
|
if dependencies:
|
|
print(f"Found {len(dependencies)} dependencies in {default_req}")
|
|
|
|
# Optionally detect imports
|
|
if detect_imports_flag:
|
|
detected = detect_imports(content)
|
|
if detected:
|
|
print(f"Detected imports: {', '.join(detected)}")
|
|
print("Resolving versions...")
|
|
|
|
# If no dependencies from requirements, use detected
|
|
if not dependencies:
|
|
# Use smart version resolution
|
|
resolved = []
|
|
for imp in detected:
|
|
# Normalize package name first
|
|
normalized_pkg = normalize_package_name(imp, use_pypi)
|
|
|
|
# Then resolve version
|
|
dep = resolve_package_version(imp, script_path, use_pypi=use_pypi)
|
|
resolved.append(dep)
|
|
|
|
# Show what was resolved
|
|
if imp in IMPORT_TO_PACKAGE:
|
|
print(f" - Mapped '{imp}' → '{IMPORT_TO_PACKAGE[imp]}' (known mapping)")
|
|
elif imp != normalized_pkg:
|
|
print(f" - Normalized '{imp}' → '{normalized_pkg}' (auto-detected)")
|
|
|
|
if '>=' in dep:
|
|
version = dep.split('>=')[1]
|
|
source = "from project" if find_version_in_project(dep.split('>=')[0], script_path) else "from PyPI"
|
|
print(f" - Resolved version: {version} {source}")
|
|
else:
|
|
print(f" - Using package: {dep} (uv will resolve version)")
|
|
|
|
dependencies = resolved
|
|
|
|
# Generate header
|
|
header = generate_header(dependencies, python_version, quiet_mode)
|
|
|
|
# Remove old shebang if present
|
|
lines = content.split('\n')
|
|
if lines and lines[0].startswith('#!'):
|
|
# Skip old shebang
|
|
content_without_shebang = '\n'.join(lines[1:])
|
|
else:
|
|
content_without_shebang = content
|
|
|
|
# Combine header and content
|
|
new_content = header + content_without_shebang
|
|
|
|
# Determine output path
|
|
if output_path is None:
|
|
# Default: add _uv before extension
|
|
stem = script_path.stem
|
|
suffix = script_path.suffix
|
|
output_path = script_path.parent / f"{stem}_uv{suffix}"
|
|
|
|
# Dry run - just print
|
|
if dry_run:
|
|
print("\n" + "=" * 60)
|
|
print("DRY RUN - Preview of converted script:")
|
|
print("=" * 60)
|
|
print(new_content[:500]) # Show first 500 chars
|
|
if len(new_content) > 500:
|
|
print(f"\n... ({len(new_content) - 500} more characters)")
|
|
print("=" * 60)
|
|
print(f"Would create: {output_path}")
|
|
return True
|
|
|
|
# Write output
|
|
try:
|
|
output_path.write_text(new_content, encoding='utf-8')
|
|
print(f"✓ Created: {output_path}")
|
|
|
|
# Make executable
|
|
import stat
|
|
current_permissions = output_path.stat().st_mode
|
|
output_path.chmod(current_permissions | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
|
|
print("✓ Made executable")
|
|
|
|
# Print next steps
|
|
print("\nNext steps:")
|
|
print(f" 1. Review dependencies in {output_path}")
|
|
print(" 2. Add version constraints if needed")
|
|
print(f" 3. Test: {output_path}")
|
|
print(f" 4. Validate: validate_script.py {output_path}")
|
|
|
|
return True
|
|
except (PermissionError, OSError) as e:
|
|
print(f"Error: Cannot write {output_path}: {e}", file=sys.stderr)
|
|
return False
|
|
|
|
|
|
def main():
|
|
"""Main entry point"""
|
|
import argparse
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description="Convert Python scripts to uv single-file format",
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
epilog=__doc__
|
|
)
|
|
parser.add_argument('script', help='Python script to convert')
|
|
parser.add_argument(
|
|
'--requirements', '-r',
|
|
help='Path to requirements.txt (default: look in same directory)'
|
|
)
|
|
parser.add_argument(
|
|
'--detect-imports', '-d',
|
|
action='store_true',
|
|
help='Detect dependencies from imports (basic detection)'
|
|
)
|
|
parser.add_argument(
|
|
'--output', '-o',
|
|
help='Output filename (default: <script>_uv.py)'
|
|
)
|
|
parser.add_argument(
|
|
'--python-version', '-p',
|
|
default='>=3.11',
|
|
help='Python version constraint (default: >=3.11)'
|
|
)
|
|
parser.add_argument(
|
|
'--quiet', '-q',
|
|
action='store_true',
|
|
help='Add --quiet flag to shebang'
|
|
)
|
|
parser.add_argument(
|
|
'--dry-run', '-n',
|
|
action='store_true',
|
|
help='Preview conversion without creating file'
|
|
)
|
|
parser.add_argument(
|
|
'--no-pypi',
|
|
action='store_true',
|
|
help='Skip PyPI queries for version resolution (faster, offline)'
|
|
)
|
|
|
|
args = parser.parse_args()
|
|
|
|
script_path = Path(args.script)
|
|
|
|
if not script_path.exists():
|
|
print(f"Error: File not found: {script_path}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Parse requirements path if provided
|
|
req_path = Path(args.requirements) if args.requirements else None
|
|
|
|
# Parse output path if provided
|
|
out_path = Path(args.output) if args.output else None
|
|
|
|
# Convert
|
|
success = convert_script(
|
|
script_path=script_path,
|
|
output_path=out_path,
|
|
requirements_path=req_path,
|
|
detect_imports_flag=args.detect_imports,
|
|
dry_run=args.dry_run,
|
|
python_version=args.python_version,
|
|
quiet_mode=args.quiet,
|
|
use_pypi=not args.no_pypi
|
|
)
|
|
|
|
sys.exit(0 if success else 1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|