ultralytics-actions 0.0.100__py3-none-any.whl → 0.1.1__py3-none-any.whl

actions/review_pr.py

@@ -0,0 +1,323 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+import json
+import re
+
+from .utils import GITHUB_API_URL, Action, get_completion, remove_html_comments
+
+REVIEW_MARKER = "🔍 PR Review"
+EMOJI_MAP = {"CRITICAL": "❗", "HIGH": "⚠️", "MEDIUM": "💡", "LOW": "📝", "SUGGESTION": "💭"}
+SKIP_PATTERNS = [
+    r"\.lock$",  # Lock files
+    r"-lock\.(json|yaml|yml)$",
+    r"\.min\.(js|css)$",  # Minified
+    r"\.bundle\.(js|css)$",
+    r"(^|/)dist/",  # Generated/vendored directories
+    r"(^|/)build/",
+    r"(^|/)vendor/",
+    r"(^|/)node_modules/",
+    r"\.pb\.py$",  # Proto generated
+    r"_pb2\.py$",
+    r"_pb2_grpc\.py$",
+    r"^package-lock\.json$",  # Package locks
+    r"^yarn\.lock$",
+    r"^poetry\.lock$",
+    r"^Pipfile\.lock$",
+    r"\.(svg|png|jpe?g|gif)$",  # Images
+]
+
+
+def parse_diff_files(diff_text: str) -> dict:
+    """Parse diff to extract file paths, valid line numbers, and line content for comments."""
+    files, current_file, current_line = {}, None, 0
+
+    for line in diff_text.split("\n"):
+        if line.startswith("diff --git"):
+            match = re.search(r" b/(.+)$", line)
+            current_file = match.group(1) if match else None
+            current_line = 0
+            if current_file:
+                files[current_file] = {}
+        elif line.startswith("@@") and current_file:
+            match = re.search(r"@@.*\+(\d+)(?:,\d+)?", line)
+            current_line = int(match.group(1)) if match else 0
+        elif current_file and current_line > 0:
+            if line.startswith("+") and not line.startswith("+++"):
+                files[current_file][current_line] = line[1:]
+                current_line += 1
+            elif not line.startswith("-"):
+                current_line += 1
+
+    return files
+
+
+def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_description: str) -> dict:
+    """Generate comprehensive PR review with line-specific comments and overall assessment."""
+    if not diff_text:
+        return {"comments": [], "summary": "No changes detected in diff"}
+
+    diff_files = parse_diff_files(diff_text)
+    if not diff_files:
+        return {"comments": [], "summary": "No files with changes detected in diff"}
+
+    # Filter out generated/vendored files
+    filtered_files = {
+        path: lines
+        for path, lines in diff_files.items()
+        if not any(re.search(pattern, path) for pattern in SKIP_PATTERNS)
+    }
+    skipped_count = len(diff_files) - len(filtered_files)
+    diff_files = filtered_files
+
+    if not diff_files:
+        return {"comments": [], "summary": f"All {skipped_count} changed files are generated/vendored (skipped review)"}
+
+    file_list = list(diff_files.keys())
+    limit = round(128000 * 3.3 * 0.5)  # 3.3 characters per token for half a 256k context window
+    diff_truncated = len(diff_text) > limit
+    lines_changed = sum(len(lines) for lines in diff_files.values())
+
+    comment_guidance = (
+        "Provide up to 1-3 comments only if critical issues exist"
+        if lines_changed < 50
+        else "Provide up to 3-5 comments only if high-impact issues exist"
+        if lines_changed < 200
+        else "Provide up to 5-10 comments only for the most critical issues"
+    )
+
+    content = (
+        "You are an expert code reviewer for Ultralytics. Provide detailed inline comments on specific code changes.\n\n"
+        "Focus on: Code quality, style, best practices, bugs, edge cases, error handling, performance, security, documentation, test coverage\n\n"
+        "FORMATTING: Use backticks for code, file names, branch names, function names, variable names, packages\n\n"
+        "CRITICAL RULES:\n"
+        "1. Quality over quantity: Zero comments is fine for clean code - only flag truly important issues\n"
+        f"2. {comment_guidance} - these are maximums, not targets\n"
+        "3. CRITICAL: Do not post separate comments on adjacent/nearby lines (within 10 lines). Combine all related issues into ONE comment\n"
+        "4. When combining issues from multiple lines, use 'start_line' (first line) and 'line' (last line) to highlight the entire range\n"
+        "5. Each comment must reference separate areas - no overlapping line ranges\n"
+        "6. Prioritize: CRITICAL bugs/security > HIGH impact issues > code quality\n"
+        "7. Keep comments concise, friendly, and easy to understand - avoid jargon when possible\n"
+        "8. DO not comment on routine changes: adding imports, adding dependencies, updating version numbers, standard refactoring\n"
+        "9. Trust the developer - only flag issues with clear evidence of problems, not hypothetical concerns\n\n"
+        "SUMMARY GUIDELINES:\n"
+        "- Keep summary brief, clear, and actionable - avoid overly detailed explanations\n"
+        "- Highlight only the most important findings\n"
+        "- Do NOT include file names or line numbers in the summary - inline comments already show exact locations\n"
+        "- Focus on what needs to be fixed, not where\n\n"
+        "CODE SUGGESTIONS:\n"
+        "- ONLY provide 'suggestion' field when you have high certainty the code is problematic AND sufficient context for a confident fix\n"
+        "- If uncertain about the correct fix, omit 'suggestion' field and explain the concern in 'message' only\n"
+        "- Suggestions must be ready-to-merge code with NO comments, placeholders, or explanations\n"
+        "- Suggestions replace ONLY the single line at 'line' - for multi-line fixes, describe the change in 'message' instead\n"
+        "- Do NOT provide 'start_line' when including a 'suggestion' - suggestions are always single-line only\n"
+        "- Suggestion content must match the exact indentation of the original line\n"
+        "- Never include triple backticks (```) in suggestions as they break markdown formatting\n"
+        "- It's better to flag an issue without a suggestion than provide a wrong or uncertain fix\n\n"
+        "Return JSON: "
+        '{"comments": [{"file": "exact/path", "line": N, "severity": "HIGH", "message": "...", "suggestion": "..."}], "summary": "..."}\n\n'
+        "Rules:\n"
+        "- Only comment on NEW lines (starting with + in diff)\n"
+        "- Use exact file paths from diff (no ./ prefix)\n"
+        "- Line numbers must match NEW file line numbers from @@ hunks\n"
+        "- When '- old' then '+ new', new line keeps SAME line number\n"
+        "- Severity: CRITICAL, HIGH, MEDIUM, LOW, SUGGESTION\n"
+        f"- Files changed: {len(file_list)} ({', '.join(file_list[:10])}{'...' if len(file_list) > 10 else ''})\n"
+        f"- Lines changed: {lines_changed}\n"
+    )
+
+    messages = [
+        {"role": "system", "content": content},
+        {
+            "role": "user",
+            "content": (
+                f"Review this PR in https://github.com/{repository}:\n"
+                f"Title: {pr_title}\n"
+                f"Description: {remove_html_comments(pr_description or '')[:1000]}\n\n"
+                f"Diff:\n{diff_text[:limit]}\n\n"
+                "Now review this diff according to the rules above. Return JSON with comments array and summary."
+            ),
+        },
+    ]
+
+    try:
+        response = get_completion(messages, reasoning_effort="medium")
+        print("\n" + "=" * 80 + f"\nFULL AI RESPONSE:\n{response}\n" + "=" * 80 + "\n")
+
+        json_str = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", response, re.DOTALL)
+        review_data = json.loads(json_str.group(1) if json_str else response)
+
+        print(f"AI generated {len(review_data.get('comments', []))} comments")
+
+        # Validate, filter, and deduplicate comments
+        unique_comments = {}
+        for c in review_data.get("comments", []):
+            file_path, line_num = c.get("file"), c.get("line", 0)
+            start_line = c.get("start_line")
+
+            # Validate line numbers are in diff
+            if file_path not in diff_files or line_num not in diff_files[file_path]:
+                print(f"Filtered out {file_path}:{line_num} (available: {list(diff_files.get(file_path, {}))[:10]}...)")
+                continue
+
+            # Validate start_line if provided - drop start_line for suggestions (single-line only)
+            if start_line:
+                if c.get("suggestion"):
+                    print(f"Dropping start_line for {file_path}:{line_num} - suggestions must be single-line only")
+                    c.pop("start_line", None)
+                elif start_line >= line_num:
+                    print(f"Invalid start_line {start_line} >= line {line_num} for {file_path}, dropping start_line")
+                    c.pop("start_line", None)
+                elif start_line not in diff_files[file_path]:
+                    print(f"start_line {start_line} not in diff for {file_path}, dropping start_line")
+                    c.pop("start_line", None)
+
+            # Deduplicate by line number
+            key = f"{file_path}:{line_num}"
+            if key not in unique_comments:
+                unique_comments[key] = c
+            else:
+                print(f"⚠️  AI duplicate for {key}: {c.get('severity')} - {c.get('message')[:60]}...")
+
+        review_data.update(
+            {
+                "comments": list(unique_comments.values()),
+                "diff_files": diff_files,
+                "diff_truncated": diff_truncated,
+                "skipped_files": skipped_count,
+            }
+        )
+        print(f"Valid comments after filtering: {len(review_data['comments'])}")
+        return review_data
+
+    except json.JSONDecodeError as e:
+        print(f"JSON parsing failed... {e}")
+        return {"comments": [], "summary": "Review generation encountered a JSON parsing error"}
+    except Exception as e:
+        print(f"Review generation failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return {"comments": [], "summary": "Review generation encountered an error"}
+
+
+def dismiss_previous_reviews(event: Action) -> int:
+    """Dismiss previous bot reviews and delete inline comments, returns count for numbering."""
+    if not (pr_number := event.pr.get("number")) or not (bot_username := event.get_username()):
+        return 1
+
+    review_count = 0
+    reviews_url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{pr_number}/reviews"
+    if (response := event.get(reviews_url)).status_code == 200:
+        for review in response.json():
+            if review.get("user", {}).get("login") == bot_username and REVIEW_MARKER in (review.get("body") or ""):
+                review_count += 1
+                if review.get("state") in ["APPROVED", "CHANGES_REQUESTED"] and (review_id := review.get("id")):
+                    event.put(f"{reviews_url}/{review_id}/dismissals", json={"message": "Superseded by new review"})
+
+    # Delete previous inline comments
+    comments_url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{pr_number}/comments"
+    if (response := event.get(comments_url)).status_code == 200:
+        for comment in response.json():
+            if comment.get("user", {}).get("login") == bot_username and (comment_id := comment.get("id")):
+                event.delete(
+                    f"{GITHUB_API_URL}/repos/{event.repository}/pulls/comments/{comment_id}",
+                    expected_status=[200, 204, 404],
+                )
+
+    return review_count + 1
+
+
+def post_review_summary(event: Action, review_data: dict, review_number: int) -> None:
+    """Post overall review summary and inline comments as a single PR review."""
+    if not (pr_number := event.pr.get("number")) or not (commit_sha := event.pr.get("head", {}).get("sha")):
+        return
+
+    review_title = f"{REVIEW_MARKER} {review_number}" if review_number > 1 else REVIEW_MARKER
+    comments = review_data.get("comments", [])
+    event_type = (
+        "REQUEST_CHANGES" if any(c.get("severity") not in ["LOW", "SUGGESTION", None] for c in comments) else "APPROVE"
+    )
+
+    body = (
+        f"## {review_title}\n\n"
+        "<sub>Made with ❤️ by [Ultralytics Actions](https://github.com/ultralytics/actions)</sub>\n\n"
+        f"{review_data.get('summary', 'Review completed')}\n\n"
+    )
+
+    if comments:
+        shown = min(len(comments), 10)
+        body += f"💬 Posted {shown} inline comment{'s' if shown != 1 else ''}{' (10 shown, more available)' if len(comments) > 10 else ''}\n"
+
+    if review_data.get("diff_truncated"):
+        body += "\n⚠️ **Large PR**: Review focused on critical issues. Some details may not be covered.\n"
+
+    if skipped := review_data.get("skipped_files"):
+        body += f"\n📋 **Skipped {skipped} file{'s' if skipped != 1 else ''}** (lock files, minified, images, etc.)\n"
+
+    # Build inline comments for the review
+    review_comments = []
+    for comment in comments[:10]:
+        if not (file_path := comment.get("file")) or not (line := comment.get("line", 0)):
+            continue
+
+        severity = comment.get("severity", "SUGGESTION")
+        comment_body = f"{EMOJI_MAP.get(severity, '💭')} **{severity}**: {comment.get('message', '')}"
+
+        if suggestion := comment.get("suggestion"):
+            if "```" not in suggestion:
+                # Extract original line indentation and apply to suggestion
+                if original_line := review_data.get("diff_files", {}).get(file_path, {}).get(line):
+                    indent = len(original_line) - len(original_line.lstrip())
+                    suggestion = " " * indent + suggestion.strip()
+                comment_body += f"\n\n**Suggested change:**\n```suggestion\n{suggestion}\n```"
+
+        # Build comment with optional start_line for multi-line context
+        review_comment = {"path": file_path, "line": line, "body": comment_body, "side": "RIGHT"}
+        if start_line := comment.get("start_line"):
+            if start_line < line:
+                review_comment["start_line"] = start_line
+                review_comment["start_side"] = "RIGHT"
+                print(f"Multi-line comment: {file_path}:{start_line}-{line}")
+
+        review_comments.append(review_comment)
+
+    # Submit review with inline comments
+    payload = {"commit_id": commit_sha, "body": body, "event": event_type}
+    if review_comments:
+        payload["comments"] = review_comments
+        print(f"Posting review with {len(review_comments)} inline comments")
+
+    event.post(
+        f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{pr_number}/reviews",
+        json=payload,
+    )
+
+
+def main(*args, **kwargs):
+    """Main entry point for PR review action."""
+    event = Action(*args, **kwargs)
+
+    # Handle review requests
+    if event.event_name == "pull_request" and event.event_data.get("action") == "review_requested":
+        if event.event_data.get("requested_reviewer", {}).get("login") != event.get_username():
+            return
+        print(f"Review requested from {event.get_username()}")
+
+    if not event.pr or event.pr.get("state") != "open":
+        print(f"Skipping: PR state is {event.pr.get('state') if event.pr else 'None'}")
+        return
+
+    print(f"Starting PR review for #{event.pr['number']}")
+    review_number = dismiss_previous_reviews(event)
+
+    diff = event.get_pr_diff()
+    review = generate_pr_review(event.repository, diff, event.pr.get("title", ""), event.pr.get("body", ""))
+
+    post_review_summary(event, review, review_number)
+    print("PR review completed")
+
+
+if __name__ == "__main__":
+    main()

actions/summarize_pr.py

@@ -2,17 +2,14 @@
 
 from __future__ import annotations
 
-import time
+from .utils import GITHUB_API_URL, Action, get_completion, get_pr_summary_prompt
 
-from .utils import GITHUB_API_URL, GITHUB_GRAPHQL_URL, Action, get_completion
-
-# Constants
 SUMMARY_START = (
     "## 🛠️ PR Summary\n\n<sub>Made with ❤️ by [Ultralytics Actions](https://github.com/ultralytics/actions)<sub>\n\n"
 )
 
 
-def generate_merge_message(pr_summary=None, pr_credit=None, pr_url=None):
+def generate_merge_message(pr_summary, pr_credit, pr_url):
     """Generates a motivating thank-you message for merged PR contributors."""
     messages = [
         {
@@ -32,17 +29,8 @@ def generate_merge_message(pr_summary=None, pr_credit=None, pr_url=None):
     return get_completion(messages)
 
 
-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)
-    event.post(comment_url, json={"body": message})
-
-
 def generate_issue_comment(pr_url, pr_summary, pr_credit, pr_title=""):
     """Generates personalized issue comment based on PR context."""
-    # Extract repo info from PR URL (format: api.github.com/repos/owner/repo/pulls/number)
     repo_parts = pr_url.split("/repos/")[1].split("/pulls/")[0] if "/repos/" in pr_url else ""
     owner_repo = repo_parts.split("/")
     repo_name = owner_repo[-1] if len(owner_repo) > 1 else "package"
@@ -72,137 +60,46 @@ def generate_issue_comment(pr_url, pr_summary, pr_credit, pr_title=""):
 
 
 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."
-    ratio = 3.3  # about 3.3 characters per token
-    limit = round(128000 * ratio * 0.5)  # use up to 50% of the 128k context window for prompt
+    """Generates a concise, professional summary of a PR using OpenAI's API."""
+    prompt, is_large = get_pr_summary_prompt(repository, diff_text)
+
     messages = [
         {
             "role": "system",
             "content": "You are an Ultralytics AI assistant skilled in software development and technical communication. Your task is to summarize GitHub PRs from Ultralytics in a way that is accurate, concise, and understandable to both expert developers and non-expert users. Focus on highlighting the key changes and their impact in simple, concise terms.",
         },
-        {
-            "role": "user",
-            "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"
-            f"\n\nHere's the PR diff:\n\n{diff_text[:limit]}",
-        },
+        {"role": "user", "content": prompt},
     ]
     reply = get_completion(messages, temperature=1.0)
-    if len(diff_text) > limit:
+    if is_large:
         reply = "**WARNING ⚠️** this PR is very large, summary may not cover all changes.\n\n" + reply
     return SUMMARY_START + reply
 
 
-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 = event.get(url).json().get("body") or ""
-        if description:
-            break
-        if i < max_retries:
-            print("No current PR description found, retrying...")
-            time.sleep(1)
-
-    # Check if existing summary is present and update accordingly
-    start = "## 🛠️ PR Summary"
-    if start in description:
-        print("Existing PR Summary found, replacing.")
-        updated_description = description.split(start)[0] + new_summary
-    else:
-        print("PR Summary not found, appending.")
-        updated_description = description + "\n\n" + new_summary
-
-    # Update the PR description
-    event.patch(url, json={"body": updated_description})
-
-
 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!) {
-    repository(owner: $owner, name: $repo) {
-        pullRequest(number: $pr_number) {
-            closingIssuesReferences(first: 50) { nodes { number } }
-            url
-            title
-            body
-            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 = 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:
-        return None  # no linked issues
-
-    try:
-        data = response.json()["data"]["repository"]["pullRequest"]
-        comments = data["reviews"]["nodes"] + data["comments"]["nodes"]
-        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", "")
-
-        # Get unique contributors from reviews and comments
-        contributors = {x["author"]["login"] for x in comments if x["author"]["__typename"] != "Bot"}
-
-        # 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, pr_credit=pr_credit, pr_title=pr_title
-        )
-
-        # Update linked issues
-        for issue in data["closingIssuesReferences"]["nodes"]:
-            number = issue["number"]
-            # Add fixed label
-            event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/labels", json={"labels": ["fixed"]})
-
-            # Add comment
-            event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/comments", json={"body": comment})
-
-        return pr_credit
-    except KeyError as e:
-        print(f"Error parsing GraphQL response: {e}")
+    pr_credit, data = event.get_pr_contributors()
+    if not pr_credit:
         return None
 
+    comment = generate_issue_comment(data["url"], pr_summary, pr_credit, data.get("title", ""))
+
+    for issue in data["closingIssuesReferences"]["nodes"]:
+        number = issue["number"]
+        event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/labels", json={"labels": ["fixed"]})
+        event.post(f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/comments", json={"body": comment})
 
-def remove_pr_labels(event, labels=()):
-    """Removes specified labels from PR."""
-    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}")
+    return pr_credit
 
 
 def main(*args, **kwargs):
     """Summarize a pull request and update its description with a summary."""
     event = Action(*args, **kwargs)
+    action = event.event_data.get("action")
+
+    if action == "opened":
+        print("Skipping PR open - handled by first_interaction.py with unified API call")
+        return
 
     print(f"Retrieving diff for PR {event.pr['number']}")
     diff = event.get_pr_diff()
@@ -213,17 +110,18 @@ def main(*args, **kwargs):
 
     # Update PR description
     print("Updating PR description...")
-    update_pr_description(event, summary)
+    event.update_pr_description(event.pr["number"], summary)
 
-    # Update linked issues and post thank you message if merged
     if event.pr.get("merged"):
         print("PR is merged, labeling fixed issues...")
         pr_credit = label_fixed_issues(event, summary)
         print("Removing TODO label from PR...")
-        remove_pr_labels(event, labels=["TODO"])
+        event.remove_labels(event.pr["number"], labels=("TODO",))
         if pr_credit:
             print("Posting PR author thank you message...")
-            post_merge_message(event, summary, pr_credit)
+            pr_url = f"{GITHUB_API_URL}/repos/{event.repository}/pulls/{event.pr['number']}"
+            message = generate_merge_message(summary, pr_credit, pr_url)
+            event.add_comment(event.pr["number"], None, message, "pull request")
 
 
 if __name__ == "__main__":

actions/summarize_release.py

@@ -42,7 +42,7 @@ def get_prs_between_tags(event, previous_tag: str, latest_tag: str) -> list:
         pr_numbers.update(pr_matches)
 
     prs = []
-    time.sleep(10)  # sleep 10 seconds to allow final PR summary to update on merge
+    time.sleep(10)  # 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/{event.repository}/pulls/{pr_number}"
         pr_response = event.get(pr_url)
@@ -68,9 +68,15 @@ def get_prs_between_tags(event, previous_tag: str, latest_tag: str) -> list:
 def get_new_contributors(event, prs: list) -> set:
     """Identify new contributors who made their first merged PR in the current release."""
     new_contributors = set()
+    checked_authors = set()
     for pr in prs:
         author = pr["author"]
-        # Check if this is the author's first contribution
+        if author in checked_authors:
+            print(f"Skipping duplicate author: {author}")
+            continue
+        checked_authors.add(author)
+
+        time.sleep(2)  # Rate limit: GitHub search API has strict limits
         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:
@@ -79,6 +85,11 @@ def get_new_contributors(event, prs: list) -> set:
                 first_pr = data["items"][0]
                 if first_pr["number"] == pr["number"]:
                     new_contributors.add(author)
+        elif r.status_code == 403:
+            print(f"⚠️ Rate limit hit checking {author}, stopping contributor check")
+            break
+        else:
+            print(f"Failed to check {author}: {r.status_code}")
     return new_contributors
 
 

actions/update_markdown_code_blocks.py

@@ -39,6 +39,9 @@ def add_indentation(code_block, num_spaces):
 
 def format_code_with_ruff(temp_dir):
     """Formats Python code files in the specified directory using ruff linter and docformatter tools."""
+    if not next(Path(temp_dir).rglob("*.py"), None):
+        return
+
     try:
         # Run ruff format
         subprocess.run(

actions/utils/__init__.py

@@ -9,7 +9,13 @@ from .common_utils import (
     remove_html_comments,
 )
 from .github_utils import GITHUB_API_URL, GITHUB_GRAPHQL_URL, Action, ultralytics_actions_info
-from .openai_utils import get_completion
+from .openai_utils import (
+    filter_labels,
+    get_completion,
+    get_pr_open_response,
+    get_pr_summary_guidelines,
+    get_pr_summary_prompt,
+)
 from .version_utils import check_pubdev_version, check_pypi_version
 
 __all__ = (
@@ -23,7 +29,11 @@ __all__ = (
     "allow_redirect",
     "check_pubdev_version",
     "check_pypi_version",
+    "filter_labels",
     "get_completion",
+    "get_pr_open_response",
+    "get_pr_summary_guidelines",
+    "get_pr_summary_prompt",
     "remove_html_comments",
     "ultralytics_actions_info",
 )