ultralytics-actions 0.0.30__tar.gz → 0.0.34__tar.gz

{ultralytics_actions-0.0.30 → ultralytics_actions-0.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics-actions
-Version: 0.0.30
+Version: 0.0.34
 Summary: Ultralytics Actions for GitHub automation and PR management.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

{ultralytics_actions-0.0.30 → ultralytics_actions-0.0.34}/actions/__init__.py

@@ -22,4 +22,4 @@
 #     ├── test_summarize_pr.py
 #     └── ...
 
-__version__ = "0.0.30"
+__version__ = "0.0.34"

{ultralytics_actions-0.0.30 → ultralytics_actions-0.0.34}/actions/first_interaction.py

@@ -6,15 +6,9 @@ from typing import Dict, List, Tuple
 import requests
 
 from .utils import (
-    EVENT_DATA,
     GITHUB_API_URL,
-    GITHUB_EVENT_NAME,
-    GITHUB_HEADERS,
-    GITHUB_REPOSITORY,
+    Action,
     get_completion,
-    get_github_data,
-    get_pr_diff,
-    graphql_request,
     remove_html_comments,
 )
 
@@ -22,21 +16,23 @@ from .utils import (
 BLOCK_USER = os.getenv("BLOCK_USER", "false").lower() == "true"
 
 
-def get_event_content() -> Tuple[int, str, str, str, str, str, str]:
+def get_event_content(event) -> Tuple[int, str, str, str, str, str, str]:
     """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 = EVENT_DATA["issue"]
+    data = event.event_data
+    name = event.event_name
+    action = data["action"]  # 'opened', 'closed', 'created' (discussion), etc.
+    if name == "issues":
+        item = data["issue"]
         issue_type = "issue"
-    elif GITHUB_EVENT_NAME in ["pull_request", "pull_request_target"]:
-        pr_number = EVENT_DATA["pull_request"]["number"]
-        item = get_github_data(f"pulls/{pr_number}")
+    elif name in ["pull_request", "pull_request_target"]:
+        pr_number = data["pull_request"]["number"]
+        item = event.get_repo_data(f"pulls/{pr_number}")
         issue_type = "pull request"
-    elif GITHUB_EVENT_NAME == "discussion":
-        item = EVENT_DATA["discussion"]
+    elif name == "discussion":
+        item = data["discussion"]
         issue_type = "discussion"
     else:
-        raise ValueError(f"Unsupported event type: {GITHUB_EVENT_NAME}")
+        raise ValueError(f"Unsupported event type: {name}")
 
     number = item["number"]
     node_id = item.get("node_id") or item.get("id")
@@ -46,7 +42,7 @@ def get_event_content() -> Tuple[int, str, str, str, str, str, str]:
     return number, node_id, title, body, username, issue_type, action
 
 
-def update_issue_pr_content(number: int, node_id: str, issue_type: str):
+def update_issue_pr_content(event, number: int, node_id: str, issue_type: str):
     """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:
@@ -68,14 +64,14 @@ mutation($discussionId: ID!, $title: String!, $body: String!) {
     }
 }
 """
-        graphql_request(mutation, variables={"discussionId": node_id, "title": new_title, "body": new_body})
+        event.graphql_request(mutation, variables={"discussionId": node_id, "title": new_title, "body": new_body})
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}"
-        r = requests.patch(url, json={"title": new_title, "body": new_body}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}"
+        r = requests.patch(url, json={"title": new_title, "body": new_body}, headers=event.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):
+def close_issue_pr(event, number: int, node_id: str, issue_type: str):
     """Closes the specified issue, pull request, or discussion using the GitHub API."""
     if issue_type == "discussion":
         mutation = """
@@ -87,14 +83,14 @@ mutation($discussionId: ID!) {
     }
 }
 """
-        graphql_request(mutation, variables={"discussionId": node_id})
+        event.graphql_request(mutation, variables={"discussionId": node_id})
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}"
-        r = requests.patch(url, json={"state": "closed"}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}"
+        r = requests.patch(url, json={"state": "closed"}, headers=event.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):
+def lock_issue_pr(event, number: int, node_id: str, issue_type: str):
     """Locks an issue, pull request, or discussion to prevent further interactions."""
     if issue_type == "discussion":
         mutation = """
@@ -108,17 +104,17 @@ mutation($lockableId: ID!, $lockReason: LockReason) {
     }
 }
 """
-        graphql_request(mutation, variables={"lockableId": node_id, "lockReason": "OFF_TOPIC"})
+        event.graphql_request(mutation, variables={"lockableId": node_id, "lockReason": "OFF_TOPIC"})
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}/lock"
-        r = requests.put(url, json={"lock_reason": "off-topic"}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/lock"
+        r = requests.put(url, json={"lock_reason": "off-topic"}, headers=event.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):
+def block_user(event, username: str):
     """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)
+    url = f"{GITHUB_API_URL}/orgs/{event.repository.split('/')[0]}/blocks/{username}"
+    r = requests.put(url, headers=event.headers)
     print(f"{'Successful' if r.status_code == 204 else 'Fail'} user block for {username}: {r.status_code}")
 
 
@@ -167,7 +163,7 @@ YOUR RESPONSE (label names only):
     messages = [
         {
             "role": "system",
-            "content": "You are a helpful assistant that labels GitHub issues, pull requests, and discussions.",
+            "content": "You are an Ultralytics AI assistant that labels GitHub issues, PRs, and discussions.",
         },
         {"role": "user", "content": prompt},
     ]
@@ -183,7 +179,7 @@ YOUR RESPONSE (label names only):
     ]
 
 
-def get_label_ids(labels: List[str]) -> List[str]:
+def get_label_ids(event, labels: List[str]) -> List[str]:
     """Retrieves GitHub label IDs for a list of label names using the GraphQL API."""
     query = """
 query($owner: String!, $name: String!) {
@@ -197,8 +193,8 @@ query($owner: String!, $name: String!) {
     }
 }
 """
-    owner, repo = GITHUB_REPOSITORY.split("/")
-    result = graphql_request(query, variables={"owner": owner, "name": repo})
+    owner, repo = event.repository.split("/")
+    result = event.graphql_request(query, variables={"owner": owner, "name": repo})
     if "data" in result and "repository" in result["data"]:
         all_labels = result["data"]["repository"]["labels"]["nodes"]
         label_map = {label["name"].lower(): label["id"] for label in all_labels}
@@ -208,14 +204,14 @@ query($owner: String!, $name: String!) {
         return []
 
 
-def apply_labels(number: int, node_id: str, labels: List[str], issue_type: str):
+def apply_labels(event, number: int, node_id: str, labels: List[str], issue_type: str):
     """Applies specified labels to a GitHub issue, pull request, or discussion using the appropriate API."""
     if "Alert" in labels:
-        create_alert_label()
+        create_alert_label(event)
 
     if issue_type == "discussion":
         print(f"Using node_id: {node_id}")  # Debug print
-        label_ids = get_label_ids(labels)
+        label_ids = get_label_ids(event, labels)
         if not label_ids:
             print("No valid labels to apply.")
             return
@@ -231,29 +227,29 @@ mutation($labelableId: ID!, $labelIds: [ID!]!) {
     }
 }
 """
-        graphql_request(mutation, {"labelableId": node_id, "labelIds": label_ids})
+        event.graphql_request(mutation, {"labelableId": node_id, "labelIds": label_ids})
         print(f"Successfully applied labels: {', '.join(labels)}")
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}/labels"
-        r = requests.post(url, json={"labels": labels}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/labels"
+        r = requests.post(url, json={"labels": labels}, headers=event.headers)
         print(f"{'Successful' if r.status_code == 200 else 'Fail'} apply labels {', '.join(labels)}: {r.status_code}")
 
 
-def create_alert_label():
+def create_alert_label(event):
     """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/{GITHUB_REPOSITORY}/labels", json=alert_label, headers=GITHUB_HEADERS)
+    requests.post(f"{GITHUB_API_URL}/repos/{event.repository}/labels", json=alert_label, headers=event.headers)
 
 
-def is_org_member(username: str) -> bool:
+def is_org_member(event, username: str) -> bool:
     """Checks if a user is a member of the organization using the GitHub API."""
-    org_name = GITHUB_REPOSITORY.split("/")[0]
+    org_name = event.repository.split("/")[0]
     url = f"{GITHUB_API_URL}/orgs/{org_name}/members/{username}"
-    r = requests.get(url, headers=GITHUB_HEADERS)
+    r = requests.get(url, headers=event.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):
+def add_comment(event, number: int, node_id: str, comment: str, issue_type: str):
     """Adds a comment to the specified issue, pull request, or discussion using the GitHub API."""
     if issue_type == "discussion":
         mutation = """
@@ -265,17 +261,17 @@ mutation($discussionId: ID!, $body: String!) {
     }
 }
 """
-        graphql_request(mutation, variables={"discussionId": node_id, "body": comment})
+        event.graphql_request(mutation, variables={"discussionId": node_id, "body": comment})
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}/comments"
-        r = requests.post(url, json={"body": comment}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/comments"
+        r = requests.post(url, json={"body": comment}, headers=event.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:
+def get_first_interaction_response(event, issue_type: str, title: str, body: str, username: str) -> str:
     """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 `{GITHUB_REPOSITORY}` 🚀 {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 `{event.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
@@ -300,10 +296,10 @@ Thank you for your contribution to improving our project!
 """
 
     pr_response = f"""
-👋 Hello @{username}, thank you for submitting an `{GITHUB_REPOSITORY}` 🚀 PR! To ensure a seamless integration of your work, please review the following checklist:
+👋 Hello @{username}, thank you for submitting an `{event.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/{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.
+- ✅ **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/{event.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 `{event.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.
@@ -318,9 +314,9 @@ 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 = GITHUB_REPOSITORY.split("/")
-    repo_url = f"https://github.com/{GITHUB_REPOSITORY}"
-    diff = get_pr_diff(number)[:32000] if issue_type == "pull request" else ""
+    org_name, repo_name = event.repository.split("/")
+    repo_url = f"https://github.com/{event.repository}"
+    diff = event.get_pr_diff()[:32000] if issue_type == "pull request" else ""
 
     prompt = f"""Generate a customized response to the new GitHub {issue_type} below:
 
@@ -359,39 +355,40 @@ YOUR {issue_type.upper()} RESPONSE:
     messages = [
         {
             "role": "system",
-            "content": f"You are a helpful assistant responding to GitHub {issue_type}s for {org_name}.",
+            "content": f"You are an Ultralytics AI assistant responding to GitHub {issue_type}s for {org_name}.",
         },
         {"role": "user", "content": prompt},
     ]
     return get_completion(messages)
 
 
-def main():
-    """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")
+def main(*args, **kwargs):
+    """Executes auto-labeling and custom response generation for new GitHub issues, PRs, and discussions."""
+    event = Action(*args, **kwargs)
+    number, node_id, title, body, username, issue_type, action = get_event_content(event)
+    available_labels = event.get_repo_data("labels")
     label_descriptions = {label["name"]: label.get("description", "") for label in available_labels}
     if issue_type == "discussion":
         current_labels = []  # For discussions, labels may need to be fetched differently or adjusted
     else:
-        current_labels = [label["name"].lower() for label in get_github_data(f"issues/{number}/labels")]
+        current_labels = [label["name"].lower() for label in event.get_repo_data(f"issues/{number}/labels")]
     relevant_labels = get_relevant_labels(issue_type, title, body, label_descriptions, current_labels)
 
     if relevant_labels:
-        apply_labels(number, node_id, relevant_labels, issue_type)
-        if "Alert" in relevant_labels and not is_org_member(username):
-            update_issue_pr_content(number, node_id, issue_type)
+        apply_labels(event, number, node_id, relevant_labels, issue_type)
+        if "Alert" in relevant_labels and not is_org_member(event, username):
+            update_issue_pr_content(event, number, node_id, issue_type)
             if issue_type != "pull request":
-                close_issue_pr(number, node_id, issue_type)
-            lock_issue_pr(number, node_id, issue_type)
+                close_issue_pr(event, number, node_id, issue_type)
+            lock_issue_pr(event, number, node_id, issue_type)
             if BLOCK_USER:
-                block_user(username=username)
+                block_user(event, username=username)
     else:
         print("No relevant labels found or applied.")
 
     if action in {"opened", "created"}:
-        custom_response = get_first_interaction_response(issue_type, title, body, username, number)
-        add_comment(number, node_id, custom_response, issue_type)
+        custom_response = get_first_interaction_response(event, issue_type, title, body, username)
+        add_comment(event, number, node_id, custom_response, issue_type)
 
 
 if __name__ == "__main__":

{ultralytics_actions-0.0.30 → ultralytics_actions-0.0.34}/actions/summarize_pr.py

@@ -6,12 +6,8 @@ import requests
 
 from .utils import (
     GITHUB_API_URL,
-    GITHUB_HEADERS,
-    GITHUB_REPOSITORY,
-    PR,
+    Action,
     get_completion,
-    get_github_username,
-    get_pr_diff,
 )
 
 # Constants
@@ -20,13 +16,8 @@ SUMMARY_START = (
 )
 
 
-def generate_merge_message(pr_author, contributors, pr_summary=None):
+def generate_merge_message(pr_summary=None, pr_credit=None):
     """Generates a thank-you message for merged PR contributors."""
-    contributors_str = ", ".join(f"@{c}" for c in contributors if c != pr_author)
-    mention_str = f"@{pr_author}"
-    if contributors_str:
-        mention_str += f" and {contributors_str}"
-
     messages = [
         {
             "role": "system",
@@ -34,10 +25,10 @@ def generate_merge_message(pr_author, contributors, pr_summary=None):
         },
         {
             "role": "user",
-            "content": f"Write a friendly thank you for a merged PR by these GitHub contributors: {mention_str}. "
+            "content": f"Write a friendly thank you for a merged GitHub PR by {pr_credit}. "
             f"Context from PR:\n{pr_summary}\n\n"
-            f"Start with the exciting message that this PR is now merged, and weave in an inspiring quote "
-            f"from a famous figure in science, philosophy or stoicism. "
+            f"Start with the exciting message that this PR is now merged, and weave in an inspiring but obscure quote "
+            f"from a historical figure in science, art, stoicism and philosophy. "
             f"Keep the message concise yet relevant to the specific contributions in this PR. "
             f"We want the contributors to feel their effort is appreciated and will make a difference in the world.",
         },
@@ -45,15 +36,15 @@ def generate_merge_message(pr_author, contributors, pr_summary=None):
     return get_completion(messages)
 
 
-def post_merge_message(pr_number, pr_author, contributors, summary):
+def post_merge_message(pr_number, repository, summary, pr_credit, headers):
     """Posts thank you message on PR after merge."""
-    message = generate_merge_message(pr_author, contributors, summary)
-    comment_url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{pr_number}/comments"
-    response = requests.post(comment_url, json={"body": message}, headers=GITHUB_HEADERS)
+    message = generate_merge_message(summary, pr_credit)
+    comment_url = f"{GITHUB_API_URL}/repos/{repository}/issues/{pr_number}/comments"
+    response = requests.post(comment_url, json={"body": message}, headers=headers)
     return response.status_code == 201
 
 
-def generate_issue_comment(pr_url, pr_summary):
+def generate_issue_comment(pr_url, pr_summary, pr_credit):
     """Generates a personalized issue comment using based on the PR context."""
     messages = [
         {
@@ -62,21 +53,22 @@ def generate_issue_comment(pr_url, pr_summary):
         },
         {
             "role": "user",
-            "content": f"Write a GitHub issue comment announcing a potential fix has been merged in linked PR {pr_url}\n\n"
+            "content": f"Write a GitHub issue comment announcing a potential fix for this issue is now merged in linked PR {pr_url} by {pr_credit}\n\n"
             f"Context from PR:\n{pr_summary}\n\n"
             f"Include:\n"
             f"1. An explanation of key changes from the PR that may resolve this issue\n"
-            f"2. Options for testing if PR changes have resolved this issue:\n"
+            f"2. Credit to the PR author and contributors\n"
+            f"3. Options for testing if PR changes have resolved this issue:\n"
             f"   - pip install git+https://github.com/ultralytics/ultralytics.git@main # test latest changes\n"
             f"   - or await next official PyPI release\n"
-            f"3. Request feedback on whether the PR changes resolve the issue\n"
-            f"4. Thank 🙏 for reporting the issue and welcome any further feedback if the issue persists\n\n",
+            f"4. Request feedback on whether the PR changes resolve the issue\n"
+            f"5. Thank 🙏 for reporting the issue and welcome any further feedback if the issue persists\n\n",
         },
     ]
     return get_completion(messages)
 
 
-def generate_pr_summary(repo_name, diff_text):
+def generate_pr_summary(repository, diff_text):
     """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."
@@ -89,7 +81,7 @@ def generate_pr_summary(repo_name, diff_text):
         },
         {
             "role": "user",
-            "content": f"Summarize this '{repo_name}' PR, focusing on major changes, their purpose, and potential impact. Keep the summary clear and concise, suitable for a broad audience. Add emojis to enliven the summary. Reply directly with a summary along these example guidelines, though feel free to adjust as appropriate:\n\n"
+            "content": f"Summarize this '{repository}' PR, focusing on major changes, their purpose, and potential impact. Keep the summary clear and concise, suitable for a broad audience. Add emojis to enliven the summary. 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"
@@ -102,12 +94,12 @@ def generate_pr_summary(repo_name, diff_text):
     return SUMMARY_START + reply
 
 
-def update_pr_description(repo_name, pr_number, new_summary, max_retries=2):
+def update_pr_description(repository, pr_number, new_summary, headers, max_retries=2):
     """Updates PR description with new summary, retrying if description is None."""
-    pr_url = f"{GITHUB_API_URL}/repos/{repo_name}/pulls/{pr_number}"
+    pr_url = f"{GITHUB_API_URL}/repos/{repository}/pulls/{pr_number}"
     description = ""
     for i in range(max_retries + 1):
-        description = requests.get(pr_url, headers=GITHUB_HEADERS).json().get("body") or ""
+        description = requests.get(pr_url, headers=headers).json().get("body") or ""
         if description:
             break
         if i < max_retries:
@@ -124,65 +116,76 @@ def update_pr_description(repo_name, pr_number, new_summary, max_retries=2):
         updated_description = description + "\n\n" + new_summary
 
     # Update the PR description
-    update_response = requests.patch(pr_url, json={"body": updated_description}, headers=GITHUB_HEADERS)
+    update_response = requests.patch(pr_url, json={"body": updated_description}, headers=headers)
     return update_response.status_code
 
 
-def label_fixed_issues(pr_number, pr_summary):
-    """Labels issues closed by this PR when merged, notifies users, and returns PR contributors."""
+def label_fixed_issues(repository, pr_number, pr_summary, headers, action):
+    """Labels issues closed by PR when merged, notifies users, returns PR contributors."""
     query = """
 query($owner: String!, $repo: String!, $pr_number: Int!) {
     repository(owner: $owner, name: $repo) {
         pullRequest(number: $pr_number) {
-            closingIssuesReferences(first: 50) {
-                nodes {
-                    number
-                }
-            }
+            closingIssuesReferences(first: 50) { nodes { number } }
             url
             body
             author { login, __typename }
-            reviews(first: 50) {
-                nodes { author { login, __typename } }
-            }
-            comments(first: 50) {
-                nodes { author { login, __typename } }
-            }
+            reviews(first: 50) { nodes { author { login, __typename } } }
+            comments(first: 50) { nodes { author { login, __typename } } }
+            commits(first: 100) { nodes { commit { author { user { login } }, committer { user { login } } } } }
         }
     }
 }
 """
-
-    owner, repo = GITHUB_REPOSITORY.split("/")
+    owner, repo = repository.split("/")
     variables = {"owner": owner, "repo": repo, "pr_number": pr_number}
     graphql_url = "https://api.github.com/graphql"
-    response = requests.post(graphql_url, json={"query": query, "variables": variables}, headers=GITHUB_HEADERS)
+    response = requests.post(graphql_url, json={"query": query, "variables": variables}, headers=headers)
+
     if response.status_code != 200:
         print(f"Failed to fetch linked issues. Status code: {response.status_code}")
         return [], None
 
     try:
         data = response.json()["data"]["repository"]["pullRequest"]
-        comments = data["reviews"]["nodes"] + data["comments"]["nodes"]  # merge lists
-        author = data["author"]["login"]
+        comments = data["reviews"]["nodes"] + data["comments"]["nodes"]
+        token_username = action.get_username()  # get GITHUB_TOKEN username
+        author = data["author"]["login"] if data["author"]["__typename"] != "Bot" else None
 
         # Get unique contributors from reviews and comments
         contributors = {x["author"]["login"] for x in comments if x["author"]["__typename"] != "Bot"}
-        contributors.discard(author)  # Remove author from contributors list
+
+        # Add commit authors and committers that have GitHub accounts linked
+        for commit in data["commits"]["nodes"]:
+            commit_data = commit["commit"]
+            for user_type in ["author", "committer"]:
+                if user := commit_data[user_type].get("user"):
+                    if login := user.get("login"):
+                        contributors.add(login)
+
+        contributors.discard(author)
+        contributors.discard(token_username)
+
+        # Write credit string
+        pr_credit = ""  # i.e. "@user1 with contributions from @user2, @user3"
+        if author and author != token_username:
+            pr_credit += f"@{author}"
+        if contributors:
+            pr_credit += (" with contributions from " if pr_credit else "") + ", ".join(f"@{c}" for c in contributors)
 
         # Generate personalized comment
-        comment = generate_issue_comment(pr_url=data["url"], pr_summary=pr_summary)
+        comment = generate_issue_comment(pr_url=data["url"], pr_summary=pr_summary, pr_credit=pr_credit)
 
         # Update linked issues
         for issue in data["closingIssuesReferences"]["nodes"]:
             issue_number = issue["number"]
             # Add fixed label
-            label_url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{issue_number}/labels"
-            label_response = requests.post(label_url, json={"labels": ["fixed"]}, headers=GITHUB_HEADERS)
+            label_url = f"{GITHUB_API_URL}/repos/{repository}/issues/{issue_number}/labels"
+            label_response = requests.post(label_url, json={"labels": ["fixed"]}, headers=headers)
 
             # Add comment
-            comment_url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{issue_number}/comments"
-            comment_response = requests.post(comment_url, json={"body": comment}, headers=GITHUB_HEADERS)
+            comment_url = f"{GITHUB_API_URL}/repos/{repository}/issues/{issue_number}/comments"
+            comment_response = requests.post(comment_url, json={"body": comment}, headers=headers)
 
             if label_response.status_code == 200 and comment_response.status_code == 201:
                 print(f"Added 'fixed' label and comment to issue #{issue_number}")
@@ -192,50 +195,49 @@ query($owner: String!, $repo: String!, $pr_number: Int!) {
                     f"Comment status: {comment_response.status_code}"
                 )
 
-        return contributors, author
+        return pr_credit
     except KeyError as e:
         print(f"Error parsing GraphQL response: {e}")
         return [], None
 
 
-def remove_todos_on_merge(pr_number):
+def remove_todos_on_merge(pr_number, repository, headers):
     """Removes specified labels from PR."""
     for label in ["TODO"]:  # Can be extended with more labels in the future
-        requests.delete(
-            f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{pr_number}/labels/{label}", headers=GITHUB_HEADERS
-        )
+        requests.delete(f"{GITHUB_API_URL}/repos/{repository}/issues/{pr_number}/labels/{label}", headers=headers)
 
 
-def main():
+def main(*args, **kwargs):
     """Summarize a pull request and update its description with a summary."""
-    pr_number = PR["number"]
+    action = Action(*args, **kwargs)
+    pr_number = action.pr["number"]
+    headers = action.headers
+    repository = action.repository
 
     print(f"Retrieving diff for PR {pr_number}")
-    diff = get_pr_diff(pr_number)
+    diff = action.get_pr_diff()
 
     # Generate PR summary
     print("Generating PR summary...")
-    summary = generate_pr_summary(GITHUB_REPOSITORY, diff)
+    summary = generate_pr_summary(repository, diff)
 
     # Update PR description
     print("Updating PR description...")
-    status_code = update_pr_description(GITHUB_REPOSITORY, pr_number, summary)
+    status_code = update_pr_description(repository, pr_number, summary, headers)
     if status_code == 200:
         print("PR description updated successfully.")
     else:
         print(f"Failed to update PR description. Status code: {status_code}")
 
     # Update linked issues and post thank you message if merged
-    if PR.get("merged"):
+    if action.pr.get("merged"):
         print("PR is merged, labeling fixed issues...")
-        contributors, author = label_fixed_issues(pr_number, summary)
+        pr_credit = label_fixed_issues(repository, pr_number, summary, headers, action)
         print("Removing TODO label from PR...")
-        remove_todos_on_merge(pr_number)
-        username = get_github_username()  # get GITHUB_TOKEN username
-        if author and author != username:
+        remove_todos_on_merge(pr_number, repository, headers)
+        if pr_credit:
             print("Posting PR author thank you message...")
-            contributors.discard(username)
-            post_merge_message(pr_number, author, contributors, summary)
+            post_merge_message(pr_number, repository, summary, pr_credit, headers)
 
 
 if __name__ == "__main__":

{ultralytics_actions-0.0.30 → ultralytics_actions-0.0.34}/actions/summarize_release.py

@@ -10,10 +10,7 @@ import requests
 
 from .utils import (
     GITHUB_API_URL,
-    GITHUB_HEADERS,
-    GITHUB_HEADERS_DIFF,
-    GITHUB_REPOSITORY,
-    GITHUB_TOKEN,
+    Action,
     get_completion,
     remove_html_comments,
 )
@@ -23,17 +20,17 @@ 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:
+def get_release_diff(repo_name: str, previous_tag: str, latest_tag: str, headers: dict) -> str:
     """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)
+    r = requests.get(url, headers=headers)
     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:
+def get_prs_between_tags(repo_name: str, previous_tag: str, latest_tag: str, headers: dict) -> list:
     """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 = requests.get(url, headers=headers)
     r.raise_for_status()
 
     data = r.json()
@@ -47,7 +44,7 @@ def get_prs_between_tags(repo_name: str, previous_tag: str, latest_tag: str) ->
     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)
+        pr_response = requests.get(pr_url, headers=headers)
         if pr_response.status_code == 200:
             pr_data = pr_response.json()
             prs.append(
@@ -67,14 +64,14 @@ def get_prs_between_tags(repo_name: str, previous_tag: str, latest_tag: str) ->
     return prs
 
 
-def get_new_contributors(repo: str, prs: list) -> set:
+def get_new_contributors(repo: str, prs: list, headers: dict) -> set:
     """Identify new contributors who made their first merged PR 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)
+        r = requests.get(url, headers=headers)
         if r.status_code == 200:
             data = r.json()
             if data["total_count"] > 0:
@@ -84,7 +81,9 @@ def get_new_contributors(repo: str, prs: list) -> set:
     return new_contributors
 
 
-def generate_release_summary(diff: str, prs: list, latest_tag: str, previous_tag: str, repo_name: str) -> str:
+def generate_release_summary(
+    diff: str, prs: list, latest_tag: str, previous_tag: str, repo_name: str, headers: dict
+) -> str:
     """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]
@@ -100,7 +99,7 @@ def generate_release_summary(diff: str, prs: list, latest_tag: str, previous_tag
     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 = get_new_contributors(repo_name, prs, headers)
     new_contributors_section = (
         "\n## New Contributors\n"
         + "\n".join(
@@ -138,11 +137,11 @@ def generate_release_summary(diff: str, prs: list, latest_tag: str, previous_tag
     return get_completion(messages) + release_suffix
 
 
-def create_github_release(repo_name: str, tag_name: str, name: str, body: str) -> int:
+def create_github_release(repo_name: str, tag_name: str, name: str, body: str, headers: dict) -> int:
     """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)
+    r = requests.post(url, headers=headers, json=data)
     return r.status_code
 
 
@@ -156,22 +155,24 @@ def get_previous_tag() -> str:
         return "HEAD~1"
 
 
-def main():
+def main(*args, **kwargs):
     """Automates generating and publishing a GitHub release summary from PRs and commit differences."""
-    if not all([GITHUB_TOKEN, CURRENT_TAG]):
+    action = Action(*args, **kwargs)
+
+    if not all([action.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(GITHUB_REPOSITORY, previous_tag, CURRENT_TAG)
+    diff = get_release_diff(action.repository, previous_tag, CURRENT_TAG, action.headers_diff)
 
     # Get PRs merged between the tags
-    prs = get_prs_between_tags(GITHUB_REPOSITORY, previous_tag, CURRENT_TAG)
+    prs = get_prs_between_tags(action.repository, previous_tag, CURRENT_TAG, action.headers)
 
     # Generate release summary
     try:
-        summary = generate_release_summary(diff, prs, CURRENT_TAG, previous_tag, GITHUB_REPOSITORY)
+        summary = generate_release_summary(diff, prs, CURRENT_TAG, previous_tag, action.repository, action.headers)
     except Exception as e:
         print(f"Failed to generate summary: {str(e)}")
         summary = "Failed to generate summary."
@@ -181,7 +182,8 @@ 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(GITHUB_REPOSITORY, CURRENT_TAG, f"{CURRENT_TAG} - {commit_message}", summary)
+    msg = f"{CURRENT_TAG} - {commit_message}"
+    status_code = create_github_release(action.repository, CURRENT_TAG, msg, summary, action.headers)
     if status_code == 201:
         print(f"Successfully created release {CURRENT_TAG}")
     else:

ultralytics_actions-0.0.34/actions/utils/__init__.py

@@ -0,0 +1,19 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+from .common_utils import remove_html_comments
+from .github_utils import (
+    GITHUB_API_URL,
+    Action,
+    check_pypi_version,
+    ultralytics_actions_info,
+)
+from .openai_utils import get_completion
+
+__all__ = (
+    "GITHUB_API_URL",
+    "Action",
+    "check_pypi_version",
+    "get_completion",
+    "remove_html_comments",
+    "ultralytics_actions_info",
+)

ultralytics_actions-0.0.34/actions/utils/github_utils.py

@@ -0,0 +1,163 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+import json
+import os
+from pathlib import Path
+
+import requests
+
+from actions import __version__
+
+GITHUB_API_URL = "https://api.github.com"
+
+
+class Action:
+    """Handles GitHub Actions API interactions and event processing."""
+
+    def __init__(
+        self,
+        token: str = None,
+        event_name: str = None,
+        event_data: dict = None,
+    ):
+        self.token = token or os.getenv("GITHUB_TOKEN")
+        self.event_name = event_name or os.getenv("GITHUB_EVENT_NAME")
+        self.event_data = event_data or self._load_event_data(os.getenv("GITHUB_EVENT_PATH"))
+
+        self.pr = self.event_data.get("pull_request", {})
+        self.repository = self.event_data.get("repository", {}).get("full_name")
+        self.headers = {"Authorization": f"token {self.token}", "Accept": "application/vnd.github.v3+json"}
+        self.headers_diff = {"Authorization": f"token {self.token}", "Accept": "application/vnd.github.v3.diff"}
+
+    @staticmethod
+    def _load_event_data(event_path: str) -> dict:
+        """Loads GitHub event data from path if it exists."""
+        if event_path and Path(event_path).exists():
+            return json.loads(Path(event_path).read_text())
+        return {}
+
+    def get_username(self) -> str | None:
+        """Gets username associated with the GitHub token."""
+        query = "query { viewer { login } }"
+        response = requests.post(f"{GITHUB_API_URL}/graphql", json={"query": query}, headers=self.headers)
+        if response.status_code != 200:
+            print(f"Failed to fetch authenticated user. Status code: {response.status_code}")
+            return None
+        try:
+            return response.json()["data"]["viewer"]["login"]
+        except KeyError as e:
+            print(f"Error parsing authenticated user response: {e}")
+            return None
+
+    def get_pr_diff(self) -> str:
+        """Retrieves the diff content for a specified pull request."""
+        url = f"{GITHUB_API_URL}/repos/{self.repository}/pulls/{self.pr.get('number')}"
+        r = requests.get(url, headers=self.headers_diff)
+        return r.text if r.status_code == 200 else ""
+
+    def get_repo_data(self, endpoint: str) -> dict:
+        """Fetches repository data from a specified endpoint."""
+        r = requests.get(f"{GITHUB_API_URL}/repos/{self.repository}/{endpoint}", headers=self.headers)
+        r.raise_for_status()
+        return r.json()
+
+    def graphql_request(self, query: str, variables: dict = None) -> dict:
+        """Executes a GraphQL query against the GitHub API."""
+        headers = {
+            "Authorization": f"Bearer {self.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 'Failed'} discussion GraphQL request: {result.get('errors', 'No errors')}"
+        )
+        return result
+
+    def print_info(self):
+        """Print GitHub Actions information."""
+        info = {
+            "github.event_name": self.event_name,
+            "github.event.action": self.event_data.get("action"),
+            "github.repository": self.repository,
+            "github.event.pull_request.number": self.pr.get("number"),
+            "github.event.pull_request.head.repo.full_name": self.pr.get("head", {}).get("repo", {}).get("full_name"),
+            "github.actor": os.environ.get("GITHUB_ACTOR"),
+            "github.event.pull_request.head.ref": self.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"),
+            "github.base_sha": self.pr.get("base", {}).get("sha"),
+        }
+
+        if self.event_name == "discussion":
+            discussion = self.event_data.get("discussion", {})
+            info.update(
+                {
+                    "github.event.discussion.node_id": discussion.get("node_id"),
+                    "github.event.discussion.number": discussion.get("number"),
+                }
+            )
+
+        max_key_length = max(len(key) for key in info)
+        header = f"Ultralytics Actions {__version__} Information " + "-" * 40
+        print(header)
+        for key, value in info.items():
+            print(f"{key:<{max_key_length + 5}}{value}")
+        print("-" * len(header))
+
+
+def ultralytics_actions_info():
+    Action().print_info()
+
+
+def check_pypi_version(pyproject_toml="pyproject.toml"):
+    """Compares local and PyPI package versions to determine if a new version should be published."""
+    import re
+
+    import tomllib  # requires Python>=3.11
+
+    version_pattern = re.compile(r"^\d+\.\d+\.\d+$")  # e.g. 0.0.0
+
+    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}")
+    if not bool(version_pattern.match(local_version)):
+        print("WARNING: Incorrect local version pattern")
+        return "0.0.0", "0.0.0", False
+
+    # 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

{ultralytics_actions-0.0.30 → ultralytics_actions-0.0.34}/actions/utils/openai_utils.py

@@ -1,7 +1,7 @@
 # Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
 
 import os
-import random
+import time
 from typing import Dict, List
 
 import requests
@@ -25,7 +25,7 @@ def get_completion(
     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)}
+        data = {"model": OPENAI_MODEL, "messages": messages, "seed": int(time.time() * 1000)}
 
         r = requests.post(url, headers=headers, json=data)
         r.raise_for_status()

{ultralytics_actions-0.0.30 → ultralytics_actions-0.0.34}/pyproject.toml

@@ -95,3 +95,16 @@ packages = { find = { where = ["."], include = ["actions", "actions.*"] } }
 
 [tool.setuptools.dynamic]
 version = { attr = "actions.__version__" }
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.docformatter]
+wrap-summaries = 120
+wrap-descriptions = 120
+pre-summary-newline = true
+close-quotes-on-newline = true
+in-place = true

{ultralytics_actions-0.0.30 → ultralytics_actions-0.0.34}/ultralytics_actions.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics-actions
-Version: 0.0.30
+Version: 0.0.34
 Summary: Ultralytics Actions for GitHub automation and PR management.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>

ultralytics_actions-0.0.30/actions/utils/__init__.py

@@ -1,45 +0,0 @@
-# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
-
-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,
-    check_pypi_version,
-    get_github_data,
-    get_github_username,
-    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",
-    "GITHUB_REPOSITORY",
-    "PR",
-    "DISCUSSION",
-    "GITHUB_EVENT_NAME",
-    "GITHUB_EVENT_PATH",
-    "get_github_data",
-    "get_pr_diff",
-    "graphql_request",
-    "OPENAI_API_KEY",
-    "OPENAI_MODEL",
-    "get_completion",
-    "get_github_username",
-    "check_pypi_version",
-    "ultralytics_actions_info",
-)

ultralytics_actions-0.0.30/actions/utils/github_utils.py

@@ -1,157 +0,0 @@
-# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
-import json
-import os
-from pathlib import Path
-
-import requests
-
-from actions import __version__
-
-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"}
-
-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", {})
-
-
-def get_github_username():
-    """Gets username associated with the GitHub token in GITHUB_HEADERS."""
-    query = """
-    query {
-        viewer {
-            login
-        }
-    }
-    """
-    response = requests.post("https://api.github.com/graphql", json={"query": query}, headers=GITHUB_HEADERS)
-    if response.status_code != 200:
-        print(f"Failed to fetch authenticated user. Status code: {response.status_code}")
-        return None
-
-    try:
-        return response.json()["data"]["viewer"]["login"]
-    except KeyError as e:
-        print(f"Error parsing authenticated user response: {e}")
-        return None
-
-
-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/{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/{GITHUB_REPOSITORY}/{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
-
-
-def check_pypi_version(pyproject_toml="pyproject.toml"):
-    """Compares local and PyPI package versions to determine if a new version should be published."""
-    import re
-
-    import tomllib  # requires Python>=3.11
-
-    version_pattern = re.compile(r"^\d+\.\d+\.\d+$")  # e.g. 0.0.0
-
-    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}")
-    if not bool(version_pattern.match(local_version)):
-        print("WARNING: Incorrect local version pattern")
-        return "0.0.0", "0.0.0", False
-
-    # 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"),
-        "github.base_sha": PR.get("base", {}).get("sha"),
-    }
-
-    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)
-    header = f"Ultralytics Actions {__version__} Information " + "-" * 40
-    print(header)
-    for key, value in info.items():
-        print(f"{key:<{max_key_length + 5}}{value}")
-    print("-" * len(header))  # footer