ultralytics-actions 0.0.40__py3-none-any.whl

actions/summarize_release.py

@@ -0,0 +1,194 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+import os
+import re
+import subprocess
+import time
+from datetime import datetime
+
+import requests
+
+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:
+    """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)
+    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:
+    """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()
+
+    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)
+
+    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)
+        if pr_response.status_code == 200:
+            pr_data = pr_response.json()
+            prs.append(
+                {
+                    "number": pr_data["number"],
+                    "title": pr_data["title"],
+                    "body": remove_html_comments(pr_data["body"]),
+                    "author": pr_data["user"]["login"],
+                    "html_url": pr_data["html_url"],
+                    "merged_at": pr_data["merged_at"],
+                }
+            )
+
+    # Sort PRs by merge date
+    prs.sort(key=lambda x: datetime.strptime(x["merged_at"], "%Y-%m-%dT%H:%M:%SZ"))
+
+    return prs
+
+
+def get_new_contributors(repo: str, prs: list, headers: dict) -> set:
+    """Identify new contributors who made their first merged PR in the current release."""
+    new_contributors = set()
+    for pr in prs:
+        author = pr["author"]
+        # Check if this is the author's first contribution
+        url = f"{GITHUB_API_URL}/search/issues?q=repo:{repo}+author:{author}+is:pr+is:merged&sort=created&order=asc"
+        r = requests.get(url, headers=headers)
+        if r.status_code == 200:
+            data = r.json()
+            if data["total_count"] > 0:
+                first_pr = data["items"][0]
+                if first_pr["number"] == pr["number"]:
+                    new_contributors.add(author)
+    return new_contributors
+
+
+def generate_release_summary(
+    diff: str, prs: list, latest_tag: str, previous_tag: str, repo_name: str, headers: dict
+) -> str:
+    """Generate a concise release summary with key changes, purpose, and impact for a new Ultralytics version."""
+    pr_summaries = "\n\n".join(
+        [f"PR #{pr['number']}: {pr['title']} by @{pr['author']}\n{pr['body'][:1000]}" for pr in prs]
+    )
+
+    current_pr = prs[-1] if prs else None
+    current_pr_summary = (
+        f"Current PR #{current_pr['number']}: {current_pr['title']} by @{current_pr['author']}\n{current_pr['body'][:1000]}"
+        if current_pr
+        else "No current PR found."
+    )
+
+    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_section = (
+        "\n## New Contributors\n"
+        + "\n".join(
+            [
+                f"* @{contributor} made their first contribution in {next(pr['html_url'] for pr in prs if pr['author'] == contributor)}"
+                for contributor in new_contributors
+            ]
+        )
+        if new_contributors
+        else ""
+    )
+
+    full_changelog = f"https://github.com/{repo_name}/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"
+    )
+
+    messages = [
+        {
+            "role": "system",
+            "content": "You are an Ultralytics AI assistant skilled in software development and technical communication. Your task is to summarize GitHub releases in a way that is detailed, accurate, and understandable to both expert developers and non-expert users. Focus on highlighting the key changes and their impact in simple and intuitive terms.",
+        },
+        {
+            "role": "user",
+            "content": f"Summarize the updates made in the '{latest_tag}' tag, focusing on major model or features changes, their purpose, and potential impact. Keep the summary clear and suitable for a broad audience. Add emojis to enliven the summary. Prioritize changes from the current PR (the first in the list), which is usually the most important in the release. 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\n\n"
+            f"Here's the information about the current PR:\n\n{current_pr_summary}\n\n"
+            f"Here's the information about PRs merged between the previous release and this one:\n\n{pr_summaries[:30000]}\n\n"
+            f"Here's the release diff:\n\n{diff[:300000]}",
+        },
+    ]
+    print(messages[-1]["content"])  # for debug
+    return get_completion(messages) + release_suffix
+
+
+def create_github_release(repo_name: str, tag_name: str, name: str, body: str, headers: dict) -> int:
+    """Creates a GitHub release with specified tag, name, and body content for the given repository."""
+    url = f"{GITHUB_API_URL}/repos/{repo_name}/releases"
+    data = {"tag_name": tag_name, "name": name, "body": body, "draft": False, "prerelease": False}
+    r = requests.post(url, headers=headers, json=data)
+    return r.status_code
+
+
+def get_previous_tag() -> str:
+    """Retrieves the previous Git tag, excluding the current tag, using the git describe command."""
+    cmd = ["git", "describe", "--tags", "--abbrev=0", "--exclude", CURRENT_TAG]
+    try:
+        return subprocess.run(cmd, check=True, text=True, capture_output=True).stdout.strip()
+    except subprocess.CalledProcessError:
+        print("Failed to get previous tag from git. Using previous commit.")
+        return "HEAD~1"
+
+
+def main(*args, **kwargs):
+    """Automates generating and publishing a GitHub release summary from PRs and commit differences."""
+    action = Action(*args, **kwargs)
+
+    if not all([action.token, CURRENT_TAG]):
+        raise ValueError("One or more required environment variables are missing.")
+
+    previous_tag = PREVIOUS_TAG or get_previous_tag()
+
+    # Get the diff between the tags
+    diff = get_release_diff(action.repository, previous_tag, CURRENT_TAG, action.headers_diff)
+
+    # Get PRs merged between the tags
+    prs = get_prs_between_tags(action.repository, previous_tag, CURRENT_TAG, action.headers)
+
+    # Generate release summary
+    try:
+        summary = generate_release_summary(diff, prs, CURRENT_TAG, previous_tag, action.repository, action.headers)
+    except Exception as e:
+        print(f"Failed to generate summary: {str(e)}")
+        summary = "Failed to generate summary."
+
+    # Get the latest commit message
+    cmd = ["git", "log", "-1", "--pretty=%B"]
+    commit_message = subprocess.run(cmd, check=True, text=True, capture_output=True).stdout.split("\n")[0].strip()
+
+    # 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}")
+
+
+if __name__ == "__main__":
+    main()

actions/update_markdown_code_blocks.py

@@ -0,0 +1,173 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+import hashlib
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+
+def extract_code_blocks(markdown_content):
+    """Extracts Python code blocks from markdown content using regex pattern matching."""
+    pattern = r"^( *)```(?:python|py|\{[ ]*\.py[ ]*\.annotate[ ]*\})\n(.*?)\n\1```"
+    code_block_pattern = re.compile(pattern, re.DOTALL | re.MULTILINE)
+    return code_block_pattern.findall(markdown_content)
+
+
+def remove_indentation(code_block, num_spaces):
+    """Removes specified leading spaces from each line in a code block to adjust indentation."""
+    lines = code_block.split("\n")
+    stripped_lines = [line[num_spaces:] if len(line) >= num_spaces else line for line in lines]
+    return "\n".join(stripped_lines)
+
+
+def add_indentation(code_block, num_spaces):
+    """Adds specified number of leading spaces to non-empty lines in a code block."""
+    indent = " " * num_spaces
+    lines = code_block.split("\n")
+    indented_lines = [indent + line if line.strip() != "" else line for line in lines]
+    return "\n".join(indented_lines)
+
+
+def format_code_with_ruff(temp_dir):
+    """Formats Python code files in the specified directory using ruff linter and docformatter tools."""
+    try:
+        # Run ruff format
+        subprocess.run(
+            [
+                "ruff",
+                "format",
+                "--line-length=120",
+                str(temp_dir),
+            ],
+            check=True,
+        )
+        print("Completed ruff format ✅")
+    except Exception as e:
+        print(f"ERROR running ruff format ❌ {e}")
+
+    try:
+        # Run ruff check with ignored rules:
+        # F821: Undefined name
+        # F841: Local variable is assigned to but never used
+        subprocess.run(
+            [
+                "ruff",
+                "check",
+                "--fix",
+                "--extend-select=I",
+                "--ignore=F821,F841",
+                str(temp_dir),
+            ],
+            check=True,
+        )
+        print("Completed ruff check ✅")
+    except Exception as e:
+        print(f"ERROR running ruff check ❌ {e}")
+
+    try:
+        # Run docformatter
+        subprocess.run(
+            [
+                "docformatter",
+                "--wrap-summaries=120",
+                "--wrap-descriptions=120",
+                "--pre-summary-newline",
+                "--close-quotes-on-newline",
+                "--in-place",
+                "--recursive",
+                str(temp_dir),
+            ],
+            check=True,
+        )
+        print("Completed docformatter ✅")
+    except Exception as e:
+        print(f"ERROR running docformatter ❌ {e}")
+
+
+def generate_temp_filename(file_path, index):
+    """Generates a unique temporary filename using a hash of the file path and index."""
+    unique_string = f"{file_path.parent}_{file_path.stem}_{index}"
+    unique_hash = hashlib.md5(unique_string.encode()).hexdigest()
+    return f"temp_{unique_hash}.py"
+
+
+def process_markdown_file(file_path, temp_dir, verbose=False):
+    """Processes a markdown file, extracting Python code blocks for formatting and updating the original file."""
+    try:
+        markdown_content = Path(file_path).read_text()
+        code_blocks = extract_code_blocks(markdown_content)
+        temp_files = []
+
+        for i, (num_spaces, code_block) in enumerate(code_blocks):
+            if verbose:
+                print(f"Extracting code block {i} from {file_path}")
+            num_spaces = len(num_spaces)
+            code_without_indentation = remove_indentation(code_block, num_spaces)
+
+            # Generate a unique temp file path
+            temp_file_path = temp_dir / generate_temp_filename(file_path, i)
+            with open(temp_file_path, "w") as temp_file:
+                temp_file.write(code_without_indentation)
+            temp_files.append((num_spaces, code_block, temp_file_path))
+
+        return markdown_content, temp_files
+
+    except Exception as e:
+        print(f"Error processing file {file_path}: {e}")
+        return None, None
+
+
+def update_markdown_file(file_path, markdown_content, temp_files):
+    """Updates a markdown file with formatted Python code blocks extracted and processed externally."""
+    for num_spaces, original_code_block, temp_file_path in temp_files:
+        try:
+            with open(temp_file_path) as temp_file:
+                formatted_code = temp_file.read().rstrip("\n")  # Strip trailing newlines
+            formatted_code_with_indentation = add_indentation(formatted_code, num_spaces)
+
+            # Replace both `python` and `py` code blocks
+            for lang in ["python", "py", "{ .py .annotate }"]:
+                markdown_content = markdown_content.replace(
+                    f"{' ' * num_spaces}```{lang}\n{original_code_block}\n{' ' * num_spaces}```",
+                    f"{' ' * num_spaces}```{lang}\n{formatted_code_with_indentation}\n{' ' * num_spaces}```",
+                )
+        except Exception as e:
+            print(f"Error updating code block in file {file_path}: {e}")
+
+    try:
+        with open(file_path, "w") as file:
+            file.write(markdown_content)
+    except Exception as e:
+        print(f"Error writing file {file_path}: {e}")
+
+
+def main(root_dir=Path.cwd(), verbose=False):
+    """Processes markdown files, extracts and formats Python code blocks, and updates the original files."""
+    root_path = Path(root_dir)
+    markdown_files = list(root_path.rglob("*.md"))
+    temp_dir = Path("temp_code_blocks")
+    temp_dir.mkdir(exist_ok=True)
+
+    # Extract code blocks and save to temp files
+    all_temp_files = []
+    for markdown_file in markdown_files:
+        if verbose:
+            print(f"Processing {markdown_file}")
+        markdown_content, temp_files = process_markdown_file(markdown_file, temp_dir)
+        if markdown_content and temp_files:
+            all_temp_files.append((markdown_file, markdown_content, temp_files))
+
+    # Format all code blocks with ruff
+    format_code_with_ruff(temp_dir)
+
+    # Update markdown files with formatted code blocks
+    for markdown_file, markdown_content, temp_files in all_temp_files:
+        update_markdown_file(markdown_file, markdown_content, temp_files)
+
+    # Clean up temp directory
+    shutil.rmtree(temp_dir)
+
+
+if __name__ == "__main__":
+    main()

actions/utils/__init__.py

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

actions/utils/common_utils.py

@@ -0,0 +1,111 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+
+import re
+import time
+from concurrent.futures import ThreadPoolExecutor
+from urllib import parse
+
+import requests
+
+
+def remove_html_comments(body: str) -> str:
+    """Removes HTML comments from a string using regex pattern matching."""
+    return re.sub(r"<!--.*?-->", "", body, flags=re.DOTALL).strip()
+
+
+def clean_url(url):
+    """Remove extra characters from URL strings."""
+    for _ in range(3):
+        url = str(url).strip('"').strip("'").rstrip(".,:;!?`\\").replace(".git@main", "").replace("git+", "")
+    return url
+
+
+def is_url(url, check=True, max_attempts=3, timeout=2):
+    """Check if string is URL and check if URL exists."""
+    allow_list = (
+        "localhost",
+        "127.0.0",
+        ":5000",
+        ":3000",
+        ":8000",
+        ":8080",
+        ":6006",
+        "MODEL_ID",
+        "API_KEY",
+        "url",
+        "example",
+        "mailto:",
+        "github.com",  # ignore GitHub links that may be private repos
+        "kaggle.com",  # blocks automated header requests
+        "reddit.com",  # blocks automated header requests
+        "linkedin.com",
+        "twitter.com",
+        "x.com",
+        "storage.googleapis.com",  # private GCS buckets
+    )
+    try:
+        # Check allow list
+        if any(x in url for x in allow_list):
+            return True
+
+        # Check structure
+        result = parse.urlparse(url)
+        partition = result.netloc.partition(".")  # i.e. netloc = "github.com" -> ("github", ".", "com")
+        if not result.scheme or not partition[0] or not partition[2]:
+            return False
+
+        # Check response
+        if check:
+            for attempt in range(max_attempts):
+                try:
+                    headers = {
+                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                        "Accept": "*/*",  # Wildcard for maximum compatibility
+                        "Accept-Language": "*",  # Wildcard for any language
+                        "Accept-Encoding": "*",  # Wildcard for any encoding
+                    }
+                    return requests.head(url, headers=headers, timeout=timeout, allow_redirects=True).status_code < 400
+                except Exception:
+                    if attempt == max_attempts - 1:  # last attempt
+                        return False
+                    time.sleep(2**attempt)  # exponential backoff
+            return False
+        return True
+    except Exception:
+        return False
+
+
+def check_links_in_string(text, verbose=True, return_bad=False):
+    """Process a given text, find unique URLs within it, and check for any 404 errors."""
+    pattern = (
+        r"\[([^\]]+)\]\(([^)]+)\)"  # Matches Markdown links [text](url)
+        r"|"
+        r"("  # Start capturing group for plaintext URLs
+        r"(?:https?://)?"  # Optional http:// or https://
+        r"(?:www\.)?"  # Optional www.
+        r"(?:[\w.-]+)?"  # Optional domain name and subdomains
+        r"\.[a-zA-Z]{2,}"  # TLD
+        r"(?:/[^\s\"')\]]*)?"  # Optional path
+        r")"
+    )
+    # all_urls.extend([url for url in match if url and parse.urlparse(url).scheme])
+    all_urls = []
+    for md_text, md_url, plain_url in re.findall(pattern, text):
+        url = md_url or plain_url
+        if url and parse.urlparse(url).scheme:
+            all_urls.append(url)
+
+    urls = set(map(clean_url, all_urls))  # remove extra characters and make unique
+    # bad_urls = [x for x in urls if not is_url(x, check=True)]  # single-thread
+    with ThreadPoolExecutor(max_workers=16) as executor:  # multi-thread
+        bad_urls = [url for url, valid in zip(urls, executor.map(lambda x: not is_url(x, check=True), urls)) if valid]
+
+    passing = not bad_urls
+    if verbose and not passing:
+        print(f"WARNING ⚠️ errors found in URLs {bad_urls}")
+
+    return (passing, bad_urls) if return_bad else passing
+
+
+if __name__ == "__main__":
+    print(is_url("https://ultralytics.com/images/bus.jpg"))

actions/utils/github_utils.py

@@ -0,0 +1,163 @@
+# Ultralytics Actions 🚀, AGPL-3.0 license https://ultralytics.com/license
+import json
+import os
+from pathlib import Path
+
+import requests
+
+from actions import __version__
+
+GITHUB_API_URL = "https://api.github.com"
+
+
+class Action:
+    """Handles GitHub Actions API interactions and event processing."""
+
+    def __init__(
+        self,
+        token: str = None,
+        event_name: str = None,
+        event_data: dict = None,
+    ):
+        """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.pr = self.event_data.get("pull_request", {})
+        self.repository = self.event_data.get("repository", {}).get("full_name")
+        self.headers = {"Authorization": f"token {self.token}", "Accept": "application/vnd.github.v3+json"}
+        self.headers_diff = {"Authorization": f"token {self.token}", "Accept": "application/vnd.github.v3.diff"}
+
+    @staticmethod
+    def _load_event_data(event_path: str) -> dict:
+        """Loads GitHub event data from path if it exists."""
+        if event_path and Path(event_path).exists():
+            return json.loads(Path(event_path).read_text())
+        return {}
+
+    def get_username(self) -> str | None:
+        """Gets username associated with the GitHub token."""
+        query = "query { viewer { login } }"
+        response = requests.post(f"{GITHUB_API_URL}/graphql", json={"query": query}, headers=self.headers)
+        if response.status_code != 200:
+            print(f"Failed to fetch authenticated user. Status code: {response.status_code}")
+            return None
+        try:
+            return response.json()["data"]["viewer"]["login"]
+        except KeyError as e:
+            print(f"Error parsing authenticated user response: {e}")
+            return None
+
+    def get_pr_diff(self) -> str:
+        """Retrieves the diff content for a specified pull request."""
+        url = f"{GITHUB_API_URL}/repos/{self.repository}/pulls/{self.pr.get('number')}"
+        r = requests.get(url, headers=self.headers_diff)
+        return r.text if r.status_code == 200 else ""
+
+    def get_repo_data(self, endpoint: str) -> dict:
+        """Fetches repository data from a specified endpoint."""
+        r = requests.get(f"{GITHUB_API_URL}/repos/{self.repository}/{endpoint}", headers=self.headers)
+        r.raise_for_status()
+        return r.json()
+
+    def graphql_request(self, query: str, variables: dict = None) -> dict:
+        """Executes a GraphQL query against the GitHub API."""
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+            "Accept": "application/vnd.github.v4+json",
+        }
+        r = requests.post(f"{GITHUB_API_URL}/graphql", json={"query": query, "variables": variables}, headers=headers)
+        r.raise_for_status()
+        result = r.json()
+        success = "data" in result and not result.get("errors")
+        print(
+            f"{'Successful' if success else 'Failed'} discussion GraphQL request: {result.get('errors', 'No errors')}"
+        )
+        return result
+
+    def print_info(self):
+        """Print GitHub Actions information."""
+        info = {
+            "github.event_name": self.event_name,
+            "github.event.action": self.event_data.get("action"),
+            "github.repository": self.repository,
+            "github.event.pull_request.number": self.pr.get("number"),
+            "github.event.pull_request.head.repo.full_name": self.pr.get("head", {}).get("repo", {}).get("full_name"),
+            "github.actor": os.environ.get("GITHUB_ACTOR"),
+            "github.event.pull_request.head.ref": self.pr.get("head", {}).get("ref"),
+            "github.ref": os.environ.get("GITHUB_REF"),
+            "github.head_ref": os.environ.get("GITHUB_HEAD_REF"),
+            "github.base_ref": os.environ.get("GITHUB_BASE_REF"),
+            "github.base_sha": self.pr.get("base", {}).get("sha"),
+        }
+
+        if self.event_name == "discussion":
+            discussion = self.event_data.get("discussion", {})
+            info |= {
+                "github.event.discussion.node_id": discussion.get("node_id"),
+                "github.event.discussion.number": discussion.get("number"),
+            }
+
+        max_key_length = max(len(key) for key in info)
+        header = f"Ultralytics Actions {__version__} Information " + "-" * 40
+        print(header)
+        for key, value in info.items():
+            print(f"{key:<{max_key_length + 5}}{value}")
+        print("-" * len(header))
+
+
+def ultralytics_actions_info():
+    """Returns GitHub Actions environment information and configuration details for Ultralytics workflows."""
+    Action().print_info()
+
+
+def check_pypi_version(pyproject_toml="pyproject.toml"):
+    """Compares local and PyPI package versions to determine if a new version should be published."""
+    import re
+
+    import tomllib  # requires Python>=3.11
+
+    version_pattern = re.compile(r"^\d+\.\d+\.\d+$")  # e.g. 0.0.0
+
+    with open(pyproject_toml, "rb") as f:
+        pyproject = tomllib.load(f)
+
+    package_name = pyproject["project"]["name"]
+    local_version = pyproject["project"].get("version", "dynamic")
+
+    # If version is dynamic, extract it from the specified file
+    if local_version == "dynamic":
+        version_attr = pyproject["tool"]["setuptools"]["dynamic"]["version"]["attr"]
+        module_path, attr_name = version_attr.rsplit(".", 1)
+        with open(f"{module_path.replace('.', '/')}/__init__.py") as f:
+            local_version = next(line.split("=")[1].strip().strip("'\"") for line in f if line.startswith(attr_name))
+
+    print(f"Local Version: {local_version}")
+    if not bool(version_pattern.match(local_version)):
+        print("WARNING: Incorrect local version pattern")
+        return "0.0.0", "0.0.0", False
+
+    # Get online version from PyPI
+    response = requests.get(f"https://pypi.org/pypi/{package_name}/json")
+    online_version = response.json()["info"]["version"] if response.status_code == 200 else None
+    print(f"Online Version: {online_version or 'Not Found'}")
+
+    # Determine if a new version should be published
+    if online_version:
+        local_ver = tuple(map(int, local_version.split(".")))
+        online_ver = tuple(map(int, online_version.split(".")))
+        major_diff = local_ver[0] - online_ver[0]
+        minor_diff = local_ver[1] - online_ver[1]
+        patch_diff = local_ver[2] - online_ver[2]
+
+        publish = (
+            (major_diff == 0 and minor_diff == 0 and 0 < patch_diff <= 2)
+            or (major_diff == 0 and minor_diff == 1 and local_ver[2] == 0)
+            or (major_diff == 1 and local_ver[1] == 0 and local_ver[2] == 0)
+        )  # should publish an update
+    else:
+        publish = True  # publish as this is likely a first release
+
+    return local_version, online_version, publish