autopkg-wrapper 2026.2.2__tar.gz → 2026.2.6__tar.gz

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.6}/.github/workflows/build-publish.yml

@@ -105,22 +105,20 @@ jobs:
     steps:
       - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
-      - name: Setup UV
-        uses: astral-sh/setup-uv@803947b9bd8e9f986429fa0c5a41c367cd732b41 # v7.2.1
+      - name: Setup mise
+        uses: jdx/mise-action@6d1e696aa24c1aa1bcc1adea0212707c71ab78a8 # v3.6.1
         with:
-          activate-environment: true
-          enable-cache: true
-          cache-dependency-glob: uv.lock
+          install: true
+          cache: true
 
-      - name: Setup Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
-        with:
-          python-version-file: pyproject.toml
+      - name: Run tests
+        run: mise run test
+
+      - name: Build package
+        env:
+          RELEASE_VERSION: ${{ needs.release.outputs.version }}
+        run: mise run build
 
-      - name: Build Package with UV
-        run: |
-          uv version ${{ needs.release.outputs.version }}
-          uv build
       - name: Upload Package Artifacts
         uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autopkg-wrapper
-Version: 2026.2.2
+Version: 2026.2.6
 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>
@@ -33,6 +33,8 @@ pip install autopkg-wrapper
 -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

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.6}/README.md

@@ -14,6 +14,8 @@ pip install autopkg-wrapper
 -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

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.6}/autopkg_wrapper/autopkg_wrapper.py

@@ -2,154 +2,20 @@
 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, recipe_type_for
+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 None
-        prefs_file = (
-            ["--prefs", args.autopkg_prefs.as_posix()] if args.autopkg_prefs else None
-        )
-        cmd = ["/usr/local/bin/autopkg", "verify-trust-info", self.filename]
-        cmd = cmd + verbose_output if verbose_output else cmd
-        cmd = cmd + prefs_file if prefs_file else cmd
-        cmd = " ".join(cmd)
-        logging.debug(f"cmd: {str(cmd)}")
-
-        p = subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
-        )
-        (output, err) = p.communicate()
-        p_status = p.wait()
-        if p_status == 0:
-            self.verified = True
-        else:
-            err = err.decode()
-            self.results["message"] = err
-            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 None
-        )
-        cmd = ["/usr/local/bin/autopkg", "update-trust-info", self.filename]
-        cmd = cmd + prefs_file if prefs_file else cmd
-        cmd = " ".join(cmd)
-        logging.debug(f"cmd: {str(cmd)}")
-
-        # Fail loudly if this exits 0
-        try:
-            subprocess.check_call(cmd, shell=True)
-        except subprocess.CalledProcessError as e:
-            logging.error(e.stderr)
-            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 None
-                )
-                verbose_output = ["-vvvv"] if args.debug else None
-                post_processor_cmd = (
-                    list(
-                        chain.from_iterable(
-                            [
-                                ("--post", processor)
-                                for processor in self.post_processors
-                            ]
-                        )
-                    )
-                    if self.post_processors
-                    else None
-                )
-                cmd = [
-                    "/usr/local/bin/autopkg",
-                    "run",
-                    self.filename,
-                    "--report-plist",
-                    str(report),
-                ]
-                cmd = cmd + post_processor_cmd if post_processor_cmd else cmd
-                cmd = cmd + verbose_output if verbose_output else cmd
-                cmd = cmd + prefs_file if prefs_file else cmd
-                cmd = " ".join(cmd)
-
-                logging.debug(f"cmd: {str(cmd)}")
-
-                subprocess.check_call(cmd, shell=True)
-
-            except subprocess.CalledProcessError:
-                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
@@ -246,7 +112,12 @@ def update_recipe_repo(recipe, git_info, disable_recipe_trust_check, args):
 
 
 def parse_recipe_list(recipes, recipe_file, post_processors, args):
-    """Parsing list of recipes into a common format"""
+    """Parse recipe inputs into a common list of recipe names.
+
+    The arguments assume that `recipes` and `recipe_file` are mutually exclusive.
+    If `args.recipe_processing_order` is provided, the list is re-ordered before
+    creating `Recipe` objects.
+    """
     recipe_list = None
 
     logging.info(f"Recipes: {recipes}") if recipes else None
@@ -256,6 +127,12 @@ def parse_recipe_list(recipes, recipe_file, post_processors, args):
         if recipe_file.suffix == ".json":
             with open(recipe_file, "r") 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:
+                recipe_list = yaml.load(f)
         elif recipe_file.suffix == ".txt":
             with open(recipe_file, "r") as f:
                 recipe_list = f.read().splitlines()
@@ -279,11 +156,16 @@ def parse_recipe_list(recipes, recipe_file, post_processors, args):
             """Please provide recipes to run via the following methods:
     --recipes recipe_one.download recipe_two.download
     --recipe-file path/to/recipe_list.json
-    Comma separated list in the AUTOPKG_RECIPES env variable"""
+    Comma separated list in the AW_RECIPES env variable"""
         )
         sys.exit(1)
 
-    logging.info(f"Processing the following recipes: {recipe_list}")
+    if args.recipe_processing_order:
+        recipe_list = order_recipe_list(
+            recipe_list=recipe_list, order=args.recipe_processing_order
+        )
+
+    logging.info(f"Processing {len(recipe_list)} recipes.")
     recipe_map = [Recipe(name, post_processors=post_processors) for name in recipe_list]
 
     return recipe_map
@@ -374,12 +256,29 @@ 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,
+        )
+        for batch in batches:
+            batch_type = recipe_type_for(batch[0]) if batch else ""
+            logging.info(
+                f"Running {len(batch)} recipes for type={batch_type or 'unknown'}"
+            )
+            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)
+    else:
+        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-2026.2.6/autopkg_wrapper/models/recipe.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import logging
+import plistlib
+import subprocess
+from datetime import datetime
+from itertools import chain
+from pathlib import Path
+
+
+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", 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-2026.2.2 → autopkg_wrapper-2026.2.6}/autopkg_wrapper/notifier/slack.py

@@ -5,7 +5,7 @@ import requests
 
 
 def send_notification(recipe, token):
-    logging.debug("Skipping Slack notification as DEBUG is enabled!")
+    logging.debug("Preparing Slack notification")
 
     if token is None:
         logging.error("Skipping Slack Notification as no SLACK_WEBHOOK_TOKEN defined!")

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.6}/autopkg_wrapper/utils/args.py

@@ -68,6 +68,33 @@ def setup_args():
                 `autopkg-wrapper`
             """,
     )
+    parser.add_argument(
+        "--recipe-processing-order",
+        nargs="*",
+        default=os.getenv("AW_RECIPE_PROCESSING_ORDER", None),
+        help="""
+            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).
+            """,
+    )
+    parser.add_argument(
+        "--autopkg-bin",
+        default=os.getenv("AW_AUTOPKG_BIN", "/usr/local/bin/autopkg"),
+        help="Path to the autopkg binary (default: /usr/local/bin/autopkg). Can also be set via AW_AUTOPKG_BIN.",
+    )
+
     parser.add_argument(
         "--debug",
         default=validate_bool(os.getenv("AW_DEBUG", False)),

{autopkg_wrapper-2026.2.2 → autopkg_wrapper-2026.2.6}/autopkg_wrapper/utils/git_functions.py

@@ -1,4 +1,5 @@
 import logging
+import re
 import subprocess
 from datetime import datetime
 
@@ -21,12 +22,26 @@ def git_run(*args):
 
 
 def get_repo_info(override_repo_git_git_dir):
-    repo_url = (
-        git_run(override_repo_git_git_dir, "config", "--get", "remote.origin.url")
-        .stdout.strip()
-        .split(".git")[0]
+    remote = git_run(
+        override_repo_git_git_dir, "config", "--get", "remote.origin.url"
+    ).stdout.strip()
+
+    # Supports:
+    # - https://github.com/<owner>/<repo>.git
+    # - git@github.com:<owner>/<repo>.git
+    # - ssh://git@github.com/<owner>/<repo>.git
+    m = re.search(
+        r"github\.com[:/](?P<owner>[^/]+)/(?P<repo>[^\s/]+?)(?:\.git)?$",
+        remote,
+        flags=re.IGNORECASE,
     )
-    remote_repo_ref = repo_url.split("https://github.com/")[1]
+    if not m:
+        raise ValueError(f"Unsupported Git remote URL: {remote}")
+
+    owner = m.group("owner")
+    repo = m.group("repo")
+    remote_repo_ref = f"{owner}/{repo}"
+    repo_url = f"https://github.com/{remote_repo_ref}"
 
     logging.debug(f"Repo URL: {repo_url}")
     logging.debug(f"Remote Repo Ref: {remote_repo_ref}")

autopkg_wrapper-2026.2.6/autopkg_wrapper/utils/recipe_batching.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Iterable, Protocol, TypeVar
+
+
+class HasFilename(Protocol):
+    filename: str
+
+
+T = TypeVar("T", bound=HasFilename)
+
+
+def recipe_type_for(recipe: HasFilename) -> str:
+    parts = recipe.filename.split(".", 1)
+    return parts[1] if len(parts) == 2 else ""
+
+
+def build_recipe_batches(
+    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