ultralytics-actions 0.0.70__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.70"
+__version__ = "0.0.71"

actions/dispatch_actions.py

@@ -4,13 +4,11 @@ import time
 from datetime import datetime
 from typing import Dict, List
 
-import requests
-
-from .utils import GITHUB_API_URL, Action, remove_html_comments
+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 = ["format.yml", "ci.yml", "docker.yml"]
+WORKFLOW_FILES = ["ci.yml", "docker.yml"]
 
 
 def get_pr_branch(event) -> str:
@@ -27,11 +25,7 @@ def trigger_and_get_workflow_info(event, branch: str) -> List[Dict]:
 
     # Trigger all workflows
     for file in WORKFLOW_FILES:
-        requests.post(
-            f"{GITHUB_API_URL}/repos/{repo}/actions/workflows/{file}/dispatches",
-            json={"ref": branch},
-            headers=event.headers,
-        )
+        event.post(f"{GITHUB_API_URL}/repos/{repo}/actions/workflows/{file}/dispatches", json={"ref": branch})
 
     # Wait for workflows to be created
     time.sleep(10)
@@ -39,7 +33,7 @@ def trigger_and_get_workflow_info(event, branch: str) -> List[Dict]:
     # Collect information about all workflows
     for file in WORKFLOW_FILES:
         # Get workflow name
-        response = requests.get(f"{GITHUB_API_URL}/repos/{repo}/actions/workflows/{file}", headers=event.headers)
+        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)
@@ -48,9 +42,8 @@ def trigger_and_get_workflow_info(event, branch: str) -> List[Dict]:
         run_url = f"https://github.com/{repo}/actions/workflows/{file}"
         run_number = None
 
-        runs_response = requests.get(
+        runs_response = event.get(
             f"{GITHUB_API_URL}/repos/{repo}/actions/workflows/{file}/runs?branch={branch}&event=workflow_dispatch&per_page=1",
-            headers=event.headers,
         )
 
         if runs_response.status_code == 200:
@@ -74,7 +67,7 @@ def update_comment(event, comment_body: str, triggered_actions: List[Dict], bran
         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 `@ultralytics/dispatch-actions command`:\n\n"
+        f"PR branch `{branch}` at {timestamp} with `{RUN_CI_KEYWORD}` command:\n\n"
     )
 
     for action in triggered_actions:
@@ -83,14 +76,7 @@ def update_comment(event, comment_body: str, triggered_actions: List[Dict], bran
 
     new_body = comment_body.replace(RUN_CI_KEYWORD, summary).strip()
     comment_id = event.event_data["comment"]["id"]
-
-    response = requests.patch(
-        f"{GITHUB_API_URL}/repos/{event.repository}/issues/comments/{comment_id}",
-        json={"body": new_body},
-        headers=event.headers,
-    )
-
-    return response.status_code == 200
+    event.patch(f"{GITHUB_API_URL}/repos/{event.repository}/issues/comments/{comment_id}", json={"body": new_body})
 
 
 def main(*args, **kwargs):
@@ -106,21 +92,24 @@ def main(*args, **kwargs):
         return
 
     # Get comment info
-    comment_body = remove_html_comments(event.event_data["comment"].get("body", ""))
+    comment_body = event.event_data["comment"].get("body", "")
     username = event.event_data["comment"]["user"]["login"]
 
-    # Check for trigger keyword and permissions
-    if RUN_CI_KEYWORD not in comment_body or not event.is_org_member(username):
+    # 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)
-    success = update_comment(event, comment_body, triggered_actions, branch)
-
-    print(f"Comment update {'succeeded' if success else 'failed'}.")
+    update_comment(event, comment_body, triggered_actions, branch)
+    event.toggle_eyes_reaction(False)
 
 
 if __name__ == "__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

@@ -156,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")]

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,50 +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]
-        url = f"{GITHUB_API_URL}/orgs/{org_name}/members/{username}"
-        r = requests.get(url, headers=self.headers)
-        return r.status_code == 204  # 204 means the user is a member
+        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.70.dist-info → ultralytics_actions-0.0.71.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics-actions
-Version: 0.0.70
+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.70.dist-info → ultralytics_actions-0.0.71.dist-info}/WHEEL

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

ultralytics_actions-0.0.70.dist-info/RECORD

@@ -1,16 +0,0 @@
-actions/__init__.py,sha256=jkNfCMkrM58RMv6ijJXC4tASCnP7q1VvKsh1yKtLQn4,742
-actions/dispatch_actions.py,sha256=plfDaFdfBPldqI1uUQPfgSeIDaRTKbkzkXnsYbGkmwI,4415
-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=BCqB2noJRXxXLAH8rmZ7c4ss1WjFXDC9OPPPFX5OuRU,11758
-actions/utils/github_utils.py,sha256=EZIATz5OSrNgdBrLFxL-9KRxn0i_Ph5-ZXHhhcIrtPE,7495
-actions/utils/openai_utils.py,sha256=txbsEPQnIOieejatBuE6Yk7xR1fQ0erWOEs6cYgUQX4,2943
-ultralytics_actions-0.0.70.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-ultralytics_actions-0.0.70.dist-info/METADATA,sha256=c9aZUeDQntfNp4gptnUlEVAxDVoEieK1h2qcGQ88jDs,10930
-ultralytics_actions-0.0.70.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-ultralytics_actions-0.0.70.dist-info/entry_points.txt,sha256=GowvOFplj0C7JmsjbKcbpgLpdf2r921pcaOQkAHWZRA,378
-ultralytics_actions-0.0.70.dist-info/top_level.txt,sha256=5apM5x80QlJcGbACn1v3fkmIuL1-XQCKcItJre7w7Tw,8
-ultralytics_actions-0.0.70.dist-info/RECORD,,