ultralytics-actions 0.0.5__py3-none-any.whl

actions/summarize_release.py

@@ -0,0 +1,192 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+import os
+import re
+import subprocess
+import time
+from datetime import datetime
+
+import requests
+
+from .utils import (
+    GITHUB_API_URL,
+    GITHUB_HEADERS,
+    GITHUB_HEADERS_DIFF,
+    GITHUB_TOKEN,
+    REPO_NAME,
+    get_completion,
+    remove_html_comments,
+)
+
+# Environment variables
+CURRENT_TAG = os.getenv("CURRENT_TAG")
+PREVIOUS_TAG = os.getenv("PREVIOUS_TAG")
+
+
+def get_release_diff(repo_name: str, previous_tag: str, latest_tag: str) -> str:
+    """Get the diff between two tags."""
+    url = f"{GITHUB_API_URL}/repos/{repo_name}/compare/{previous_tag}...{latest_tag}"
+    r = requests.get(url, headers=GITHUB_HEADERS_DIFF)
+    return r.text if r.status_code == 200 else f"Failed to get diff: {r.content}"
+
+
+def get_prs_between_tags(repo_name: str, previous_tag: str, latest_tag: str) -> list:
+    """Get PRs merged between two tags using the compare API."""
+    url = f"{GITHUB_API_URL}/repos/{repo_name}/compare/{previous_tag}...{latest_tag}"
+    r = requests.get(url, headers=GITHUB_HEADERS)
+    r.raise_for_status()
+
+    data = r.json()
+    pr_numbers = set()
+
+    for commit in data["commits"]:
+        pr_matches = re.findall(r"#(\d+)", commit["commit"]["message"])
+        pr_numbers.update(pr_matches)
+
+    prs = []
+    time.sleep(10)  # sleep 10 seconds to allow final PR summary to update on merge
+    for pr_number in sorted(pr_numbers):  # earliest to latest
+        pr_url = f"{GITHUB_API_URL}/repos/{repo_name}/pulls/{pr_number}"
+        pr_response = requests.get(pr_url, headers=GITHUB_HEADERS)
+        if pr_response.status_code == 200:
+            pr_data = pr_response.json()
+            prs.append(
+                {
+                    "number": pr_data["number"],
+                    "title": pr_data["title"],
+                    "body": remove_html_comments(pr_data["body"]),
+                    "author": pr_data["user"]["login"],
+                    "html_url": pr_data["html_url"],
+                    "merged_at": pr_data["merged_at"],
+                }
+            )
+
+    # Sort PRs by merge date
+    prs.sort(key=lambda x: datetime.strptime(x["merged_at"], "%Y-%m-%dT%H:%M:%SZ"))
+
+    return prs
+
+
+def get_new_contributors(repo: str, prs: list) -> set:
+    """Identify genuinely new contributors in the current release."""
+    new_contributors = set()
+    for pr in prs:
+        author = pr["author"]
+        # Check if this is the author's first contribution
+        url = f"{GITHUB_API_URL}/search/issues?q=repo:{repo}+author:{author}+is:pr+is:merged&sort=created&order=asc"
+        r = requests.get(url, headers=GITHUB_HEADERS)
+        if r.status_code == 200:
+            data = r.json()
+            if data["total_count"] > 0:
+                first_pr = data["items"][0]
+                if first_pr["number"] == pr["number"]:
+                    new_contributors.add(author)
+    return new_contributors
+
+
+def generate_release_summary(diff: str, prs: list, latest_tag: str, previous_tag: str, repo_name: str) -> str:
+    """Generate a summary for the release."""
+    pr_summaries = "\n\n".join(
+        [f"PR #{pr['number']}: {pr['title']} by @{pr['author']}\n{pr['body'][:1000]}" for pr in prs]
+    )
+
+    current_pr = prs[-1] if prs else None
+    current_pr_summary = (
+        f"Current PR #{current_pr['number']}: {current_pr['title']} by @{current_pr['author']}\n{current_pr['body'][:1000]}"
+        if current_pr
+        else "No current PR found."
+    )
+
+    whats_changed = "\n".join([f"* {pr['title']} by @{pr['author']} in {pr['html_url']}" for pr in prs])
+
+    # Generate New Contributors section
+    new_contributors = get_new_contributors(repo_name, prs)
+    new_contributors_section = (
+        "\n## New Contributors\n"
+        + "\n".join(
+            [
+                f"* @{contributor} made their first contribution in {next(pr['html_url'] for pr in prs if pr['author'] == contributor)}"
+                for contributor in new_contributors
+            ]
+        )
+        if new_contributors
+        else ""
+    )
+
+    full_changelog = f"https://github.com/{repo_name}/compare/{previous_tag}...{latest_tag}"
+    release_suffix = (
+        f"\n\n## What's Changed\n{whats_changed}\n{new_contributors_section}\n\n**Full Changelog**: {full_changelog}\n"
+    )
+
+    messages = [
+        {
+            "role": "system",
+            "content": "You are an Ultralytics AI assistant skilled in software development and technical communication. Your task is to summarize GitHub releases in a way that is detailed, accurate, and understandable to both expert developers and non-expert users. Focus on highlighting the key changes and their impact in simple and intuitive terms.",
+        },
+        {
+            "role": "user",
+            "content": f"Summarize the updates made in the '{latest_tag}' tag, focusing on major model or features changes, their purpose, and potential impact. Keep the summary clear and suitable for a broad audience. Add emojis to enliven the summary. Prioritize changes from the current PR (the first in the list), which is usually the most important in the release. Reply directly with a summary along these example guidelines, though feel free to adjust as appropriate:\n\n"
+            f"## 🌟 Summary (single-line synopsis)\n"
+            f"## 📊 Key Changes (bullet points highlighting any major changes)\n"
+            f"## 🎯 Purpose & Impact (bullet points explaining any benefits and potential impact to users)\n\n\n"
+            f"Here's the information about the current PR:\n\n{current_pr_summary}\n\n"
+            f"Here's the information about PRs merged between the previous release and this one:\n\n{pr_summaries[:30000]}\n\n"
+            f"Here's the release diff:\n\n{diff[:300000]}",
+        },
+    ]
+    print(messages[-1]["content"])  # for debug
+    return get_completion(messages) + release_suffix
+
+
+def create_github_release(repo_name: str, tag_name: str, name: str, body: str) -> int:
+    """Create a release on GitHub."""
+    url = f"{GITHUB_API_URL}/repos/{repo_name}/releases"
+    data = {"tag_name": tag_name, "name": name, "body": body, "draft": False, "prerelease": False}
+    r = requests.post(url, headers=GITHUB_HEADERS, json=data)
+    return r.status_code
+
+
+def get_previous_tag() -> str:
+    """Get the previous tag from git tags."""
+    cmd = ["git", "describe", "--tags", "--abbrev=0", "--exclude", CURRENT_TAG]
+    try:
+        return subprocess.run(cmd, check=True, text=True, capture_output=True).stdout.strip()
+    except subprocess.CalledProcessError:
+        print("Failed to get previous tag from git. Using previous commit.")
+        return "HEAD~1"
+
+
+def main():
+    """Automates generating and publishing a GitHub release summary from PRs and commit differences."""
+    if not all([GITHUB_TOKEN, CURRENT_TAG]):
+        raise ValueError("One or more required environment variables are missing.")
+
+    previous_tag = PREVIOUS_TAG or get_previous_tag()
+
+    # Get the diff between the tags
+    diff = get_release_diff(REPO_NAME, previous_tag, CURRENT_TAG)
+
+    # Get PRs merged between the tags
+    prs = get_prs_between_tags(REPO_NAME, previous_tag, CURRENT_TAG)
+
+    # Generate release summary
+    try:
+        summary = generate_release_summary(diff, prs, CURRENT_TAG, previous_tag, REPO_NAME)
+    except Exception as e:
+        print(f"Failed to generate summary: {str(e)}")
+        summary = "Failed to generate summary."
+
+    # Get the latest commit message
+    cmd = ["git", "log", "-1", "--pretty=%B"]
+    commit_message = subprocess.run(cmd, check=True, text=True, capture_output=True).stdout.split("\n")[0].strip()
+
+    # Create the release on GitHub
+    status_code = create_github_release(REPO_NAME, CURRENT_TAG, f"{CURRENT_TAG} - {commit_message}", summary)
+    if status_code == 201:
+        print(f"Successfully created release {CURRENT_TAG}")
+    else:
+        print(f"Failed to create release {CURRENT_TAG}. Status code: {status_code}")
+
+
+if __name__ == "__main__":
+    main()

actions/update_markdown_code_blocks.py

@@ -0,0 +1,173 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+import hashlib
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+
+def extract_code_blocks(markdown_content):
+    """Extract Python code blocks with ``` followed by "python", "py", or "{ .py .annotate }"."""
+    pattern = r"^( *)```(?:python|py|\{[ ]*\.py[ ]*\.annotate[ ]*\})\n(.*?)\n\1```"
+    code_block_pattern = re.compile(pattern, re.DOTALL | re.MULTILINE)
+    return code_block_pattern.findall(markdown_content)
+
+
+def remove_indentation(code_block, num_spaces):
+    """Removes `num_spaces` leading spaces from each line in `code_block` and returns the modified string."""
+    lines = code_block.split("\n")
+    stripped_lines = [line[num_spaces:] if len(line) >= num_spaces else line for line in lines]
+    return "\n".join(stripped_lines)
+
+
+def add_indentation(code_block, num_spaces):
+    """Adds `num_spaces` leading spaces to each non-empty line in `code_block`."""
+    indent = " " * num_spaces
+    lines = code_block.split("\n")
+    indented_lines = [indent + line if line.strip() != "" else line for line in lines]
+    return "\n".join(indented_lines)
+
+
+def format_code_with_ruff(temp_dir):
+    """Formats all Python code files in the `temp_dir` directory using the 'ruff' linter tool."""
+    try:
+        # Run ruff format
+        subprocess.run(
+            [
+                "ruff",
+                "format",
+                "--line-length=120",
+                str(temp_dir),
+            ],
+            check=True,
+        )
+        print("Completed ruff format ✅")
+    except Exception as e:
+        print(f"ERROR running ruff format ❌ {e}")
+
+    try:
+        # Run ruff check with ignored rules:
+        # F821: Undefined name
+        # F841: Local variable is assigned to but never used
+        subprocess.run(
+            [
+                "ruff",
+                "check",
+                "--fix",
+                "--extend-select=I",
+                "--ignore=F821,F841",
+                str(temp_dir),
+            ],
+            check=True,
+        )
+        print("Completed ruff check ✅")
+    except Exception as e:
+        print(f"ERROR running ruff check ❌ {e}")
+
+    try:
+        # Run docformatter
+        subprocess.run(
+            [
+                "docformatter",
+                "--wrap-summaries=120",
+                "--wrap-descriptions=120",
+                "--pre-summary-newline",
+                "--close-quotes-on-newline",
+                "--in-place",
+                "--recursive",
+                str(temp_dir),
+            ],
+            check=True,
+        )
+        print("Completed docformatter ✅")
+    except Exception as e:
+        print(f"ERROR running docformatter ❌ {e}")
+
+
+def generate_temp_filename(file_path, index):
+    """Generates a unique temporary filename based on the file path and index."""
+    unique_string = f"{file_path.parent}_{file_path.stem}_{index}"
+    unique_hash = hashlib.md5(unique_string.encode()).hexdigest()
+    return f"temp_{unique_hash}.py"
+
+
+def process_markdown_file(file_path, temp_dir, verbose=False):
+    """Reads a markdown file, extracts Python code blocks, saves them to temp files, and updates the file."""
+    try:
+        markdown_content = Path(file_path).read_text()
+        code_blocks = extract_code_blocks(markdown_content)
+        temp_files = []
+
+        for i, (num_spaces, code_block) in enumerate(code_blocks):
+            if verbose:
+                print(f"Extracting code block {i} from {file_path}")
+            num_spaces = len(num_spaces)
+            code_without_indentation = remove_indentation(code_block, num_spaces)
+
+            # Generate a unique temp file path
+            temp_file_path = temp_dir / generate_temp_filename(file_path, i)
+            with open(temp_file_path, "w") as temp_file:
+                temp_file.write(code_without_indentation)
+            temp_files.append((num_spaces, code_block, temp_file_path))
+
+        return markdown_content, temp_files
+
+    except Exception as e:
+        print(f"Error processing file {file_path}: {e}")
+        return None, None
+
+
+def update_markdown_file(file_path, markdown_content, temp_files):
+    """Updates the markdown file with formatted code blocks."""
+    for num_spaces, original_code_block, temp_file_path in temp_files:
+        try:
+            with open(temp_file_path) as temp_file:
+                formatted_code = temp_file.read().rstrip("\n")  # Strip trailing newlines
+            formatted_code_with_indentation = add_indentation(formatted_code, num_spaces)
+
+            # Replace both `python` and `py` code blocks
+            for lang in ["python", "py", "{ .py .annotate }"]:
+                markdown_content = markdown_content.replace(
+                    f"{' ' * num_spaces}```{lang}\n{original_code_block}\n{' ' * num_spaces}```",
+                    f"{' ' * num_spaces}```{lang}\n{formatted_code_with_indentation}\n{' ' * num_spaces}```",
+                )
+        except Exception as e:
+            print(f"Error updating code block in file {file_path}: {e}")
+
+    try:
+        with open(file_path, "w") as file:
+            file.write(markdown_content)
+    except Exception as e:
+        print(f"Error writing file {file_path}: {e}")
+
+
+def main(root_dir=Path.cwd(), verbose=False):
+    """Processes all markdown files in a specified directory and its subdirectories."""
+    root_path = Path(root_dir)
+    markdown_files = list(root_path.rglob("*.md"))
+    temp_dir = Path("temp_code_blocks")
+    temp_dir.mkdir(exist_ok=True)
+
+    # Extract code blocks and save to temp files
+    all_temp_files = []
+    for markdown_file in markdown_files:
+        if verbose:
+            print(f"Processing {markdown_file}")
+        markdown_content, temp_files = process_markdown_file(markdown_file, temp_dir)
+        if markdown_content and temp_files:
+            all_temp_files.append((markdown_file, markdown_content, temp_files))
+
+    # Format all code blocks with ruff
+    format_code_with_ruff(temp_dir)
+
+    # Update markdown files with formatted code blocks
+    for markdown_file, markdown_content, temp_files in all_temp_files:
+        update_markdown_file(markdown_file, markdown_content, temp_files)
+
+    # Clean up temp directory
+    shutil.rmtree(temp_dir)
+
+
+if __name__ == "__main__":
+    main()

actions/utils/__init__.py

@@ -0,0 +1,35 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+from .common_utils import remove_html_comments
+from .github_utils import (
+    GITHUB_API_URL,
+    GITHUB_EVENT_NAME,
+    GITHUB_EVENT_PATH,
+    GITHUB_HEADERS,
+    GITHUB_HEADERS_DIFF,
+    GITHUB_TOKEN,
+    PR_NUMBER,
+    REPO_NAME,
+    get_github_data,
+    get_pr_diff,
+    graphql_request,
+)
+from .openai_utils import OPENAI_API_KEY, OPENAI_MODEL, get_completion
+
+__all__ = (
+    "remove_html_comments",
+    "GITHUB_API_URL",
+    "GITHUB_HEADERS",
+    "GITHUB_HEADERS_DIFF",
+    "GITHUB_TOKEN",
+    "REPO_NAME",
+    "PR_NUMBER",
+    "GITHUB_EVENT_NAME",
+    "GITHUB_EVENT_PATH",
+    "get_github_data",
+    "get_pr_diff",
+    "graphql_request",
+    "OPENAI_API_KEY",
+    "OPENAI_MODEL",
+    "get_completion",
+)

actions/utils/common_utils.py

@@ -0,0 +1,8 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+import re
+
+
+def remove_html_comments(body: str) -> str:
+    """Removes HTML comments from a string using regex pattern matching."""
+    return re.sub(r"<!--.*?-->", "", body, flags=re.DOTALL).strip()

actions/utils/github_utils.py

@@ -0,0 +1,44 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+import os
+
+import requests
+
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
+GITHUB_API_URL = "https://api.github.com"
+GITHUB_HEADERS = {"Authorization": f"token {GITHUB_TOKEN}", "Accept": "application/vnd.github.v3+json"}
+GITHUB_HEADERS_DIFF = {"Authorization": f"token {GITHUB_TOKEN}", "Accept": "application/vnd.github.v3.diff"}
+
+PR_NUMBER = os.getenv("PR_NUMBER")
+REPO_NAME = os.getenv("GITHUB_REPOSITORY")
+GITHUB_EVENT_NAME = os.getenv("GITHUB_EVENT_NAME")
+GITHUB_EVENT_PATH = os.getenv("GITHUB_EVENT_PATH")
+
+
+def get_pr_diff(pr_number: int) -> str:
+    """Retrieves the diff content for a specified pull request in a GitHub repository."""
+    url = f"{GITHUB_API_URL}/repos/{REPO_NAME}/pulls/{pr_number}"
+    r = requests.get(url, headers=GITHUB_HEADERS_DIFF)
+    return r.text if r.status_code == 200 else ""
+
+
+def get_github_data(endpoint: str) -> dict:
+    """Fetches GitHub repository data from a specified endpoint using the GitHub API."""
+    r = requests.get(f"{GITHUB_API_URL}/repos/{REPO_NAME}/{endpoint}", headers=GITHUB_HEADERS)
+    r.raise_for_status()
+    return r.json()
+
+
+def graphql_request(query: str, variables: dict = None) -> dict:
+    """Executes a GraphQL query against the GitHub API and returns the response as a dictionary."""
+    headers = {
+        "Authorization": f"Bearer {GITHUB_TOKEN}",
+        "Content-Type": "application/json",
+        "Accept": "application/vnd.github.v4+json",
+    }
+    r = requests.post(f"{GITHUB_API_URL}/graphql", json={"query": query, "variables": variables}, headers=headers)
+    r.raise_for_status()
+    result = r.json()
+    success = "data" in result and not result.get("errors")
+    print(f"{'Successful' if success else 'Fail'} discussion GraphQL request: {result.get('errors', 'No errors')}")
+    return result

actions/utils/openai_utils.py

@@ -0,0 +1,24 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+import os
+
+import requests
+
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+
+def get_completion(messages: list) -> str:
+    """Generates a completion using OpenAI's API based on input messages."""
+    assert OPENAI_API_KEY, "OpenAI API key is required."
+    url = "https://api.openai.com/v1/chat/completions"
+    headers = {"Authorization": f"Bearer {OPENAI_API_KEY}", "Content-Type": "application/json"}
+    data = {"model": OPENAI_MODEL, "messages": messages}
+
+    r = requests.post(url, headers=headers, json=data)
+    r.raise_for_status()
+    content = r.json()["choices"][0]["message"]["content"].strip()
+    remove = [" @giscus[bot]"]
+    for x in remove:
+        content = content.replace(x, "")
+    return content