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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics-actions
-Version: 0.0.30
+Version: 0.0.36
 Summary: Ultralytics Actions for GitHub automation and PR management.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -28,12 +28,11 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests>=2.26.0
-Requires-Dist: ruff>=0.1.6
+Requires-Dist: requests>=2.32.3
+Requires-Dist: ruff>=0.8.4
 Requires-Dist: docformatter>=1.7.5
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: black; extra == "dev"
 
 <a href="https://www.ultralytics.com/" target="_blank"><img src="https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg" width="320" alt="Ultralytics logo"></a>
 

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

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

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

@@ -6,15 +6,9 @@ from typing import Dict, List, Tuple
 import requests
 
 from .utils import (
-    EVENT_DATA,
     GITHUB_API_URL,
-    GITHUB_EVENT_NAME,
-    GITHUB_HEADERS,
-    GITHUB_REPOSITORY,
+    Action,
     get_completion,
-    get_github_data,
-    get_pr_diff,
-    graphql_request,
     remove_html_comments,
 )
 
@@ -22,21 +16,23 @@ from .utils import (
 BLOCK_USER = os.getenv("BLOCK_USER", "false").lower() == "true"
 
 
-def get_event_content() -> Tuple[int, str, str, str, str, str, str]:
+def get_event_content(event) -> Tuple[int, str, str, str, str, str, str]:
     """Extracts key information from GitHub event data for issues, pull requests, or discussions."""
-    action = EVENT_DATA["action"]  # 'opened', 'closed', 'created' (discussion), etc.
-    if GITHUB_EVENT_NAME == "issues":
-        item = EVENT_DATA["issue"]
+    data = event.event_data
+    name = event.event_name
+    action = data["action"]  # 'opened', 'closed', 'created' (discussion), etc.
+    if name == "issues":
+        item = data["issue"]
         issue_type = "issue"
-    elif GITHUB_EVENT_NAME in ["pull_request", "pull_request_target"]:
-        pr_number = EVENT_DATA["pull_request"]["number"]
-        item = get_github_data(f"pulls/{pr_number}")
+    elif name in ["pull_request", "pull_request_target"]:
+        pr_number = data["pull_request"]["number"]
+        item = event.get_repo_data(f"pulls/{pr_number}")
         issue_type = "pull request"
-    elif GITHUB_EVENT_NAME == "discussion":
-        item = EVENT_DATA["discussion"]
+    elif name == "discussion":
+        item = data["discussion"]
         issue_type = "discussion"
     else:
-        raise ValueError(f"Unsupported event type: {GITHUB_EVENT_NAME}")
+        raise ValueError(f"Unsupported event type: {name}")
 
     number = item["number"]
     node_id = item.get("node_id") or item.get("id")
@@ -46,7 +42,7 @@ def get_event_content() -> Tuple[int, str, str, str, str, str, str]:
     return number, node_id, title, body, username, issue_type, action
 
 
-def update_issue_pr_content(number: int, node_id: str, issue_type: str):
+def update_issue_pr_content(event, number: int, node_id: str, issue_type: str):
     """Updates the title and body of an issue, pull request, or discussion with predefined content."""
     new_title = "Content Under Review"
     new_body = """This post has been flagged for review by [Ultralytics Actions](https://ultralytics.com/actions) due to possible spam, abuse, or off-topic content. For more information please see our:
@@ -68,14 +64,14 @@ mutation($discussionId: ID!, $title: String!, $body: String!) {
     }
 }
 """
-        graphql_request(mutation, variables={"discussionId": node_id, "title": new_title, "body": new_body})
+        event.graphql_request(mutation, variables={"discussionId": node_id, "title": new_title, "body": new_body})
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}"
-        r = requests.patch(url, json={"title": new_title, "body": new_body}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}"
+        r = requests.patch(url, json={"title": new_title, "body": new_body}, headers=event.headers)
         print(f"{'Successful' if r.status_code == 200 else 'Fail'} issue/PR #{number} update: {r.status_code}")
 
 
-def close_issue_pr(number: int, node_id: str, issue_type: str):
+def close_issue_pr(event, number: int, node_id: str, issue_type: str):
     """Closes the specified issue, pull request, or discussion using the GitHub API."""
     if issue_type == "discussion":
         mutation = """
@@ -87,14 +83,14 @@ mutation($discussionId: ID!) {
     }
 }
 """
-        graphql_request(mutation, variables={"discussionId": node_id})
+        event.graphql_request(mutation, variables={"discussionId": node_id})
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}"
-        r = requests.patch(url, json={"state": "closed"}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}"
+        r = requests.patch(url, json={"state": "closed"}, headers=event.headers)
         print(f"{'Successful' if r.status_code == 200 else 'Fail'} issue/PR #{number} close: {r.status_code}")
 
 
-def lock_issue_pr(number: int, node_id: str, issue_type: str):
+def lock_issue_pr(event, number: int, node_id: str, issue_type: str):
     """Locks an issue, pull request, or discussion to prevent further interactions."""
     if issue_type == "discussion":
         mutation = """
@@ -108,17 +104,17 @@ mutation($lockableId: ID!, $lockReason: LockReason) {
     }
 }
 """
-        graphql_request(mutation, variables={"lockableId": node_id, "lockReason": "OFF_TOPIC"})
+        event.graphql_request(mutation, variables={"lockableId": node_id, "lockReason": "OFF_TOPIC"})
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}/lock"
-        r = requests.put(url, json={"lock_reason": "off-topic"}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/lock"
+        r = requests.put(url, json={"lock_reason": "off-topic"}, headers=event.headers)
         print(f"{'Successful' if r.status_code in {200, 204} else 'Fail'} issue/PR #{number} lock: {r.status_code}")
 
 
-def block_user(username: str):
+def block_user(event, username: str):
     """Blocks a user from the organization using the GitHub API."""
-    url = f"{GITHUB_API_URL}/orgs/{GITHUB_REPOSITORY.split('/')[0]}/blocks/{username}"
-    r = requests.put(url, headers=GITHUB_HEADERS)
+    url = f"{GITHUB_API_URL}/orgs/{event.repository.split('/')[0]}/blocks/{username}"
+    r = requests.put(url, headers=event.headers)
     print(f"{'Successful' if r.status_code == 204 else 'Fail'} user block for {username}: {r.status_code}")
 
 
@@ -167,7 +163,7 @@ YOUR RESPONSE (label names only):
     messages = [
         {
             "role": "system",
-            "content": "You are a helpful assistant that labels GitHub issues, pull requests, and discussions.",
+            "content": "You are an Ultralytics AI assistant that labels GitHub issues, PRs, and discussions.",
         },
         {"role": "user", "content": prompt},
     ]
@@ -183,7 +179,7 @@ YOUR RESPONSE (label names only):
     ]
 
 
-def get_label_ids(labels: List[str]) -> List[str]:
+def get_label_ids(event, labels: List[str]) -> List[str]:
     """Retrieves GitHub label IDs for a list of label names using the GraphQL API."""
     query = """
 query($owner: String!, $name: String!) {
@@ -197,8 +193,8 @@ query($owner: String!, $name: String!) {
     }
 }
 """
-    owner, repo = GITHUB_REPOSITORY.split("/")
-    result = graphql_request(query, variables={"owner": owner, "name": repo})
+    owner, repo = event.repository.split("/")
+    result = event.graphql_request(query, variables={"owner": owner, "name": repo})
     if "data" in result and "repository" in result["data"]:
         all_labels = result["data"]["repository"]["labels"]["nodes"]
         label_map = {label["name"].lower(): label["id"] for label in all_labels}
@@ -208,14 +204,14 @@ query($owner: String!, $name: String!) {
         return []
 
 
-def apply_labels(number: int, node_id: str, labels: List[str], issue_type: str):
+def apply_labels(event, number: int, node_id: str, labels: List[str], issue_type: str):
     """Applies specified labels to a GitHub issue, pull request, or discussion using the appropriate API."""
     if "Alert" in labels:
-        create_alert_label()
+        create_alert_label(event)
 
     if issue_type == "discussion":
         print(f"Using node_id: {node_id}")  # Debug print
-        label_ids = get_label_ids(labels)
+        label_ids = get_label_ids(event, labels)
         if not label_ids:
             print("No valid labels to apply.")
             return
@@ -231,29 +227,29 @@ mutation($labelableId: ID!, $labelIds: [ID!]!) {
     }
 }
 """
-        graphql_request(mutation, {"labelableId": node_id, "labelIds": label_ids})
+        event.graphql_request(mutation, {"labelableId": node_id, "labelIds": label_ids})
         print(f"Successfully applied labels: {', '.join(labels)}")
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}/labels"
-        r = requests.post(url, json={"labels": labels}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/labels"
+        r = requests.post(url, json={"labels": labels}, headers=event.headers)
         print(f"{'Successful' if r.status_code == 200 else 'Fail'} apply labels {', '.join(labels)}: {r.status_code}")
 
 
-def create_alert_label():
+def create_alert_label(event):
     """Creates the 'Alert' label in the repository if it doesn't exist, with a red color and description."""
     alert_label = {"name": "Alert", "color": "FF0000", "description": "Potential spam, abuse, or off-topic."}
-    requests.post(f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/labels", json=alert_label, headers=GITHUB_HEADERS)
+    requests.post(f"{GITHUB_API_URL}/repos/{event.repository}/labels", json=alert_label, headers=event.headers)
 
 
-def is_org_member(username: str) -> bool:
+def is_org_member(event, username: str) -> bool:
     """Checks if a user is a member of the organization using the GitHub API."""
-    org_name = GITHUB_REPOSITORY.split("/")[0]
+    org_name = event.repository.split("/")[0]
     url = f"{GITHUB_API_URL}/orgs/{org_name}/members/{username}"
-    r = requests.get(url, headers=GITHUB_HEADERS)
+    r = requests.get(url, headers=event.headers)
     return r.status_code == 204  # 204 means the user is a member
 
 
-def add_comment(number: int, node_id: str, comment: str, issue_type: str):
+def add_comment(event, number: int, node_id: str, comment: str, issue_type: str):
     """Adds a comment to the specified issue, pull request, or discussion using the GitHub API."""
     if issue_type == "discussion":
         mutation = """
@@ -265,17 +261,17 @@ mutation($discussionId: ID!, $body: String!) {
     }
 }
 """
-        graphql_request(mutation, variables={"discussionId": node_id, "body": comment})
+        event.graphql_request(mutation, variables={"discussionId": node_id, "body": comment})
     else:
-        url = f"{GITHUB_API_URL}/repos/{GITHUB_REPOSITORY}/issues/{number}/comments"
-        r = requests.post(url, json={"body": comment}, headers=GITHUB_HEADERS)
+        url = f"{GITHUB_API_URL}/repos/{event.repository}/issues/{number}/comments"
+        r = requests.post(url, json={"body": comment}, headers=event.headers)
         print(f"{'Successful' if r.status_code in {200, 201} else 'Fail'} issue/PR #{number} comment: {r.status_code}")
 
 
-def get_first_interaction_response(issue_type: str, title: str, body: str, username: str, number: int) -> str:
+def get_first_interaction_response(event, issue_type: str, title: str, body: str, username: str) -> str:
     """Generates a custom LLM response for GitHub issues, PRs, or discussions based on content."""
     issue_discussion_response = f"""
-👋 Hello @{username}, thank you for submitting a `{GITHUB_REPOSITORY}` 🚀 {issue_type.capitalize()}. To help us address your concern efficiently, please ensure you've provided the following information:
+👋 Hello @{username}, thank you for submitting a `{event.repository}` 🚀 {issue_type.capitalize()}. To help us address your concern efficiently, please ensure you've provided the following information:
 
 1. For bug reports:
    - A clear and concise description of the bug
@@ -300,10 +296,10 @@ Thank you for your contribution to improving our project!
 """
 
     pr_response = f"""
-👋 Hello @{username}, thank you for submitting an `{GITHUB_REPOSITORY}` 🚀 PR! To ensure a seamless integration of your work, please review the following checklist:
+👋 Hello @{username}, thank you for submitting an `{event.repository}` 🚀 PR! To ensure a seamless integration of your work, please review the following checklist:
 
-- ✅ **Define a Purpose**: Clearly explain the purpose of your fix or feature in your PR description, and link to any [relevant issues](https://github.com/{GITHUB_REPOSITORY}/issues). Ensure your commit messages are clear, concise, and adhere to the project's conventions.
-- ✅ **Synchronize with Source**: Confirm your PR is synchronized with the `{GITHUB_REPOSITORY}` `main` branch. If it's behind, update it by clicking the 'Update branch' button or by running `git pull` and `git merge main` locally.
+- ✅ **Define a Purpose**: Clearly explain the purpose of your fix or feature in your PR description, and link to any [relevant issues](https://github.com/{event.repository}/issues). Ensure your commit messages are clear, concise, and adhere to the project's conventions.
+- ✅ **Synchronize with Source**: Confirm your PR is synchronized with the `{event.repository}` `main` branch. If it's behind, update it by clicking the 'Update branch' button or by running `git pull` and `git merge main` locally.
 - ✅ **Ensure CI Checks Pass**: Verify all Ultralytics [Continuous Integration (CI)](https://docs.ultralytics.com/help/CI/) checks are passing. If any checks fail, please address the issues.
 - ✅ **Update Documentation**: Update the relevant [documentation](https://docs.ultralytics.com) for any new or modified features.
 - ✅ **Add Tests**: If applicable, include or update tests to cover your changes, and confirm that all tests are passing.
@@ -318,9 +314,9 @@ For more guidance, please refer to our [Contributing Guide](https://docs.ultraly
     else:
         example = os.getenv("FIRST_ISSUE_RESPONSE") or issue_discussion_response
 
-    org_name, repo_name = GITHUB_REPOSITORY.split("/")
-    repo_url = f"https://github.com/{GITHUB_REPOSITORY}"
-    diff = get_pr_diff(number)[:32000] if issue_type == "pull request" else ""
+    org_name, repo_name = event.repository.split("/")
+    repo_url = f"https://github.com/{event.repository}"
+    diff = event.get_pr_diff()[:32000] if issue_type == "pull request" else ""
 
     prompt = f"""Generate a customized response to the new GitHub {issue_type} below:
 
@@ -359,39 +355,40 @@ YOUR {issue_type.upper()} RESPONSE:
     messages = [
         {
             "role": "system",
-            "content": f"You are a helpful assistant responding to GitHub {issue_type}s for {org_name}.",
+            "content": f"You are an Ultralytics AI assistant responding to GitHub {issue_type}s for {org_name}.",
         },
         {"role": "user", "content": prompt},
     ]
     return get_completion(messages)
 
 
-def main():
-    """Executes autolabeling and custom response generation for new GitHub issues, PRs, and discussions."""
-    number, node_id, title, body, username, issue_type, action = get_event_content()
-    available_labels = get_github_data("labels")
+def main(*args, **kwargs):
+    """Executes auto-labeling and custom response generation for new GitHub issues, PRs, and discussions."""
+    event = Action(*args, **kwargs)
+    number, node_id, title, body, username, issue_type, action = get_event_content(event)
+    available_labels = event.get_repo_data("labels")
     label_descriptions = {label["name"]: label.get("description", "") for label in available_labels}
     if issue_type == "discussion":
         current_labels = []  # For discussions, labels may need to be fetched differently or adjusted
     else:
-        current_labels = [label["name"].lower() for label in get_github_data(f"issues/{number}/labels")]
+        current_labels = [label["name"].lower() for label in event.get_repo_data(f"issues/{number}/labels")]
     relevant_labels = get_relevant_labels(issue_type, title, body, label_descriptions, current_labels)
 
     if relevant_labels:
-        apply_labels(number, node_id, relevant_labels, issue_type)
-        if "Alert" in relevant_labels and not is_org_member(username):
-            update_issue_pr_content(number, node_id, issue_type)
+        apply_labels(event, number, node_id, relevant_labels, issue_type)
+        if "Alert" in relevant_labels and not is_org_member(event, username):
+            update_issue_pr_content(event, number, node_id, issue_type)
             if issue_type != "pull request":
-                close_issue_pr(number, node_id, issue_type)
-            lock_issue_pr(number, node_id, issue_type)
+                close_issue_pr(event, number, node_id, issue_type)
+            lock_issue_pr(event, number, node_id, issue_type)
             if BLOCK_USER:
-                block_user(username=username)
+                block_user(event, username=username)
     else:
         print("No relevant labels found or applied.")
 
     if action in {"opened", "created"}:
-        custom_response = get_first_interaction_response(issue_type, title, body, username, number)
-        add_comment(number, node_id, custom_response, issue_type)
+        custom_response = get_first_interaction_response(event, issue_type, title, body, username)
+        add_comment(event, number, node_id, custom_response, issue_type)
 
 
 if __name__ == "__main__":

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

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