Added utils scripts

michalChrobot · michalChrobot · commit 69c9a621ba08 · 2025-08-15T10:21:55.000+02:00
diff --git a/Tools/scripts/Utils/config.py b/Tools/scripts/Utils/config.py
@@ -0,0 +1,47 @@
+﻿"""
+Configuration for NGO Release Automation
+"""
+
+def getDefaultRepoBranch():
+    """
+    Returns the name of Tools repo default branch.
+    This will be used to for example push changelog update for the release.
+    In general this branch is the default working branch
+    """
+    return 'develop-2.0.0'
+
+def getNetcodeGithubRepo():
+    """Returns the name of MP Tools repo."""
+    return 'Unity-Technologies/com.unity.netcode.gameobjects'
+
+def getNetcodePackageName():
+    """Returns the name of the MP Tools package."""
+    return 'com.unity.netcode.gameobjects'
+
+def getPackageManifestPath():
+    """Returns the path to the Netcode package manifest."""
+
+    return 'com.unity.netcode.gameobjects/package.json'
+    
+def getPackageValidationExceptionsPath():
+    """Returns the path to the Netcode ValidationExceptions."""
+
+    return 'com.unity.netcode.gameobjects/ValidationExceptions.json'
+
+def getPackageChangelogPath():
+    """Returns the path to the Netcode package manifest."""
+
+    return 'com.unity.netcode.gameobjects/CHANGELOG.md'
+
+def getNetcodeReleaseBranchName(package_version):
+    """
+    Returns the branch name for the Netcode release.
+    """
+    return f"release/{package_version}"
+
+def getNetcodeProjectID():
+    """
+    Returns the Unity project ID for the DOTS monorepo.
+    Useful when for example triggering Yamato jobs
+    """
+    return '1201'
diff --git a/Tools/scripts/Utils/general_utils.py b/Tools/scripts/Utils/general_utils.py
@@ -0,0 +1,173 @@
+﻿"""Helper class for common operations."""
+#!/usr/bin/env python3
+import json
+import os
+import re
+import datetime
+
+from config import getPackageChangelogPath
+
+UNRELEASED_CHANGELOG_SECTION_TEMPLATE = r"""
+## [Unreleased]
+
+### Added
+
+
+### Changed
+
+
+### Deprecated
+
+
+### Removed
+
+
+### Fixed
+
+
+### Security
+
+
+### Obsolete
+"""
+
+def get_package_version_from_manifest(filepath):
+    """
+    Reads the package.json file and returns the version specified in it.
+    """
+
+    if not os.path.exists(filepath):
+        print("get_manifest_json_version function couldn't find a specified filepath")
+        return None
+
+    with open(filepath, 'rb') as f:
+        json_text = f.read()
+        data = json.loads(json_text)
+
+    return data['version']
+
+
+def update_package_version_by_patch(changelog_file):
+    """
+    Updates the package version in the package.json file.
+    This function will bump the package version by a patch.
+
+    The usual usage would be to bump package version during/after release to represent the "current package state" which progresses since the release branch was created
+    """
+
+    if not os.path.exists(changelog_file):
+        raise FileNotFoundError(f"The file {changelog_file} does not exist.")
+
+    with open(changelog_file, 'r', encoding='UTF-8') as f:
+        package_json = json.load(f)
+
+    version_parts = package_json['version'].split('.')
+    if len(version_parts) != 3:
+        raise ValueError("Version format is not valid. Expected format: 'major.minor.patch'.")
+
+    # Increment the patch version
+    version_parts[2] = str(int(version_parts[2]) + 1)
+    new_version = '.'.join(version_parts)
+
+    package_json['version'] = new_version
+
+    with open(changelog_file, 'w', encoding='UTF-8') as f:
+        json.dump(package_json, f, indent=4)
+
+    return new_version
+
+def update_validation_exceptions(validation_file, package_version):
+    """
+    Updates the ValidationExceptions.json file with the new package version.
+    """
+
+    # If files do not exist, exit
+    if not os.path.exists(validation_file):
+        return
+
+    # Update the PackageVersion in the exceptions
+    with open(validation_file, 'rb') as f:
+        json_text = f.read()
+        data = json.loads(json_text)
+        updated = False
+        for exceptionElements in ["WarningExceptions", "ErrorExceptions"]:
+            exceptions = data.get(exceptionElements)
+
+            if exceptions is not None:
+                for exception in exceptions:
+                    if 'PackageVersion' in exception:
+                        exception['PackageVersion'] = package_version
+                        updated = True
+
+    # If no exceptions were updated, we do not need to write the file
+    if not updated:
+        return
+
+    with open(validation_file, 'w', encoding='UTF-8', newline='\n') as json_file:
+        json.dump(data, json_file, ensure_ascii=False, indent=2)
+        json_file.write("\n")  # Add newline cause Py JSON does not
+        print(f"  updated `{validation_file}`")
+
+def update_changelog(new_version, add_unreleased_template=False):
+    """
+    Cleans the [Unreleased] section of the changelog by removing empty subsections,
+    then replaces the '[Unreleased]' tag with the new version and release date.
+    If the version header already exists, it will remove the [Unreleased] section and add any entries under the present version.
+    If add_unreleased_template is specified then it will also include the template at the top of the file
+
+    1 - Cleans the [Unreleased] section by removing empty subsections.
+    2 - Checks if the version header already has its section in the changelog.
+    3 - If it does, it removes the [Unreleased] section and its content.
+    4 - If it does not, it replaces the [Unreleased] section with the new version and today's date.
+    """
+
+    new_changelog_entry = f'## [{new_version}] - {datetime.date.today().isoformat()}'
+    version_header_to_find_if_exists = f'## [{new_version}]'
+    changelog_path = getPackageChangelogPath()
+
+    if not os.path.exists(changelog_path):
+        print("CHANGELOG path is incorrect, the script will terminate without updating the CHANGELOG")
+        return None
+
+    with open(changelog_path, 'r', encoding='UTF-8') as f:
+        changelog_text = f.read()
+
+    # This pattern finds a line starting with '###', followed by its newline,
+    # and then two more lines that contain only whitespace.
+    # The re.MULTILINE flag allows '^' to match the start of each line.
+    pattern = re.compile(r"^###.*\n\n\n", re.MULTILINE)
+
+    # Replace every match with an empty string. The goal is to remove empty CHANGELOG subsections.
+    cleaned_content = pattern.sub('', changelog_text)
+
+    if version_header_to_find_if_exists in changelog_text:
+        print(f"A changelog entry for version '{new_version}' already exists. The script will just remove Unreleased section and its content.")
+        changelog_text = re.sub(r'(?s)## \[Unreleased(.*?)(?=## \[)', '', changelog_text)
+    else:
+        # Replace the [Unreleased] section with the new version + cleaned subsections
+        print("Latest CHANGELOG entry will be modified to: " + new_changelog_entry)
+        changelog_text = re.sub(r'## \[Unreleased\]', new_changelog_entry, cleaned_content)
+
+    # Accounting for the very top of the changelog format
+    header_end_pos = changelog_text.find('---', 1)
+    insertion_point = changelog_text.find('\n', header_end_pos)
+
+    final_content = ""
+    if add_unreleased_template:
+        print("Adding [Unreleased] section template to the top of the changelog.")
+        final_content = (
+            changelog_text[:insertion_point] +
+            f"\n{UNRELEASED_CHANGELOG_SECTION_TEMPLATE}" +
+            changelog_text[insertion_point:]
+        )
+    else:
+        final_content = (
+            changelog_text[:insertion_point] +
+            changelog_text[insertion_point:]
+        )
+
+    # Write the changes
+    with open(changelog_path, 'w', encoding='UTF-8') as file:
+        file.write(final_content)
+
+    return final_content
diff --git a/Tools/scripts/Utils/git_utils.py b/Tools/scripts/Utils/git_utils.py
@@ -0,0 +1,96 @@
+"""Helper class for Git repo operations."""
+import subprocess
+import sys
+from git import Repo
+from github import Github
+from github import GithubException
+
+class GithubUtils:
+    def __init__(self, access_token, repo):
+        self.github = Github(base_url="https://api.github.com",
+                             login_or_token=access_token)
+        self.repo = self.github.get_repo(repo)
+
+    def is_branch_present(self, branch_name):
+        try:
+            self.repo.get_branch(branch_name)
+            return True # Branch exists
+
+        except GithubException as ghe:
+            if ghe.status == 404:
+                return False # Branch does not exist
+            print(f"An error occurred with the GitHub API: {ghe.status}", file=sys.stderr)
+            print(f"Error details: {ghe.data}", file=sys.stderr)
+            sys.exit(1)
+
+def get_local_repo():
+    root_dir = subprocess.check_output(['git', 'rev-parse', '--show-toplevel'],
+                                       universal_newlines=True, stderr=subprocess.STDOUT).strip()
+    return Repo(root_dir)
+
+
+def get_latest_git_revision(branch_name):
+    """Gets the latest commit SHA for a given branch using git rev-parse."""
+    try:
+        subprocess.run(
+            ['git', 'fetch', 'origin'],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        remote_branch_name = f'origin/{branch_name}'
+        # Executes the git command: git rev-parse <remote_branch_name>
+        result = subprocess.run(
+            ['git', 'rev-parse', remote_branch_name],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout.strip()
+    except FileNotFoundError:
+        print("Error: 'git' command not found. Is Git installed and in your PATH?", file=sys.stderr)
+        sys.exit(1)
+    except subprocess.CalledProcessError as e:
+        print(f"Error: Failed to get revision for branch '{branch_name}'.", file=sys.stderr)
+        print(f"Git stderr: {e.stderr}", file=sys.stderr)
+        sys.exit(1)
+
+def create_branch_execute_commands_and_push(github_token, github_repo, branch_name, commit_message, command_to_run=None):
+    """
+    Creates a new branch with the specified name, performs specified action, commits the current changes and pushes it to the repo.
+    Note that command_to_run should be a single command that will be executed using subprocess.run. For multiple commands consider using a Python script file.
+    """
+
+    try:
+        # Initialize PyGithub and get the repository object
+        github_manager = GithubUtils(github_token, github_repo)
+
+        if github_manager.is_branch_present(branch_name):
+            print(f"Branch '{branch_name}' already exists. Exiting.")
+            sys.exit(1)
+
+        repo = get_local_repo()
+
+        new_branch = repo.create_head(branch_name, repo.head.commit)
+        new_branch.checkout()
+        print(f"Created and checked out new branch: {branch_name}")
+
+        if command_to_run:
+            print(f"\nExecuting command on branch '{branch_name}': {' '.join(command_to_run)}")
+            subprocess.run(command_to_run, text=True, check=True)
+
+        print("Executed release.py script successfully.")
+
+        repo.git.add('.')
+        repo.index.commit(commit_message, skip_hooks=True)
+        repo.git.push("origin", branch_name)
+
+        print(f"Successfully created, updated and pushed new branch: {branch_name}")
+
+    except GithubException as e:
+        print(f"An error occurred with the GitHub API: {e.status}", file=sys.stderr)
+        print(f"Error details: {e.data}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}", file=sys.stderr)
+        sys.exit(1)
