Add release scripts

Author: trissim

scripts/release.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import requests
+from packaging import version
+
+
+def get_current_version():
+    with open("src/pycodify/__init__.py", "r") as f:
+        for line in f:
+            if line.startswith("__version__"):
+                return line.split("=")[1].strip().strip('"\'')
+    return None
+
+def get_pypi_version():
+    try:
+        response = requests.get("https://pypi.org/pypi/pycodify/json")
+        if response.status_code == 200:
+            return response.json()["info"]["version"]
+    except:
+        pass
+    return None
+
+def main():
+    # Get current version
+    current_version = get_current_version()
+    if not current_version:
+        print("Error: Could not find version in __init__.py")
+        sys.exit(1)
+    
+    # Get PyPI version
+    pypi_version = get_pypi_version()
+    print(f"Current package version: {current_version}")
+    print(f"Current PyPI version: {pypi_version}")
+    
+    if pypi_version and version.parse(current_version) <= version.parse(pypi_version):
+        print(f"Error: Current version ({current_version}) must be greater than PyPI version ({pypi_version})")
+        sys.exit(1)
+    
+    # Confirm with user
+    response = input(f"Create release for v{current_version}? [y/N] ")
+    if response.lower() != 'y':
+        print("Aborted.")
+        return
+    
+    try:
+        # Create and push tag
+        subprocess.run(['git', 'tag', '-a', f'v{current_version}', '-m', f'Release version {current_version}'], check=True)
+        subprocess.run(['git', 'push', 'origin', f'v{current_version}'], check=True)
+        
+        print(f"\nSuccessfully created and pushed tag v{current_version}")
+        print("GitHub Actions workflow should start automatically.")
+        print("Monitor progress at: https://github.com/OpenHCSDev/pycodify/actions")
+    
+    except subprocess.CalledProcessError as e:
+        print(f"Error during release process: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

scripts/update_and_release.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from packaging import version
+
+
+def run_command(command, check=True):
+    """Run a command and return its output"""
+    try:
+        result = subprocess.run(command, check=check, capture_output=True, text=True)
+        return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        print(f"Error running command {' '.join(command)}: {e}")
+        print(f"Error output: {e.stderr}")
+        sys.exit(1)
+
+def get_modified_files():
+    """Get list of modified files"""
+    # Get both staged and unstaged changes
+    staged = run_command(['git', 'diff', '--staged', '--name-only']).split('\n')
+    unstaged = run_command(['git', 'diff', '--name-only']).split('\n')
+    # Combine and remove duplicates while preserving order
+    all_files = []
+    for f in staged + unstaged:
+        if f and f not in all_files:
+            all_files.append(f)
+    return all_files
+
+def check_unstaged_changes():
+    """Check for unstaged changes"""
+    result = subprocess.run(['git', 'diff', '--quiet'], capture_output=True)
+    return result.returncode != 0
+
+def commit_changes(files, message):
+    """Commit specified files with a message"""
+    try:
+        # Add files explicitly first
+        for file in files:
+            print(f"Adding file: {file}")
+            subprocess.run(['git', 'add', file], check=True)
+        
+        # Show what's being committed
+        print("\nFiles staged for commit:")
+        subprocess.run(['git', 'status', '--short'], check=True)
+        
+        # Commit
+        print(f"\nCommitting with message: {message}")
+        subprocess.run(['git', 'commit', '-m', message], check=True)
+        
+        # Now pull with rebase (after changes are committed)
+        print("\nPulling latest changes...")
+        subprocess.run(['git', 'pull', '--rebase', 'origin', 'main'], check=True)
+        
+        # Push
+        print("\nPushing to origin main...")
+        subprocess.run(['git', 'push', 'origin', 'main'], check=True)
+        
+        print("Changes committed and pushed successfully!")
+        
+    except subprocess.CalledProcessError as e:
+        print(f"Git operation failed: {e}")
+        print(f"Error output: {e.stderr if e.stderr else 'None'}")
+        sys.exit(1)
+
+def update_version():
+    """Run the version update script"""
+    try:
+        subprocess.run([sys.executable, 'scripts/update_version.py'], check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"Error updating version: {e}")
+        sys.exit(1)
+
+def create_release():
+    """Run the release script"""
+    try:
+        subprocess.run([sys.executable, 'scripts/release.py'], check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"Error creating release: {e}")
+        sys.exit(1)
+
+def main():
+    # 1. Get modified files
+    modified_files = [f for f in get_modified_files() if f]
+    
+    # Handle existing changes if any
+    if modified_files:
+        print("\nModified files:")
+        for f in modified_files:
+            print(f"- {f}")
+        
+        response = input("\nCommit these changes before release? [y/N] ")
+        if response.lower() == 'y':
+            commit_message = input("\nEnter commit message: ")
+            if not commit_message:
+                print("Commit message cannot be empty.")
+                sys.exit(1)
+            
+            print("\nCommitting changes...")
+            commit_changes(modified_files, commit_message)
+    
+    # Always proceed with version update and release
+    print("\nUpdating version...")
+    update_version()
+    
+    print("\nCreating release...")
+    create_release()
+    
+    print("\nProcess completed successfully!")
+
+if __name__ == "__main__":
+    main()

scripts/update_version.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from packaging import version
+
+
+def get_current_version():
+    """Get the current version from __init__.py"""
+    init_file = Path("src/pycodify/__init__.py")
+    content = init_file.read_text()
+    match = re.search(r'__version__\s*=\s*["\']([^"\']+)["\']', content)
+    return match.group(1) if match else None
+
+def validate_version(new_version):
+    """Validate the new version string"""
+    try:
+        v = version.parse(new_version)
+        if not isinstance(v, version.Version):
+            raise ValueError("Invalid version format")
+        return True
+    except version.InvalidVersion:
+        raise ValueError("Invalid version format. Use semantic versioning (e.g., 1.2.3)")
+
+def check_for_uncommitted_changes():
+    """Check if there are any uncommitted changes in tracked files"""
+    # Check for staged and unstaged changes in tracked files
+    staged = subprocess.run(['git', 'diff', '--staged', '--quiet'])
+    unstaged = subprocess.run(['git', 'diff', '--quiet'])
+    return staged.returncode != 0 or unstaged.returncode != 0
+
+def update_version(new_version=None):
+    """Update version in files and create git commit"""
+    try:
+        # Get current version first
+        current_version = get_current_version()
+        if not current_version:
+            print("Error: Could not find current version in __init__.py")
+            sys.exit(1)
+
+        if new_version is None:
+            # Auto-increment patch version if no version specified
+            v = version.parse(current_version)
+            new_version = f"{v.major}.{v.minor}.{v.micro + 1}"
+        
+        # Validate new version
+        validate_version(new_version)
+        if version.parse(new_version) <= version.parse(current_version):
+            print(f"Error: New version ({new_version}) must be greater than current version ({current_version})")
+            sys.exit(1)
+
+        # Check for uncommitted changes
+        if check_for_uncommitted_changes():
+            print("Error: You have uncommitted changes. Please commit or stash them first.")
+            sys.exit(1)
+
+        # Pull latest changes
+        try:
+            subprocess.run(['git', 'pull', 'origin', 'main'], check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Error: Failed to pull latest changes: {e}")
+            sys.exit(1)
+        
+        # Update version in __init__.py
+        init_file = Path("src/pycodify/__init__.py")
+        content = init_file.read_text()
+        new_content = re.sub(
+            r'(__version__\s*=\s*[\'"])[^\'"]+([\'"])',
+            rf'\g<1>{new_version}\2',
+            content
+        )
+        init_file.write_text(new_content)
+
+        # Commit and push changes
+        subprocess.run(['git', 'add', 'src/pycodify/__init__.py'], check=True)
+        subprocess.run(['git', 'commit', '-m', f'bump version to {new_version}'], check=True)
+        subprocess.run(['git', 'push', 'origin', 'main'], check=True)
+        
+        print(f"Successfully updated version to {new_version}")
+        print("Now run: python scripts/release.py")
+        
+    except subprocess.CalledProcessError as e:
+        print(f"Error during version update: {e}")
+        sys.exit(1)
+    except ValueError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+def main():
+    parser = argparse.ArgumentParser(description='Update pycodify version number')
+    parser.add_argument('--version', '-v',
+                      help='New version number (e.g., 1.2.3). If not provided, will increment patch version.')
+    args = parser.parse_args()
+
+    update_version(args.version)
+
+if __name__ == "__main__":
+    main()