ultralytics-actions 0.0.5__py3-none-any.whl → 0.0.10__py3-none-any.whl

actions/__init__.py

@@ -22,10 +22,4 @@
 #     ├── test_summarize_pr.py
 #     └── ...
 
-from .first_interaction import main as first_interaction_main
-from .summarize_pr import main as summarize_pr_main
-from .summarize_release import main as summarize_release_main
-from .update_markdown_code_blocks import main as update_markdown_code_blocks_main
-
-__all__ = ["first_interaction_main", "summarize_pr_main", "summarize_release_main", "update_markdown_code_blocks_main"]
-__version__ = "0.0.5"
+__version__ = "0.0.10"

actions/first_interaction.py

@@ -1,17 +1,16 @@
 # Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
 
-import json
 import os
 from typing import Dict, List, Tuple
 
 import requests
 
 from .utils import (
+    EVENT_DATA,
     GITHUB_API_URL,
     GITHUB_EVENT_NAME,
-    GITHUB_EVENT_PATH,
     GITHUB_HEADERS,
-    REPO_NAME,
+    GITHUB_REPOSITORY,
     get_completion,
     get_github_data,
     get_pr_diff,
@@ -24,19 +23,17 @@ BLOCK_USER = os.getenv("BLOCK_USER", "false").lower() == "true"
 
 
 def get_event_content() -> Tuple[int, str, str, str, str, str, str]:
-    """Extracts the number, node_id, title, body, username, and issue_type."""
-    with open(GITHUB_EVENT_PATH) as f:
-        data = json.load(f)
-    action = data["action"]  # 'opened', 'closed', 'created' (discussion), etc.
+    """Extracts key information from GitHub event data for issues, pull requests, or discussions."""
+    action = EVENT_DATA["action"]  # 'opened', 'closed', 'created' (discussion), etc.
     if GITHUB_EVENT_NAME == "issues":
-        item = data["issue"]
+        item = EVENT_DATA["issue"]
         issue_type = "issue"
     elif GITHUB_EVENT_NAME in ["pull_request", "pull_request_target"]:
-        pr_number = data["pull_request"]["number"]
+        pr_number = EVENT_DATA["pull_request"]["number"]
         item = get_github_data(f"pulls/{pr_number}")
         issue_type = "pull request"
     elif GITHUB_EVENT_NAME == "discussion":
-        item = data["discussion"]
+        item = EVENT_DATA["discussion"]
         issue_type = "discussion"
     else:
         raise ValueError(f"Unsupported event type: {GITHUB_EVENT_NAME}")
@@ -50,7 +47,7 @@ def get_event_content() -> Tuple[int, str, str, str, str, str, str]:
 
 
 def update_issue_pr_content(number: int, node_id: str, issue_type: str):
-    """Updates the title and body of the issue, pull request, or discussion."""
+    """Updates the title and body of an issue, pull request, or discussion with predefined content."""
     new_title = "Content Under Review"
     new_body = """This post has been flagged for review by [Ultralytics Actions](https://ultralytics.com/actions) due to possible spam, abuse, or off-topic content. For more information please see our:
 
@@ -73,13 +70,13 @@ mutation($discussionId: ID!, $title: String!, $body: String!) {
 """
         graphql_request(mutation, variables={"discussionId": node_id, "title": new_title, "body": new_body})
     else:
-        url = f"{GITHUB_API_URL}/repos/{REPO_NAME}/issues/{number}"
+        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}"
         r = requests.patch(url, json={"title": new_title, "body": new_body}, headers=GITHUB_HEADERS)
         print(f"{'Successful' if r.status_code == 200 else 'Fail'} issue/PR #{number} update: {r.status_code}")
 
 
 def close_issue_pr(number: int, node_id: str, issue_type: str):
-    """Closes the issue, pull request, or discussion."""
+    """Closes the specified issue, pull request, or discussion using the GitHub API."""
     if issue_type == "discussion":
         mutation = """
 mutation($discussionId: ID!) {
@@ -92,13 +89,13 @@ mutation($discussionId: ID!) {
 """
         graphql_request(mutation, variables={"discussionId": node_id})
     else:
-        url = f"{GITHUB_API_URL}/repos/{REPO_NAME}/issues/{number}"
+        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}"
         r = requests.patch(url, json={"state": "closed"}, headers=GITHUB_HEADERS)
         print(f"{'Successful' if r.status_code == 200 else 'Fail'} issue/PR #{number} close: {r.status_code}")
 
 
 def lock_issue_pr(number: int, node_id: str, issue_type: str):
-    """Locks the issue, pull request, or discussion."""
+    """Locks an issue, pull request, or discussion to prevent further interactions."""
     if issue_type == "discussion":
         mutation = """
 mutation($lockableId: ID!, $lockReason: LockReason) {
@@ -113,14 +110,14 @@ mutation($lockableId: ID!, $lockReason: LockReason) {
 """
         graphql_request(mutation, variables={"lockableId": node_id, "lockReason": "OFF_TOPIC"})
     else:
-        url = f"{GITHUB_API_URL}/repos/{REPO_NAME}/issues/{number}/lock"
+        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}/lock"
         r = requests.put(url, json={"lock_reason": "off-topic"}, headers=GITHUB_HEADERS)
         print(f"{'Successful' if r.status_code in {200, 204} else 'Fail'} issue/PR #{number} lock: {r.status_code}")
 
 
 def block_user(username: str):
-    """Blocks a user from the organization."""
-    url = f"{GITHUB_API_URL}/orgs/{REPO_NAME.split('/')[0]}/blocks/{username}"
+    """Blocks a user from the organization using the GitHub API."""
+    url = f"{GITHUB_API_URL}/orgs/{GITHUB_REPOSITORY.split('/')[0]}/blocks/{username}"
     r = requests.put(url, headers=GITHUB_HEADERS)
     print(f"{'Successful' if r.status_code == 204 else 'Fail'} user block for {username}: {r.status_code}")
 
@@ -128,7 +125,7 @@ def block_user(username: str):
 def get_relevant_labels(
     issue_type: str, title: str, body: str, available_labels: Dict, current_labels: List
 ) -> List[str]:
-    """Uses OpenAI to determine the most relevant labels."""
+    """Determines relevant labels for GitHub issues/PRs using OpenAI, considering title, body, and existing labels."""
     # Remove mutually exclusive labels like both 'bug' and 'question' or inappropriate labels like 'help wanted'
     for label in ["help wanted", "TODO"]:  # normal case
         available_labels.pop(label, None)  # remove as should only be manually added
@@ -200,7 +197,7 @@ query($owner: String!, $name: String!) {
     }
 }
 """
-    owner, repo = REPO_NAME.split("/")
+    owner, repo = GITHUB_REPOSITORY.split("/")
     result = graphql_request(query, variables={"owner": owner, "name": repo})
     if "data" in result and "repository" in result["data"]:
         all_labels = result["data"]["repository"]["labels"]["nodes"]
@@ -212,7 +209,7 @@ query($owner: String!, $name: String!) {
 
 
 def apply_labels(number: int, node_id: str, labels: List[str], issue_type: str):
-    """Applies the given labels to the issue, pull request, or discussion."""
+    """Applies specified labels to a GitHub issue, pull request, or discussion using the appropriate API."""
     if "Alert" in labels:
         create_alert_label()
 
@@ -237,27 +234,27 @@ mutation($labelableId: ID!, $labelIds: [ID!]!) {
         graphql_request(mutation, {"labelableId": node_id, "labelIds": label_ids})
         print(f"Successfully applied labels: {', '.join(labels)}")
     else:
-        url = f"{GITHUB_API_URL}/repos/{REPO_NAME}/issues/{number}/labels"
+        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}/labels"
         r = requests.post(url, json={"labels": labels}, headers=GITHUB_HEADERS)
         print(f"{'Successful' if r.status_code == 200 else 'Fail'} apply labels {', '.join(labels)}: {r.status_code}")
 
 
 def create_alert_label():
-    """Creates the 'Alert' label in the repository if it doesn't exist."""
+    """Creates the 'Alert' label in the repository if it doesn't exist, with a red color and description."""
     alert_label = {"name": "Alert", "color": "FF0000", "description": "Potential spam, abuse, or off-topic."}
-    requests.post(f"{GITHUB_API_URL}/repos/{REPO_NAME}/labels", json=alert_label, headers=GITHUB_HEADERS)
+    requests.post(f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/labels", json=alert_label, headers=GITHUB_HEADERS)
 
 
 def is_org_member(username: str) -> bool:
-    """Checks if a user is a member of the organization."""
-    org_name = REPO_NAME.split("/")[0]
+    """Checks if a user is a member of the organization using the GitHub API."""
+    org_name = GITHUB_REPOSITORY.split("/")[0]
     url = f"{GITHUB_API_URL}/orgs/{org_name}/members/{username}"
     r = requests.get(url, headers=GITHUB_HEADERS)
     return r.status_code == 204  # 204 means the user is a member
 
 
 def add_comment(number: int, node_id: str, comment: str, issue_type: str):
-    """Adds a comment to the issue, pull request, or discussion."""
+    """Adds a comment to the specified issue, pull request, or discussion using the GitHub API."""
     if issue_type == "discussion":
         mutation = """
 mutation($discussionId: ID!, $body: String!) {
@@ -270,15 +267,15 @@ mutation($discussionId: ID!, $body: String!) {
 """
         graphql_request(mutation, variables={"discussionId": node_id, "body": comment})
     else:
-        url = f"{GITHUB_API_URL}/repos/{REPO_NAME}/issues/{number}/comments"
+        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}/comments"
         r = requests.post(url, json={"body": comment}, headers=GITHUB_HEADERS)
         print(f"{'Successful' if r.status_code in {200, 201} else 'Fail'} issue/PR #{number} comment: {r.status_code}")
 
 
 def get_first_interaction_response(issue_type: str, title: str, body: str, username: str, number: int) -> str:
-    """Generates a custom response using LLM based on the issue/PR content and instructions."""
+    """Generates a custom LLM response for GitHub issues, PRs, or discussions based on content."""
     issue_discussion_response = f"""
-👋 Hello @{username}, thank you for submitting a `{REPO_NAME}` 🚀 {issue_type.capitalize()}. To help us address your concern efficiently, please ensure you've provided the following information:
+👋 Hello @{username}, thank you for submitting a `{GITHUB_REPOSITORY}` 🚀 {issue_type.capitalize()}. To help us address your concern efficiently, please ensure you've provided the following information:
 
 1. For bug reports:
    - A clear and concise description of the bug
@@ -303,10 +300,10 @@ Thank you for your contribution to improving our project!
 """
 
     pr_response = f"""
-👋 Hello @{username}, thank you for submitting an `{REPO_NAME}` 🚀 PR! To ensure a seamless integration of your work, please review the following checklist:
+👋 Hello @{username}, thank you for submitting an `{GITHUB_REPOSITORY}` 🚀 PR! To ensure a seamless integration of your work, please review the following checklist:
 
-- ✅ **Define a Purpose**: Clearly explain the purpose of your fix or feature in your PR description, and link to any [relevant issues](https://github.com/{REPO_NAME}/issues). Ensure your commit messages are clear, concise, and adhere to the project's conventions.
-- ✅ **Synchronize with Source**: Confirm your PR is synchronized with the `{REPO_NAME}` `main` branch. If it's behind, update it by clicking the 'Update branch' button or by running `git pull` and `git merge main` locally.
+- ✅ **Define a Purpose**: Clearly explain the purpose of your fix or feature in your PR description, and link to any [relevant issues](https://github.com/{GITHUB_REPOSITORY}/issues). Ensure your commit messages are clear, concise, and adhere to the project's conventions.
+- ✅ **Synchronize with Source**: Confirm your PR is synchronized with the `{GITHUB_REPOSITORY}` `main` branch. If it's behind, update it by clicking the 'Update branch' button or by running `git pull` and `git merge main` locally.
 - ✅ **Ensure CI Checks Pass**: Verify all Ultralytics [Continuous Integration (CI)](https://docs.ultralytics.com/help/CI/) checks are passing. If any checks fail, please address the issues.
 - ✅ **Update Documentation**: Update the relevant [documentation](https://docs.ultralytics.com) for any new or modified features.
 - ✅ **Add Tests**: If applicable, include or update tests to cover your changes, and confirm that all tests are passing.
@@ -321,8 +318,8 @@ For more guidance, please refer to our [Contributing Guide](https://docs.ultraly
     else:
         example = os.getenv("FIRST_ISSUE_RESPONSE") or issue_discussion_response
 
-    org_name, repo_name = REPO_NAME.split("/")
-    repo_url = f"https://github.com/{REPO_NAME}"
+    org_name, repo_name = GITHUB_REPOSITORY.split("/")
+    repo_url = f"https://github.com/{GITHUB_REPOSITORY}"
     diff = get_pr_diff(number)[:32000] if issue_type == "pull request" else ""
 
     prompt = f"""Generate a customized response to the new GitHub {issue_type} below:
@@ -370,7 +367,7 @@ YOUR {issue_type.upper()} RESPONSE:
 
 
 def main():
-    """Runs autolabel action and adds custom response for new issues/PRs/Discussions."""
+    """Executes autolabeling and custom response generation for new GitHub issues, PRs, and discussions."""
     number, node_id, title, body, username, issue_type, action = get_event_content()
     available_labels = get_github_data("labels")
     label_descriptions = {label["name"]: label.get("description", "") for label in available_labels}

actions/summarize_pr.py

@@ -5,8 +5,8 @@ import requests
 from .utils import (
     GITHUB_API_URL,
     GITHUB_HEADERS,
-    PR_NUMBER,
-    REPO_NAME,
+    GITHUB_REPOSITORY,
+    PR,
     get_completion,
     get_pr_diff,
 )
@@ -18,7 +18,7 @@ SUMMARY_START = (
 
 
 def generate_pr_summary(repo_name, diff_text):
-    """Generates a professionally written yet accessible summary of a PR using OpenAI's API."""
+    """Generates a concise, professional summary of a PR using OpenAI's API for Ultralytics repositories."""
     if not diff_text:
         diff_text = "**ERROR: DIFF IS EMPTY, THERE ARE ZERO CODE CHANGES IN THIS PR."
     ratio = 3.3  # about 3.3 characters per token
@@ -45,7 +45,7 @@ def generate_pr_summary(repo_name, diff_text):
 
 
 def update_pr_description(repo_name, pr_number, new_summary):
-    """Updates the original PR description with a new summary, replacing an existing summary if found."""
+    """Updates the PR description with a new summary, replacing existing summary if present."""
     # Fetch the current PR description
     pr_url = f"{GITHUB_API_URL}/repos/{repo_name}/pulls/{pr_number}"
     pr_response = requests.get(pr_url, headers=GITHUB_HEADERS)
@@ -64,14 +64,19 @@ def update_pr_description(repo_name, pr_number, new_summary):
 
 
 def main():
-    """Summarize PR."""
-    diff = get_pr_diff(PR_NUMBER)
+    """Summarize a pull request and update its description with an AI-generated summary."""
+    pr_number = PR["number"]
+
+    print(f"Retrieving diff for PR {pr_number}")
+    diff = get_pr_diff(PR["number"])
 
     # Generate PR summary
-    summary = generate_pr_summary(REPO_NAME, diff)
+    print("Generating PR summary...")
+    summary = generate_pr_summary(GITHUB_REPOSITORY, diff)
 
     # Update PR description
-    status_code = update_pr_description(REPO_NAME, PR_NUMBER, summary)
+    print("Updating PR description...")
+    status_code = update_pr_description(GITHUB_REPOSITORY, pr_number, summary)
     if status_code == 200:
         print("PR description updated successfully.")
     else:

actions/summarize_release.py

@@ -12,8 +12,8 @@ from .utils import (
     GITHUB_API_URL,
     GITHUB_HEADERS,
     GITHUB_HEADERS_DIFF,
+    GITHUB_REPOSITORY,
     GITHUB_TOKEN,
-    REPO_NAME,
     get_completion,
     remove_html_comments,
 )
@@ -24,14 +24,14 @@ 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."""
+    """Retrieves the differences between two specified Git tags in a GitHub repository."""
     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."""
+    """Retrieves and processes pull requests merged between two specified tags in a GitHub repository."""
     url = f"{GITHUB_API_URL}/repos/{repo_name}/compare/{previous_tag}...{latest_tag}"
     r = requests.get(url, headers=GITHUB_HEADERS)
     r.raise_for_status()
@@ -68,7 +68,7 @@ def get_prs_between_tags(repo_name: str, previous_tag: str, latest_tag: str) ->
 
 
 def get_new_contributors(repo: str, prs: list) -> set:
-    """Identify genuinely new contributors in the current release."""
+    """Identify new contributors who made their first merged PR in the current release."""
     new_contributors = set()
     for pr in prs:
         author = pr["author"]
@@ -85,7 +85,7 @@ def get_new_contributors(repo: str, prs: list) -> set:
 
 
 def generate_release_summary(diff: str, prs: list, latest_tag: str, previous_tag: str, repo_name: str) -> str:
-    """Generate a summary for the release."""
+    """Generate a concise release summary with key changes, purpose, and impact for a new Ultralytics version."""
     pr_summaries = "\n\n".join(
         [f"PR #{pr['number']}: {pr['title']} by @{pr['author']}\n{pr['body'][:1000]}" for pr in prs]
     )
@@ -139,7 +139,7 @@ def generate_release_summary(diff: str, prs: list, latest_tag: str, previous_tag
 
 
 def create_github_release(repo_name: str, tag_name: str, name: str, body: str) -> int:
-    """Create a release on GitHub."""
+    """Creates a GitHub release with specified tag, name, and body content for the given repository."""
     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)
@@ -147,7 +147,7 @@ def create_github_release(repo_name: str, tag_name: str, name: str, body: str) -
 
 
 def get_previous_tag() -> str:
-    """Get the previous tag from git tags."""
+    """Retrieves the previous Git tag, excluding the current tag, using the git describe command."""
     cmd = ["git", "describe", "--tags", "--abbrev=0", "--exclude", CURRENT_TAG]
     try:
         return subprocess.run(cmd, check=True, text=True, capture_output=True).stdout.strip()
@@ -164,14 +164,14 @@ def main():
     previous_tag = PREVIOUS_TAG or get_previous_tag()
 
     # Get the diff between the tags
-    diff = get_release_diff(REPO_NAME, previous_tag, CURRENT_TAG)
+    diff = get_release_diff(GITHUB_REPOSITORY, previous_tag, CURRENT_TAG)
 
     # Get PRs merged between the tags
-    prs = get_prs_between_tags(REPO_NAME, previous_tag, CURRENT_TAG)
+    prs = get_prs_between_tags(GITHUB_REPOSITORY, previous_tag, CURRENT_TAG)
 
     # Generate release summary
     try:
-        summary = generate_release_summary(diff, prs, CURRENT_TAG, previous_tag, REPO_NAME)
+        summary = generate_release_summary(diff, prs, CURRENT_TAG, previous_tag, GITHUB_REPOSITORY)
     except Exception as e:
         print(f"Failed to generate summary: {str(e)}")
         summary = "Failed to generate summary."
@@ -181,7 +181,7 @@ def main():
     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)
+    status_code = create_github_release(GITHUB_REPOSITORY, CURRENT_TAG, f"{CURRENT_TAG} - {commit_message}", summary)
     if status_code == 201:
         print(f"Successfully created release {CURRENT_TAG}")
     else:

actions/update_markdown_code_blocks.py

@@ -8,21 +8,21 @@ from pathlib import Path
 
 
 def extract_code_blocks(markdown_content):
-    """Extract Python code blocks with ``` followed by "python", "py", or "{ .py .annotate }"."""
+    """Extracts Python code blocks from markdown content using regex pattern matching."""
     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."""
+    """Removes specified leading spaces from each line in a code block to adjust indentation."""
     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`."""
+    """Adds specified number of leading spaces to non-empty lines in a code block."""
     indent = " " * num_spaces
     lines = code_block.split("\n")
     indented_lines = [indent + line if line.strip() != "" else line for line in lines]
@@ -30,7 +30,7 @@ def add_indentation(code_block, num_spaces):
 
 
 def format_code_with_ruff(temp_dir):
-    """Formats all Python code files in the `temp_dir` directory using the 'ruff' linter tool."""
+    """Formats Python code files in the specified directory using ruff linter and docformatter tools."""
     try:
         # Run ruff format
         subprocess.run(
@@ -86,14 +86,14 @@ def format_code_with_ruff(temp_dir):
 
 
 def generate_temp_filename(file_path, index):
-    """Generates a unique temporary filename based on the file path and index."""
+    """Generates a unique temporary filename using a hash of 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."""
+    """Processes a markdown file, extracting Python code blocks for formatting and updating the original file."""
     try:
         markdown_content = Path(file_path).read_text()
         code_blocks = extract_code_blocks(markdown_content)
@@ -119,7 +119,7 @@ def process_markdown_file(file_path, temp_dir, verbose=False):
 
 
 def update_markdown_file(file_path, markdown_content, temp_files):
-    """Updates the markdown file with formatted code blocks."""
+    """Updates a markdown file with formatted Python code blocks extracted and processed externally."""
     for num_spaces, original_code_block, temp_file_path in temp_files:
         try:
             with open(temp_file_path) as temp_file:
@@ -143,7 +143,7 @@ def update_markdown_file(file_path, markdown_content, temp_files):
 
 
 def main(root_dir=Path.cwd(), verbose=False):
-    """Processes all markdown files in a specified directory and its subdirectories."""
+    """Processes markdown files, extracts and formats Python code blocks, and updates the original files."""
     root_path = Path(root_dir)
     markdown_files = list(root_path.rglob("*.md"))
     temp_dir = Path("temp_code_blocks")

actions/utils/__init__.py

@@ -2,28 +2,34 @@
 
 from .common_utils import remove_html_comments
 from .github_utils import (
+    DISCUSSION,
+    EVENT_DATA,
     GITHUB_API_URL,
     GITHUB_EVENT_NAME,
     GITHUB_EVENT_PATH,
     GITHUB_HEADERS,
     GITHUB_HEADERS_DIFF,
+    GITHUB_REPOSITORY,
     GITHUB_TOKEN,
-    PR_NUMBER,
-    REPO_NAME,
+    PR,
+    check_pypi_version,
     get_github_data,
     get_pr_diff,
     graphql_request,
+    ultralytics_actions_info,
 )
 from .openai_utils import OPENAI_API_KEY, OPENAI_MODEL, get_completion
 
 __all__ = (
     "remove_html_comments",
+    "EVENT_DATA",
     "GITHUB_API_URL",
     "GITHUB_HEADERS",
     "GITHUB_HEADERS_DIFF",
     "GITHUB_TOKEN",
-    "REPO_NAME",
-    "PR_NUMBER",
+    "GITHUB_REPOSITORY",
+    "PR",
+    "DISCUSSION",
     "GITHUB_EVENT_NAME",
     "GITHUB_EVENT_PATH",
     "get_github_data",
@@ -32,4 +38,6 @@ __all__ = (
     "OPENAI_API_KEY",
     "OPENAI_MODEL",
     "get_completion",
+    "check_pypi_version",
+    "ultralytics_actions_info",
 )

actions/utils/common_utils.py

@@ -1,8 +1,100 @@
 # Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
 
 import re
+import socket
+import time
+import urllib
+from concurrent.futures import ThreadPoolExecutor
 
 
 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()
+
+
+def clean_url(url):
+    """Remove extra characters from URL strings."""
+    for _ in range(3):
+        url = str(url).strip('"').strip("'").rstrip(".,:;!?`\\").replace(".git@main", "").replace("git+", "")
+    return url
+
+
+def is_url(url, check=True, max_attempts=3, timeout=2):
+    """Check if string is URL and check if URL exists."""
+    allow_list = (
+        "localhost",
+        "127.0.0",
+        ":5000",
+        ":3000",
+        ":8000",
+        ":8080",
+        ":6006",
+        "MODEL_ID",
+        "API_KEY",
+        "url",
+        "example",
+        "mailto:",
+        "github.com",  # ignore GitHub links that may be private repos
+        "kaggle.com",  # blocks automated header requests
+    )
+    try:
+        # Check allow list
+        if any(x in url for x in allow_list):
+            return True
+
+        # Check structure
+        result = urllib.parse.urlparse(url)
+        if not all([result.scheme, result.netloc]):
+            return False
+
+        # Check response
+        if check:
+            for attempt in range(max_attempts):
+                try:
+                    req = urllib.request.Request(
+                        url,
+                        method="HEAD",
+                        headers={
+                            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                        },
+                    )
+                    with urllib.request.urlopen(req, timeout=timeout) as response:
+                        return response.getcode() < 400
+                except (urllib.error.URLError, socket.timeout):
+                    if attempt == max_attempts - 1:  # last attempt
+                        return False
+                    time.sleep(2**attempt)  # exponential backoff
+            return False
+        return True
+    except Exception:
+        return False
+
+
+def check_links_in_string(text, verbose=True, return_bad=False):
+    """Process a given text, find unique URLs within it, and check for any 404 errors."""
+    pattern = (
+        r"\[([^\]]+)\]\(([^)]+)\)"  # Matches Markdown links [text](url)
+        r"|"
+        r"("  # Start capturing group for plaintext URLs
+        r"(?:https?://)?"  # Optional http:// or https://
+        r"(?:www\.)?"  # Optional www.
+        r"[\w.-]+"  # Domain name and subdomains
+        r"\.[a-zA-Z]{2,}"  # TLD
+        r"(?:/[^\s\"')\]]*)?"  # Optional path
+        r")"
+    )
+    all_urls = []
+    for md_text, md_url, plain_url in re.findall(pattern, text):
+        url = md_url or plain_url
+        if url and urllib.parse.urlparse(url).scheme:
+            all_urls.append(url)
+
+    urls = set(map(clean_url, all_urls))  # remove extra characters and make unique
+    with ThreadPoolExecutor(max_workers=16) as executor:  # multi-thread
+        bad_urls = [url for url, valid in zip(urls, executor.map(lambda x: not is_url(x, check=True), urls)) if valid]
+
+    passing = not bad_urls
+    if verbose and not passing:
+        print(f"WARNING ⚠️ errors found in URLs {bad_urls}")
+
+    return (passing, bad_urls) if return_bad else passing

actions/utils/github_utils.py

@@ -1,30 +1,39 @@
 # Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
-
+import json
 import os
+from pathlib import Path
 
 import requests
 
 GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
+GITHUB_REPOSITORY = os.getenv("GITHUB_REPOSITORY")
+GITHUB_EVENT_NAME = os.getenv("GITHUB_EVENT_NAME")
+GITHUB_EVENT_PATH = os.getenv("GITHUB_EVENT_PATH")
 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")
+EVENT_DATA = {}
+if GITHUB_EVENT_PATH:
+    event_path = Path(GITHUB_EVENT_PATH)
+    if event_path.exists():
+        EVENT_DATA = json.loads(event_path.read_text())
+PR = EVENT_DATA.get("pull_request", {})
+DISCUSSION = EVENT_DATA.get("discussion", {})
+
+INPUTS = {k[6:].lower(): v for k, v in os.environ.items() if k.startswith("INPUT_")}  # actions inputs dictionary
 
 
 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}"
+    url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/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 = requests.get(f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/{endpoint}", headers=GITHUB_HEADERS)
     r.raise_for_status()
     return r.json()
 
@@ -42,3 +51,77 @@ def graphql_request(query: str, variables: dict = None) -> dict:
     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
+
+
+def check_pypi_version(pyproject_toml="pyproject.toml"):
+    """Compares local and PyPI package versions to determine if a new version should be published."""
+    import tomllib  # requires Python>=3.11
+
+    with open(pyproject_toml, "rb") as f:
+        pyproject = tomllib.load(f)
+
+    package_name = pyproject["project"]["name"]
+    local_version = pyproject["project"].get("version", "dynamic")
+
+    # If version is dynamic, extract it from the specified file
+    if local_version == "dynamic":
+        version_attr = pyproject["tool"]["setuptools"]["dynamic"]["version"]["attr"]
+        module_path, attr_name = version_attr.rsplit(".", 1)
+        with open(f"{module_path.replace('.', '/')}/__init__.py") as f:
+            local_version = next(line.split("=")[1].strip().strip("'\"") for line in f if line.startswith(attr_name))
+
+    print(f"Local Version: {local_version}")
+
+    # Get online version from PyPI
+    response = requests.get(f"https://pypi.org/pypi/{package_name}/json")
+    online_version = response.json()["info"]["version"] if response.status_code == 200 else None
+    print(f"Online Version: {online_version or 'Not Found'}")
+
+    # Determine if a new version should be published
+    if online_version:
+        local_ver = tuple(map(int, local_version.split(".")))
+        online_ver = tuple(map(int, online_version.split(".")))
+        major_diff = local_ver[0] - online_ver[0]
+        minor_diff = local_ver[1] - online_ver[1]
+        patch_diff = local_ver[2] - online_ver[2]
+
+        publish = (
+            (major_diff == 0 and minor_diff == 0 and 0 < patch_diff <= 2)
+            or (major_diff == 0 and minor_diff == 1 and local_ver[2] == 0)
+            or (major_diff == 1 and local_ver[1] == 0 and local_ver[2] == 0)
+        )  # should publish an update
+    else:
+        publish = True  # publish as this is likely a first release
+
+    return local_version, online_version, publish
+
+
+def ultralytics_actions_info():
+    """Print Ultralytics Actions information."""
+    info = {
+        "github.event_name": GITHUB_EVENT_NAME,
+        "github.event.action": EVENT_DATA.get("action"),
+        "github.repository": GITHUB_REPOSITORY,
+        "github.event.pull_request.number": PR.get("number"),
+        "github.event.pull_request.head.repo.full_name": PR.get("head", {}).get("repo", {}).get("full_name"),
+        "github.actor": os.environ.get("GITHUB_ACTOR"),
+        "github.event.pull_request.head.ref": PR.get("head", {}).get("ref"),
+        "github.ref": os.environ.get("GITHUB_REF"),
+        "github.head_ref": os.environ.get("GITHUB_HEAD_REF"),
+        "github.base_ref": os.environ.get("GITHUB_BASE_REF"),
+    }
+
+    if GITHUB_EVENT_NAME == "discussion":
+        info.update(
+            {
+                "github.event.discussion.node_id": DISCUSSION.get("node_id"),
+                "github.event.discussion.number": DISCUSSION.get("number"),
+            }
+        )
+
+    # Print information
+    max_key_length = max(len(key) for key in info.keys())
+    print("Ultralytics Actions Information " + "-" * 40)  # header (72 long)
+    for key, value in info.items():
+        print(f"{key:<{max_key_length + 5}}{value}")
+    print("-" * 72)  # footer

actions/utils/openai_utils.py

@@ -1,24 +1,45 @@
 # Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
 
 import os
+import random
+from typing import Dict, List
 
 import requests
 
-OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o")
+from actions.utils.common_utils import check_links_in_string
+
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o")
 
 
-def get_completion(messages: list) -> str:
+def get_completion(
+    messages: List[Dict[str, str]],
+    check_links: bool = True,
+    remove: List[str] = (" @giscus[bot]",),  # strings to remove from response
+) -> 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, "")
+
+    content = ""
+    max_retries = 2
+    for attempt in range(max_retries + 2):  # attempt = [0, 1, 2, 3], 2 random retries before asking for no links
+        data = {"model": OPENAI_MODEL, "messages": messages, "seed": random.randint(1, 1000000)}
+
+        r = requests.post(url, headers=headers, json=data)
+        r.raise_for_status()
+        content = r.json()["choices"][0]["message"]["content"].strip()
+        for x in remove:
+            content = content.replace(x, "")
+        if not check_links or check_links_in_string(content):  # if no checks or checks are passing return response
+            return content
+
+        if attempt < max_retries:
+            print(f"Attempt {attempt + 1}: Found bad URLs. Retrying with a new random seed.")
+        else:
+            print("Max retries reached. Updating prompt to exclude links.")
+            messages.append({"role": "user", "content": "Please provide a response without any URLs or links in it."})
+            check_links = False  # automatically accept the last message
+
     return content

{ultralytics_actions-0.0.5.dist-info → ultralytics_actions-0.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics-actions
-Version: 0.0.5
+Version: 0.0.10
 Summary: Ultralytics Actions for GitHub automation and PR management.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -42,6 +42,8 @@ Welcome to the [Ultralytics Actions](https://github.com/ultralytics/actions) rep
 
 [![GitHub Actions Marketplace](https://img.shields.io/badge/Marketplace-Ultralytics_Actions-blue?style=flat&logo=github)](https://github.com/marketplace/actions/ultralytics-actions) [![Ultralytics Actions](https://github.com/ultralytics/actions/actions/workflows/format.yml/badge.svg)](https://github.com/ultralytics/actions/actions/workflows/format.yml) <a href="https://discord.com/invite/ultralytics"><img alt="Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a> <a href="https://community.ultralytics.com/"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a> <a href="https://reddit.com/r/ultralytics"><img alt="Ultralytics Reddit" src="https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue"></a>
 
+[![PyPI version](https://badge.fury.io/py/ultralytics-actions.svg)](https://badge.fury.io/py/ultralytics-actions) [![Downloads](https://static.pepy.tech/badge/ultralytics-actions)](https://pepy.tech/project/ultralytics-actions)
+
 ## 📄 Actions Description
 
 Ultralytics Actions automatically applies formats, updates, and enhancements:

ultralytics_actions-0.0.10.dist-info/RECORD

@@ -0,0 +1,15 @@
+actions/__init__.py,sha256=Eko4c5hZ6l7Dg7GO0v0C5Lp72mdL4RDxAjkLO2mjqsI,749
+actions/first_interaction.py,sha256=cLXo5hmhOgTfk7F9LbGJeRdg6vvrKUe-0taCa_TkpAg,17683
+actions/summarize_pr.py,sha256=ysbGgomPXMXBZQQROWTv06syA59gJmGMvpWxDO66cLQ,3779
+actions/summarize_release.py,sha256=l8NBdTAXLysfNKl1Kf_1tyuBRmeEBLyzTDXS6s5_eQg,8350
+actions/update_markdown_code_blocks.py,sha256=WBNcMD_KKsZS-qSPBn6O1G0ggQ_VrT-jTQffbg7xH_M,6369
+actions/utils/__init__.py,sha256=0vRjFc7i2WOlphuxdUxQo5BuNipgwGw2Bs-fdUBDeUw,973
+actions/utils/common_utils.py,sha256=PaXyUAf675PEjzXY7ZFCcyfes1mkibB1OuvKU06N-ug,3490
+actions/utils/github_utils.py,sha256=2H4pRum8tLSbLKGoO85Ea4E8psxZICyvFO_1hwQPuoU,5431
+actions/utils/openai_utils.py,sha256=SQWOjU3hdfI_0LKb3uqM5pNsoMyE7W0hGxXy7ISk97M,1823
+ultralytics_actions-0.0.10.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+ultralytics_actions-0.0.10.dist-info/METADATA,sha256=KhVf3iB6wqE6AuGSi0NSJBCAXFj-cq1Knn2xZRn9r3I,10535
+ultralytics_actions-0.0.10.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+ultralytics_actions-0.0.10.dist-info/entry_points.txt,sha256=GowvOFplj0C7JmsjbKcbpgLpdf2r921pcaOQkAHWZRA,378
+ultralytics_actions-0.0.10.dist-info/top_level.txt,sha256=5apM5x80QlJcGbACn1v3fkmIuL1-XQCKcItJre7w7Tw,8
+ultralytics_actions-0.0.10.dist-info/RECORD,,

{ultralytics_actions-0.0.5.dist-info → ultralytics_actions-0.0.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{ultralytics_actions-0.0.5.dist-info → ultralytics_actions-0.0.10.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 ultralytics-actions-first-interaction = actions.first_interaction:main
+ultralytics-actions-info = actions.utils:ultralytics_actions_info
 ultralytics-actions-summarize-pr = actions.summarize_pr:main
 ultralytics-actions-summarize-release = actions.summarize_release:main
 ultralytics-actions-update-markdown-code-blocks = actions.update_markdown_code_blocks:main

ultralytics_actions-0.0.5.dist-info/RECORD

@@ -1,15 +0,0 @@
-actions/__init__.py,sha256=gQgelJXb-pdXlmEB1emplvz7LMwt23p26a1zVOI0_Ak,1127
-actions/first_interaction.py,sha256=28WnEN0TWV0RYeQJ81ai5uuTnUhEsOopmbBx14W4I2o,17292
-actions/summarize_pr.py,sha256=BUZ8MuIxzXU4Tl5L8UXiUyUXYWKYEe_34lbK4IP2TuA,3531
-actions/summarize_release.py,sha256=Gu1RM6bQ8dJ6Vd5lWFtisL9TBI3hQZA9QbgNMTFaVyo,8009
-actions/update_markdown_code_blocks.py,sha256=J5gQAxAt9giogDxMf6zFQ2ZS7XtoJZ9gWO9GmvTeRRY,6308
-actions/utils/__init__.py,sha256=3PHLC4zhx_6bGi83msXeusuacmzNjE5Q8iV7FK9EBsI,791
-actions/utils/common_utils.py,sha256=A_lzlzyTkrwd5fpqvDnIT1hhdBlHDdwtlxjAcKn4da0,278
-actions/utils/github_utils.py,sha256=CLzS0k9aaCpaaeObSDRq00sN_gsOEaspyeqiqpeqHxs,1853
-actions/utils/openai_utils.py,sha256=-N63TWvlw0lfDJBVeZMhONgwe41_3TQT_3fTlkpWrwo,849
-ultralytics_actions-0.0.5.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-ultralytics_actions-0.0.5.dist-info/METADATA,sha256=eqJ7Gck8Bdf4gwZ28wDjxUo_vrfToiExX_UD4CVhg74,10305
-ultralytics_actions-0.0.5.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-ultralytics_actions-0.0.5.dist-info/entry_points.txt,sha256=S8UXCzr5pW9tUAPck-gZTfdvX10a-gambB9wmFRWDnw,312
-ultralytics_actions-0.0.5.dist-info/top_level.txt,sha256=5apM5x80QlJcGbACn1v3fkmIuL1-XQCKcItJre7w7Tw,8
-ultralytics_actions-0.0.5.dist-info/RECORD,,