autopkg-wrapper 2026.2.5__py3-none-any.whl → 2026.2.8__py3-none-any.whl

autopkg_wrapper/autopkg_wrapper.py

@@ -2,151 +2,23 @@
 import json
 import logging
 import plistlib
-import subprocess
 import sys
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime
-from itertools import chain
 from pathlib import Path
 
 import autopkg_wrapper.utils.git_functions as git
+from autopkg_wrapper.models.recipe import Recipe
 from autopkg_wrapper.notifier import slack
 from autopkg_wrapper.utils.args import setup_args
 from autopkg_wrapper.utils.logging import setup_logger
+from autopkg_wrapper.utils.recipe_batching import (
+    build_recipe_batches,
+    describe_recipe_batches,
+)
 from autopkg_wrapper.utils.recipe_ordering import order_recipe_list
 from autopkg_wrapper.utils.report_processor import process_reports
 
 
-class Recipe(object):
-    def __init__(self, name: str, post_processors: list = None):
-        self.filename = name
-        self.error = False
-        self.results = {}
-        self.updated = False
-        self.verified = None
-        self.pr_url = None
-        self.post_processors = post_processors
-
-        self._keys = None
-        self._has_run = False
-
-    @property
-    def name(self):
-        name = self.filename.split(".")[0]
-
-        return name
-
-    def verify_trust_info(self, args):
-        verbose_output = ["-vvvv"] if args.debug else []
-        prefs_file = (
-            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else []
-        )
-        autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
-        cmd = (
-            [autopkg_bin, "verify-trust-info", self.filename]
-            + verbose_output
-            + prefs_file
-        )
-        logging.debug(f"cmd: {cmd}")
-
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        if result.returncode == 0:
-            self.verified = True
-        else:
-            self.results["message"] = (result.stderr or "").strip()
-            self.verified = False
-        return self.verified
-
-    def update_trust_info(self, args):
-        prefs_file = (
-            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else []
-        )
-        autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
-        cmd = [autopkg_bin, "update-trust-info", self.filename] + prefs_file
-        logging.debug(f"cmd: {cmd}")
-
-        # Fail loudly if this exits 0
-        try:
-            subprocess.check_call(cmd)
-        except subprocess.CalledProcessError as e:
-            logging.error(str(e))
-            raise e
-
-    def _parse_report(self, report):
-        with open(report, "rb") as f:
-            report_data = plistlib.load(f)
-
-        failed_items = report_data.get("failures", [])
-        imported_items = []
-        if report_data["summary_results"]:
-            # This means something happened
-            munki_results = report_data["summary_results"].get(
-                "munki_importer_summary_result", {}
-            )
-            imported_items.extend(munki_results.get("data_rows", []))
-
-        return {"imported": imported_items, "failed": failed_items}
-
-    def run(self, args):
-        if self.verified is False:
-            self.error = True
-            self.results["failed"] = True
-            self.results["imported"] = ""
-        else:
-            report_dir = Path("/private/tmp/autopkg")
-            report_time = datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
-            report_name = Path(f"{self.name}-{report_time}.plist")
-
-            report_dir.mkdir(parents=True, exist_ok=True)
-            report = report_dir / report_name
-            report.touch(exist_ok=True)
-
-            try:
-                prefs_file = (
-                    ["--prefs", args.autopkg_prefs.as_posix()]
-                    if args.autopkg_prefs
-                    else []
-                )
-                verbose_output = ["-vvvv"] if args.debug else []
-                post_processor_cmd = (
-                    list(
-                        chain.from_iterable(
-                            [
-                                ("--post", processor)
-                                for processor in self.post_processors
-                            ]
-                        )
-                    )
-                    if self.post_processors
-                    else []
-                )
-                autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
-                cmd = [
-                    autopkg_bin,
-                    "run",
-                    self.filename,
-                    "--report-plist",
-                    str(report),
-                ]
-                cmd = cmd + post_processor_cmd + verbose_output + prefs_file
-
-                logging.debug(f"cmd: {cmd}")
-
-                result = subprocess.run(cmd, capture_output=True, text=True)
-                if result.returncode != 0:
-                    self.error = True
-
-            except Exception:
-                self.error = True
-
-            self._has_run = True
-            self.results = self._parse_report(report)
-            if not self.results["failed"] and not self.error:
-                self.updated = True
-
-        return self.results
-
-
 def get_override_repo_info(args):
     if args.overrides_repo_path:
         recipe_override_dirs = args.overrides_repo_path
@@ -158,7 +30,7 @@ def get_override_repo_info(args):
             autopkg_prefs_path = Path(args.autopkg_prefs).resolve()
 
             if autopkg_prefs_path.suffix == ".json":
-                with open(autopkg_prefs_path, "r") as f:
+                with open(autopkg_prefs_path) as f:
                     autopkg_prefs = json.load(f)
             elif autopkg_prefs_path.suffix == ".plist":
                 autopkg_prefs = plistlib.loads(autopkg_prefs_path.read_bytes())
@@ -234,7 +106,7 @@ def update_recipe_repo(recipe, git_info, disable_recipe_trust_check, args):
 
             git.stage_recipe(git_info)
             git.commit_recipe(
-                git_info, message=f"Updating Trust Info for {recipe.name}"
+                git_info, message=f"Updating Trust Info for {recipe.identifier}"
             )
             git.pull_branch(git_info)
             git.push_branch(git_info)
@@ -251,21 +123,21 @@ def parse_recipe_list(recipes, recipe_file, post_processors, args):
     """
     recipe_list = None
 
-    logging.info(f"Recipes: {recipes}") if recipes else None
-    logging.info(f"Recipe List: {recipe_file}") if recipe_file else None
+    logging.debug(f"Recipes: {recipes}") if recipes else None
+    logging.debug(f"Recipe List: {recipe_file}") if recipe_file else None
 
     if recipe_file:
         if recipe_file.suffix == ".json":
-            with open(recipe_file, "r") as f:
+            with open(recipe_file) as f:
                 recipe_list = json.load(f)
         elif recipe_file.suffix in {".yaml", ".yml"}:
             from ruamel.yaml import YAML
 
             yaml = YAML(typ="safe")
-            with open(recipe_file, "r", encoding="utf-8") as f:
+            with open(recipe_file, encoding="utf-8") as f:
                 recipe_list = yaml.load(f)
         elif recipe_file.suffix == ".txt":
-            with open(recipe_file, "r") as f:
+            with open(recipe_file) as f:
                 recipe_list = f.read().splitlines()
     if recipes:
         if isinstance(recipes, list):
@@ -378,7 +250,7 @@ def main():
     logging.info(f"Running recipes with concurrency={max_workers}")
 
     def run_one(r: Recipe):
-        logging.info(f"Processing Recipe: {r.name}")
+        logging.info(f"Processing Recipe: {r.identifier}")
         process_recipe(
             recipe=r,
             disable_recipe_trust_check=args.disable_recipe_trust_check,
@@ -387,12 +259,33 @@ def main():
         # Git updates and notifications are applied serially after all recipes finish
         return r
 
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        futures = [executor.submit(run_one, r) for r in recipe_list]
-        for fut in as_completed(futures):
-            r = fut.result()
-            if r.error or r.results.get("failed"):
-                failed_recipes.append(r)
+    if args.recipe_processing_order:
+        batches = build_recipe_batches(
+            recipe_list=recipe_list,
+            recipe_processing_order=args.recipe_processing_order,
+        )
+        logging.info("Recipe processing batches:")
+        batch_descriptions = describe_recipe_batches(batches)
+        for batch, batch_desc in zip(batches, batch_descriptions, strict=False):
+            batch_type = batch_desc.get("type") or "unknown"
+            logging.info(f"Batch type={batch_type} count={batch_desc.get('count', 0)}")
+            logging.info(f"Batch recipes: {batch_desc.get('recipes', [])}")
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                futures = [executor.submit(run_one, r) for r in batch]
+                for fut in as_completed(futures):
+                    r = fut.result()
+                    if r.error or r.results.get("failed"):
+                        failed_recipes.append(r)
+    elif recipe_list:
+        logging.info("Recipe processing batches:")
+        logging.info("Batch type=all count=%d", len(recipe_list))
+        logging.info("Batch recipes: %s", [r.identifier for r in recipe_list])
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [executor.submit(run_one, r) for r in recipe_list]
+            for fut in as_completed(futures):
+                r = fut.result()
+                if r.error or r.results.get("failed"):
+                    failed_recipes.append(r)
 
     # Apply git updates serially to avoid branch/commit conflicts when concurrency > 1
     for r in recipe_list:

autopkg_wrapper/models/recipe.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import logging
+import plistlib
+import subprocess
+from datetime import datetime
+from itertools import chain
+from pathlib import Path
+
+
+class Recipe:
+    def __init__(self, name: str, post_processors: list = None):
+        self.filename = name
+        self.error = False
+        self.results = {}
+        self.updated = False
+        self.verified = None
+        self.pr_url = None
+        self.post_processors = post_processors
+
+        self._keys = None
+        self._has_run = False
+
+    @property
+    def name(self):
+        name = self.filename.split(".")[0]
+
+        return name
+
+    @property
+    def identifier(self):
+        return self.filename
+
+    def verify_trust_info(self, args):
+        verbose_output = ["-vvvv"] if args.debug else []
+        prefs_file = (
+            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else []
+        )
+        autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
+        cmd = (
+            [autopkg_bin, "verify-trust-info", self.filename]
+            + verbose_output
+            + prefs_file
+        )
+        logging.debug(f"cmd: {cmd}")
+
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode == 0:
+            self.verified = True
+        else:
+            self.results["message"] = (result.stderr or "").strip()
+            self.verified = False
+        return self.verified
+
+    def update_trust_info(self, args):
+        prefs_file = (
+            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else []
+        )
+        autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
+        cmd = [autopkg_bin, "update-trust-info", self.filename] + prefs_file
+        logging.debug(f"cmd: {cmd}")
+
+        # Fail loudly if this exits 0
+        try:
+            subprocess.check_call(cmd)
+        except subprocess.CalledProcessError as e:
+            logging.error(str(e))
+            raise e
+
+    def _parse_report(self, report):
+        with open(report, "rb") as f:
+            report_data = plistlib.load(f)
+
+        failed_items = report_data.get("failures", [])
+        imported_items = []
+        if report_data["summary_results"]:
+            # This means something happened
+            munki_results = report_data["summary_results"].get(
+                "munki_importer_summary_result", {}
+            )
+            imported_items.extend(munki_results.get("data_rows", []))
+
+        return {"imported": imported_items, "failed": failed_items}
+
+    def run(self, args):
+        if self.verified is False:
+            self.error = True
+            self.results["failed"] = True
+            self.results["imported"] = ""
+        else:
+            report_dir = Path("/private/tmp/autopkg")
+            report_time = datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
+            report_name = Path(f"{self.name}-{report_time}.plist")
+
+            report_dir.mkdir(parents=True, exist_ok=True)
+            report = report_dir / report_name
+            report.touch(exist_ok=True)
+
+            try:
+                prefs_file = (
+                    ["--prefs", args.autopkg_prefs.as_posix()]
+                    if args.autopkg_prefs
+                    else []
+                )
+                verbose_output = ["-vvvv"] if args.debug else []
+                post_processor_cmd = (
+                    list(
+                        chain.from_iterable(
+                            [
+                                ("--post", processor)
+                                for processor in self.post_processors
+                            ]
+                        )
+                    )
+                    if self.post_processors
+                    else []
+                )
+                autopkg_bin = getattr(args, "autopkg_bin", "/usr/local/bin/autopkg")
+                cmd = (
+                    [autopkg_bin, "run", self.filename, "--report-plist", report]
+                    + verbose_output
+                    + prefs_file
+                    + post_processor_cmd
+                )
+                logging.debug(f"cmd: {cmd}")
+
+                result = subprocess.run(cmd, capture_output=True, text=True)
+                if result.returncode == 0:
+                    report_info = self._parse_report(report)
+                    self.results = report_info
+                else:
+                    self.error = True
+                    self.results["failed"] = True
+                    self.results["message"] = (result.stderr or "").strip()
+                    self.results["imported"] = ""
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                logging.error(f"Recipe run failed: {e}")
+                self.error = True
+                self.results["failed"] = True
+                self.results["message"] = (result.stderr or "").strip()
+                self.results["imported"] = ""
+
+        return self

autopkg_wrapper/notifier/slack.py

@@ -11,11 +11,13 @@ def send_notification(recipe, token):
         logging.error("Skipping Slack Notification as no SLACK_WEBHOOK_TOKEN defined!")
         return
 
+    recipe_identifier = getattr(recipe, "identifier", None) or recipe.name
+
     if recipe.verified is False:
-        task_title = f"{recipe.name} failed trust verification"
+        task_title = f"{recipe_identifier} failed trust verification"
         task_description = recipe.results["message"]
     elif recipe.error:
-        task_title = f"Failed to import {recipe.name}"
+        task_title = f"Failed to import {recipe_identifier}"
         if not recipe.results["failed"]:
             task_description = "Unknown error"
         else:
@@ -27,8 +29,8 @@ def send_notification(recipe, token):
             if "No releases found for repo" in task_description:
                 return
     elif recipe.updated:
-        task_title = f"{recipe.name} has been uploaded to Jamf"
-        task_description = f"It's time to test {recipe.name}!"
+        task_title = f"{recipe_identifier} has been uploaded to Jamf"
+        task_description = f"It's time to test {recipe_identifier}!"
     else:
         return
 
@@ -56,6 +58,6 @@ def send_notification(recipe, token):
     )
     if response.status_code != 200:
         raise ValueError(
-            "Request to slack returned an error %s, the response is:\n%s"
-            % (response.status_code, response.text)
+            "Request to slack returned an error "
+            f"{response.status_code}, the response is:\n{response.text}"
         )

autopkg_wrapper/utils/git_functions.py

@@ -110,9 +110,9 @@ def push_branch(git_info):
 
 
 def create_pull_request(git_info, recipe):
-    title = f"Update Trust Information: {recipe.name}"
+    title = f"Update Trust Information: {recipe.identifier}"
     body = f"""
-Recipe Verification information is out-of-date for {recipe.name}.
+Recipe Verification information is out-of-date for {recipe.identifier}.
 Please review and merge the updated trust information for this override.
     """
 
@@ -152,7 +152,8 @@ def create_issue_for_failed_recipes(git_info, failed_recipes):
 
     body = "## Recipe Failure Details:\n\n"
     for recipe in failed_recipes:
-        body += f"#### {recipe.name}\n"
+        identifier = getattr(recipe, "identifier", None) or recipe.name
+        body += f"#### {identifier}\n"
 
         if recipe.results.get("failed"):
             for failure in recipe.results.get("failed", []):

autopkg_wrapper/utils/recipe_batching.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Protocol
+
+
+class HasFilename(Protocol):
+    filename: str
+
+
+def recipe_type_for(recipe: HasFilename) -> str:
+    parts = recipe.filename.split(".", 1)
+    return parts[1] if len(parts) == 2 else ""
+
+
+def recipe_identifier_for(recipe: HasFilename) -> str:
+    identifier = getattr(recipe, "identifier", None)
+    return identifier if identifier else recipe.filename
+
+
+def build_recipe_batches[T: HasFilename](
+    recipe_list: Iterable[T], recipe_processing_order
+) -> list[list[T]]:
+    recipe_list = list(recipe_list)
+    if not recipe_list:
+        return []
+    if not recipe_processing_order:
+        return [recipe_list]
+
+    batches: list[list[T]] = []
+    current_batch: list[T] = []
+    current_type = None
+    for recipe in recipe_list:
+        r_type = recipe_type_for(recipe)
+        if current_type is None or r_type == current_type:
+            current_batch.append(recipe)
+            current_type = r_type
+            continue
+        batches.append(current_batch)
+        current_batch = [recipe]
+        current_type = r_type
+    if current_batch:
+        batches.append(current_batch)
+    return batches
+
+
+def describe_recipe_batches[T: HasFilename](
+    batches: Iterable[Iterable[T]],
+) -> list[dict[str, object]]:
+    descriptions: list[dict[str, object]] = []
+    for batch in batches:
+        batch_list = list(batch)
+        batch_type = recipe_type_for(batch_list[0]) if batch_list else ""
+        identifiers = [recipe_identifier_for(r) for r in batch_list]
+        descriptions.append(
+            {"type": batch_type, "count": len(batch_list), "recipes": identifiers}
+        )
+    return descriptions

autopkg_wrapper/utils/recipe_ordering.py

@@ -64,6 +64,17 @@ def order_recipe_list(recipe_list, order):
         parts = recipe_name.split(".", 1)
         return parts[1] if len(parts) == 2 else ""
 
+    def order_recipes_by_type(recipes: list[str]) -> list[str]:
+        groups: dict[str, list[str]] = {}
+        for r in recipes:
+            t = recipe_type(r)
+            groups.setdefault(t, []).append(r)
+
+        ordered_recipes: list[str] = []
+        for t in sorted(groups.keys(), key=lambda x: (x == "", x.casefold())):
+            ordered_recipes.extend(sorted(groups[t], key=str.casefold))
+        return ordered_recipes
+
     def recipe_segments_after_first_dot(recipe_name: str) -> list[str]:
         after_first = recipe_type(recipe_name)
         return [p for p in after_first.split(".") if p] if after_first else []
@@ -131,17 +142,11 @@ def order_recipe_list(recipe_list, order):
 
     ordered: list[str] = []
     for p in normalised_order:
-        ordered.extend(sorted(pattern_groups[p], key=str.casefold))
+        ordered.extend(order_recipes_by_type(pattern_groups[p]))
 
     # Remaining recipes: group by their full type string and order groups alphabetically,
     # with empty-type last.
-    groups: dict[str, list[str]] = {}
-    for r in unmatched:
-        t = recipe_type(r)
-        groups.setdefault(t, []).append(r)
-
-    for t in sorted(groups.keys(), key=lambda x: (x == "", x.casefold())):
-        ordered.extend(sorted(groups[t], key=str.casefold))
+    ordered.extend(order_recipes_by_type(unmatched))
 
     logging.debug(f"Recipe processing order: {normalised_order}")
     logging.debug(f"Ordered recipes: {ordered}")

autopkg_wrapper/utils/report_processor.py

@@ -4,11 +4,10 @@ import os
 import plistlib
 import re
 import zipfile
-from typing import Dict, List, Optional, Tuple
 
 
-def find_report_dirs(base_path: str) -> List[str]:
-    dirs: List[str] = []
+def find_report_dirs(base_path: str) -> list[str]:
+    dirs: list[str] = []
     if not os.path.exists(base_path):
         return dirs
     for root, subdirs, _files in os.walk(base_path):
@@ -28,9 +27,9 @@ def find_report_dirs(base_path: str) -> List[str]:
     return sorted(dirs)
 
 
-def parse_json_file(path: str) -> Dict:
+def parse_json_file(path: str) -> dict:
     try:
-        with open(path, "r", encoding="utf-8") as f:
+        with open(path, encoding="utf-8") as f:
             return json.load(f)
     except Exception:
         return {}
@@ -46,10 +45,10 @@ def _infer_recipe_name_from_filename(path: str) -> str:
     return base
 
 
-def parse_text_file(path: str) -> Dict[str, List]:
-    uploads: List[Dict] = []
-    policies: List[Dict] = []
-    errors: List[str] = []
+def parse_text_file(path: str) -> dict[str, list]:
+    uploads: list[dict] = []
+    policies: list[dict] = []
+    errors: list[str] = []
 
     re_error = re.compile(r"ERROR[:\s-]+(.+)", re.IGNORECASE)
     re_upload = re.compile(
@@ -59,7 +58,7 @@ def parse_text_file(path: str) -> Dict[str, List]:
     re_policy = re.compile(r"Policy (created|updated):\s*(?P<name>.+)", re.IGNORECASE)
 
     try:
-        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        with open(path, encoding="utf-8", errors="ignore") as f:
             for line in f:
                 m_err = re_error.search(line)
                 if m_err:
@@ -91,13 +90,13 @@ def parse_text_file(path: str) -> Dict[str, List]:
     return {"uploads": uploads, "policies": policies, "errors": errors}
 
 
-def parse_plist_file(path: str) -> Dict[str, List]:
-    uploads: List[Dict] = []
-    policies: List[Dict] = []
-    errors: List[str] = []
-    upload_rows: List[Dict] = []
-    policy_rows: List[Dict] = []
-    error_rows: List[Dict] = []
+def parse_plist_file(path: str) -> dict[str, list]:
+    uploads: list[dict] = []
+    policies: list[dict] = []
+    errors: list[str] = []
+    upload_rows: list[dict] = []
+    policy_rows: list[dict] = []
+    error_rows: list[dict] = []
 
     try:
         with open(path, "rb") as f:
@@ -117,7 +116,7 @@ def parse_plist_file(path: str) -> Dict[str, List]:
     sr = plist.get("summary_results", {}) or {}
 
     recipe_name = _infer_recipe_name_from_filename(path)
-    recipe_identifier: Optional[str] = None
+    recipe_identifier: str | None = None
 
     jpu = sr.get("jamfpackageuploader_summary_result")
     if isinstance(jpu, dict):
@@ -200,7 +199,7 @@ def parse_plist_file(path: str) -> Dict[str, List]:
     }
 
 
-def aggregate_reports(base_path: str) -> Dict:
+def aggregate_reports(base_path: str) -> dict:
     summary = {
         "uploads": [],
         "policies": [],
@@ -270,8 +269,8 @@ def aggregate_reports(base_path: str) -> Dict:
 
 
 def _aggregate_for_display(
-    summary: Dict,
-) -> Tuple[Dict[str, set], Dict[str, set], Dict[str, int]]:
+    summary: dict,
+) -> tuple[dict[str, set], dict[str, set], dict[str, int]]:
     uploads = summary.get("uploads", [])
     policies = summary.get("policies", [])
     errors = summary.get("errors", [])
@@ -281,11 +280,9 @@ def _aggregate_for_display(
             return False
         if n.lower() in {"apps", "packages", "pkg", "file", "37"}:
             return False
-        if not re.search(r"[A-Za-z]", n):
-            return False
-        return True
+        return re.search(r"[A-Za-z]", n) is not None
 
-    uploads_by_app: Dict[str, set] = {}
+    uploads_by_app: dict[str, set] = {}
     for u in uploads:
         if isinstance(u, dict):
             name = (u.get("name") or "-").strip()
@@ -297,7 +294,7 @@ def _aggregate_for_display(
             name = "-"
         uploads_by_app.setdefault(name, set()).add(ver)
 
-    policies_by_name: Dict[str, set] = {}
+    policies_by_name: dict[str, set] = {}
     for p in policies:
         if isinstance(p, dict):
             name = (p.get("name") or "-").strip()
@@ -307,7 +304,7 @@ def _aggregate_for_display(
             action = "-"
         policies_by_name.setdefault(name, set()).add(action)
 
-    error_categories: Dict[str, int] = {
+    error_categories: dict[str, int] = {
         "trust": 0,
         "signature": 0,
         "download": 0,
@@ -353,9 +350,9 @@ def _aggregate_for_display(
     return uploads_by_app, policies_by_name, error_categories
 
 
-def render_job_summary(summary: Dict, environment: str, run_date: str) -> str:
-    lines: List[str] = []
-    title_bits: List[str] = []
+def render_job_summary(summary: dict, environment: str, run_date: str) -> str:
+    lines: list[str] = []
+    title_bits: list[str] = []
     if environment:
         title_bits.append(environment)
     if run_date:
@@ -435,15 +432,15 @@ def render_job_summary(summary: Dict, environment: str, run_date: str) -> str:
     return "\n".join(lines)
 
 
-def render_issue_body(summary: Dict, environment: str, run_date: str) -> str:
-    lines: List[str] = []
+def render_issue_body(summary: dict, environment: str, run_date: str) -> str:
+    lines: list[str] = []
     total_errors = len(summary.get("errors", []))
     _uploads_by_app, _policies_by_name, _error_categories = _aggregate_for_display(
         summary
     )
 
     prefix = "Autopkg run"
-    suffix_bits: List[str] = []
+    suffix_bits: list[str] = []
     if run_date:
         suffix_bits.append(f"on {run_date}")
     if environment:
@@ -523,10 +520,10 @@ def _normalize_host(url: str) -> str:
     return h.rstrip("/")
 
 
-def build_pkg_map(jss_url: str, client_id: str, client_secret: str) -> Dict[str, str]:
+def build_pkg_map(jss_url: str, client_id: str, client_secret: str) -> dict[str, str]:
     host = _normalize_host(jss_url)
     _ = host  # silence linters about unused var; kept for readability
-    pkg_map: Dict[str, str] = {}
+    pkg_map: dict[str, str] = {}
     try:
         from jamf_pro_sdk import (  # type: ignore
             ApiClientCredentialsProvider,
@@ -540,8 +537,8 @@ def build_pkg_map(jss_url: str, client_id: str, client_secret: str) -> Dict[str,
         packages = client.pro_api.get_packages_v1()
         for p in packages:
             try:
-                name = str(getattr(p, "packageName")).strip()
-                pid = str(getattr(p, "id")).strip()
+                name = str(p.packageName).strip()
+                pid = str(p.id).strip()
             except Exception as e:  # noqa: F841
                 # ignore objects that do not match expected shape
                 continue
@@ -555,7 +552,7 @@ def build_pkg_map(jss_url: str, client_id: str, client_secret: str) -> Dict[str,
     return pkg_map
 
 
-def enrich_upload_rows(upload_rows: List[Dict], pkg_map: Dict[str, str]) -> int:
+def enrich_upload_rows(upload_rows: list[dict], pkg_map: dict[str, str]) -> int:
     linked = 0
     for row in upload_rows:
         pkg_name = str(row.get("package") or "").strip()
@@ -567,8 +564,8 @@ def enrich_upload_rows(upload_rows: List[Dict], pkg_map: Dict[str, str]) -> int:
 
 
 def enrich_upload_rows_with_jamf(
-    summary: Dict, jss_url: str, client_id: str, client_secret: str
-) -> Tuple[int, List[str]]:
+    summary: dict, jss_url: str, client_id: str, client_secret: str
+) -> tuple[int, list[str]]:
     pkg_map = build_pkg_map(jss_url, client_id, client_secret)
     linked = enrich_upload_rows(summary.get("upload_rows", []), pkg_map)
     return linked, sorted(set(pkg_map.keys()))
@@ -576,9 +573,9 @@ def enrich_upload_rows_with_jamf(
 
 def process_reports(
     *,
-    zip_file: Optional[str],
+    zip_file: str | None,
     extract_dir: str,
-    reports_dir: Optional[str],
+    reports_dir: str | None,
     environment: str = "",
     run_date: str = "",
     out_dir: str,
@@ -605,7 +602,7 @@ def process_reports(
     jss_client_secret = os.environ.get("AUTOPKG_CLIENT_SECRET")
     jamf_attempted = False
     jamf_linked = 0
-    jamf_keys: List[str] = []
+    jamf_keys: list[str] = []
     jamf_total = len(summary.get("upload_rows", []))
     if jss_url and jss_client_id and jss_client_secret and jamf_total:
         jamf_attempted = True

autopkg_wrapper-2026.2.8.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: autopkg-wrapper
+Version: 2026.2.8
+Summary: A package used to execute some autopkg functions, primarily within the context of a GitHub Actions runner.
+Project-URL: Repository, https://github.com/smithjw/autopkg-wrapper
+Author-email: James Smith <james@smithjw.me>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: ~=3.14.0
+Requires-Dist: chardet
+Requires-Dist: idna
+Requires-Dist: jamf-pro-sdk
+Requires-Dist: pygithub
+Requires-Dist: requests
+Requires-Dist: ruamel-yaml
+Requires-Dist: toml
+Requires-Dist: urllib3
+Description-Content-Type: text/markdown
+
+# autopkg-wrapper
+
+`autopkg_wrapper` is a small package that can be used to run [`autopkg`](https://github.com/autopkg/autopkg) within CI/CD environments such as GitHub Actions.
+
+The easiest way to run it is by installing with pip.
+
+```shell
+pip install autopkg-wrapper
+```
+
+## Development
+
+This project uses `uv` for dependency management and `mise` tasks for common workflows.
+
+```bash
+mise run install
+mise run test
+mise run build
+```
+
+## Command Line Parameters
+
+<!-- CLI-PARAMS-START -->
+
+```shell
+usage: autopkg_wrapper [-h] [--recipe-file RECIPE_FILE |
+                       --recipes [RECIPES ...]]
+                       [--recipe-processing-order [RECIPE_PROCESSING_ORDER ...]]
+                       [--autopkg-bin AUTOPKG_BIN] [--debug]
+                       [--disable-recipe-trust-check] [--disable-git-commands]
+                       [--concurrency CONCURRENCY]
+                       [--github-token GITHUB_TOKEN]
+                       [--branch-name BRANCH_NAME] [--create-pr]
+                       [--create-issues]
+                       [--overrides-repo-path OVERRIDES_REPO_PATH]
+                       [--post-processors [POST_PROCESSORS ...]]
+                       [--autopkg-prefs AUTOPKG_PREFS] [--process-reports]
+                       [--reports-zip REPORTS_ZIP]
+                       [--reports-extract-dir REPORTS_EXTRACT_DIR]
+                       [--reports-dir REPORTS_DIR]
+                       [--reports-out-dir REPORTS_OUT_DIR]
+                       [--reports-run-date REPORTS_RUN_DATE]
+                       [--reports-strict]
+
+Run autopkg recipes
+
+options:
+  -h, --help            show this help message and exit
+  --recipe-file RECIPE_FILE
+                        Provide the list of recipes to run via a JSON file for
+                        easier management.
+  --recipes [RECIPES ...]
+                        Recipes to run via CLI flag or environment variable.
+                        If the '--recipes' flag is used, simply provide a
+                        space-separated list on the command line: `autopkg-
+                        wrapper --recipes recipe_one.download
+                        recipe_two.download` Alternatively, you can provide a
+                        space/comma-separated list in the 'AW_RECIPES'
+                        environment variable: `export
+                        AW_RECIPES="recipe_one.download recipe_two.download"`
+                        `export AW_RECIPES="recipe_one.pkg,recipe_two.pkg"`
+                        `autopkg-wrapper`
+  --recipe-processing-order [RECIPE_PROCESSING_ORDER ...]
+                        This option comes in handy if you include additional
+                        recipe type names in your overrides and wish them to
+                        be processed in a specific order. We'll specifically
+                        look for these recipe types after the first period (.)
+                        in the recipe name. Order items can be either a full
+                        type suffix (e.g. "upload.jamf") or a partial token
+                        (e.g. "upload", "auto_update"). Partial tokens are
+                        matched against the dot-separated segments after the
+                        first '.' so recipes like "Foo.epz.auto_update.jamf"
+                        will match "auto_update". This can also be provided
+                        via the 'AW_RECIPE_PROCESSING_ORDER' environment
+                        variable as a comma-separated list (e.g.
+                        "upload,self_service,auto_update"). For example, if
+                        you have the following recipes to be processed:
+                        ExampleApp.auto_install.jamf ExampleApp.upload.jamf
+                        ExampleApp.self_service.jamf And you want to ensure
+                        that the .upload recipes are always processed first,
+                        followed by .auto_install, and finally .self_service,
+                        you would provide the following processing order:
+                        `--recipe-processing-order upload.jamf
+                        auto_install.jamf self_service.jamf` This would ensure
+                        that all .upload recipes are processed before any
+                        other recipe types. Within each recipe type, the
+                        recipes will be ordered alphabetically. We assume that
+                        no extensions are provided (but will strip them if
+                        needed - extensions that are stripped include .recipe
+                        or .recipe.yaml).
+  --autopkg-bin AUTOPKG_BIN
+                        Path to the autopkg binary (default:
+                        /usr/local/bin/autopkg). Can also be set via
+                        AW_AUTOPKG_BIN.
+  --debug               Enable debug logging when running script
+  --disable-recipe-trust-check
+                        If this option is used, recipe trust verification will
+                        not be run prior to a recipe run. This does not set
+                        FAIL_RECIPES_WITHOUT_TRUST_INFO to No. You will need
+                        to set that outside of this application.
+  --disable-git-commands
+                        If this option is used, git commands won't be run
+  --concurrency CONCURRENCY
+                        Number of recipes to run in parallel (default: 1)
+  --github-token GITHUB_TOKEN
+  --branch-name BRANCH_NAME
+                        Branch name to be used recipe overrides have failed
+                        their trust verification and need to be updated. By
+                        default, this will be in the format of
+                        "fix/update_trust_information/YYYY-MM-DDTHH-MM-SS"
+  --create-pr           If enabled, autopkg_wrapper will open a PR for updated
+                        trust information
+  --create-issues       Create a GitHub issue for recipes that fail during
+                        processing
+  --overrides-repo-path OVERRIDES_REPO_PATH
+                        The path on disk to the git repository containing the
+                        autopkg overrides directory. If none is provided, we
+                        will try to determine it for you.
+  --post-processors [POST_PROCESSORS ...]
+                        One or more autopkg post processors to run after each
+                        recipe execution
+  --autopkg-prefs AUTOPKG_PREFS
+                        Path to the autopkg preferences you'd like to use
+  --process-reports     Process autopkg report directories or zip and emit
+                        markdown summaries
+  --reports-zip REPORTS_ZIP
+                        Path to an autopkg_report-*.zip to extract and process
+  --reports-extract-dir REPORTS_EXTRACT_DIR
+                        Directory to extract the zip into (default:
+                        autopkg_reports_summary/reports)
+  --reports-dir REPORTS_DIR
+                        Directory of reports to process (if no zip provided)
+  --reports-out-dir REPORTS_OUT_DIR
+                        Directory to write markdown outputs (default:
+                        autopkg_reports_summary/summary)
+  --reports-run-date REPORTS_RUN_DATE
+                        Run date string to include in the summary
+  --reports-strict      Exit non-zero if any errors are detected in processed
+                        reports
+```
+
+<!-- CLI-PARAMS-END -->
+
+## Examples
+
+Run recipes (serial):
+
+```bash
+autopkg_wrapper --recipes Foo.download Bar.download
+```
+
+Run 3 recipes concurrently and process reports afterward:
+
+```bash
+autopkg_wrapper \
+  --recipe-file /path/to/recipe_list.txt \
+  --concurrency 3 \
+  --disable-git-commands \
+  --process-reports \
+  --reports-out-dir /tmp/autopkg_reports_summary \
+  --reports-strict
+```
+
+Process a reports zip explicitly (no recipe run):
+
+```bash
+autopkg_wrapper \
+  --process-reports \
+  --reports-zip /path/to/autopkg_report-2026-02-02.zip \
+  --reports-extract-dir /tmp/autopkg_reports \
+  --reports-out-dir /tmp/autopkg_reports_summary
+```
+
+## Recipe Processing Flow
+
+```mermaid
+flowchart TD
+    start([Start]) --> args[Parse CLI args]
+    args --> load[Load recipes list]
+    load --> order{Processing order provided?}
+    order -- Yes --> batches[Build recipe batches by type]
+    order -- No --> all[Single batch of all recipes]
+    batches --> log[Log each batch type and identifiers]
+    all --> log
+    log --> run[Run batch recipes concurrently within batch]
+    run --> next{More batches?}
+    next -- Yes --> log
+    next -- No --> git[Apply git updates serially]
+    git --> notify[Send notifications]
+    notify --> pr{Create PR?}
+    pr -- Yes --> createPR[Open trust update PR]
+    pr -- No --> issues{Create issues?}
+    createPR --> issues
+    issues -- Yes --> createIssue[Open failures issue]
+    issues -- No --> reports{Process reports?}
+    createIssue --> reports
+    reports -- Yes --> process[Process reports output]
+    reports -- No --> done([Done])
+    process --> done
+```
+
+Related code:
+
+- `autopkg_wrapper/autopkg_wrapper.py`
+- `autopkg_wrapper/utils/recipe_batching.py`
+- `autopkg_wrapper/utils/recipe_ordering.py`
+- `autopkg_wrapper/utils/report_processor.py`
+- `autopkg_wrapper/notifier/slack.py`
+
+Notes:
+
+- During recipe runs, per‑recipe plist reports are written to `/private/tmp/autopkg`.
+- Log output references full recipe identifiers (for example, `Foo.upload.jamf`) and batch logs list recipe identifiers grouped by type.
+- When `--process-reports` is supplied without `--reports-zip` or `--reports-dir`, the tool processes `/private/tmp/autopkg`.
+- If `AUTOPKG_JSS_URL`, `AUTOPKG_CLIENT_ID`, and `AUTOPKG_CLIENT_SECRET` are set, uploaded package rows are enriched with Jamf package links.
+  - No extra CLI flag is required; enrichment runs automatically when all three env vars are present.
+
+An example folder structure and GitHub Actions Workflow is available within the [`actions-demo`](actions-demo)
+
+## Credits
+
+- [`autopkg_tools` from Facebook](https://github.com/facebook/IT-CPE/tree/main/legacy/autopkg_tools)
+- [`autopkg_tools` from Facebook, modified by Gusto](https://github.com/Gusto/it-cpe-opensource/tree/main/autopkg)

autopkg_wrapper-2026.2.8.dist-info/RECORD

@@ -0,0 +1,17 @@
+autopkg_wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autopkg_wrapper/autopkg_wrapper.py,sha256=YBXttf3JDDP7tI3zoTAtBnXSGXssltLY7qk3Gy_cgNI,12728
+autopkg_wrapper/models/recipe.py,sha256=OQabJ-4ORbhueYZuZrq9bovXbcAC9flBoTc8A998mlE,4953
+autopkg_wrapper/notifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autopkg_wrapper/notifier/slack.py,sha256=O5Dc3ux7w258zTkfyDkjNbpfFLLCaCCoGUguOYfOETk,2056
+autopkg_wrapper/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autopkg_wrapper/utils/args.py,sha256=1uEdjTIuqQQcealiEqihZNAamSDLbU9qBzJ6M-tpsS4,8423
+autopkg_wrapper/utils/git_functions.py,sha256=5egBB4itrEusGrANoL2_8F13diRAZSfBcnZrUxn6Z5M,4976
+autopkg_wrapper/utils/logging.py,sha256=3knpMViO_zAU8WM5bSImQaz5M01vMFk_raB4lt1cbvo,324
+autopkg_wrapper/utils/recipe_batching.py,sha256=ohZUPyr6IFD8j4m9VSASsLOFh_9Fs0_UkIo6MIR4fIQ,1722
+autopkg_wrapper/utils/recipe_ordering.py,sha256=LWxbktRo_NlDNaW7NL63GJHSXGspYHDvu-2mP1JATFE,6190
+autopkg_wrapper/utils/report_processor.py,sha256=iB48pV_K2P11jkR9IZbeoA7dmyaZBiD0BHKwDOBwHgQ,22296
+autopkg_wrapper-2026.2.8.dist-info/METADATA,sha256=vWcsRVxM3ymlfXEEZmrfjEODzCkaNsPMvcfFdhFrSfc,10750
+autopkg_wrapper-2026.2.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+autopkg_wrapper-2026.2.8.dist-info/entry_points.txt,sha256=TVIcOt7OozzX1c00pwMGbBysaHg_v_N3mO3juoFqPpo,73
+autopkg_wrapper-2026.2.8.dist-info/licenses/LICENSE,sha256=PpNOQjZGcsKFuA0wU16YU7PueVxqPX4OnyZ7TlLQlq4,1602
+autopkg_wrapper-2026.2.8.dist-info/RECORD,,

autopkg_wrapper-2026.2.5.dist-info/METADATA

@@ -1,107 +0,0 @@
-Metadata-Version: 2.4
-Name: autopkg-wrapper
-Version: 2026.2.5
-Summary: A package used to execute some autopkg functions, primarily within the context of a GitHub Actions runner.
-Project-URL: Repository, https://github.com/smithjw/autopkg-wrapper
-Author-email: James Smith <james@smithjw.me>
-License-Expression: BSD-3-Clause
-License-File: LICENSE
-Requires-Python: ~=3.14.0
-Requires-Dist: chardet
-Requires-Dist: idna
-Requires-Dist: jamf-pro-sdk
-Requires-Dist: pygithub
-Requires-Dist: requests
-Requires-Dist: ruamel-yaml
-Requires-Dist: toml
-Requires-Dist: urllib3
-Description-Content-Type: text/markdown
-
-# autopkg-wrapper
-
-`autopkg_wrapper` is a small package that can be used to run [`autopkg`](https://github.com/autopkg/autopkg) within CI/CD environments such as GitHub Actions.
-
-The easiest way to run it is by installing with pip.
-
-```shell
-pip install autopkg-wrapper
-```
-
-## Command Line Parameters
-
-```shell
--h, --help                      Show this help message and exit
---recipe-file RECIPE_FILE       Path to a list of recipes to run (cannot be run with --recipes)
---recipes [RECIPES ...]         Recipes to run with autopkg (cannot be run with --recipe-file)
---recipe-processing-order [RECIPE_PROCESSING_ORDER ...]
-                                Optional processing order for recipe "types" (suffix segments after the first '.'); supports partial tokens like upload/auto_update; env var AW_RECIPE_PROCESSING_ORDER expects comma-separated values
---debug                         Enable debug logging when running script
- --disable-recipe-trust-check    If this option is used, recipe trust verification will not be run prior to a recipe run.
- --github-token GITHUB_TOKEN     A token used to publish a PR to your GitHub repo if overrides require their trust to be updated
- --branch-name BRANCH_NAME       Branch name to be used where recipe overrides have failed their trust verification and need to be updated.
-                                 By default, this will be in the format of "fix/update_trust_information/YYYY-MM-DDTHH-MM-SS"
- --create-pr                     If enabled, autopkg_wrapper will open a PR for updated trust information
- --create-issues                 Create a GitHub issue for recipes that fail during processing
- --disable-git-commands          If this option is used, git commands won't be run
- --post-processors [POST_PROCESSORS ...]
-                                 One or more autopkg post processors to run after each recipe execution
- --autopkg-prefs AW_AUTOPKG_PREFS_FILE
-                                 Path to the autopkg preferences you'd like to use
- --overrides-repo-path AUTOPKG_OVERRIDES_REPO_PATH
-                                 The path on disk to the git repository containing the autopkg overrides directory. If none is provided, we will try to determine it for you.
- --concurrency CONCURRENCY       Number of recipes to run in parallel (default: 1)
- --process-reports               Process autopkg report directories or zip and emit markdown summaries (runs after recipes complete)
- --reports-zip REPORTS_ZIP       Path to an autopkg_report-*.zip to extract and process
- --reports-extract-dir REPORTS_EXTRACT_DIR
-                                 Directory to extract the zip into (default: autopkg_reports_summary/reports)
- --reports-dir REPORTS_DIR       Directory of reports to process (if no zip provided). Defaults to /private/tmp/autopkg when processing after a run
- --reports-out-dir REPORTS_OUT_DIR
-                                 Directory to write markdown outputs (default: autopkg_reports_summary/summary)
- --reports-run-date REPORTS_RUN_DATE
-                                 Run date string to include in the summary
- --reports-strict                Exit non-zero if any errors are detected in processed reports
-```
-
-## Examples
-
-Run recipes (serial):
-
-```bash
-autopkg_wrapper --recipes Foo.download Bar.download
-```
-
-Run 3 recipes concurrently and process reports afterward:
-
-```bash
-autopkg_wrapper \
-  --recipe-file /path/to/recipe_list.txt \
-  --concurrency 3 \
-  --disable-git-commands \
-  --process-reports \
-  --reports-out-dir /tmp/autopkg_reports_summary \
-  --reports-strict
-```
-
-Process a reports zip explicitly (no recipe run):
-
-```bash
-autopkg_wrapper \
-  --process-reports \
-  --reports-zip /path/to/autopkg_report-2026-02-02.zip \
-  --reports-extract-dir /tmp/autopkg_reports \
-  --reports-out-dir /tmp/autopkg_reports_summary
-```
-
-Notes:
-
-- During recipe runs, per‑recipe plist reports are written to `/private/tmp/autopkg`.
-- When `--process-reports` is supplied without `--reports-zip` or `--reports-dir`, the tool processes `/private/tmp/autopkg`.
-- If `AUTOPKG_JSS_URL`, `AUTOPKG_CLIENT_ID`, and `AUTOPKG_CLIENT_SECRET` are set, uploaded package rows are enriched with Jamf package links.
-  - No extra CLI flag is required; enrichment runs automatically when all three env vars are present.
-
-An example folder structure and GitHub Actions Workflow is available within the [`actions-demo`](actions-demo)
-
-## Credits
-
-- [`autopkg_tools` from Facebook](https://github.com/facebook/IT-CPE/tree/main/legacy/autopkg_tools)
-- [`autopkg_tools` from Facebook, modified by Gusto](https://github.com/Gusto/it-cpe-opensource/tree/main/autopkg)

autopkg_wrapper-2026.2.5.dist-info/RECORD

@@ -1,15 +0,0 @@
-autopkg_wrapper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autopkg_wrapper/autopkg_wrapper.py,sha256=bfPrZQgcoBZLGKaclBwUh-J2gi8lxIqxFQdDI2AO3lU,15856
-autopkg_wrapper/notifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autopkg_wrapper/notifier/slack.py,sha256=pUsjwpVfwDSn3c09O3UbdcNtfD98q2fXJ_rKPWvDw7E,1959
-autopkg_wrapper/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autopkg_wrapper/utils/args.py,sha256=1uEdjTIuqQQcealiEqihZNAamSDLbU9qBzJ6M-tpsS4,8423
-autopkg_wrapper/utils/git_functions.py,sha256=e7wiUIW8Pu6m4oK0LlH7Vnrvp8XzknwTPYXz-Ekn40o,4893
-autopkg_wrapper/utils/logging.py,sha256=3knpMViO_zAU8WM5bSImQaz5M01vMFk_raB4lt1cbvo,324
-autopkg_wrapper/utils/recipe_ordering.py,sha256=v5yn8KAcvOnNuvAL93ZXwkCUlmNnTGo3oNIqpUAF2jk,5974
-autopkg_wrapper/utils/report_processor.py,sha256=TjSvW02Jq62JhsHNmt_JmZCuQwT_x5RfJNfVTmIePrY,22420
-autopkg_wrapper-2026.2.5.dist-info/METADATA,sha256=mzvKpevomEGeb2iPYjg424EWA3U9yhLdPpRkmR1Nu14,5223
-autopkg_wrapper-2026.2.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-autopkg_wrapper-2026.2.5.dist-info/entry_points.txt,sha256=TVIcOt7OozzX1c00pwMGbBysaHg_v_N3mO3juoFqPpo,73
-autopkg_wrapper-2026.2.5.dist-info/licenses/LICENSE,sha256=PpNOQjZGcsKFuA0wU16YU7PueVxqPX4OnyZ7TlLQlq4,1602
-autopkg_wrapper-2026.2.5.dist-info/RECORD,,