ultralytics-actions 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

actions/__init__.py

@@ -18,6 +18,7 @@
 # │   ├── scan_prs.py
 # │   ├── summarize_pr.py
 # │   ├── summarize_release.py
+# │   ├── format_python_docstrings.py
 # │   ├── update_file_headers.py
 # │   └── update_markdown_code_blocks.py
 # └── tests/
@@ -26,4 +27,4 @@
 #     ├── test_summarize_pr.py
 #     └── ...
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

actions/first_interaction.py

@@ -7,7 +7,7 @@ import time
 
 from . import review_pr
 from .summarize_pr import SUMMARY_MARKER
-from .utils import ACTIONS_CREDIT, Action, filter_labels, get_completion, get_pr_open_response, remove_html_comments
+from .utils import ACTIONS_CREDIT, Action, filter_labels, get_pr_open_response, get_response, remove_html_comments
 
 BLOCK_USER = os.getenv("BLOCK_USER", "false").lower() == "true"
 AUTO_PR_REVIEW = os.getenv("REVIEW", "true").lower() == "true"
@@ -91,7 +91,7 @@ YOUR RESPONSE (label names only):
         },
         {"role": "user", "content": prompt},
     ]
-    suggested_labels = get_completion(messages, temperature=1.0)
+    suggested_labels = get_response(messages, temperature=1.0)
     if "none" in suggested_labels.lower():
         return []
 
@@ -170,7 +170,7 @@ YOUR {issue_type.upper()} RESPONSE:
         },
         {"role": "user", "content": prompt},
     ]
-    return get_completion(messages)
+    return get_response(messages)
 
 
 def main(*args, **kwargs):

actions/format_python_docstrings.py

@@ -0,0 +1,511 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+import ast
+import re
+import sys
+import time
+from pathlib import Path
+
+SECTIONS = ("Args", "Attributes", "Methods", "Returns", "Yields", "Raises", "Example", "Notes", "References")
+LIST_RX = re.compile(r"""^(\s*)(?:[-*•]\s+|(?:\d+|[A-Za-z]+)[\.\)]\s+)""")
+TABLE_RX = re.compile(r"^\s*\|.*\|\s*$")
+TABLE_RULE_RX = re.compile(r"^\s*[:\-\|\s]{3,}$")
+TREE_CHARS = ("└", "├", "│", "─")
+
+
+def wrap_words(words: list[str], width: int, indent: int, min_words_per_line: int = 1) -> list[str]:
+    """Wrap words to width with indent; optionally avoid very short orphan lines."""
+    pad = " " * indent
+    if not words:
+        return []
+    lines: list[list[str]] = []
+    cur: list[str] = []
+    cur_len = indent
+    for w in words:
+        need = len(w) + (1 if cur else 0)
+        if cur and cur_len + need > width:
+            lines.append(cur)
+            cur, cur_len = [w], indent + len(w)
+        else:
+            cur.append(w)
+            cur_len += need
+    if cur:
+        lines.append(cur)
+
+    # Rebalance to avoid too-short continuation lines when requested
+    if min_words_per_line > 1:
+        i = 1
+        while i < len(lines):
+            if len(lines[i]) < min_words_per_line and len(lines[i - 1]) > 1:
+                donor = lines[i - 1][-1]
+                this_len = len(pad) + sum(len(w) for w in lines[i]) + (len(lines[i]) - 1)
+                if this_len + (1 if lines[i] else 0) + len(donor) <= width:
+                    lines[i - 1].pop()
+                    lines[i].insert(0, donor)
+                    if i - 1 > 0 and len(lines[i - 1]) == 1:
+                        i -= 1
+                        continue
+            i += 1
+
+    return [pad + " ".join(line) for line in lines]
+
+
+def wrap_para(text: str, width: int, indent: int, min_words_per_line: int = 1) -> list[str]:
+    """Wrap a paragraph string; orphan control via min_words_per_line."""
+    text = text.strip()
+    if not text:
+        return []
+    return wrap_words(text.split(), width, indent, min_words_per_line)
+
+
+def wrap_hanging(head: str, desc: str, width: int, cont_indent: int) -> list[str]:
+    """Wrap 'head + desc' with hanging indent; ensure first continuation has ≥2 words."""
+    room = width - len(head)
+    words = desc.split()
+    if not words:
+        return [head.rstrip()]
+
+    take, used = [], 0
+    for w in words:
+        need = len(w) + (1 if take else 0)
+        if used + need <= room:
+            take.append(w)
+            used += need
+        else:
+            break
+
+    out: list[str] = []
+    if take:
+        out.append(head + " ".join(take))
+        rest = words[len(take) :]
+    else:
+        out.append(head.rstrip())
+        rest = words
+
+    out.extend(wrap_words(rest, width, cont_indent, min_words_per_line=2))
+    return out
+
+
+def is_list_item(s: str) -> bool:
+    """True if s looks like a bullet/numbered list item."""
+    return bool(LIST_RX.match(s.lstrip()))
+
+
+def is_fence_line(s: str) -> bool:
+    t = s.lstrip()
+    return t.startswith("```")
+
+
+def is_table_like(s: str) -> bool:
+    return bool(TABLE_RX.match(s)) or bool(TABLE_RULE_RX.match(s))
+
+
+def is_tree_like(s: str) -> bool:
+    return any(ch in s for ch in TREE_CHARS)
+
+
+def is_indented_block_line(s: str) -> bool:
+    # Treat lines with >=8 leading spaces or any tab as preformatted
+    return bool(s.startswith("        ")) or s.startswith("\t")
+
+
+def header_name(line: str) -> str | None:
+    """Return canonical section header or None."""
+    s = line.strip()
+    if not s.endswith(":") or len(s) <= 1:
+        return None
+    name = s[:-1].strip()
+    if name == "Examples":
+        name = "Example"
+    if name == "Note":
+        name = "Notes"
+    return name if name in SECTIONS else None
+
+
+def add_header(lines: list[str], indent: int, title: str, opener_line: str) -> None:
+    """Append a section header; no blank before first header, exactly one before subsequent ones."""
+    while lines and lines[-1] == "":
+        lines.pop()
+    if lines and lines[-1] != opener_line:
+        lines.append("")
+    lines.append(" " * indent + f"{title}:")
+
+
+def emit_paragraphs(
+    src: list[str], width: int, indent: int, list_indent: int | None = None, orphan_min: int = 1
+) -> list[str]:
+    """Wrap normal text; preserve lists, fenced code, tables, ASCII trees, and deeply-indented blocks."""
+    out: list[str] = []
+    buf: list[str] = []
+    in_fence = False
+
+    def flush():
+        nonlocal buf
+        if buf:
+            out.extend(wrap_para(" ".join(x.strip() for x in buf), width, indent, min_words_per_line=orphan_min))
+            buf = []
+
+    for raw in src:
+        s = raw.rstrip("\n")
+        stripped = s.strip()
+
+        # blank line
+        if not stripped:
+            flush()
+            out.append("")
+            continue
+
+        # fence start/stop
+        if is_fence_line(s):
+            flush()
+            out.append(s.rstrip())
+            in_fence = not in_fence
+            continue
+
+        if in_fence or is_table_like(s) or is_tree_like(s) or is_indented_block_line(s):
+            flush()
+            out.append(s.rstrip())
+            continue
+
+        if is_list_item(s):
+            flush()
+            out.append((" " * list_indent + stripped) if list_indent is not None else s.rstrip())
+            continue
+
+        buf.append(s)
+    flush()
+    while out and out[-1] == "":
+        out.pop()
+    return out
+
+
+def parse_sections(text: str) -> dict[str, list[str]]:
+    """Parse Google-style docstring into sections."""
+    parts = {k: [] for k in ("summary", "description", *SECTIONS)}
+    cur = "summary"
+    for raw in text.splitlines():
+        line = raw.rstrip("\n")
+        h = header_name(line)
+        if h:
+            cur = h
+            continue
+        if not line.strip():
+            if cur == "summary" and parts["summary"]:
+                cur = "description"
+            if parts[cur]:
+                parts[cur].append("")
+            continue
+        parts[cur].append(line)
+    return parts
+
+
+def looks_like_param(s: str) -> bool:
+    """Heuristic: 'name:' without being a list item."""
+    if is_list_item(s) or ":" not in s:
+        return False
+    head = s.split(":", 1)[0].strip()
+    return bool(head)
+
+
+def iter_items(lines: list[str]) -> list[list[str]]:
+    """Group lines into logical items separated by next param."""
+    items, i, n = [], 0, len(lines)
+    while i < n:
+        while i < n and not lines[i].strip():
+            i += 1
+        if i >= n:
+            break
+        item = [lines[i]]
+        i += 1
+        while i < n:
+            st = lines[i].strip()
+            if st and looks_like_param(st):
+                break
+            item.append(lines[i])
+            i += 1
+        items.append(item)
+    return items
+
+
+def format_structured_block(lines: list[str], width: int, base: int) -> list[str]:
+    """Format Args/Returns/etc.; continuation at base+4, lists at base+8. Preserve missing colons."""
+    out: list[str] = []
+    cont, lst = base + 4, base + 8
+    for item in iter_items(lines):
+        first = item[0].strip()
+        name, desc = ([*first.split(":", 1), ""])[:2]
+        name, desc = name.strip(), desc.strip()
+        had_colon = ":" in first
+
+        if not name or (" " in name and "(" not in name and ")" not in name):
+            out.extend(emit_paragraphs(item, width, cont, lst, orphan_min=2))
+            continue
+
+        head = " " * cont + (f"{name}: " if (desc or had_colon) else name)
+        out.extend(wrap_hanging(head, desc, width, cont + 4))
+
+        tail = item[1:]
+        if tail:
+            body = emit_paragraphs(tail, width, cont + 4, lst, orphan_min=2)
+            if body:
+                out.extend(body)
+    return out
+
+
+def detect_opener(original_literal: str) -> tuple[str, str, bool]:
+    """Return (prefix, quotes, inline_hint) from the original string token safely."""
+    s = original_literal.lstrip()
+    i = 0
+    while i < len(s) and s[i] in "rRuUbBfF":
+        i += 1
+    quotes = '"""'
+    if i + 3 <= len(s) and s[i : i + 3] in ('"""', "'''"):
+        quotes = s[i : i + 3]
+    keep = "".join(ch for ch in s[:i] if ch in "rRuU")
+    j = i + len(quotes)
+    inline_hint = j < len(s) and s[j : j + 1] not in {"", "\n", "\r"}
+    return keep, quotes, inline_hint
+
+
+def format_google(text: str, indent: int, width: int, quotes: str, prefix: str, inline_first_line: bool) -> str:
+    """Format multi-line Google-style docstring with given quotes/prefix."""
+    p = parse_sections(text)
+    opener = prefix + quotes
+    out = [opener]
+    if p["summary"]:
+        lines = emit_paragraphs(p["summary"], width, indent, list_indent=indent, orphan_min=1)
+        if inline_first_line and lines:
+            pad = " " * indent
+            first = lines[0][len(pad) :] if lines[0].startswith(pad) else lines[0].lstrip()
+            out[0] = opener + first
+            out.extend(lines[1:])
+        else:
+            out.extend(lines)
+    if any(x.strip() for x in p["description"]):
+        out.append("")
+        out.extend(emit_paragraphs(p["description"], width, indent, list_indent=indent, orphan_min=1))
+    for sec in ("Args", "Attributes", "Methods", "Returns", "Yields", "Raises"):
+        if any(x.strip() for x in p[sec]):
+            add_header(out, indent, sec, opener)
+            out.extend(format_structured_block(p[sec], width, indent))
+    for sec in ("Example", "Notes", "References"):
+        if any(x.strip() for x in p[sec]):
+            title = "Examples" if sec == "Example" else sec
+            add_header(out, indent, title, opener)
+            out.extend(x.rstrip() for x in p[sec])
+    while out and out[-1] == "":
+        out.pop()
+    out.append(" " * indent + quotes)
+    return "\n".join(out)
+
+
+def format_docstring(
+    content: str,
+    indent: int,
+    width: int,
+    quotes: str,
+    prefix: str,
+    inline_hint: bool,
+    preserve_inline: bool = True,
+) -> str:
+    """Single-line if short/sectionless/no-lists; else Google-style. Preserve quotes/prefix."""
+    if not content or not content.strip():
+        return f"{prefix}{quotes}{quotes}"
+    text = content.strip()
+    has_section = any(f"{s}:" in text for s in (*SECTIONS, "Examples"))
+    has_list = any(is_list_item(l) for l in text.splitlines())
+    single_ok = (
+        ("\n" not in text)
+        and not has_section
+        and not has_list
+        and (indent + len(prefix) + len(quotes) * 2 + len(text) <= width)
+    )
+    if single_ok:
+        words = text.split()
+        if words and not (words[0].startswith(("http://", "https://")) or words[0][0].isupper()):
+            words[0] = words[0][0].upper() + words[0][1:]
+        out = " ".join(words)
+        if out and out[-1] not in ".!?":
+            out += "."
+        return f"{prefix}{quotes}{out}{quotes}"
+    return format_google(text, indent, width, quotes, prefix, inline_first_line=(preserve_inline and inline_hint))
+
+
+class Visitor(ast.NodeVisitor):
+    """Collect docstring replacements for classes and functions."""
+
+    def __init__(self, src: list[str], width: int = 120, preserve_inline: bool = True):
+        """Init with source lines, target width, and inline preservation flag."""
+        self.src, self.width, self.repl, self.preserve_inline = src, width, [], preserve_inline
+
+    def visit_Module(self, node):
+        """Skip module docstring; visit children."""
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node):
+        self._handle(node)
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        self._handle(node)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        self._handle(node)
+        self.generic_visit(node)
+
+    def _handle(self, node):
+        """If first stmt is a string expr, schedule replacement."""
+        try:
+            doc = ast.get_docstring(node, clean=False)
+            if not doc or not node.body or not isinstance(node.body[0], ast.Expr):
+                return
+            s = node.body[0].value
+            if not (isinstance(s, ast.Constant) and isinstance(s.value, str)):
+                return
+            sl, el = node.body[0].lineno - 1, node.body[0].end_lineno - 1
+            sc, ec = node.body[0].col_offset, node.body[0].end_col_offset
+            if sl < 0 or el >= len(self.src):
+                return
+            original = (
+                self.src[sl][sc:ec]
+                if sl == el
+                else "\n".join([self.src[sl][sc:], *self.src[sl + 1 : el], self.src[el][:ec]])
+            )
+            prefix, quotes, inline_hint = detect_opener(original)
+            formatted = format_docstring(doc, sc, self.width, quotes, prefix, inline_hint, self.preserve_inline)
+            if formatted.strip() != original.strip():
+                self.repl.append((sl, el, sc, ec, formatted))
+        except Exception:
+            return
+
+
+def format_python_file(text: str, width: int = 120, preserve_inline: bool = True) -> str:
+    """Return source with reformatted docstrings; on failure, return original."""
+    if not text.strip():
+        return text
+    try:
+        tree = ast.parse(text)
+    except SyntaxError:
+        return text
+    src = text.splitlines()
+    v = Visitor(src, width, preserve_inline=preserve_inline)
+    try:
+        v.visit(tree)
+    except Exception:
+        return text
+    for sl, el, sc, ec, rep in reversed(v.repl):
+        try:
+            if sl == el:
+                src[sl] = src[sl][:sc] + rep + src[sl][ec:]
+            else:
+                nl = rep.splitlines()
+                nl[0] = src[sl][:sc] + nl[0]
+                nl[-1] += src[el][ec:]
+                src[sl : el + 1] = nl
+        except Exception:
+            continue
+    return "\n".join(src)
+
+
+def preserve_trailing_newlines(original: str, formatted: str) -> str:
+    """Preserve the original trailing newline count."""
+    o = len(original) - len(original.rstrip("\n"))
+    f = len(formatted) - len(formatted.rstrip("\n"))
+    return formatted if o == f else formatted.rstrip("\n") + ("\n" * o)
+
+
+def iter_py_files(paths: list[Path]) -> list[Path]:
+    """Expand input paths to sorted unique *.py files."""
+    out: list[Path] = []
+    for p in paths:
+        if p.is_dir():
+            out.extend(sorted(p.rglob("*.py")))
+        elif p.is_file() and p.suffix == ".py":
+            out.append(p)
+    seen, uniq = set(), []
+    for f in out:
+        if f not in seen:
+            seen.add(f)
+            uniq.append(f)
+    return uniq
+
+
+def process_file(path: Path, width: int = 120, check: bool = False, preserve_inline: bool = True) -> bool:
+    """Process one file; True if unchanged/success, False if changed."""
+    if path.suffix != ".py":
+        return True
+    try:
+        orig = path.read_text(encoding="utf-8")
+        fmt = preserve_trailing_newlines(orig, format_python_file(orig, width, preserve_inline=preserve_inline))
+        if check:
+            if orig != fmt:
+                print(f"  {path}")
+                return False
+            return True
+        if orig != fmt:
+            path.write_text(fmt, encoding="utf-8")
+            print(f"  {path}")
+            return False
+        return True
+    except Exception as e:
+        print(f"  Error: {path}: {e}")
+        return True
+
+
+def parse_cli(argv: list[str]) -> tuple[list[Path], int, bool, bool]:
+    """Minimal argv parser: (paths, width, check, preserve_inline)."""
+    width, check, paths, preserve_inline = 120, False, [], True
+    for a in argv:
+        if a == "--check":
+            check = True
+        elif a == "--no-preserve-inline":
+            preserve_inline = False
+        elif a.startswith("--line-width="):
+            try:
+                width = int(a.split("=", 1)[1])
+            except ValueError:
+                pass
+        else:
+            paths.append(Path(a))
+    return paths, width, check, preserve_inline
+
+
+def main() -> None:
+    """CLI entry point."""
+    args = sys.argv[1:]
+    if not args:
+        print(
+            "Usage: format_python_docstrings.py [--check] [--no-preserve-inline] [--line-width=120] <files_or_dirs...>"
+        )
+        return
+    paths, width, check, preserve_inline = parse_cli(args)
+    files = iter_py_files(paths)
+    if not files:
+        print("No Python files found")
+        return
+
+    t0 = time.time()
+    print(f"{'Checking' if check else 'Formatting'} {len(files)} file{'s' if len(files) != 1 else ''}")
+    changed = sum(not process_file(f, width, check, preserve_inline=preserve_inline) for f in files)
+
+    dur = time.time() - t0
+    if changed:
+        verb = "would be reformatted" if check else "reformatted"
+        unchanged = len(files) - changed
+        parts = []
+        if changed:
+            parts.append(f"{changed} file{'s' if changed != 1 else ''} {verb}")
+        if unchanged:
+            parts.append(f"{unchanged} file{'s' if unchanged != 1 else ''} left unchanged")
+        print(f"{', '.join(parts)} ({dur:.1f}s)")
+        if check:
+            sys.exit(1)
+    else:
+        print(f"{len(files)} file{'s' if len(files) != 1 else ''} left unchanged ({dur:.1f}s)")
+
+
+if __name__ == "__main__":
+    main()

actions/review_pr.py

@@ -4,8 +4,9 @@ from __future__ import annotations
 
 import json
 import re
+from pathlib import Path
 
-from .utils import ACTIONS_CREDIT, GITHUB_API_URL, MAX_PROMPT_CHARS, Action, get_completion, remove_html_comments
+from .utils import ACTIONS_CREDIT, GITHUB_API_URL, MAX_PROMPT_CHARS, Action, get_response, remove_html_comments
 
 REVIEW_MARKER = "## 🔍 PR Review"
 ERROR_MARKER = "⚠️ Review generation encountered an error"
@@ -69,7 +70,9 @@ def parse_diff_files(diff_text: str) -> tuple[dict, str]:
     return files, "\n".join(augmented_lines)
 
 
-def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_description: str) -> dict:
+def generate_pr_review(
+    repository: str, diff_text: str, pr_title: str, pr_description: str, event: Action = None
+) -> dict:
     """Generate comprehensive PR review with line-specific comments and overall assessment."""
     if not diff_text:
         return {"comments": [], "summary": "No changes detected in diff"}
@@ -94,6 +97,28 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
     diff_truncated = len(augmented_diff) > MAX_PROMPT_CHARS
     lines_changed = sum(len(sides["RIGHT"]) + len(sides["LEFT"]) for sides in diff_files.values())
 
+    # Fetch full file contents for better context if within token budget
+    full_files_section = ""
+    if event and len(file_list) <= 10:  # Reasonable file count limit
+        file_contents = []
+        total_chars = len(augmented_diff)
+        for file_path in file_list:
+            try:
+                local_path = Path(file_path)
+                if not local_path.exists():
+                    continue
+                content = local_path.read_text(encoding="utf-8")
+                # Only include if within budget
+                if total_chars + len(content) + 1000 < MAX_PROMPT_CHARS:  # 1000 char buffer for formatting
+                    file_contents.append(f"### {file_path}\n```\n{content}\n```")
+                    total_chars += len(content) + 1000
+                else:
+                    break  # Stop when we hit budget limit
+            except Exception:
+                continue
+        if file_contents:
+            full_files_section = f"FULL FILE CONTENTS:\n{chr(10).join(file_contents)}\n\n"
+
     content = (
         "You are an expert code reviewer for Ultralytics. Review the code changes and provide inline comments where you identify issues or opportunities for improvement.\n\n"
         "Focus on: bugs, security vulnerabilities, performance issues, best practices, edge cases, error handling, and code clarity.\n\n"
@@ -113,6 +138,7 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
         "- For single-line fixes: provide 'suggestion' without 'start_line' to replace the line at 'line'\n"
         "- Do not provide multi-line fixes: suggestions should only be single line\n"
         "- Match the exact indentation of the original code\n"
+        "- Web search is available to consult docs, dependencies, or technical details\n"
         "- Avoid triple backticks (```) in suggestions as they break markdown formatting\n\n"
         "LINE NUMBERS:\n"
         "- Each line in the diff is prefixed with its line number for clarity:\n"
@@ -141,6 +167,7 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
                 f"Review this PR in https://github.com/{repository}:\n\n"
                 f"TITLE:\n{pr_title}\n\n"
                 f"BODY:\n{remove_html_comments(pr_description or '')[:1000]}\n\n"
+                f"{full_files_section}"
                 f"DIFF:\n{augmented_diff[:MAX_PROMPT_CHARS]}\n\n"
                 "Now review this diff according to the rules above. Return JSON with comments array and summary."
             ),
@@ -152,10 +179,37 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
     # print(f"\nUser prompt (first 3000 chars):\n{messages[1]['content'][:3000]}...\n")
 
     try:
-        response = get_completion(
+        schema = {
+            "type": "object",
+            "properties": {
+                "comments": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "file": {"type": "string"},
+                            "line": {"type": "integer"},
+                            "side": {"type": "string", "enum": ["LEFT", "RIGHT"]},
+                            "severity": {"type": "string", "enum": ["CRITICAL", "HIGH", "MEDIUM", "LOW", "SUGGESTION"]},
+                            "message": {"type": "string"},
+                            "start_line": {"type": ["integer", "null"]},
+                            "suggestion": {"type": ["string", "null"]},
+                        },
+                        "required": ["file", "line", "side", "severity", "message", "start_line", "suggestion"],
+                        "additionalProperties": False,
+                    },
+                },
+                "summary": {"type": "string"},
+            },
+            "required": ["comments", "summary"],
+            "additionalProperties": False,
+        }
+
+        response = get_response(
             messages,
             reasoning_effort="low",
             model="gpt-5-codex",
+            text_format={"format": {"type": "json_schema", "name": "pr_review", "strict": True, "schema": schema}},
             tools=[
                 {
                     "type": "web_search",
@@ -170,17 +224,15 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
             ],
         )
 
-        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(json.dumps(review_data, indent=2))
+        print(json.dumps(response, indent=2))
 
         # Count comments BEFORE filtering (for COMMENT vs APPROVE decision)
-        comments_before_filtering = len(review_data.get("comments", []))
+        comments_before_filtering = len(response.get("comments", []))
         print(f"AI generated {comments_before_filtering} comments")
 
         # Validate, filter, and deduplicate comments
         unique_comments = {}
-        for c in review_data.get("comments", []):
+        for c in response.get("comments", []):
             file_path, line_num = c.get("file"), c.get("line", 0)
             start_line = c.get("start_line")
             side = (c.get("side") or "RIGHT").upper()  # Default to RIGHT (added lines)
@@ -218,7 +270,7 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
             else:
                 print(f"⚠️  AI duplicate for {key}: {c.get('severity')} - {(c.get('message') or '')[:60]}...")
 
-        review_data.update(
+        response.update(
             {
                 "comments": list(unique_comments.values()),
                 "comments_before_filtering": comments_before_filtering,
@@ -227,8 +279,8 @@ def generate_pr_review(repository: str, diff_text: str, pr_title: str, pr_descri
                 "skipped_files": skipped_count,
             }
         )
-        print(f"Valid comments after filtering: {len(review_data['comments'])}")
-        return review_data
+        print(f"Valid comments after filtering: {len(response['comments'])}")
+        return response
 
     except Exception as e:
         import traceback
@@ -360,7 +412,7 @@ def main(*args, **kwargs):
     review_number = dismiss_previous_reviews(event)
 
     diff = event.get_pr_diff()
-    review = generate_pr_review(event.repository, diff, event.pr.get("title") or "", event.pr.get("body") or "")
+    review = generate_pr_review(event.repository, diff, event.pr.get("title") or "", event.pr.get("body") or "", event)
 
     post_review_summary(event, review, review_number)
     print("PR review completed")

actions/scan_prs.py

@@ -24,32 +24,70 @@ def get_phase_emoji(age_days):
         return "🔴", f"{age_days} days"
 
 
-def run():
-    """List open PRs across organization and auto-merge eligible Dependabot PRs."""
-    # Get and validate settings
-    org = os.getenv("ORG", "ultralytics")
-    visibility = os.getenv("VISIBILITY", "public").lower()
-    repo_visibility = os.getenv("REPO_VISIBILITY", "public").lower()
-    valid_visibilities = {"public", "private", "internal", "all"}
+def parse_visibility(visibility_input, repo_visibility):
+    """Parse and validate visibility settings with security checks."""
+    valid = {"public", "private", "internal", "all"}
+    stripped = [v.strip() for v in visibility_input.lower().split(",") if v.strip()]
+    repo_visibility = (repo_visibility or "").lower()
+
+    # Warn about invalid values
+    if invalid := [v for v in stripped if v not in valid]:
+        print(f"⚠️  Invalid visibility values: {', '.join(invalid)} - ignoring")
+
+    visibility_list = [v for v in stripped if v in valid]
+    if not visibility_list:
+        print("⚠️  No valid visibility values, defaulting to 'public'")
+        return ["public"]
+
+    # Security: public repos can only scan public repos
+    if repo_visibility == "public" and visibility_list != ["public"]:
+        print("⚠️  Security: Public repo cannot scan non-public repos. Restricting to public only.")
+        return ["public"]
+
+    return visibility_list
 
-    if visibility not in valid_visibilities:
-        print(f"⚠️  Invalid visibility '{visibility}', defaulting to 'public'")
-        visibility = "public"
 
-    # Security: if calling repo is public, restrict to public repos only
-    if repo_visibility == "public" and visibility != "public":
-        print(f"⚠️  Security: Public repo cannot scan {visibility} repos. Restricting to public only.")
-        visibility = "public"
+def get_repo_filter(visibility_list):
+    """Return filtering strategy for repo visibility."""
+    if len(visibility_list) == 1 and visibility_list[0] != "all":
+        return {"flag": ["--visibility", visibility_list[0]], "filter": None, "str": visibility_list[0]}
 
-    print(f"🔍 Scanning {visibility} repositories in {org} organization...")
+    filter_set = {"public", "private", "internal"} if "all" in visibility_list else set(visibility_list)
+    return {
+        "flag": [],
+        "filter": filter_set,
+        "str": "all" if "all" in visibility_list else ", ".join(sorted(visibility_list)),
+    }
 
-    # Get active repos with specified visibility
-    cmd = ["gh", "repo", "list", org, "--limit", "1000", "--json", "name,url,isArchived"]
-    if visibility != "all":
-        cmd.extend(["--visibility", visibility])
 
-    result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-    repos = {r["name"]: r["url"] for r in json.loads(result.stdout) if not r["isArchived"]}
+def get_status_checks(rollup):
+    """Extract and validate status checks from rollup, return failed checks."""
+    checks = rollup if isinstance(rollup, list) else rollup.get("contexts", []) if isinstance(rollup, dict) else []
+    return [c for c in checks if c.get("conclusion") not in ["SUCCESS", "SKIPPED", "NEUTRAL"]]
+
+
+def run():
+    """List open PRs across organization and auto-merge eligible Dependabot PRs."""
+    org = os.getenv("ORG", "ultralytics")
+    visibility_list = parse_visibility(os.getenv("VISIBILITY", "public"), os.getenv("REPO_VISIBILITY", "public"))
+    filter_config = get_repo_filter(visibility_list)
+
+    print(f"🔍 Scanning {filter_config['str']} repositories in {org} organization...")
+
+    # Get active repos
+    result = subprocess.run(
+        ["gh", "repo", "list", org, "--limit", "1000", "--json", "name,url,isArchived,visibility"]
+        + filter_config["flag"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    all_repos = [r for r in json.loads(result.stdout) if not r["isArchived"]]
+    repos = {
+        r["name"]: r["url"]
+        for r in all_repos
+        if not filter_config["filter"] or r["visibility"].lower() in filter_config["filter"]
+    }
 
     if not repos:
         print("⚠️  No repositories found")
@@ -84,25 +122,26 @@ def run():
         print("✅ No open PRs found")
         return
 
+    # Filter PRs to only include those from scanned repos
+    all_prs = [pr for pr in all_prs if pr["repository"]["name"] in repos]
+
+    if not all_prs:
+        print("✅ No open PRs found in scanned repositories")
+        return
+
     # Count PRs by phase
     phase_counts = {"new": 0, "green": 0, "yellow": 0, "red": 0}
     for pr in all_prs:
-        age_days = get_age_days(pr["createdAt"])
-        phase_counts[
-            "new" if age_days == 0 else "green" if age_days <= 7 else "yellow" if age_days <= 30 else "red"
-        ] += 1
+        age = get_age_days(pr["createdAt"])
+        phase_counts["new" if age == 0 else "green" if age <= 7 else "yellow" if age <= 30 else "red"] += 1
 
-    repo_count = len({pr["repository"]["name"] for pr in all_prs if pr["repository"]["name"] in repos})
     summary = [
         f"# 🔍 Open Pull Requests - {org.title()} Organization\n",
-        f"**Total:** {len(all_prs)} open PRs across {repo_count} repos",
-        f"**By Phase:** 🆕 {phase_counts['new']} New | 🟢 {phase_counts['green']} Green (≤7d) | 🟡 {phase_counts['yellow']} Yellow (≤30d) | 🔴 {phase_counts['red']} Red (>30d)\n",
+        f"**Total:** {len(all_prs)} open PRs across {len({pr['repository']['name'] for pr in all_prs})}/{len(repos)} {filter_config['str']} repos",
+        f"**By Phase:** 🆕 {phase_counts['new']} New | 🟢 {phase_counts['green']} ≤7d | 🟡 {phase_counts['yellow']} ≤30d | 🔴 {phase_counts['red']} >30d\n",
     ]
 
     for repo_name in sorted({pr["repository"]["name"] for pr in all_prs}):
-        if repo_name not in repos:
-            continue
-
         repo_prs = [pr for pr in all_prs if pr["repository"]["name"] == repo_name]
         summary.append(
             f"## 📦 [{repo_name}]({repos[repo_name]}) - {len(repo_prs)} open PR{'s' if len(repo_prs) > 1 else ''}"
@@ -110,7 +149,7 @@ def run():
 
         for pr in repo_prs[:30]:
             emoji, age_str = get_phase_emoji(get_age_days(pr["createdAt"]))
-            summary.append(f"- 🔀 [#{pr['number']}]({pr['url']}) {pr['title']} {emoji} {age_str}")
+            summary.append(f"- [#{pr['number']}]({pr['url']}) {pr['title']} {emoji} {age_str}")
 
         if len(repo_prs) > 30:
             summary.append(f"- ... {len(repo_prs) - 30} more PRs")
@@ -161,18 +200,8 @@ def run():
                 total_skipped += 1
                 continue
 
-            # Check if all status checks passed (normalize rollup structure)
-            rollup = pr.get("statusCheckRollup")
-            if isinstance(rollup, list):
-                checks = rollup
-            elif isinstance(rollup, dict):
-                checks = rollup.get("contexts", [])
-            else:
-                checks = []
-            failed_checks = [c for c in checks if c.get("conclusion") not in ["SUCCESS", "SKIPPED", "NEUTRAL"]]
-
-            if failed_checks:
-                for check in failed_checks:
+            if failed := get_status_checks(pr.get("statusCheckRollup")):
+                for check in failed:
                     print(f"    ❌ Failing check: {check.get('name', 'unknown')} = {check.get('conclusion')}")
                 total_skipped += 1
                 continue
@@ -195,7 +224,6 @@ def run():
     summary.append(f"\n**Summary:** Found {total_found} | Merged {total_merged} | Skipped {total_skipped}")
     print(f"\n📊 Dependabot Summary: Found {total_found} | Merged {total_merged} | Skipped {total_skipped}")
 
-    # Write to GitHub step summary if available
     if summary_file := os.getenv("GITHUB_STEP_SUMMARY"):
         with open(summary_file, "a") as f:
             f.write("\n".join(summary))

actions/summarize_pr.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from .utils import ACTIONS_CREDIT, GITHUB_API_URL, Action, get_completion, get_pr_summary_prompt
+from .utils import ACTIONS_CREDIT, GITHUB_API_URL, Action, get_pr_summary_prompt, get_response
 
 SUMMARY_MARKER = "## 🛠️ PR Summary"
 
@@ -24,7 +24,7 @@ def generate_merge_message(pr_summary, pr_credit, pr_url):
             ),
         },
     ]
-    return get_completion(messages)
+    return get_response(messages)
 
 
 def generate_issue_comment(pr_url, pr_summary, pr_credit, pr_title=""):
@@ -54,7 +54,7 @@ def generate_issue_comment(pr_url, pr_summary, pr_credit, pr_title=""):
             f"5. Thank 🙏 for reporting the issue and welcome any further feedback if the issue persists\n\n",
         },
     ]
-    return get_completion(messages)
+    return get_response(messages)
 
 
 def generate_pr_summary(repository, diff_text):
@@ -68,7 +68,7 @@ def generate_pr_summary(repository, diff_text):
         },
         {"role": "user", "content": prompt},
     ]
-    reply = get_completion(messages, temperature=1.0)
+    reply = get_response(messages, temperature=1.0)
     if is_large:
         reply = "**WARNING ⚠️** this PR is very large, summary may not cover all changes.\n\n" + reply
 

actions/summarize_release.py

@@ -8,7 +8,7 @@ import subprocess
 import time
 from datetime import datetime
 
-from .utils import GITHUB_API_URL, Action, get_completion, remove_html_comments
+from .utils import GITHUB_API_URL, Action, get_response, remove_html_comments
 
 # Environment variables
 CURRENT_TAG = os.getenv("CURRENT_TAG")
@@ -150,7 +150,7 @@ def generate_release_summary(
         },
     ]
     # print(messages[-1]["content"])  # for debug
-    return get_completion(messages, temperature=1.0) + release_suffix
+    return get_response(messages, temperature=1.0) + release_suffix
 
 
 def create_github_release(event, tag_name: str, name: str, body: str):

actions/update_markdown_code_blocks.py

@@ -38,7 +38,7 @@ 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."""
+    """Formats Python code files in the specified directory using ruff and Python docstring formatter."""
     if not next(Path(temp_dir).rglob("*.py"), None):
         return
 
@@ -81,23 +81,17 @@ def format_code_with_ruff(temp_dir):
         print(f"ERROR running ruff check ❌ {e}")
 
     try:
-        # Run docformatter
+        # Run Ultralytics Python docstring formatter
         subprocess.run(
             [
-                "docformatter",
-                "--wrap-summaries=120",
-                "--wrap-descriptions=120",
-                "--pre-summary-newline",
-                "--close-quotes-on-newline",
-                "--in-place",
-                "--recursive",
+                "ultralytics-actions-format-python-docstrings",
                 str(temp_dir),
             ],
             check=True,
         )
-        print("Completed docformatter ✅")
+        print("Completed Python docstring formatting ✅")
     except Exception as e:
-        print(f"ERROR running docformatter ❌ {e}")
+        print(f"ERROR running Python docstring formatter ❌ {e}")
 
 
 def format_bash_with_prettier(temp_dir):

actions/utils/__init__.py

@@ -13,10 +13,10 @@ from .github_utils import GITHUB_API_URL, GITHUB_GRAPHQL_URL, Action, ultralytic
 from .openai_utils import (
     MAX_PROMPT_CHARS,
     filter_labels,
-    get_completion,
     get_pr_open_response,
     get_pr_summary_guidelines,
     get_pr_summary_prompt,
+    get_response,
 )
 from .version_utils import check_pubdev_version, check_pypi_version
 
@@ -34,10 +34,10 @@ __all__ = (
     "check_pubdev_version",
     "check_pypi_version",
     "filter_labels",
-    "get_completion",
     "get_pr_open_response",
     "get_pr_summary_guidelines",
     "get_pr_summary_prompt",
+    "get_response",
     "remove_html_comments",
     "ultralytics_actions_info",
 )

actions/utils/openai_utils.py

@@ -109,13 +109,13 @@ def get_pr_first_comment_template(repository: str, username: str) -> str:
 For more guidance, please refer to our [Contributing Guide](https://docs.ultralytics.com/help/contributing/). Don't hesitate to leave a comment if you have any questions. Thank you for contributing to Ultralytics! 🚀"""
 
 
-def get_completion(
+def get_response(
     messages: list[dict[str, str]],
     check_links: bool = True,
     remove: list[str] = (" @giscus[bot]",),
     temperature: float = 1.0,
     reasoning_effort: str | None = None,
-    response_format: dict | None = None,
+    text_format: dict | None = None,
     model: str = OPENAI_MODEL,
     tools: list[dict] | None = None,
 ) -> str | dict:
@@ -130,6 +130,8 @@ def get_completion(
         data = {"model": model, "input": messages, "store": False, "temperature": temperature}
         if "gpt-5" in model:
             data["reasoning"] = {"effort": reasoning_effort or "low"}
+        if text_format:
+            data["text"] = text_format
         if tools:
             data["tools"] = tools
 
@@ -145,6 +147,11 @@ def get_completion(
                 time.sleep(2**attempt)
                 continue
 
+            if r.status_code >= 400:
+                error_body = r.text
+                print(f"API Error {r.status_code}: {error_body}")
+                r.reason = f"{r.reason}\n{error_body}"  # Add error body to exception message
+
             r.raise_for_status()
 
             # Parse response
@@ -173,7 +180,7 @@ def get_completion(
                     token_str += f" (+{thinking_tokens} thinking)"
                 print(f"{model} ({token_str} = {input_tokens + output_tokens} tokens, ${cost:.5f}, {elapsed:.1f}s)")
 
-            if response_format and response_format.get("type") == "json_object":
+            if text_format and text_format.get("format", {}).get("type") in ["json_object", "json_schema"]:
                 return json.loads(content)
 
             content = remove_outer_codeblocks(content)
@@ -230,16 +237,28 @@ Customized welcome message adapting the template below:
 - No spaces between bullet points
 
 Example comment template (adapt as needed, keep all links):
-{get_pr_first_comment_template(repository, username)}
-
-Return ONLY valid JSON in this exact format:
-{{"summary": "...", "labels": [...], "first_comment": "..."}}"""
+{get_pr_first_comment_template(repository, username)}"""
+
+    schema = {
+        "type": "object",
+        "properties": {
+            "summary": {"type": "string", "description": "PR summary with emoji sections"},
+            "labels": {"type": "array", "items": {"type": "string"}, "description": "Array of label names"},
+            "first_comment": {"type": "string", "description": "Welcome comment with checklist"},
+        },
+        "required": ["summary", "labels", "first_comment"],
+        "additionalProperties": False,
+    }
 
     messages = [
         {"role": "system", "content": "You are an Ultralytics AI assistant processing GitHub PRs."},
         {"role": "user", "content": prompt},
     ]
-    result = get_completion(messages, temperature=1.0, response_format={"type": "json_object"})
+    result = get_response(
+        messages,
+        temperature=1.0,
+        text_format={"format": {"type": "json_schema", "name": "pr_open_response", "strict": True, "schema": schema}},
+    )
     if is_large and "summary" in result:
         result["summary"] = (
             "**WARNING ⚠️** this PR is very large, summary may not cover all changes.\n\n" + result["summary"]
@@ -252,5 +271,5 @@ if __name__ == "__main__":
         {"role": "system", "content": "You are a helpful AI assistant."},
         {"role": "user", "content": "Explain how to export a YOLO11 model to CoreML."},
     ]
-    response = get_completion(messages)
+    response = get_response(messages)
     print(response)

{ultralytics_actions-0.2.1.dist-info → ultralytics_actions-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics-actions
-Version: 0.2.1
+Version: 0.2.2
 Summary: Ultralytics Actions for GitHub automation and PR management.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -30,7 +30,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.28.1
 Requires-Dist: ruff>=0.9.1
-Requires-Dist: docformatter>=1.7.5
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -68,8 +67,8 @@ AI-powered formatting, labeling, and PR summaries for Python, Swift, and Markdow
 ### 📄 Features
 
 - **Python Code:** Formatted using [Ruff](https://github.com/astral-sh/ruff), an extremely fast Python linter and formatter
+- **Python Docstrings:** Google-style formatting enforced with Ultralytics Python docstring formatter (optional)
 - **Markdown Files:** Styled with [Prettier](https://github.com/prettier/prettier) to ensure consistent documentation appearance
-- **Docstrings:** Cleaned and standardized using [docformatter](https://github.com/PyCQA/docformatter)
 - **Swift Code:** Formatted with [`swift-format`](https://github.com/swiftlang/swift-format) _(requires `macos-latest` runner)_
 - **Spell Check:** Common misspellings caught using [codespell](https://github.com/codespell-project/codespell)
 - **Broken Links Check:** Broken links identified using [Lychee](https://github.com/lycheeverse/lychee)
@@ -118,7 +117,8 @@ jobs:
         with:
           token: ${{ secrets.GITHUB_TOKEN }} # Auto-generated token
           labels: true # Auto-label issues/PRs using AI
-          python: true # Format Python with Ruff and docformatter
+          python: true # Format Python with Ruff
+          python_docstrings: false # Format Python docstrings (default: false)
           prettier: true # Format YAML, JSON, Markdown, CSS
           swift: false # Format Swift (requires macos-latest)
           dart: false # Format Dart/Flutter
@@ -166,7 +166,7 @@ List open PRs across an organization and auto-merge eligible Dependabot PRs.
   with:
     token: ${{ secrets.GITHUB_TOKEN }}
     org: ultralytics # Optional: defaults to ultralytics
-    visibility: public # Optional: public, private, internal, or all
+    visibility: private,internal # Optional: public, private, internal, all, or comma-separated
 ```
 
 [**📖 Full Documentation →**](scan-prs/README.md)

ultralytics_actions-0.2.2.dist-info/RECORD

@@ -0,0 +1,21 @@
+actions/__init__.py,sha256=GaEFrlnYBqX5C9GJF1MEGHZP1TVWbOfa7VSXFMaffHQ,927
+actions/dispatch_actions.py,sha256=ljlFR1o8m1qTHbStsJJVMVDdJv7iVqMfdPzKlZyKXl8,6743
+actions/first_interaction.py,sha256=FTPcXjtBkM0Egc6VR5eVMvjF6uvarditTx9qaaoPcnU,9809
+actions/format_python_docstrings.py,sha256=prK0U2EpwBlhkXgNnr72NsJFtSXTJaTCzMBcqL1N7wo,17150
+actions/review_pr.py,sha256=wuPYqtDwt92e990mx1kSyfciICgZ1ZxduCyhpx4tc4M,19790
+actions/scan_prs.py,sha256=y0J0PvEFVfWyB8SpGqyMXMhuPG7rGwrzkbkRL8VBS6A,8483
+actions/summarize_pr.py,sha256=NChej-45frhhYLiNZ67DqhaHbxMhsjzYQqIE6FoAOcs,5707
+actions/summarize_release.py,sha256=W1lgMdArgcte-_4h408eQH17t6H1giVnoIvnm-jR02g,9074
+actions/update_file_headers.py,sha256=E5fKYLdeW16-BHCcuqxohGpGZqgEh-WX4ZmCQJw2R90,6684
+actions/update_markdown_code_blocks.py,sha256=l3_nWNvujplYlY-Db3JOCG-qwMigp6BADjd7SaIEBpQ,8550
+actions/utils/__init__.py,sha256=RcmBEPaQIR9mtNt2rO96Eru69EkSOaJwP2Eb9SogQbY,1111
+actions/utils/common_utils.py,sha256=InBc-bsXcwzQYjuDxtrrm3bj7J-70U54G0s2nQKgCg8,12052
+actions/utils/github_utils.py,sha256=5yzNIiu7-WBmH1-gSi4O31m1Fwd4k8pfbwM2BPVGf88,19989
+actions/utils/openai_utils.py,sha256=XnteiRDrhQZRm9TTszM0qGO9fxSafRPJwQKM_zXuKvA,12753
+actions/utils/version_utils.py,sha256=EIbm3iZVNyNl3dh8aNz_9ITeTC93ZxfyUzIRkO3tSXw,3242
+ultralytics_actions-0.2.2.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+ultralytics_actions-0.2.2.dist-info/METADATA,sha256=Kt1MSjpUo7mgHfd6NTI8mJqEtJmjrMUxXXrFEolAsO0,12542
+ultralytics_actions-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ultralytics_actions-0.2.2.dist-info/entry_points.txt,sha256=HZhkijH7tyA2igb3OoS9K4xc-_yAl8kYNRVUobqeq7w,581
+ultralytics_actions-0.2.2.dist-info/top_level.txt,sha256=5apM5x80QlJcGbACn1v3fkmIuL1-XQCKcItJre7w7Tw,8
+ultralytics_actions-0.2.2.dist-info/RECORD,,

{ultralytics_actions-0.2.1.dist-info → ultralytics_actions-0.2.2.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 ultralytics-actions-first-interaction = actions.first_interaction:main
+ultralytics-actions-format-python-docstrings = actions.format_python_docstrings:main
 ultralytics-actions-headers = actions.update_file_headers:main
 ultralytics-actions-info = actions.utils:ultralytics_actions_info
 ultralytics-actions-review-pr = actions.review_pr:main

ultralytics_actions-0.2.1.dist-info/RECORD

@@ -1,20 +0,0 @@
-actions/__init__.py,sha256=G-r-dtUaDXDKiTJuqW8GafMpIpOjbCVlG1ETyC4_yqY,881
-actions/dispatch_actions.py,sha256=ljlFR1o8m1qTHbStsJJVMVDdJv7iVqMfdPzKlZyKXl8,6743
-actions/first_interaction.py,sha256=wcKzLEUJmYnHmtwn-sz3N5erwftMT9jn7XxSKATAmXY,9815
-actions/review_pr.py,sha256=QqYmWE37sA4mJ6bPcY5M2dlNc1lRJPwT7XcJJFP1C7c,17466
-actions/scan_prs.py,sha256=9Gu4EHmLjdShIlkoCQfIrcxLpMZeOOnpKEyv_mVc3rU,7407
-actions/summarize_pr.py,sha256=0y4Cl4_ZMMtDWVhxwWasn3mHo_4GCnegJrf29yujUYM,5715
-actions/summarize_release.py,sha256=8D5EOQ36mho1HKtWD2J-IDH_xJJb3q0shgXZSdemmDM,9078
-actions/update_file_headers.py,sha256=E5fKYLdeW16-BHCcuqxohGpGZqgEh-WX4ZmCQJw2R90,6684
-actions/update_markdown_code_blocks.py,sha256=w3DTRltg2Rmr4-qrNawv_S2vJbheKE0tne1iz79FzXg,8692
-actions/utils/__init__.py,sha256=Uf7S5qYHS59zoAP9uKVIZwhpUbgyI947dD9jAWu50Lg,1115
-actions/utils/common_utils.py,sha256=InBc-bsXcwzQYjuDxtrrm3bj7J-70U54G0s2nQKgCg8,12052
-actions/utils/github_utils.py,sha256=5yzNIiu7-WBmH1-gSi4O31m1Fwd4k8pfbwM2BPVGf88,19989
-actions/utils/openai_utils.py,sha256=07g5NsfAfSuJ6CqWWQxsZ0MR4_kh6-Rjmud_iGPm49U,11965
-actions/utils/version_utils.py,sha256=EIbm3iZVNyNl3dh8aNz_9ITeTC93ZxfyUzIRkO3tSXw,3242
-ultralytics_actions-0.2.1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-ultralytics_actions-0.2.1.dist-info/METADATA,sha256=1kN57DVDjQZMQGlhfF_3ugsfYGaXCsxFM-5guwrgFT4,12478
-ultralytics_actions-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ultralytics_actions-0.2.1.dist-info/entry_points.txt,sha256=n_VbDs3Xj33daaeN_2D72UTEuyeH8hVc6-CPH55ymkY,496
-ultralytics_actions-0.2.1.dist-info/top_level.txt,sha256=5apM5x80QlJcGbACn1v3fkmIuL1-XQCKcItJre7w7Tw,8
-ultralytics_actions-0.2.1.dist-info/RECORD,,