ultralytics-actions 0.0.69__py3-none-any.whl → 0.0.71__py3-none-any.whl

actions/__init__.py

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

actions/dispatch_actions.py

@@ -0,0 +1,116 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import time
+from datetime import datetime
+from typing import Dict, List
+
+from .utils import GITHUB_API_URL, Action
+
+# Configuration
+RUN_CI_KEYWORD = "@ultralytics/run-ci"  # and then to merge "@ultralytics/run-ci-and-merge"
+WORKFLOW_FILES = ["ci.yml", "docker.yml"]
+
+
+def get_pr_branch(event) -> str:
+    """Gets the PR branch name."""
+    pr_number = event.event_data["issue"]["number"]
+    pr_data = event.get_repo_data(f"pulls/{pr_number}")
+    return pr_data.get("head", {}).get("ref", "main")
+
+
+def trigger_and_get_workflow_info(event, branch: str) -> List[Dict]:
+    """Triggers workflows and returns their information."""
+    repo = event.repository
+    results = []
+
+    # Trigger all workflows
+    for file in WORKFLOW_FILES:
+        event.post(f"{GITHUB_API_URL}/repos/{repo}/actions/workflows/{file}/dispatches", json={"ref": branch})
+
+    # Wait for workflows to be created
+    time.sleep(10)
+
+    # Collect information about all workflows
+    for file in WORKFLOW_FILES:
+        # Get workflow name
+        response = event.get(f"{GITHUB_API_URL}/repos/{repo}/actions/workflows/{file}")
+        name = file.replace(".yml", "").title()
+        if response.status_code == 200:
+            name = response.json().get("name", name)
+
+        # Get run information
+        run_url = f"https://github.com/{repo}/actions/workflows/{file}"
+        run_number = None
+
+        runs_response = event.get(
+            f"{GITHUB_API_URL}/repos/{repo}/actions/workflows/{file}/runs?branch={branch}&event=workflow_dispatch&per_page=1",
+        )
+
+        if runs_response.status_code == 200:
+            runs = runs_response.json().get("workflow_runs", [])
+            if runs:
+                run_url = runs[0].get("html_url", run_url)
+                run_number = runs[0].get("run_number")
+
+        results.append({"name": name, "file": file, "url": run_url, "run_number": run_number})
+
+    return results
+
+
+def update_comment(event, comment_body: str, triggered_actions: List[Dict], branch: str) -> bool:
+    """Updates the comment with workflow information."""
+    if not triggered_actions:
+        return False
+
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S UTC")
+    summary = (
+        f"\n\n## ⚡ Actions Trigger\n\n"
+        f"<sub>Made with ❤️ by [Ultralytics Actions](https://www.ultralytics.com/actions)<sub>\n\n"
+        f"GitHub Actions below triggered via workflow dispatch on this "
+        f"PR branch `{branch}` at {timestamp} with `{RUN_CI_KEYWORD}` command:\n\n"
+    )
+
+    for action in triggered_actions:
+        run_info = f" run {action['run_number']}" if action["run_number"] else ""
+        summary += f"* ✅ [{action['name']}]({action['url']}): `{action['file']}`{run_info}\n"
+
+    new_body = comment_body.replace(RUN_CI_KEYWORD, summary).strip()
+    comment_id = event.event_data["comment"]["id"]
+    event.patch(f"{GITHUB_API_URL}/repos/{event.repository}/issues/comments/{comment_id}", json={"body": new_body})
+
+
+def main(*args, **kwargs):
+    """Handles triggering workflows from PR comments."""
+    event = Action(*args, **kwargs)
+
+    # Only process new comments on PRs
+    if (
+        event.event_name != "issue_comment"
+        or "pull_request" not in event.event_data.get("issue", {})
+        or event.event_data.get("action") != "created"
+    ):
+        return
+
+    # Get comment info
+    comment_body = event.event_data["comment"].get("body", "")
+    username = event.event_data["comment"]["user"]["login"]
+
+    # Check for keyword without surrounding backticks to avoid triggering on replies
+    has_keyword = RUN_CI_KEYWORD in comment_body and comment_body.count(RUN_CI_KEYWORD) > comment_body.count(
+        f"`{RUN_CI_KEYWORD}`"
+    )
+    if not has_keyword or not event.is_org_member(username):
+        return
+
+    # Get branch, trigger workflows, and update comment
+    event.toggle_eyes_reaction(True)
+    branch = get_pr_branch(event)
+    print(f"Triggering workflows on branch: {branch}")
+
+    triggered_actions = trigger_and_get_workflow_info(event, branch)
+    update_comment(event, comment_body, triggered_actions, branch)
+    event.toggle_eyes_reaction(False)
+
+
+if __name__ == "__main__":
+    main()

actions/first_interaction.py

@@ -3,14 +3,7 @@
 import os
 from typing import Dict, List, Tuple
 
-import requests
-
-from .utils import (
-    GITHUB_API_URL,
-    Action,
-    get_completion,
-    remove_html_comments,
-)
+from .utils import GITHUB_API_URL, Action, get_completion, remove_html_comments
 
 # Environment variables
 BLOCK_USER = os.getenv("BLOCK_USER", "false").lower() == "true"
@@ -67,8 +60,7 @@ mutation($discussionId: ID!, $title: String!, $body: String!) {
         event.graphql_request(mutation, variables={"discussionId": node_id, "title": new_title, "body": new_body})
     else:
         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}")
+        event.patch(url, json={"title": new_title, "body": new_body})
 
 
 def close_issue_pr(event, number: int, node_id: str, issue_type: str):
@@ -86,8 +78,7 @@ mutation($discussionId: ID!) {
         event.graphql_request(mutation, variables={"discussionId": node_id})
     else:
         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}")
+        event.patch(url, json={"state": "closed"})
 
 
 def lock_issue_pr(event, number: int, node_id: str, issue_type: str):
@@ -107,15 +98,13 @@ mutation($lockableId: ID!, $lockReason: LockReason) {
         event.graphql_request(mutation, variables={"lockableId": node_id, "lockReason": "OFF_TOPIC"})
     else:
         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}")
+        event.put(url, json={"lock_reason": "off-topic"})
 
 
 def block_user(event, username: str):
     """Blocks a user from the organization using the GitHub API."""
     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}")
+    event.put(url)
 
 
 def get_relevant_labels(
@@ -169,7 +158,6 @@ AVAILABLE LABELS:
 
 YOUR RESPONSE (label names only):
 """
-    print(prompt)  # for short-term debugging
     messages = [
         {
             "role": "system",
@@ -210,7 +198,6 @@ query($owner: String!, $name: String!) {
         label_map = {label["name"].lower(): label["id"] for label in all_labels}
         return [label_map.get(label.lower()) for label in labels if label.lower() in label_map]
     else:
-        print(f"Failed to fetch labels: {result.get('errors', 'Unknown error')}")
         return []
 
 
@@ -220,7 +207,6 @@ def apply_labels(event, number: int, node_id: str, labels: List[str], issue_type
         create_alert_label(event)
 
     if issue_type == "discussion":
-        print(f"Using node_id: {node_id}")  # Debug print
         label_ids = get_label_ids(event, labels)
         if not label_ids:
             print("No valid labels to apply.")
@@ -238,25 +224,15 @@ mutation($labelableId: ID!, $labelIds: [ID!]!) {
 }
 """
         event.graphql_request(mutation, {"labelableId": node_id, "labelIds": label_ids})
-        print(f"Successfully applied labels: {', '.join(labels)}")
     else:
         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}")
+        event.post(url, json={"labels": labels})
 
 
 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/{event.repository}/labels", json=alert_label, headers=event.headers)
-
-
-def is_org_member(event, username: str) -> bool:
-    """Checks if a user is a member of the organization using the GitHub API."""
-    org_name = event.repository.split("/")[0]
-    url = f"{GITHUB_API_URL}/orgs/{org_name}/members/{username}"
-    r = requests.get(url, headers=event.headers)
-    return r.status_code == 204  # 204 means the user is a member
+    event.post(f"{GITHUB_API_URL}/repos/{event.repository}/labels", json=alert_label)
 
 
 def add_comment(event, number: int, node_id: str, comment: str, issue_type: str):
@@ -274,8 +250,7 @@ mutation($discussionId: ID!, $body: String!) {
         event.graphql_request(mutation, variables={"discussionId": node_id, "body": comment})
     else:
         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}")
+        event.post(url, json={"body": comment}, headers=event.headers)
 
 
 def get_first_interaction_response(event, issue_type: str, title: str, body: str, username: str) -> str:
@@ -361,7 +336,7 @@ EXAMPLE {issue_type.upper()} RESPONSE:
 
 YOUR {issue_type.upper()} RESPONSE:
 """
-    print(f"\n\n{prompt}\n\n")  # for debug
+    # print(f"\n\n{prompt}\n\n")  # for debug
     messages = [
         {
             "role": "system",
@@ -384,7 +359,7 @@ def main(*args, **kwargs):
         current_labels = [label["name"].lower() for label in event.get_repo_data(f"issues/{number}/labels")]
     if relevant_labels := get_relevant_labels(issue_type, title, body, label_descriptions, current_labels):
         apply_labels(event, number, node_id, relevant_labels, issue_type)
-        if "Alert" in relevant_labels and not is_org_member(event, username):
+        if "Alert" in relevant_labels and not event.is_org_member(username):
             update_issue_pr_content(event, number, node_id, issue_type)
             if issue_type != "pull request":
                 close_issue_pr(event, number, node_id, issue_type)

actions/summarize_pr.py

@@ -2,13 +2,7 @@
 
 import time
 
-import requests
-
-from .utils import (
-    GITHUB_API_URL,
-    Action,
-    get_completion,
-)
+from .utils import GITHUB_API_URL, GITHUB_GRAPHQL_URL, Action, get_completion
 
 # Constants
 SUMMARY_START = (
@@ -36,12 +30,12 @@ def generate_merge_message(pr_summary=None, pr_credit=None, pr_url=None):
     return get_completion(messages)
 
 
-def post_merge_message(pr_number, pr_url, repository, summary, pr_credit, headers):
+def post_merge_message(event, summary, pr_credit):
     """Posts thank you message on PR after merge."""
+    pr_url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{event.pr['number']}"
+    comment_url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{event.pr['number']}/comments"
     message = generate_merge_message(summary, pr_credit, pr_url)
-    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
+    event.post(comment_url, json={"body": message})
 
 
 def generate_issue_comment(pr_url, pr_summary, pr_credit, pr_title=""):
@@ -101,11 +95,12 @@ def generate_pr_summary(repository, diff_text):
     return SUMMARY_START + reply
 
 
-def update_pr_description(pr_url, new_summary, headers, max_retries=2):
+def update_pr_description(event, new_summary, max_retries=2):
     """Updates PR description with new summary, retrying if description is None."""
     description = ""
+    url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{event.pr['number']}"
     for i in range(max_retries + 1):
-        description = requests.get(pr_url, headers=headers).json().get("body") or ""
+        description = event.get(url).json().get("body") or ""
         if description:
             break
         if i < max_retries:
@@ -122,11 +117,10 @@ def update_pr_description(pr_url, new_summary, headers, 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=headers)
-    return update_response.status_code
+    event.patch(url, json={"body": updated_description})
 
 
-def label_fixed_issues(repository, pr_number, pr_summary, headers, action):
+def label_fixed_issues(event, pr_summary):
     """Labels issues closed by PR when merged, notifies users, and returns PR contributors."""
     query = """
 query($owner: String!, $repo: String!, $pr_number: Int!) {
@@ -144,19 +138,16 @@ query($owner: String!, $repo: String!, $pr_number: Int!) {
     }
 }
 """
-    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=headers)
-
+    owner, repo = event.repository.split("/")
+    variables = {"owner": owner, "repo": repo, "pr_number": event.pr["number"]}
+    response = event.post(GITHUB_GRAPHQL_URL, json={"query": query, "variables": variables})
     if response.status_code != 200:
-        print(f"Failed to fetch linked issues. Status code: {response.status_code}")
-        return None
+        return None  # no linked issues
 
     try:
         data = response.json()["data"]["repository"]["pullRequest"]
         comments = data["reviews"]["nodes"] + data["comments"]["nodes"]
-        token_username = action.get_username()  # get GITHUB_TOKEN username
+        token_username = event.get_username()  # get GITHUB_TOKEN username
         author = data["author"]["login"] if data["author"]["__typename"] != "Bot" else None
         pr_title = data.get("title", "")
 
@@ -188,22 +179,12 @@ query($owner: String!, $repo: String!, $pr_number: Int!) {
 
         # Update linked issues
         for issue in data["closingIssuesReferences"]["nodes"]:
-            issue_number = issue["number"]
+            number = issue["number"]
             # Add fixed label
-            label_url = f"{GITHUB_API_URL}/repos/{repository}/issues/{issue_number}/labels"
-            label_response = requests.post(label_url, json={"labels": ["fixed"]}, headers=headers)
+            event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/labels", json={"labels": ["fixed"]})
 
             # Add comment
-            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}")
-            else:
-                print(
-                    f"Failed to update issue #{issue_number}. Label status: {label_response.status_code}, "
-                    f"Comment status: {comment_response.status_code}"
-                )
+            event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/comments", json={"body": comment})
 
         return pr_credit
     except KeyError as e:
@@ -211,44 +192,36 @@ query($owner: String!, $repo: String!, $pr_number: Int!) {
         return None
 
 
-def remove_todos_on_merge(pr_number, repository, headers):
+def remove_pr_labels(event, labels=()):
     """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/{repository}/issues/{pr_number}/labels/{label}", headers=headers)
+    for label in labels:  # Can be extended with more labels in the future
+        event.delete(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{event.pr['number']}/labels/{label}")
 
 
 def main(*args, **kwargs):
     """Summarize a pull request and update its description with a summary."""
-    action = Action(*args, **kwargs)
-    headers = action.headers
-    repository = action.repository
-    pr_number = action.pr["number"]
-    pr_url = f"{GITHUB_API_URL}/repos/{repository}/pulls/{pr_number}"
+    event = Action(*args, **kwargs)
 
-    print(f"Retrieving diff for PR {pr_number}")
-    diff = action.get_pr_diff()
+    print(f"Retrieving diff for PR {event.pr['number']}")
+    diff = event.get_pr_diff()
 
     # Generate PR summary
     print("Generating PR summary...")
-    summary = generate_pr_summary(repository, diff)
+    summary = generate_pr_summary(event.repository, diff)
 
     # Update PR description
     print("Updating PR description...")
-    status_code = update_pr_description(pr_url, summary, headers)
-    if status_code == 200:
-        print("PR description updated successfully.")
-    else:
-        print(f"Failed to update PR description. Status code: {status_code}")
+    update_pr_description(event, summary)
 
     # Update linked issues and post thank you message if merged
-    if action.pr.get("merged"):
+    if event.pr.get("merged"):
         print("PR is merged, labeling fixed issues...")
-        pr_credit = label_fixed_issues(repository, pr_number, summary, headers, action)
+        pr_credit = label_fixed_issues(event, summary)
         print("Removing TODO label from PR...")
-        remove_todos_on_merge(pr_number, repository, headers)
+        remove_pr_labels(event, labels=["TODO"])
         if pr_credit:
             print("Posting PR author thank you message...")
-            post_merge_message(pr_number, pr_url, repository, summary, pr_credit, headers)
+            post_merge_message(event, summary, pr_credit)
 
 
 if __name__ == "__main__":

actions/summarize_release.py

@@ -6,36 +6,27 @@ import subprocess
 import time
 from datetime import datetime
 
-import requests
-
-from .utils import (
-    GITHUB_API_URL,
-    Action,
-    get_completion,
-    remove_html_comments,
-)
+from .utils import GITHUB_API_URL, Action, get_completion, remove_html_comments
 
 # Environment variables
 CURRENT_TAG = os.getenv("CURRENT_TAG")
 PREVIOUS_TAG = os.getenv("PREVIOUS_TAG")
 
 
-def get_release_diff(repo_name: str, previous_tag: str, latest_tag: str, headers: dict) -> str:
+def get_release_diff(event, previous_tag: str, latest_tag: str) -> 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=headers)
+    url = f"{GITHUB_API_URL}/repos/{event.repository}/compare/{previous_tag}...{latest_tag}"
+    r = event.get(url, headers=event.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, headers: dict) -> list:
+def get_prs_between_tags(event, previous_tag: str, latest_tag: str) -> 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=headers)
-    r.raise_for_status()
+    url = f"{GITHUB_API_URL}/repos/{event.repository}/compare/{previous_tag}...{latest_tag}"
+    r = event.get(url)
 
     data = r.json()
     pr_numbers = set()
-
     for commit in data["commits"]:
         pr_matches = re.findall(r"#(\d+)", commit["commit"]["message"])
         pr_numbers.update(pr_matches)
@@ -43,8 +34,8 @@ def get_prs_between_tags(repo_name: str, previous_tag: str, latest_tag: str, hea
     prs = []
     time.sleep(10)  # sleep 10 seconds to allow final PR summary to update on merge
     for pr_number in sorted(pr_numbers):  # earliest to latest
-        pr_url = f"{GITHUB_API_URL}/repos/{repo_name}/pulls/{pr_number}"
-        pr_response = requests.get(pr_url, headers=headers)
+        pr_url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{pr_number}"
+        pr_response = event.get(pr_url)
         if pr_response.status_code == 200:
             pr_data = pr_response.json()
             prs.append(
@@ -64,14 +55,14 @@ def get_prs_between_tags(repo_name: str, previous_tag: str, latest_tag: str, hea
     return prs
 
 
-def get_new_contributors(repo: str, prs: list, headers: dict) -> set:
+def get_new_contributors(event, prs: list) -> 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=headers)
+        url = f"{GITHUB_API_URL}/search/issues?q=repo:{event.repository}+author:{author}+is:pr+is:merged&sort=created&order=asc"
+        r = event.get(url)
         if r.status_code == 200:
             data = r.json()
             if data["total_count"] > 0:
@@ -82,7 +73,11 @@ def get_new_contributors(repo: str, prs: list, headers: dict) -> set:
 
 
 def generate_release_summary(
-    diff: str, prs: list, latest_tag: str, previous_tag: str, repo_name: str, headers: dict
+    event,
+    diff: str,
+    prs: list,
+    latest_tag: str,
+    previous_tag: str,
 ) -> str:
     """Generate a concise release summary with key changes, purpose, and impact for a new Ultralytics version."""
     pr_summaries = "\n\n".join(
@@ -99,7 +94,7 @@ def generate_release_summary(
     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, headers)
+    new_contributors = get_new_contributors(event, prs)
     new_contributors_section = (
         "\n## New Contributors\n"
         + "\n".join(
@@ -112,7 +107,7 @@ def generate_release_summary(
         else ""
     )
 
-    full_changelog = f"https://github.com/{repo_name}/compare/{previous_tag}...{latest_tag}"
+    full_changelog = f"https://github.com/{event.repository}/compare/{previous_tag}...{latest_tag}"
     release_suffix = (
         f"\n\n## What's Changed\n{whats_changed}\n{new_contributors_section}\n\n**Full Changelog**: {full_changelog}\n"
     )
@@ -133,16 +128,15 @@ def generate_release_summary(
             f"Here's the release diff:\n\n{diff[:300000]}",
         },
     ]
-    print(messages[-1]["content"])  # for debug
+    # print(messages[-1]["content"])  # for debug
     return get_completion(messages, temperature=0.2) + release_suffix
 
 
-def create_github_release(repo_name: str, tag_name: str, name: str, body: str, headers: dict) -> int:
+def create_github_release(event, tag_name: str, name: str, body: str):
     """Creates a GitHub release with specified tag, name, and body content for the given repository."""
-    url = f"{GITHUB_API_URL}/repos/{repo_name}/releases"
+    url = f"{GITHUB_API_URL}/repos/{event.repository}/releases"
     data = {"tag_name": tag_name, "name": name, "body": body, "draft": False, "prerelease": False}
-    r = requests.post(url, headers=headers, json=data)
-    return r.status_code
+    event.post(url, json=data)
 
 
 def get_previous_tag() -> str:
@@ -157,22 +151,22 @@ def get_previous_tag() -> str:
 
 def main(*args, **kwargs):
     """Automates generating and publishing a GitHub release summary from PRs and commit differences."""
-    action = Action(*args, **kwargs)
+    event = Action(*args, **kwargs)
 
-    if not all([action.token, CURRENT_TAG]):
+    if not all([event.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(action.repository, previous_tag, CURRENT_TAG, action.headers_diff)
+    diff = get_release_diff(event, previous_tag, CURRENT_TAG)
 
     # Get PRs merged between the tags
-    prs = get_prs_between_tags(action.repository, previous_tag, CURRENT_TAG, action.headers)
+    prs = get_prs_between_tags(event, previous_tag, CURRENT_TAG)
 
     # Generate release summary
     try:
-        summary = generate_release_summary(diff, prs, CURRENT_TAG, previous_tag, action.repository, action.headers)
+        summary = generate_release_summary(event, diff, prs, CURRENT_TAG, previous_tag)
     except Exception as e:
         print(f"Failed to generate summary: {str(e)}")
         summary = "Failed to generate summary."
@@ -183,11 +177,7 @@ def main(*args, **kwargs):
 
     # Create the release on GitHub
     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:
-        print(f"Failed to create release {CURRENT_TAG}. Status code: {status_code}")
+    create_github_release(event, CURRENT_TAG, msg, summary)
 
 
 if __name__ == "__main__":

actions/utils/__init__.py

@@ -8,11 +8,12 @@ from .common_utils import (
     allow_redirect,
     remove_html_comments,
 )
-from .github_utils import GITHUB_API_URL, Action, check_pypi_version, ultralytics_actions_info
+from .github_utils import GITHUB_API_URL, GITHUB_GRAPHQL_URL, Action, check_pypi_version, ultralytics_actions_info
 from .openai_utils import get_completion
 
 __all__ = (
     "GITHUB_API_URL",
+    "GITHUB_GRAPHQL_URL",
     "REQUESTS_HEADERS",
     "URL_IGNORE_LIST",
     "REDIRECT_START_IGNORE_LIST",

actions/utils/common_utils.py

@@ -36,6 +36,15 @@ BAD_HTTP_CODES = frozenset(
         525,  # Cloudfare handshake error
     }
 )
+
+URL_ERROR_LIST = {  # automatically reject these URLs (important: replace spaces with '%20')
+    "https://blog.research.google/search/label/Spam%20and%20Abuse",
+    "https://blog.research.google/search/label/Adversarial%20Attacks",
+    "https://www.microsoft.com/en-us/security/business/ai-machine-learning-security",
+    "https://about.netflix.com/en/news/netflix-recommendations-beyond-the-5-stars-part-1",
+    "https://about.netflix.com/en/news/netflix-research-recommendations",
+}
+
 URL_IGNORE_LIST = {  # use a set (not frozenset) to update with possible private GitHub repos
     "localhost",
     "127.0.0",
@@ -51,10 +60,11 @@ URL_IGNORE_LIST = {  # use a set (not frozenset) to update with possible private
     "mailto:",
     "linkedin.com",
     "twitter.com",
-    "x.com",
+    "https://x.com",  # do not use just 'x' as this will catch other domains like netflix.com
     "storage.googleapis.com",  # private GCS buckets
     "{",  # possible Python fstring
     "(",  # breaks pattern matches
+    ")",
     "api.",  # ignore api endpoints
 }
 REDIRECT_START_IGNORE_LIST = frozenset(
@@ -69,9 +79,14 @@ REDIRECT_START_IGNORE_LIST = frozenset(
         "ultralytics.com/actions",
         "ultralytics.com/bilibili",
         "ultralytics.com/images",
+        "ultralytics.com/license",
+        "ultralytics.com/assets",
         "app.gong.io/call?",
         "docs.openvino.ai",
+        ".git",
+        "/raw/",  # GitHub images
     }
+    | URL_IGNORE_LIST
 )
 REDIRECT_END_IGNORE_LIST = frozenset(
     {
@@ -141,11 +156,10 @@ def brave_search(query, api_key, count=5):
     """Search for alternative URLs using Brave Search API."""
     if not api_key:
         return
-    headers = {"X-Subscription-Token": api_key, "Accept": "application/json"}
     if len(query) > 400:
         print(f"WARNING ⚠️ Brave search query length {len(query)} exceed limit of 400 characters, truncating.")
     url = f"https://api.search.brave.com/res/v1/web/search?q={parse.quote(query.strip()[:400])}&count={count}"
-    response = requests.get(url, headers=headers)
+    response = requests.get(url, headers={"X-Subscription-Token": api_key, "Accept": "application/json"})
     data = response.json() if response.status_code == 200 else {}
     results = data.get("web", {}).get("results", []) if data else []
     return [result.get("url") for result in results if result.get("url")]
@@ -161,7 +175,7 @@ def is_url(url, session=None, check=True, max_attempts=3, timeout=3, return_url=
         # Check structure
         result = parse.urlparse(url)
         partition = result.netloc.partition(".")  # i.e. netloc = "github.com" -> ("github", ".", "com")
-        if not result.scheme or not partition[0] or not partition[2]:
+        if not result.scheme or not partition[0] or not partition[2] or (url in URL_ERROR_LIST):
             return (False, url) if return_url else False
 
         if check:

actions/utils/github_utils.py

@@ -9,6 +9,7 @@ import requests
 from actions import __version__
 
 GITHUB_API_URL = "https://api.github.com"
+GITHUB_GRAPHQL_URL = "https://api.github.com/graphql"
 
 
 class Action:
@@ -19,16 +20,69 @@ class Action:
         token: str = None,
         event_name: str = None,
         event_data: dict = None,
+        verbose: bool = True,
     ):
         """Initializes a GitHub Actions API handler with token and event data for processing events."""
         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._default_status = {
+            "get": [200],
+            "post": [200, 201],
+            "put": [200, 201, 204],
+            "patch": [200],
+            "delete": [200, 204],
+        }
 
         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"}
+        self.headers = {"Authorization": f"Bearer {self.token}", "Accept": "application/vnd.github+json"}
+        self.headers_diff = {"Authorization": f"Bearer {self.token}", "Accept": "application/vnd.github.v3.diff"}
+        self.eyes_reaction_id = None
+        self.verbose = verbose
+
+    def _request(self, method: str, url: str, headers=None, expected_status=None, **kwargs):
+        """Unified request handler with error checking."""
+        headers = headers or self.headers
+        expected_status = expected_status or self._default_status[method.lower()]
+
+        response = getattr(requests, method)(url, headers=headers, **kwargs)
+        status = response.status_code
+        success = status in expected_status
+
+        if self.verbose:
+            print(f"{'✓' if success else '✗'} {method.upper()} {url} → {status}")
+            if not success:
+                try:
+                    error_detail = response.json()
+                    print(f"  Error: {error_detail.get('message', 'Unknown error')}")
+                except:
+                    print(f"  Error: {response.text[:100]}...")
+
+        if not success:
+            response.raise_for_status()
+
+        return response
+
+    def get(self, url, **kwargs):
+        """Performs GET request with error handling."""
+        return self._request("get", url, **kwargs)
+
+    def post(self, url, **kwargs):
+        """Performs POST request with error handling."""
+        return self._request("post", url, **kwargs)
+
+    def put(self, url, **kwargs):
+        """Performs PUT request with error handling."""
+        return self._request("put", url, **kwargs)
+
+    def patch(self, url, **kwargs):
+        """Performs PATCH request with error handling."""
+        return self._request("patch", url, **kwargs)
+
+    def delete(self, url, **kwargs):
+        """Performs DELETE request with error handling."""
+        return self._request("delete", url, **kwargs)
 
     @staticmethod
     def _load_event_data(event_path: str) -> dict:
@@ -39,43 +93,57 @@ class Action:
 
     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
+        response = self.post(GITHUB_GRAPHQL_URL, json={"query": "query { viewer { login } }"})
+        if response.status_code == 200:
+            try:
+                return response.json()["data"]["viewer"]["login"]
+            except KeyError as e:
+                print(f"Error parsing authenticated user response: {e}")
+        return None
+
+    def is_org_member(self, username: str) -> bool:
+        """Checks if a user is a member of the organization using the GitHub API."""
+        org_name = self.repository.split("/")[0]
+        response = self.get(f"{GITHUB_API_URL}/orgs/{org_name}/members/{username}")
+        return response.status_code == 204  # 204 means the user is a member
 
     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 ""
+        response = self.get(url, headers=self.headers_diff)
+        return response.text if response.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()
+        response = self.get(f"{GITHUB_API_URL}/repos/{self.repository}/{endpoint}")
+        return response.json()
+
+    def toggle_eyes_reaction(self, add: bool = True) -> None:
+        """Adds or removes eyes emoji reaction."""
+        if self.event_name in ["pull_request", "pull_request_target"]:
+            id = self.pr.get("number")
+        elif self.event_name == "issue_comment":
+            id = f"comments/{self.event_data.get('comment', {}).get('id')}"
+        else:
+            id = self.event_data.get("issue", {}).get("number")
+        if not id:
+            return
+        url = f"{GITHUB_API_URL}/repos/{self.repository}/issues/{id}/reactions"
+
+        if add:
+            response = self.post(url, json={"content": "eyes"})
+            if response.status_code == 201:
+                self.eyes_reaction_id = response.json().get("id")
+        elif self.eyes_reaction_id:
+            self.delete(f"{url}/{self.eyes_reaction_id}")
+            self.eyes_reaction_id = None
 
     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()
+        r = self.post(GITHUB_GRAPHQL_URL, json={"query": query, "variables": variables})
         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')}"
-        )
+        if "data" not in result or result.get("errors"):
+            print(result.get("errors"))
         return result
 
     def print_info(self):

{ultralytics_actions-0.0.69.dist-info → ultralytics_actions-0.0.71.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics-actions
-Version: 0.0.69
+Version: 0.0.71
 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.71.dist-info/RECORD

@@ -0,0 +1,16 @@
+actions/__init__.py,sha256=KuXt92GxOFYtPimGijr5CdEXsLmxIG4MQWAaAgFd3ew,742
+actions/dispatch_actions.py,sha256=vbA4w_B8vMXMen__ck2WoDsUFCELjXOQbpLzZCmqTXg,4240
+actions/first_interaction.py,sha256=Yagh38abX638DNYr18HoiEEfCZOJfrqObhJIff54Sx0,16350
+actions/summarize_pr.py,sha256=NCaDSbw4PVoRbPJzji_Ua2HadI2pn7QOE_dy3VK9_cc,10463
+actions/summarize_release.py,sha256=OncODHx7XsmB-nPf-B1tnxUTcaJx6hM4JAMa9frypzM,7922
+actions/update_markdown_code_blocks.py,sha256=9PL7YIQfApRNAa0que2hYHv7umGZTZoHlblesB0xFj4,8587
+actions/utils/__init__.py,sha256=TXYvhFgDeAnosePM4jfOrEd6PlC7tWC-WMOgCB_T6Tw,728
+actions/utils/common_utils.py,sha256=2eNwGJFigl9bBXcyWzdr8mr97Lrx7zFKWIFYugZcUJw,11736
+actions/utils/github_utils.py,sha256=bpFMbpzPvtBiqtNvzISFkCp8_7EboMiD3aMA8RG_tTs,9785
+actions/utils/openai_utils.py,sha256=txbsEPQnIOieejatBuE6Yk7xR1fQ0erWOEs6cYgUQX4,2943
+ultralytics_actions-0.0.71.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+ultralytics_actions-0.0.71.dist-info/METADATA,sha256=Q0n2vt5uFAB2167ciNanCwJk86uLv_6sry9l8mKgvNU,10930
+ultralytics_actions-0.0.71.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+ultralytics_actions-0.0.71.dist-info/entry_points.txt,sha256=GowvOFplj0C7JmsjbKcbpgLpdf2r921pcaOQkAHWZRA,378
+ultralytics_actions-0.0.71.dist-info/top_level.txt,sha256=5apM5x80QlJcGbACn1v3fkmIuL1-XQCKcItJre7w7Tw,8
+ultralytics_actions-0.0.71.dist-info/RECORD,,

{ultralytics_actions-0.0.69.dist-info → ultralytics_actions-0.0.71.dist-info}/WHEEL

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

ultralytics_actions-0.0.69.dist-info/RECORD

@@ -1,15 +0,0 @@
-actions/__init__.py,sha256=jfTLYF5qlHNX7JutT_TeZ7oSc5jmqIYB-X87ISRWvzc,742
-actions/first_interaction.py,sha256=1_WvQHCi5RWaSfyi49ClF2Zk_3CKGjFnZqz6FlxPRAc,17868
-actions/summarize_pr.py,sha256=BKttOq-MGaanVaChLU5B1ewKUA8K6S05Cy3FQtyRmxU,11681
-actions/summarize_release.py,sha256=tov6qsYGC68lfobvkwVyoWZBGtJ598G0m097n4Ydzvo,8472
-actions/update_markdown_code_blocks.py,sha256=9PL7YIQfApRNAa0que2hYHv7umGZTZoHlblesB0xFj4,8587
-actions/utils/__init__.py,sha256=ZE0RmC9qOCt9TUhvORd6uVhbxOKVFWJDobR454v55_M,682
-actions/utils/common_utils.py,sha256=YRdEz8qluwzCZfWgqXNmyhKqNhdxNMpoHhGaHUD4AaM,11013
-actions/utils/github_utils.py,sha256=-F--JgxtXE0fSPMFEzakz7iZilp-vonzLiyXfg0b17Y,7117
-actions/utils/openai_utils.py,sha256=txbsEPQnIOieejatBuE6Yk7xR1fQ0erWOEs6cYgUQX4,2943
-ultralytics_actions-0.0.69.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-ultralytics_actions-0.0.69.dist-info/METADATA,sha256=94Bmnj4tirzyhs7DAqvkEvjP0cPg_uIUXSLqlt1_fBI,10930
-ultralytics_actions-0.0.69.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ultralytics_actions-0.0.69.dist-info/entry_points.txt,sha256=GowvOFplj0C7JmsjbKcbpgLpdf2r921pcaOQkAHWZRA,378
-ultralytics_actions-0.0.69.dist-info/top_level.txt,sha256=5apM5x80QlJcGbACn1v3fkmIuL1-XQCKcItJre7w7Tw,8
-ultralytics_actions-0.0.69.dist-info/RECORD,,